implementado typescript 7
This commit is contained in:
parent
cd4ea4d36b
commit
e9a323f18c
80 changed files with 5711 additions and 2455 deletions
|
|
@ -1,159 +1,246 @@
|
|||
"use strict";
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var filtroDelta_exports = {};
|
||||
__export(filtroDelta_exports, {
|
||||
criarFiltroDelta: () => criarFiltroDelta,
|
||||
iniciarFiltroDelta: () => iniciarFiltroDelta,
|
||||
operadorFiltroDeltaDetalhes: () => operadorFiltroDeltaDetalhes,
|
||||
zColunaFiltroDelta: () => zColunaFiltroDelta,
|
||||
zCondicaoFiltroDelta: () => zCondicaoFiltroDelta,
|
||||
zFiltroDelta: () => zFiltroDelta,
|
||||
zOperadorFiltroDelta: () => zOperadorFiltroDelta
|
||||
});
|
||||
module.exports = __toCommonJS(filtroDelta_exports);
|
||||
var import_zod = __toESM(require("zod"));
|
||||
const zOperadorFiltroDelta = import_zod.default.enum([">", "<", ">=", "<=", "=", "!=", "in", "like", "\u2229"]);
|
||||
const operadorFiltroDeltaDetalhes = {
|
||||
">": {
|
||||
rotulo: "Maior que",
|
||||
descricao: "O valor de A deve ser maior que o valor de B"
|
||||
},
|
||||
"<": {
|
||||
rotulo: "Menor que",
|
||||
descricao: "O valor de A deve ser menor que o valor de B"
|
||||
},
|
||||
">=": {
|
||||
rotulo: "Maior ou igual a",
|
||||
descricao: "O valor de A deve ser maior ou igual ao valor de B"
|
||||
},
|
||||
"<=": {
|
||||
rotulo: "Menor ou igual a",
|
||||
descricao: "O valor de A deve ser menor ou igual ao valor de B"
|
||||
},
|
||||
"=": {
|
||||
rotulo: "Igual a",
|
||||
descricao: "O valor de A deve ser igual ao valor de B"
|
||||
},
|
||||
"!=": {
|
||||
rotulo: "Diferente de",
|
||||
descricao: "O valor de A deve ser diferente do valor de B"
|
||||
},
|
||||
in: {
|
||||
rotulo: "Est\xE1 em",
|
||||
descricao: "O valor de A deve estar presente na cole\xE7\xE3o ou lista definida em B"
|
||||
},
|
||||
like: {
|
||||
rotulo: "Cont\xE9m",
|
||||
descricao: "O valor de A deve conter o texto informado em B"
|
||||
},
|
||||
"\u2229": {
|
||||
rotulo: "Interse\xE7\xE3o",
|
||||
descricao: "A e B devem possuir pelo menos um elemento em comum"
|
||||
}
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.iniciarFiltroDelta = exports.criarFiltroDelta = exports.zFiltroDelta = exports.zCondicaoFiltroDelta = exports.zColunaFiltroDelta = exports.operadorFiltroDeltaDetalhes = exports.zOperadorFiltroDelta = void 0;
|
||||
const zod_1 = __importDefault(require("zod"));
|
||||
/**
|
||||
* =============================================================================
|
||||
* FILTRO DELTA (zFiltroDelta)
|
||||
* =============================================================================
|
||||
*
|
||||
* OBJETIVO
|
||||
* -----------------------------------------------------------------------------
|
||||
* Novo sistema de filtros projetado para maior flexibilidade e geração segura
|
||||
* de instruções SQL dinâmicas (WHERE).
|
||||
*
|
||||
* REGRAS IMPORTANTES (PARA IA)
|
||||
* -----------------------------------------------------------------------------
|
||||
* - O filtro é composto de duas partes obrigatórias: `condicoes` e `formula`.
|
||||
* - Apenas referências aos `id`s das `condicoes` podem ser usadas na `formula`.
|
||||
* - Não use sintaxe baseada em objetos aninhados para agrupamento (ex: { E: [], OU: [] }). Use fórmulas em string.
|
||||
*
|
||||
* 1) CONDIÇÕES (`condicoes`):
|
||||
* Array de objetos contendo as definições isoladas de cada comparação.
|
||||
* Exemplo:
|
||||
* [
|
||||
* { id: "{1}", coluna: "idade", operador: ">=", valor: 18 },
|
||||
* { id: "{2}", coluna: "nome", operador: "like", valor: "%pa%" }
|
||||
* ]
|
||||
* - `id`: Deve SEMPRE seguir o formato {identificador}. Ex: `{c1}`, `{idade_min}`.
|
||||
* - `coluna`: O nome da coluna ou um path JSONB válido (ex: `veiculo.ano`).
|
||||
* - `operador`: Um dos valores do tipo `tipoOperadorFiltroDelta` (veja a constante).
|
||||
*
|
||||
* 2) FÓRMULA (`formula`):
|
||||
* String que define a expressão lógica relacionando as condições através de seus `id`s.
|
||||
* Operadores Lógicos Suportados (EM MAIÚSCULO):
|
||||
* - `E` (AND)
|
||||
* - `OU` (OR)
|
||||
* - `NAO` (NOT)
|
||||
* Suporta o agrupamento lógico usando parênteses `()`
|
||||
* Exemplo válido: "({1} E NAO({2})) OU {3}"
|
||||
*
|
||||
* =============================================================================
|
||||
*/
|
||||
/**
|
||||
* Operadores permitidos para comparação.
|
||||
*/
|
||||
exports.zOperadorFiltroDelta = zod_1.default.enum([">", "<", ">=", "<=", "=", "!=", "in", "like", "∩"]);
|
||||
exports.operadorFiltroDeltaDetalhes = {
|
||||
">": {
|
||||
rotulo: "Maior que",
|
||||
descricao: "O valor de A deve ser maior que o valor de B",
|
||||
},
|
||||
"<": {
|
||||
rotulo: "Menor que",
|
||||
descricao: "O valor de A deve ser menor que o valor de B",
|
||||
},
|
||||
">=": {
|
||||
rotulo: "Maior ou igual a",
|
||||
descricao: "O valor de A deve ser maior ou igual ao valor de B",
|
||||
},
|
||||
"<=": {
|
||||
rotulo: "Menor ou igual a",
|
||||
descricao: "O valor de A deve ser menor ou igual ao valor de B",
|
||||
},
|
||||
"=": {
|
||||
rotulo: "Igual a",
|
||||
descricao: "O valor de A deve ser igual ao valor de B",
|
||||
},
|
||||
"!=": {
|
||||
rotulo: "Diferente de",
|
||||
descricao: "O valor de A deve ser diferente do valor de B",
|
||||
},
|
||||
in: {
|
||||
rotulo: "Está em",
|
||||
descricao: "O valor de A deve estar presente na coleção ou lista definida em B",
|
||||
},
|
||||
like: {
|
||||
rotulo: "Contém",
|
||||
descricao: "O valor de A deve conter o texto informado em B",
|
||||
},
|
||||
"∩": {
|
||||
rotulo: "Interseção",
|
||||
descricao: "A e B devem possuir pelo menos um elemento em comum",
|
||||
},
|
||||
};
|
||||
/**
|
||||
* Valida o identificador da condição.
|
||||
*
|
||||
* Formato esperado:
|
||||
* {identificador} ou {identificador:sufixo}
|
||||
*/
|
||||
const regexIdCondicaoFiltroDelta = /^\{[\w:]+\}$/;
|
||||
/**
|
||||
* Valida nomes de colunas e caminhos jsonb.
|
||||
*/
|
||||
const regexColunaFiltroDelta = /^\w+(\.\w+)*$/;
|
||||
const zColunaFiltroDelta = import_zod.default.string().regex(regexColunaFiltroDelta, "Coluna inv\xE1lida").describe("nome da coluna ou caminho aninhado do jsonb");
|
||||
const zCondicaoFiltroDelta = import_zod.default.object({
|
||||
/**
|
||||
* Identificador único da condição.
|
||||
*
|
||||
* Exemplo:
|
||||
* {1}
|
||||
*/
|
||||
id: import_zod.default.string().describe("id da condi\xE7\xE3o do filtro").regex(regexIdCondicaoFiltroDelta, "O id deve seguir o formato {identificador}"),
|
||||
/**
|
||||
* Nome da coluna ou caminho jsonb.
|
||||
*/
|
||||
coluna: zColunaFiltroDelta,
|
||||
/**
|
||||
* Operador da comparação.
|
||||
*/
|
||||
operador: zOperadorFiltroDelta,
|
||||
/**
|
||||
* Valor utilizado na comparação.
|
||||
*/
|
||||
valor: import_zod.default.any().describe("valor de compara\xE7\xE3o")
|
||||
/**
|
||||
* Coluna simples ou caminho aninhado de jsonb.
|
||||
*/
|
||||
exports.zColunaFiltroDelta = zod_1.default
|
||||
.string()
|
||||
.regex(regexColunaFiltroDelta, "Coluna inválida")
|
||||
.describe("nome da coluna ou caminho aninhado do jsonb");
|
||||
/**
|
||||
* Estrutura individual de uma condição do filtro.
|
||||
*/
|
||||
exports.zCondicaoFiltroDelta = zod_1.default.object({
|
||||
/**
|
||||
* Identificador único da condição.
|
||||
*
|
||||
* Exemplo:
|
||||
* {1}
|
||||
*/
|
||||
id: zod_1.default
|
||||
.string()
|
||||
.describe("id da condição do filtro")
|
||||
.regex(regexIdCondicaoFiltroDelta, "O id deve seguir o formato {identificador}"),
|
||||
/**
|
||||
* Nome da coluna ou caminho jsonb.
|
||||
*/
|
||||
coluna: exports.zColunaFiltroDelta,
|
||||
/**
|
||||
* Operador da comparação.
|
||||
*/
|
||||
operador: exports.zOperadorFiltroDelta,
|
||||
/**
|
||||
* Valor utilizado na comparação.
|
||||
*/
|
||||
valor: zod_1.default.any().describe("valor de comparação"),
|
||||
});
|
||||
/**
|
||||
* Verifica se a fórmula possui uma estrutura lógica válida.
|
||||
*/
|
||||
const formulaFiltroDeltaValida = (formula) => {
|
||||
const tokensPermitidos = formula.match(/\{[\w:]+\}|\bNAO\b|\bE\b|\bOU\b|\(|\)/g) || [];
|
||||
const formulaReconstruida = tokensPermitidos.join("");
|
||||
const formulaOriginalSemEspacos = formula.replace(/\s+/g, "");
|
||||
const formulaReconstruidaSemEspacos = formulaReconstruida.replace(/\s+/g, "");
|
||||
if (formulaOriginalSemEspacos !== formulaReconstruidaSemEspacos) {
|
||||
return false;
|
||||
}
|
||||
const expressaoLogica = formula.replace(/\{[\w:]+\}/g, "true").replace(/\bNAO\b/g, "!").replace(/\bE\b/g, "&&").replace(/\bOU\b/g, "||");
|
||||
try {
|
||||
new Function(`return (${expressaoLogica})`)();
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
const zFiltroDelta = import_zod.default.object({
|
||||
/**
|
||||
* Lista de condições disponíveis.
|
||||
*/
|
||||
condicoes: import_zod.default.array(zCondicaoFiltroDelta),
|
||||
/**
|
||||
* Fórmula lógica que combina as condições.
|
||||
*/
|
||||
formula: import_zod.default.string().refine(formulaFiltroDeltaValida, {
|
||||
message: "F\xF3rmula inv\xE1lida. Use apenas refer\xEAncias de condi\xE7\xF5es {id} ou {id:sufixo}, operadores E/OU/NAO e par\xEAnteses."
|
||||
})
|
||||
}).superRefine((value, ctx) => {
|
||||
const idsCondicoes = new Set(value.condicoes.map((condicao) => condicao.id));
|
||||
const referenciasFormula = value.formula.match(/\{[\w:]+\}/g) || [];
|
||||
for (const referencia of referenciasFormula) {
|
||||
if (!idsCondicoes.has(referencia)) {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
path: ["formula"],
|
||||
message: `A refer\xEAncia ${referencia} n\xE3o existe em condicoes.`
|
||||
});
|
||||
/**
|
||||
* Extrai apenas os tokens permitidos:
|
||||
* - referências de condição: {id} ou {id:sufixo}
|
||||
* - operadores lógicos: E, OU
|
||||
* - negação: NAO(...)
|
||||
* - parênteses
|
||||
*/
|
||||
const tokensPermitidos = formula.match(/\{[\w:]+\}|\bNAO\b|\bE\b|\bOU\b|\(|\)/g) || [];
|
||||
/**
|
||||
* Reconstrói a fórmula usando apenas os tokens válidos.
|
||||
*/
|
||||
const formulaReconstruida = tokensPermitidos.join("");
|
||||
/**
|
||||
* Remove espaços para comparar o texto original com o texto reconstruído.
|
||||
*/
|
||||
const formulaOriginalSemEspacos = formula.replace(/\s+/g, "");
|
||||
const formulaReconstruidaSemEspacos = formulaReconstruida.replace(/\s+/g, "");
|
||||
/**
|
||||
* Se forem diferentes, há conteúdo não permitido na fórmula.
|
||||
*/
|
||||
if (formulaOriginalSemEspacos !== formulaReconstruidaSemEspacos) {
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Converte a fórmula para uma expressão JavaScript equivalente.
|
||||
*
|
||||
* NAO(x) → !x
|
||||
* E → &&
|
||||
* OU → ||
|
||||
*/
|
||||
const expressaoLogica = formula
|
||||
.replace(/\{[\w:]+\}/g, "true")
|
||||
.replace(/\bNAO\b/g, "!")
|
||||
.replace(/\bE\b/g, "&&")
|
||||
.replace(/\bOU\b/g, "||");
|
||||
try {
|
||||
/**
|
||||
* Valida a ordem dos operadores, parênteses e estrutura lógica geral.
|
||||
*/
|
||||
new Function(`return (${expressaoLogica})`)();
|
||||
return true;
|
||||
}
|
||||
catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
});
|
||||
const criarFiltroDelta = (filtro) => zFiltroDelta.parse(filtro);
|
||||
const iniciarFiltroDelta = () => {
|
||||
return {
|
||||
criarFiltroDelta
|
||||
};
|
||||
};
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
criarFiltroDelta,
|
||||
iniciarFiltroDelta,
|
||||
operadorFiltroDeltaDetalhes,
|
||||
zColunaFiltroDelta,
|
||||
zCondicaoFiltroDelta,
|
||||
zFiltroDelta,
|
||||
zOperadorFiltroDelta
|
||||
/**
|
||||
* Estrutura principal do filtro delta.
|
||||
*/
|
||||
exports.zFiltroDelta = zod_1.default
|
||||
.object({
|
||||
/**
|
||||
* Lista de condições disponíveis.
|
||||
*/
|
||||
condicoes: zod_1.default.array(exports.zCondicaoFiltroDelta),
|
||||
/**
|
||||
* Fórmula lógica que combina as condições.
|
||||
*/
|
||||
formula: zod_1.default.string().refine(formulaFiltroDeltaValida, {
|
||||
message: "Fórmula inválida. Use apenas referências de condições {id} ou {id:sufixo}, operadores E/OU/NAO e parênteses.",
|
||||
}),
|
||||
})
|
||||
.superRefine((value, ctx) => {
|
||||
/**
|
||||
* IDs das condições cadastradas.
|
||||
*/
|
||||
const idsCondicoes = new Set(value.condicoes.map((condicao) => condicao.id));
|
||||
/**
|
||||
* Referências usadas dentro da fórmula.
|
||||
*/
|
||||
const referenciasFormula = value.formula.match(/\{[\w:]+\}/g) || [];
|
||||
/**
|
||||
* Verifica se toda referência da fórmula existe em condicoes.
|
||||
*/
|
||||
for (const referencia of referenciasFormula) {
|
||||
if (!idsCondicoes.has(referencia)) {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
path: ["formula"],
|
||||
message: `A referência ${referencia} não existe em condicoes.`,
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
const criarFiltroDelta = (filtro) => exports.zFiltroDelta.parse(filtro);
|
||||
exports.criarFiltroDelta = criarFiltroDelta;
|
||||
/**
|
||||
* Fábrica para criar filtros com colunas estritamente tipadas.
|
||||
* Útil para autocompletar os nomes das colunas e garantir a estrutura no TypeScript.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* const { criarFiltroDelta } = iniciarFiltroDelta<"nome" | "idade" | "jsonb.propriedade">()
|
||||
*
|
||||
* const filtro = criarFiltroDelta({
|
||||
* condicoes: [
|
||||
* { id: "{c1}", coluna: "idade", operador: ">", valor: 18 },
|
||||
* { id: "{c2}", coluna: "nome", operador: "=", valor: "luiz" },
|
||||
* { id: "{c3}", coluna: "jsonb.propriedade", operador: "=", valor: "valor" },
|
||||
* ],
|
||||
* formula: "({c1} E {c2}) OU {c3}",
|
||||
* })
|
||||
* ```
|
||||
*/
|
||||
const iniciarFiltroDelta = () => {
|
||||
return {
|
||||
criarFiltroDelta: exports.criarFiltroDelta,
|
||||
};
|
||||
};
|
||||
exports.iniciarFiltroDelta = iniciarFiltroDelta;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue