datera 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,67 @@
+# Mudanças
+
+Tudo que muda de uma versão pra outra do Datera fica aqui, da mais nova pra mais antiga. Vale pro pacote do npm, pro comando `datera` e pros dois apps, que saem sempre com o mesmo número.
+
+Os números seguem o [versionamento semântico](https://semver.org/lang/pt-BR/):
+
+- o último número sobe quando é só correção (`0.1.0` → `0.1.1`)
+- o do meio sobe quando entra coisa nova sem quebrar o que já funcionava (`0.1.1` → `0.2.0`)
+- o primeiro sobe quando alguma coisa deixa de funcionar do jeito antigo e precisa de ajuste de quem usa (`0.9.0` → `1.0.0`)
+
+## [Não lançado]
+
+## [0.2.0] - 2026-09-29
+
+### Adicionado
+
+- este CHANGELOG, e o `npm run release:prepare -- <versão>`, que troca a versão nos três `package.json` e fecha a seção do CHANGELOG de uma vez
+- a action da aba Releases agora usa a seção do CHANGELOG como texto da release, e não deixa publicar uma versão sem ela
+- MySQL, PostgreSQL, SQL Server e SQLite como destino: o resultado vai pra uma tabela nova e as pendências pra outra (`_pendencias` no fim do nome, ou o `pendingTable`), tudo numa transação
+- o Datera anota as tabelas que ele cria em `datera_tabelas` e nunca apaga uma tabela que não foi ele que criou, nem a tabela de onde ele lê
+- variáveis `DEST_DB_*` no `.env` pro banco de destino. Se for o mesmo banco da fonte, o que faltar é copiado dela
+- `--output-table` no `convert`, `dedupe` e `merge`, e as opções `table` e `pendingTable` no `writeRows` e no `convert`
+- no app, banco de dados e arquivo SQLite aparecem como destino no passo a passo, com a opção de salvar no mesmo servidor da fonte, e o Datera Dev ganhou os trechos de destino dos quatro bancos
+- testes de tela dos dois apps com Playwright (`npm run test:telas`), nos temas claro e escuro, rodando no CI com as fotos de cada tela
+
+### Mudou
+
+- os testes usam só os dados da escola de música inventada, sem "clientes" nem telefone
+- o `config.json.example` virou uma config de verdade, que já roda lendo o CSV de exemplo
+
+### Segurança
+
+- o CSV desarma célula de texto que o Excel leria como fórmula (começando com `=`, `+`, `-` ou `@`), colocando um `'` na frente. Dá pra desligar com `escapeFormulas: false`
+- no app, a primeira exportação de cada configuração mostra de onde ela lê e onde grava, e só continua se você confirmar
+- a senha da fonte só é reaproveitada no destino quando os dois são o mesmo servidor
+- `ssl` no MySQL, pra conexão criptografada
+- os instaladores desligam os recursos do Electron que deixariam usar o app como um Node.js escondido
+- nome de tabela ou coluna com caractere invisível é recusado antes de gravar no banco
+
+### Removido
+
+- os scripts `test:config` e `test:connection`, que faziam o mesmo que o `datera validate` e o `--dry-run`
+
+## [0.1.0] - 2026-09-29
+
+Primeira versão publicada no npm e na aba Releases.
+
+### Adicionado
+
+- lê de MySQL, PostgreSQL, SQL Server, SQLite, Google Sheets, Excel, CSV, JSON, XML e Parquet, e escreve no Google Sheets, Excel, CSV, JSON, XML e Parquet
+- modos `raw`, `dedupe` e `merge`, com normalizadores (`trim`, `lowercase`, `digitsOnly`, `alphanumeric`) e os seus próprios
+- preparação (`fillEmpty`, `combineColumns`, `distribute`) e validação com a lista de pendências e o motivo de cada linha
+- app Datera, pra quem não programa, com passo a passo, regras em frases, prévia, histórico e tema escuro
+- app Datera Dev, com editor da config, erros marcados na linha, paleta de comandos e teste de normalizador
+- instaladores pra Windows gerados sozinhos a cada tag de versão
+- comando `datera` com `run`, `validate`, `init`, `convert`, `dedupe`, `merge`, `columns`, `preview`, `normalizers` e `normalize`
+- funções pra usar no código: `readRows`, `writeRows`, `convert`, `clean`, `fillEmpty`, `combineColumns`, `validate`, `dedupe`, `merge`, `describeColumns`, `defineConfig` e `onStep` pra acompanhar o progresso
+- `dedupeKeyNormalizer`, pra comparar repetidos depois de passar por um normalizador
+- os pacotes de Excel, Parquet, Google Sheets e dos bancos são opcionais: só instala quem for usar
+
+### Segurança
+
+- arquivos de código citados na config só rodam depois de confirmados no app
+- a senha do banco fica no `.env`, e o app só lê do `.env` as variáveis que conhece
+- as telas não navegam pra fora do app nem abrem janelas novas
+- o leitor de XML recusa `<!DOCTYPE>`
+- entrada e saída nunca podem ser o mesmo arquivo, mesmo escrito de outro jeito

package/README.md

@@ -6,6 +6,7 @@
 
 <p align="center">
   <a href="https://github.com/alessandravieiradev-blip/datera/actions/workflows/ci.yml"><img src="https://github.com/alessandravieiradev-blip/datera/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://www.npmjs.com/package/datera"><img src="https://img.shields.io/npm/v/datera" alt="Versão no npm"></a>
 </p>
 
 <p align="center">
@@ -27,12 +28,14 @@ flowchart LR
     end
     subgraph destinos["Escreve em"]
         direction TB
+        B2["Bancos<br/>MySQL · PostgreSQL<br/>SQL Server · SQLite"]
         P2["Planilhas<br/>Google Sheets · Excel"]
         A2["Arquivos<br/>CSV · JSON<br/>XML · Parquet"]
     end
     B --> D((Datera))
     P1 --> D
     A1 --> D
+    D --> B2
     D --> P2
     D --> A2
     classDef datera fill:#2563EB,stroke:#2563EB,color:#ffffff
@@ -49,11 +52,11 @@ Então o Datera funciona assim: as regras ficam num arquivo de configuração (o
 
 Por isso ele tem três jeitos de usar, todos com o mesmo motor e a mesma configuração:
 
-| Jeito          | Pra quem                                      | O que tem                                                                 |
-| -------------- | --------------------------------------------- | ------------------------------------------------------------------------- |
-| **Datera**     | quem cuida dos dados mas não programa         | app com tela, passo a passo, regras em frases, gráficos e histórico       |
-| **Datera Dev** | quem programa                                 | app escuro com editor da config, prévia na hora, log e paleta de comandos |
-| **Terminal**   | quem quer automatizar ou usar em outro código | o comando `datera`, `--dry-run` e a função `runEtl`                       |
+| Jeito                 | Pra quem                                       | O que tem                                                                 |
+| --------------------- | ---------------------------------------------- | ------------------------------------------------------------------------- |
+| **Datera**            | quem cuida dos dados mas não programa          | app com tela, passo a passo, regras em frases, gráficos e histórico       |
+| **Datera Dev**        | quem programa                                  | app escuro com editor da config, prévia na hora, log e paleta de comandos |
+| **Terminal e código** | quem quer automatizar ou usar em outro projeto | o comando `datera` e funções pra usar no código, pelo npm                 |
 
 ## Como funciona
 
@@ -77,6 +80,10 @@ Hoje ele consegue:
 - decidir o que fazer com as linhas que não têm chave, sem elas sumirem nem se misturarem
 - espalhar valores em várias colunas sem jogar nenhum fora
 - ler e escrever em formatos diferentes sem mudar nada das regras
+- gravar o resultado numa tabela nova de banco, sem nunca mexer numa tabela que não foi ele que criou
+- converter um arquivo de um formato pra outro, tirar repetidos ou juntar cadastros com um comando só, sem montar config
+- mostrar um raio-x das colunas de um arquivo (quantas vazias, quantos valores diferentes) antes de montar as regras
+- ser usado dentro de outro projeto em JavaScript ou TypeScript, com as mesmas regras da config
 
 ## Escolha o seu caminho
 
@@ -98,6 +105,10 @@ Você quer usar o app com tela: instalar, escolher de onde vêm os dados, montar
 
 Você quer rodar pelo terminal, usar o Datera Dev, escrever a config na mão, criar normalizadores ou chamar o Datera de dentro de outro código.
 
+```bash
+npm install -g datera
+```
+
 <a href="docs/devs.md"><img src="https://img.shields.io/badge/Abrir%20o%20guia%20para%20devs-16181D?style=for-the-badge" alt="Abrir o guia para devs"></a>
 <a href="docs/api.md"><img src="https://img.shields.io/badge/Comandos%20e%20API-475569?style=for-the-badge" alt="Comandos e API"></a>
 
@@ -121,11 +132,11 @@ Você quer rodar pelo terminal, usar o Datera Dev, escrever a config na mão, cr
 
 ## Contribuir e licença
 
-Se quiser ajudar, o jeito de rodar, testar e mandar mudanças está no [CONTRIBUTING.md](CONTRIBUTING.md). O código é aberto, sob a [licença MIT](LICENSE).
+Se quiser ajudar, o jeito de rodar, testar e mandar mudanças está no [CONTRIBUTING.md](CONTRIBUTING.md). O código é aberto, sob a [licença MIT](LICENSE), e o que mudou em cada versão está no [CHANGELOG](CHANGELOG.md). Quem participa segue o [código de conduta](CODE_OF_CONDUCT.md), e falha de segurança se avisa pelo caminho do [SECURITY.md](SECURITY.md).
 
 ## Próximos passos
 
-A ideia é chegar num instalador de um clique pra quem não programa e numa biblioteca no npm pra quem programa.
+A ideia é que qualquer pessoa consiga usar o Datera: quem não programa, pelo instalador de um clique, e quem programa, pelo pacote no npm, no terminal ou no código.
 
 O que eu quero fazer fica nas [issues](https://github.com/alessandravieiradev-blip/datera/issues), agrupadas em etapas nos [milestones](https://github.com/alessandravieiradev-blip/datera/milestones). Lá dá pra ver o que já foi feito e o que falta, e tudo se atualiza sozinho conforme eu vou fazendo.
 

package/dist/api/formats.d.ts

@@ -7,10 +7,14 @@ export interface ReadOptions {
     delimiter?: string | undefined;
     encoding?: "utf-8" | "latin1" | undefined;
 }
+export declare const DEFAULT_TABLE = "dados";
 export interface WriteOptions {
+    table?: string | undefined;
+    pendingTable?: string | undefined;
     sheet?: string | undefined;
     delimiter?: string | undefined;
     bom?: boolean | undefined;
+    escapeFormulas?: boolean | undefined;
     root?: string | undefined;
     record?: string | undefined;
 }

package/dist/api/formats.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TABLE = void 0;
 exports.detectFormat = detectFormat;
 exports.sourceFromPath = sourceFromPath;
 exports.destinationFromPath = destinationFromPath;
@@ -19,6 +20,7 @@ const EXTENSIONS = {
     ".sqlite": "sqlite",
     ".sqlite3": "sqlite",
 };
+exports.DEFAULT_TABLE = "dados";
 function defined(value) {
     return Object.fromEntries(Object.entries(value).filter(([, inner]) => inner !== undefined));
 }
@@ -82,6 +84,7 @@ function destinationFromPath(filePath, options = {}) {
                         ? "\t"
                         : undefined),
                 bom: options.bom,
+                escapeFormulas: options.escapeFormulas,
             });
         case "json":
             return { type: "json", path: filePath };
@@ -101,6 +104,11 @@ function destinationFromPath(filePath, options = {}) {
         case "parquet":
             return { type: "parquet", path: filePath };
         case "sqlite":
-            throw new Error("Ainda não dá pra gravar em SQLite. Escolha outro formato pra saída.");
+            return defined({
+                type: "sqlite",
+                path: filePath,
+                table: options.table?.trim() || exports.DEFAULT_TABLE,
+                pendingTable: options.pendingTable,
+            });
     }
 }

package/dist/api/inspect.js

@@ -6,6 +6,7 @@ exports.normalize = normalize;
 const header_1 = require("../io/header");
 const normalizers_1 = require("../normalizers");
 const registry_1 = require("../normalizers/registry");
+const cells_1 = require("../cells");
 const EXAMPLES = 3;
 function isEmpty(value) {
     return value === null || value === undefined || value === "";
@@ -21,7 +22,7 @@ function kindOf(values) {
 function describeColumns(rows) {
     return (0, header_1.buildHeader)(rows).map((name) => {
         const present = rows
-            .map((row) => row[name])
+            .map((row) => (0, cells_1.cellOf)(row, name))
             .filter((value) => !isEmpty(value));
         const distinct = new Set(present.map((value) => String(value)));
         return {

package/dist/cells.d.ts

@@ -0,0 +1,5 @@
+import { TableRow } from "./types";
+export type Cell = TableRow[string];
+export declare function hasCell(row: TableRow, column: string): boolean;
+export declare function cellOf(row: TableRow, column: string): Cell | undefined;
+export declare function setCell(row: TableRow, column: string, value: Cell): void;

package/dist/cells.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCell = hasCell;
+exports.cellOf = cellOf;
+exports.setCell = setCell;
+const own = Object.prototype.hasOwnProperty;
+function hasCell(row, column) {
+    return own.call(row, column);
+}
+function cellOf(row, column) {
+    return own.call(row, column) ? row[column] : undefined;
+}
+function setCell(row, column, value) {
+    if (column === "__proto__") {
+        Object.defineProperty(row, column, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+        return;
+    }
+    row[column] = value;
+}

package/dist/cli.js

@@ -25,6 +25,7 @@ function withReadFlags(command) {
 }
 function withWriteFlags(command) {
     return command
+        .option("--output-table <tabela>", 'Tabela onde gravar, quando a saída é SQLite (padrão: "dados").')
         .option("--output-sheet <aba>", "Nome da aba, quando a saída é Excel.")
         .option("--output-delimiter <separador>", "Separador do CSV de saída.")
         .option("--root <nome>", "Elemento de fora, quando a saída é XML.")
@@ -41,6 +42,7 @@ function readOptions(flags) {
 }
 function writeOptions(flags) {
     return {
+        table: flags.outputTable,
         sheet: flags.outputSheet,
         delimiter: flags.outputDelimiter,
         root: flags.root,

package/dist/commands.js

@@ -11,6 +11,13 @@ const config_1 = require("./config");
 const api_1 = require("./api");
 const safety_1 = require("./io/safety");
 const pipeline_1 = require("./pipeline");
+function assertSafeOutput(cli) {
+    (0, safety_1.assertSourceIsSafe)({
+        mode: "raw",
+        source: (0, api_1.sourceFromPath)(cli.input, cli.read),
+        destination: (0, api_1.destinationFromPath)(cli.output, cli.write),
+    });
+}
 function plural(count, one, many) {
     return `${count} ${count === 1 ? one : many}`;
 }
@@ -112,7 +119,7 @@ async function runCommand(cli, logger) {
             return 0;
         }
         case "dedupe": {
-            (0, safety_1.assertDifferentFiles)(cli.input, cli.output);
+            assertSafeOutput(cli);
             const rows = await (0, api_1.readRows)(cli.input, cli.read);
             const result = (0, api_1.dedupe)(rows, cli.by, {
                 keep: cli.keep,
@@ -123,7 +130,7 @@ async function runCommand(cli, logger) {
             return 0;
         }
         case "merge": {
-            (0, safety_1.assertDifferentFiles)(cli.input, cli.output);
+            assertSafeOutput(cli);
             const rows = await (0, api_1.readRows)(cli.input, cli.read);
             const result = (0, api_1.merge)(rows, cli.key, {
                 normalizer: cli.normalizer,

package/dist/config/check.js

@@ -10,6 +10,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const messages_1 = require("./messages");
 const schema_1 = require("./schema");
+const safety_1 = require("../io/safety");
 function pathText(parts) {
     return parts
         .filter((part) => typeof part === "string" || typeof part === "number")
@@ -74,6 +75,9 @@ function checkConfigText(text, folder) {
         };
     }
     const problems = missingFiles(result.data, folder);
+    const tables = (0, safety_1.tableProblem)(result.data);
+    if (tables !== null)
+        problems.push({ where: "destination.table", message: tables });
     return { ok: problems.length === 0, problems };
 }
 function checkConfigFile(configPath) {

package/dist/config/ioSchema.d.ts

@@ -7,6 +7,7 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     database: z.ZodOptional<z.ZodString>;
     table: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"mysql">;
+    ssl: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     host: z.ZodOptional<z.ZodString>;
     port: z.ZodOptional<z.ZodNumber>;
@@ -64,6 +65,42 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>], "type">;
 export declare const destinationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+    pendingTable: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"mysql">;
+    ssl: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+    pendingTable: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"postgres">;
+    ssl: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodOptional<z.ZodString>;
+    pendingTable: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"sqlserver">;
+    encrypt: z.ZodOptional<z.ZodBoolean>;
+    trustServerCertificate: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    pendingTable: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodString;
+    table: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"sheets">;
     spreadsheetId: z.ZodOptional<z.ZodString>;
     credentialsPath: z.ZodOptional<z.ZodString>;
@@ -73,6 +110,7 @@ export declare const destinationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     path: z.ZodString;
     delimiter: z.ZodOptional<z.ZodString>;
     bom: z.ZodOptional<z.ZodBoolean>;
+    escapeFormulas: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"json">;
     path: z.ZodString;

package/dist/config/ioSchema.js

@@ -17,6 +17,7 @@ exports.sourceSchema = zod_1.z.discriminatedUnion("type", [
     zod_1.z.object({
         type: zod_1.z.literal("mysql"),
         ...serverFields,
+        ssl: zod_1.z.boolean().optional(),
     }),
     zod_1.z.object({
         type: zod_1.z.literal("postgres"),
@@ -71,7 +72,35 @@ exports.sourceSchema = zod_1.z.discriminatedUnion("type", [
         options: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
     }),
 ]);
+const tableTargetFields = {
+    pendingTable: zod_1.z.string().trim().min(1).optional(),
+};
 exports.destinationSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("mysql"),
+        ...serverFields,
+        ...tableTargetFields,
+        ssl: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("postgres"),
+        ...serverFields,
+        ...tableTargetFields,
+        ssl: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("sqlserver"),
+        ...serverFields,
+        ...tableTargetFields,
+        encrypt: zod_1.z.boolean().optional(),
+        trustServerCertificate: zod_1.z.boolean().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("sqlite"),
+        path: zod_1.z.string(),
+        table: zod_1.z.string().trim().min(1),
+        ...tableTargetFields,
+    }),
     zod_1.z.object({
         type: zod_1.z.literal("sheets"),
         spreadsheetId: zod_1.z.string().optional(),
@@ -83,6 +112,7 @@ exports.destinationSchema = zod_1.z.discriminatedUnion("type", [
         path: zod_1.z.string(),
         delimiter: zod_1.z.string().min(1).optional(),
         bom: zod_1.z.boolean().optional(),
+        escapeFormulas: zod_1.z.boolean().optional(),
     }),
     zod_1.z.object({
         type: zod_1.z.literal("json"),

package/dist/config/load.js

@@ -15,10 +15,17 @@ function loadJsonConfig(filePath) {
     const parsedData = JSON.parse(content);
     return schema_1.etlConfigSchema.parse(parsedData);
 }
+function envPassword(prefix) {
+    const password = (0, env_1.getOptionalEnv)(`${prefix}_PASSWORD`);
+    if (password === undefined)
+        return undefined;
+    if ((0, env_1.getOptionalEnv)(`${prefix}_HOST`) === undefined) {
+        throw new Error(`Por segurança, a senha do .env (${prefix}_PASSWORD) só é usada quando o .env também diz qual é o servidor (${prefix}_HOST). Assim uma config não consegue mandar a sua senha pra outro endereço. Coloque ${prefix}_HOST=<endereço do servidor> no .env, do lado da senha.`);
+    }
+    return password;
+}
 function withDatabaseEnv(source) {
-    if (source?.type !== "mysql" &&
-        source?.type !== "postgres" &&
-        source?.type !== "sqlserver")
+    if (!isServer(source))
         return source;
     const port = (0, env_1.getOptionalEnv)("DB_PORT");
     return {
@@ -26,11 +33,30 @@ function withDatabaseEnv(source) {
         host: (0, env_1.getOptionalEnv)("DB_HOST") ?? source.host,
         port: port !== undefined ? Number(port) : source.port,
         user: (0, env_1.getOptionalEnv)("DB_USER") ?? source.user,
-        password: (0, env_1.getOptionalEnv)("DB_PASSWORD") ?? source.password,
+        password: envPassword("DB") ?? source.password,
         database: (0, env_1.getOptionalEnv)("DB_NAME") ?? source.database,
         table: (0, env_1.getOptionalEnv)("DB_TABLE") ?? source.table,
     };
 }
+function isServer(side) {
+    return (side?.type === "mysql" ||
+        side?.type === "postgres" ||
+        side?.type === "sqlserver");
+}
+function withDestinationDatabaseEnv(destination) {
+    if (!isServer(destination))
+        return destination;
+    const port = (0, env_1.getOptionalEnv)("DEST_DB_PORT");
+    return {
+        ...destination,
+        host: (0, env_1.getOptionalEnv)("DEST_DB_HOST") ?? destination.host,
+        port: port !== undefined ? Number(port) : destination.port,
+        user: (0, env_1.getOptionalEnv)("DEST_DB_USER") ?? destination.user,
+        password: envPassword("DEST_DB") ?? destination.password,
+        database: (0, env_1.getOptionalEnv)("DEST_DB_NAME") ?? destination.database,
+        table: (0, env_1.getOptionalEnv)("DEST_DB_TABLE") ?? destination.table,
+    };
+}
 function withSheetsEnv(destination) {
     if (destination?.type !== "sheets")
         return destination;
@@ -47,7 +73,7 @@ function withEnv(jsonConfig) {
     const finalConfig = {
         ...jsonConfig,
         source: withDatabaseEnv(jsonConfig.source),
-        destination: withSheetsEnv(jsonConfig.destination),
+        destination: withDestinationDatabaseEnv(withSheetsEnv(jsonConfig.destination)),
         tableName: (0, env_1.getOptionalEnv)("DB_TABLE") ?? jsonConfig.tableName,
         spreadsheetId: (0, env_1.getOptionalEnv)("GOOGLE_SPREADSHEET_ID") ?? jsonConfig.spreadsheetId,
         credentialsPath: (0, env_1.getOptionalEnv)("GOOGLE_SERVICE_ACCOUNT_KEY_PATH") ??
@@ -55,7 +81,9 @@ function withEnv(jsonConfig) {
         dbHost: (0, env_1.getOptionalEnv)("DB_HOST") ?? jsonConfig.dbHost,
         dbPort: dbPort !== undefined ? Number(dbPort) : jsonConfig.dbPort,
         dbUser: (0, env_1.getOptionalEnv)("DB_USER") ?? jsonConfig.dbUser,
-        dbPassword: (0, env_1.getOptionalEnv)("DB_PASSWORD") ?? jsonConfig.dbPassword,
+        dbPassword: jsonConfig.source === undefined
+            ? (envPassword("DB") ?? jsonConfig.dbPassword)
+            : jsonConfig.dbPassword,
         dbName: (0, env_1.getOptionalEnv)("DB_NAME") ?? jsonConfig.dbName,
     };
     return schema_1.etlConfigSchema.parse(finalConfig);

package/dist/config/schema.d.ts

@@ -8,6 +8,7 @@ export declare const etlConfigSchema: z.ZodObject<{
         database: z.ZodOptional<z.ZodString>;
         table: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"mysql">;
+        ssl: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, z.ZodObject<{
         host: z.ZodOptional<z.ZodString>;
         port: z.ZodOptional<z.ZodNumber>;
@@ -65,6 +66,42 @@ export declare const etlConfigSchema: z.ZodObject<{
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>], "type">>;
     destination: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        pendingTable: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"mysql">;
+        ssl: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        pendingTable: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"postgres">;
+        ssl: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+        table: z.ZodOptional<z.ZodString>;
+        pendingTable: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"sqlserver">;
+        encrypt: z.ZodOptional<z.ZodBoolean>;
+        trustServerCertificate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        pendingTable: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"sqlite">;
+        path: z.ZodString;
+        table: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"sheets">;
         spreadsheetId: z.ZodOptional<z.ZodString>;
         credentialsPath: z.ZodOptional<z.ZodString>;
@@ -74,6 +111,7 @@ export declare const etlConfigSchema: z.ZodObject<{
         path: z.ZodString;
         delimiter: z.ZodOptional<z.ZodString>;
         bom: z.ZodOptional<z.ZodBoolean>;
+        escapeFormulas: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"json">;
         path: z.ZodString;

package/dist/env.d.ts

@@ -1,2 +1 @@
-export declare function requireEnv(name: string): string;
 export declare function getOptionalEnv(name: string): string | undefined;

package/dist/env.js

@@ -1,15 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireEnv = requireEnv;
 exports.getOptionalEnv = getOptionalEnv;
-function requireEnv(name) {
-    const value = process.env[name];
-    if (!value) {
-        throw new Error(`Variável de ambiente ausente: ${name}`);
-    }
-    return value;
-}
 function getOptionalEnv(name) {
     return process.env[name];
 }
-;

package/dist/filters/combine.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CombineFilter = void 0;
+const cells_1 = require("../cells");
 class CombineFilter {
     combinations;
     constructor(combinations) {
@@ -31,24 +32,24 @@ class CombineFilter {
         for (const [column, value] of Object.entries(row)) {
             const into = anchorOf.get(column);
             if (into !== undefined)
-                result[into] = combined.get(into) ?? null;
+                (0, cells_1.setCell)(result, into, combined.get(into) ?? null);
             if (combined.has(column)) {
-                result[column] = combined.get(column) ?? null;
+                (0, cells_1.setCell)(result, column, combined.get(column) ?? null);
             }
             else if (!sourcesToRemove.has(column)) {
-                result[column] = value;
+                (0, cells_1.setCell)(result, column, value);
             }
         }
         for (const [into, value] of combined) {
-            if (!(into in result))
-                result[into] = value;
+            if (!(0, cells_1.hasCell)(result, into))
+                (0, cells_1.setCell)(result, into, value);
         }
         return result;
     }
     combine(row, { columns, separator = " " }) {
         const values = [];
         for (const column of columns) {
-            const raw = row[column];
+            const raw = (0, cells_1.cellOf)(row, column);
             const text = raw === null || raw === undefined ? "" : String(raw).trim();
             if (text === "")
                 return null;

package/dist/filters/dedupe.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DedupeFilter = void 0;
+const cells_1 = require("../cells");
 class DedupeFilter {
     column;
     strategy;
@@ -11,7 +12,7 @@ class DedupeFilter {
         this.normalizer = normalizer;
     }
     keyOf(row) {
-        const raw = row[this.column];
+        const raw = (0, cells_1.cellOf)(row, this.column);
         if (raw === null || raw === undefined)
             return undefined;
         if (!this.normalizer)