@designliquido/lincones-sqlite/fontes/lincones-sqlite.js

Implementação de LinConEs para SQLite.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LinconesSQLite = void 0;
const tradutor_1 = require("./tradutor");
const avaliador_sintatico_1 = require("./comum/fontes/avaliador-sintatico");
const lexador_1 = require("./comum/fontes/lexador");
const cliente_sqlite_1 = require("./infraestrutura/cliente-sqlite");
const infraestrutura_1 = require("./infraestrutura");
/**
 * Implementação da tecnologia LinConEs para SQLite, permitindo a execução de comandos escritos em LinConEs diretamente em um banco de dados SQLite.
 * Esta classe integra o processo de lexagem, avaliação sintática, tradução e execução de comandos, proporcionando uma interface unificada para
 * interagir com o banco de dados SQLite usando a sintaxe do LinConEs.
 */
class LinconesSQLite {
    constructor(configuracao) {
        this.lexador = new lexador_1.Lexador();
        this.avaliadorSintatico = new avaliador_sintatico_1.AvaliadorSintatico();
        this.tradutor = new tradutor_1.TradutorSqLite();
        this.configuracao = configuracao;
    }
    async iniciar(caminho) {
        var _a, _b;
        const caminhoEfetivo = (_b = caminho !== null && caminho !== void 0 ? caminho : (_a = this.configuracao) === null || _a === void 0 ? void 0 : _a.caminho) !== null && _b !== void 0 ? _b : null;
        this.clienteSQLite = new cliente_sqlite_1.ClienteSQLite(caminhoEfetivo);
        await this.clienteSQLite.abrir();
    }
    async executarComando(comando) {
        return await this.executarInterno([comando], comando.parametros);
    }
    /**
     * Traduz um comando de LinConEs para SQL e executa no banco de dados SQLite.
     * @param _ Normalmente a instância do interpretador Delégua.
     * @param sentencaLincones A sentença em LinConEs a ser traduzida e executada.
     * @param parametros Parâmetros adicionais para o comando, se necessário.
     * @returns {Promise<RetornoComando[]>} Uma promessa que resolve para um array de objetos RetornoComando, representando os resultados da execução dos comandos.
     */
    async executar(_, sentencaLincones, parametros = []) {
        const parametrosNaoNulos = parametros || [];
        const resultadoLexador = this.lexador.mapear([sentencaLincones]);
        const resultadoAvaliacaoSintatica = this.avaliadorSintatico.analisar(resultadoLexador);
        if (resultadoAvaliacaoSintatica.erros.length > 0) {
            throw new Error(`Erros encontrados na avaliação de comandos: ${resultadoAvaliacaoSintatica.erros.reduce((mensagens, erro) => mensagens += erro.message + '; ', '')}.`);
        }
        return await this.executarInterno(resultadoAvaliacaoSintatica.comandos, parametrosNaoNulos);
    }
    async executarInterno(comandos, parametros) {
        if (comandos.length <= 0) {
            return [];
        }
        const retornosComandos = [];
        // Filtrar comandos nulos ou indefinidos antes de processar.
        const comandosValidos = comandos.filter((c) => c);
        for (const comando of comandosValidos) {
            const resultadoTraducao = this.tradutor.traduzir([comando]);
            if (!resultadoTraducao || resultadoTraducao.trim() === '') {
                throw new Error(`Tradução produziu SQL vazio para comando: ${comando.constructor.name}`);
            }
            // TODO: Parâmetros
            if (!this.clienteSQLite) {
                throw new Error("Cliente SQLite não inicializado.");
            }
            const resultadoExecucao = await this.clienteSQLite.executarComando(resultadoTraducao, parametros);
            const retorno = new infraestrutura_1.RetornoComando(resultadoExecucao);
            retornosComandos.push(retorno);
        }
        return retornosComandos;
    }
}
exports.LinconesSQLite = LinconesSQLite;
//# sourceMappingURL=lincones-sqlite.js.map