Shortcuts CRUD for an organic JSON database

[Teggui]

It's exactly as indicated in the title. These shortcuts will help you manage a extensive knowledge base in JSON format and update and reuse it from anywhere in the vault.
First of all, I want to thank jon-heard for this Obsidian plugin, obsidian-inline-scripts, because it's wonderful. It gave me the opportunity to work on something I've needed for a long time and enhances my study and learning.
On the other hand, I would like to apologize for two things: the code is in Spanish because I'm a Spanish speaker, and I know that using English is better for collaboration, but I'm already burnt out. I also apologize for any bad practices in the JavaScript code because I'm a C# developer, and it's a bit tedious for me.
An example of what I built with these shortcuts:

__
^sfile setup$
__
pathMyData = "D:\GDrive\NotasObsidian\MisNotas\MisNotas\Scripts\miData.json";
__
Setup this shortcut-file

__
post ([^ ]+) (.+)$
__

const fs = require('fs');
const path = require('path');

let clave = $1;
let valor = $2;

pathMyData = "D:\\GDrive\\NotasObsidian\\MisNotas\\MisNotas\\Scripts\\miData.json";
try {
    let data = {};

    // Verificar si el archivo JSON existe
    if (fs.existsSync(pathMyData)) {
        // Leer el archivo JSON existente si tiene datos válidos
        const jsonData = fs.readFileSync(pathMyData, 'utf-8');
        if (jsonData.trim() !== '') {
            data = JSON.parse(jsonData);
        }
    }

    // Separar la clave en partes utilizando el carácter "."
    const partesClave = clave.split('.');

    // Recorrer las partes de la clave para crear subclaves anidadas
    let objetoActual = data;
    for (let i = 0; i < partesClave.length - 1; i++) {
        const parte = partesClave[i];
        if (!objetoActual.hasOwnProperty(parte) || typeof objetoActual[parte] !== 'object') {
            let valorViejoAux = objetoActual[parte];
        objetoActual[parte] = {};
        objetoActual = objetoActual[parte];
        objetoActual["|"+parte] = valorViejoAux;      
        }
        else{
	        objetoActual = objetoActual[parte];
        };
    }

    // Asignar el nuevo valor en la subclave final
    const subclaveFinal = partesClave[partesClave.length - 1];

    // Reemplazar el valor existente (si lo hay) con el nuevo valor
    objetoActual[subclaveFinal] = valor + "\\n";

    // Convierte el objeto actual nuevamente a JSON
    const nuevoContenidoJSON = JSON.stringify(data, null, 2);
    
    // Escribe el JSON modificado en el archivo
    fs.writeFileSync(pathMyData, nuevoContenidoJSON, 'utf-8');
    console.log(`Valor "${valor}" reemplazado en la clave "${clave}" en ${pathMyData}`);
} catch (error) {
    console.error('Error al guardar en el archivo JSON:', error);
}

__
Guarda y reemplaza el valor de una clave de json
$1 clave, $valor

__
get ([^ ]+)$
__

const fs = require('fs');
const path = require('path');

clave = $1

try {
	let data = {};

	// Verificar si el archivo JSON existe
	if (fs.existsSync(pathMyData)) {
		// Leer el archivo JSON existente si tiene datos válidos
		const jsonData = fs.readFileSync(pathMyData, 'utf-8');
		if (jsonData.trim() !== '') {
			data = JSON.parse(jsonData);
		}
	}

	// Separar la clave en partes utilizando el carácter "."
	const partesClave = clave.split('.');

	// Recorrer las partes de la clave para acceder al valor final
	let objetoActual = data;
	for (let i = 0; i < partesClave.length; i++) {
		const parte = partesClave[i];
		if (!objetoActual.hasOwnProperty(parte)) {
			return null; // La clave no existe
		}
		objetoActual = objetoActual[parte];
		var ultimaParte = parte;
	}
	
	console.log(objetoActual);
	if (String.isString(objetoActual)){
		return `${ultimaParte} \n`+ objetoActual.replace(/\\n/g, '\n');
	}
	if (objetoActual.hasOwnProperty("|"+ultimaParte)) {
			objetoActual = objetoActual["|"+ultimaParte];
		}
	return `${ultimaParte} \n`+JSON.stringify(objetoActual)
	.split('\\n')
	.join('\n')
	.replace(/[\{\}\\]+/g, '');
} catch (error) {
	console.error('Error al obtener valores del archivo JSON:', error);
	return null; // Ocurrió un error
}

__
Recupera valor de una clave json
$1 = clave

__
get ([^ ]+) ([^ ]+)$
__

const fs = require('fs');
const path = require('path');

let claveInicio = $1
let claveFin = $2

try {
	let data = {};

	// Verificar si el archivo JSON existe
	if (fs.existsSync(pathMyData)) {
		// Leer el archivo JSON existente si tiene datos válidos
		const jsonData = fs.readFileSync(pathMyData, 'utf-8');
		if (jsonData.trim() !== '') {
			data = JSON.parse(jsonData);
		}
	}

	// Función recursiva para recopilar valores entre claves
	function recopilarValores(objetoActual, claveActual, claveInicio, claveFin) {
		const valores = [];
		for (const clave in objetoActual) {
		
			if (objetoActual.hasOwnProperty(clave)) {
				const nuevaClave = claveActual ? `${claveActual}.${clave}` : clave;
				if (nuevaClave === claveInicio) {
					// Comenzar a recopilar valores cuando se alcanza la clave de inicio
					recopilando = true;
				}
				if (recopilando) {
					if (typeof objetoActual[clave] === 'string') {
					if(isNaN(clave)){
		continue;
		}
						valores.push(`${clave}\n `+objetoActual[clave]);
					}else{
					if(isNaN(clave)){
		continue;
		}
						let objetoAux = objetoActual[clave];
					
					if (typeof objetoAux["|"+clave] === 'string'){
					
						valores.push(`${clave}\n `+objetoAux["|"+clave])
						}
					}
				}
				if (nuevaClave === claveFin) {
					// Dejar de recopilar valores cuando se alcanza la clave de fin
					recopilando = false;
				}
				if (typeof objetoActual[clave] === 'object') {
					// Recursivamente recopilar valores de objetos anidados
					const valoresSubclaves = recopilarValores(objetoActual[clave], nuevaClave, claveInicio, claveFin);
					valores.push(...valoresSubclaves);
				}
			}
		}
		return valores;
	}

	// Iniciar el proceso de recopilación de valores
	let recopilando = false;
	const valoresRecopilados = recopilarValores(data, '', claveInicio, claveFin);

	// Unir los valores recopilados con saltos de línea
	let valoresUnidos = valoresRecopilados.join('\n');
	valoresUnidos = valoresUnidos.replace(/\\n/g, '\n');
	return valoresUnidos;
} catch (error) {
	console.error('Error al obtener los valores entre claves en el archivo JSON:', error);
	return '';
}

__
Recupera valores en un rango ejemplo: c.1 - c.3 => retorna valores de c1, c2, c3.
también puede recorrer c.1.1 - c.2.1 => retorna valores de c1.1, c.1.2 , c2.1
$1 = clave desde $2 = clave hasta

__
put ([^ ]+) (.+)$
__

const fs = require('fs');
const path = require('path');

let clave = $1;
let valor = $2;

try {
    let data = {};

    // Verificar si el archivo JSON existe
    if (fs.existsSync(pathMyData)) {
        // Leer el archivo JSON existente si tiene datos válidos
        const jsonData = fs.readFileSync(pathMyData, 'utf-8');
        if (jsonData.trim() !== '') {
            data = JSON.parse(jsonData);
        }
    }

    // Separar la clave en partes utilizando el carácter "."
    const partesClave = clave.split('.');

    // Recorrer las partes de la clave para crear subclaves anidadas
    let objetoActual = data;
    for (let i = 0; i < partesClave.length - 1; i++) {
        const parte = partesClave[i];
        if (!objetoActual.hasOwnProperty(parte) || typeof objetoActual[parte] !== 'object') {
        let valorViejoAux = objetoActual[parte];
        objetoActual[parte] = {};
        objetoActual = objetoActual[parte];
        objetoActual["|"+parte] = valorViejoAux;        
        }else{
	        objetoActual = objetoActual[parte];
        }
    }

    // Asignar el nuevo valor en la subclave final
    const subclaveFinal = partesClave[partesClave.length - 1];

    if (objetoActual[subclaveFinal] && typeof objetoActual[subclaveFinal] === 'string') {
        // Si ya existe un valor en la subclave final y es una cadena, concatena el nuevo valor
        objetoActual[subclaveFinal] += valor + "\\n";
    } else {
        // Si no existe un valor o no es una cadena, asigna el nuevo valor directamente
        objetoActual[subclaveFinal] = valor + "\\n";
    }

    // Convierte el objeto actual nuevamente a JSON
    const nuevoContenidoJSON = JSON.stringify(data, null, 2);
    
    // Escribe el JSON modificado en el archivo
    fs.writeFileSync(pathMyData, nuevoContenidoJSON, 'utf-8');
    console.log(`Valor "${valor}" agregado en la clave "${clave}" en ${pathMyData}`);
} catch (error) {
    console.error('Error al guardar en el archivo JSON:', error);
}

__
Appendea texto en una clave o la crea
$1 clave $2 valor

__
del ([^ ]+)$
__

const fs = require('fs');
const path = require('path');


clave = $1;

try {
	let data = {};

	// Verificar si el archivo JSON existe
	if (fs.existsSync(pathMyData)) {
		// Leer el archivo JSON existente si tiene datos válidos
		const jsonData = fs.readFileSync(pathMyData, 'utf-8');
		if (jsonData.trim() !== '') {
			data = JSON.parse(jsonData);
		}
	}

	// Separar la clave en partes utilizando el carácter "."
	const partesClave = clave.split('.');

	// Recorrer las partes de la clave para acceder a la ubicación deseada
	let objetoActual = data;
	for (let i = 0; i < partesClave.length - 1; i++) {
		const parte = partesClave[i];
		if (!objetoActual.hasOwnProperty(parte) || typeof objetoActual[parte] !== 'object') {
			// La clave no existe, no se puede eliminar
			console.log(`La clave "${clave}" no existe en el JSON.`);
			return;
		}
		objetoActual = objetoActual[parte];
	}

	// Eliminar la subclave final
	const subclaveFinal = partesClave[partesClave.length - 1];
	if (objetoActual.hasOwnProperty(subclaveFinal)) {
		delete objetoActual[subclaveFinal];
		console.log(`La clave "${clave}" ha sido eliminada del JSON.`);
		
		// Convierte el objeto actual nuevamente a JSON con formato de salto de línea
		const nuevoContenidoJSON = JSON.stringify(data, null, 2);
		
		// Escribe el JSON modificado en el archivo
		fs.writeFileSync(pathMyData, nuevoContenidoJSON, 'utf-8');
	} else {
		console.log(`La clave "${clave}" no existe en el JSON.`);
	}
} catch (error) {
	console.error('Error al eliminar la clave del archivo JSON:', error);
}

__
Elimina clave
$1 clave
__
move ([^ ]+) ([^ ]+)$
__

const fs = require('fs');
const path = require('path');
let claveOrigen = $1;
let claveDestino = $2;

try {
	let data = {};

	// Verificar si el archivo JSON existe
	if (fs.existsSync(pathMyData)) {
		// Leer el archivo JSON existente si tiene datos válidos
		const jsonData = fs.readFileSync(pathMyData, 'utf-8');
		if (jsonData.trim() !== '') {
			data = JSON.parse(jsonData);
		}
	}

	// Separar las claves en partes utilizando el carácter "."
	const partesOrigen = claveOrigen.split('.');
	const partesDestino = claveDestino.split('.');

	// Recorrer las partes de la clave origen para acceder al valor
	let objetoOrigen = data;
	for (let i = 0; i < partesOrigen.length - 1; i++) {
		const parte = partesOrigen[i];
		if (!objetoOrigen.hasOwnProperty(parte) || typeof objetoOrigen[parte] !== 'object') {
			// La clave origen no existe, no se puede mover
			console.log(`La clave origen "${claveOrigen}" no existe en el JSON.`);
			return;
		}
		objetoOrigen = objetoOrigen[parte];
	}

	// Verificar que la clave origen existe y es un valor
	const subclaveOrigen = partesOrigen[partesOrigen.length - 1];
	if (!objetoOrigen.hasOwnProperty(subclaveOrigen)) {
		console.log(`La clave origen "${claveOrigen}" no existe en el JSON.`);
		return;
	}

	// Obtener el valor de la clave origen
	const valorOrigen = objetoOrigen[subclaveOrigen];

	// Eliminar la clave origen
	delete objetoOrigen[subclaveOrigen];

	// Crear la clave destino si no existe
	let objetoDestino = data;
	for (let i = 0; i < partesDestino.length - 1; i++) {
		const parte = partesDestino[i];
		if (!objetoDestino.hasOwnProperty(parte) || typeof objetoDestino[parte] !== 'object') {
			objetoDestino[parte] = {};
		}
		objetoDestino = objetoDestino[parte];
	}

	// Verificar si la clave destino ya tiene un valor
	const subclaveDestino = partesDestino[partesDestino.length - 1];
	if (objetoDestino.hasOwnProperty(subclaveDestino)) {
		// Concatenar el valor al valor existente
		if (String.isString(valorOrigen)){
			objetoDestino[subclaveDestino] += valorOrigen;
		}else{
			objetoDestino[subclaveDestino]
			objetoDestino[subclaveDestino] += JSON.stringify(valorOrigen);
		}
	} else {
		// Crear la clave destino con el valor
		objetoDestino[subclaveDestino] = valorOrigen;
	}

	// Convierte el objeto actual nuevamente a JSON con formato de salto de línea
	const nuevoContenidoJSON = JSON.stringify(data, null, 2);

	// Escribe el JSON modificado en el archivo
	fs.writeFileSync(pathMyData, nuevoContenidoJSON, 'utf-8');
	console.log(`Valor movido de "${claveOrigen}" a "${claveDestino}" en ${pathMyData}`);
} catch (error) {
	console.error('Error al mover el valor en el archivo JSON:', error);
}

__
Mueve la clave1 a la clave2
$1 clave origen
$2 clave destino
__
copy ([^ ]+) ([^ ]+)$
__

const fs = require('fs');
const path = require('path');

let claveOrigen = $1
let claveDestino = $2

try {
	let data = {};

	// Verificar si el archivo JSON existe
	if (fs.existsSync(pathMyData)) {
		// Leer el archivo JSON existente si tiene datos válidos
		const jsonData = fs.readFileSync(pathMyData, 'utf-8');
		if (jsonData.trim() !== '') {
			data = JSON.parse(jsonData);
		}
	}

	// Separar las claves en partes utilizando el carácter "."
	const partesOrigen = claveOrigen.split('.');
	const partesDestino = claveDestino.split('.');

	// Recorrer las partes de la clave origen para acceder al valor
	let objetoOrigen = data;
	for (let i = 0; i < partesOrigen.length - 1; i++) {
		const parte = partesOrigen[i];
		if (!objetoOrigen.hasOwnProperty(parte) || typeof objetoOrigen[parte] !== 'object') {
			// La clave origen no existe, no se puede copiar
			console.log(`La clave origen "${claveOrigen}" no existe en el JSON.`);
			return;
		}
		objetoOrigen = objetoOrigen[parte];
	}

	// Verificar que la clave origen existe y es un valor
	const subclaveOrigen = partesOrigen[partesOrigen.length - 1];
	if (!objetoOrigen.hasOwnProperty(subclaveOrigen)) {
		console.log(`La clave origen "${claveOrigen}" no existe en el JSON.`);
		return;
	}

	// Obtener el valor de la clave origen
	const valorOrigen = objetoOrigen[subclaveOrigen];

	// Crear la clave destino si no existe
	let objetoDestino = data;
	for (let i = 0; i < partesDestino.length - 1; i++) {
		const parte = partesDestino[i];
		if (!objetoDestino.hasOwnProperty(parte) || typeof objetoDestino[parte] !== 'object') {
			objetoDestino[parte] = {};
		}
		objetoDestino = objetoDestino[parte];
	}

	// Asignar el valor de la clave origen a la clave destino
	const subclaveDestino = partesDestino[partesDestino.length - 1];
	objetoDestino[subclaveDestino] = valorOrigen;

	// Convierte el objeto actual nuevamente a JSON con formato de salto de línea
	const nuevoContenidoJSON = JSON.stringify(data, null, 2).replace(/\\n/g, '\n');

	// Escribe el JSON modificado en el archivo
	fs.writeFileSync(pathMyData, nuevoContenidoJSON, 'utf-8');
	console.log(`Valor copiado de "${claveOrigen}" a "${claveDestino}" en ${pathMyData}`);
} catch (error) {
	console.error('Error al copiar el valor en el archivo JSON:', error);
}

__
Copia la clave1 a la clave2
$1 clave origen
$2 clave destino

[Teggui]

example:
;;post shopping.2023.09.20 - [ ] cheese \n - [ ] water \n beer::
=>

;;get shopping.2023.09.20::
=>

;;get shopping::
=>

;;get shopping.2023.09.20 shopping.2023.09.22::
=>