datera 0.1.0

package/dist/api/parse.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWith = parseWith;
+const messages_1 = require("../config/messages");
+function where(path) {
+    return path
+        .filter((part) => typeof part === "string" || typeof part === "number")
+        .join(".");
+}
+function parseWith(schema, value, label) {
+    const result = schema.safeParse(value);
+    if (result.success)
+        return result.data;
+    const problems = result.error.issues.map((issue) => {
+        const place = where(issue.path);
+        return `${place ? `${place}: ` : ""}${(0, messages_1.translateIssue)(issue)}`;
+    });
+    throw new Error(`${label} com problema: ${problems.join(" ")}`);
+}

package/dist/api/rows.d.ts

@@ -0,0 +1,23 @@
+import { DestinationConfig, SourceConfig } from "../config/ioSchema";
+import { Logger } from "../logger";
+import { TableRow } from "../types";
+import { ReadOptions, WriteOptions } from "./formats";
+export type Input = string | SourceConfig;
+export type Output = string | DestinationConfig;
+export interface ReadRowsOptions extends ReadOptions {
+    logger?: Logger | undefined;
+}
+export interface WriteRowsOptions extends WriteOptions {
+    pending?: TableRow[] | undefined;
+    pendingName?: string | undefined;
+    logger?: Logger | undefined;
+}
+export declare const DEFAULT_PENDING_NAME = "Pend\u00EAncias";
+export declare function readRows(input: Input, options?: ReadRowsOptions): Promise<TableRow[]>;
+export declare function writeRows(rows: TableRow[], output: Output, options?: WriteRowsOptions): Promise<void>;
+export interface ConvertOptions {
+    read?: ReadOptions | undefined;
+    write?: WriteOptions | undefined;
+    logger?: Logger | undefined;
+}
+export declare function convert(input: Input, output: Output, options?: ConvertOptions): Promise<number>;

package/dist/api/rows.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PENDING_NAME = void 0;
+exports.readRows = readRows;
+exports.writeRows = writeRows;
+exports.convert = convert;
+const ioSchema_1 = require("../config/ioSchema");
+const factory_1 = require("../io/factory");
+const normalizers_1 = require("../normalizers");
+const logger_1 = require("../logger");
+const formats_1 = require("./formats");
+const parse_1 = require("./parse");
+exports.DEFAULT_PENDING_NAME = "Pendências";
+function sourceOf(input, options) {
+    return typeof input === "string"
+        ? (0, formats_1.sourceFromPath)(input, options)
+        : (0, parse_1.parseWith)(ioSchema_1.sourceSchema, input, "A fonte");
+}
+function destinationOf(output, options) {
+    return typeof output === "string"
+        ? (0, formats_1.destinationFromPath)(output, options)
+        : (0, parse_1.parseWith)(ioSchema_1.destinationSchema, output, "O destino");
+}
+async function readRows(input, options = {}) {
+    (0, normalizers_1.registerBuiltinKeyNormalizers)();
+    const config = { mode: "raw", source: sourceOf(input, options) };
+    const source = (0, factory_1.createSource)(config, options.logger ?? logger_1.silentLogger);
+    try {
+        return await source.read();
+    }
+    finally {
+        await source.close?.();
+    }
+}
+async function writeRows(rows, output, options = {}) {
+    const config = {
+        mode: "raw",
+        destination: destinationOf(output, options),
+    };
+    const sink = (0, factory_1.createSink)(config, options.logger ?? logger_1.silentLogger);
+    await sink.write(rows);
+    if (options.pending !== undefined) {
+        await sink.write(options.pending, {
+            name: options.pendingName ?? exports.DEFAULT_PENDING_NAME,
+        });
+    }
+}
+async function convert(input, output, options = {}) {
+    const source = sourceOf(input, options.read ?? {});
+    const destination = destinationOf(output, options.write ?? {});
+    const config = { mode: "raw", source, destination };
+    const logger = options.logger ?? logger_1.silentLogger;
+    const reader = (0, factory_1.createSource)(config, logger);
+    const sink = (0, factory_1.createSink)(config, logger);
+    try {
+        const rows = await reader.read();
+        await sink.write(rows);
+        return rows.length;
+    }
+    finally {
+        await reader.close?.();
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,62 @@
+import { Command } from "commander";
+import { ReadOptions, WriteOptions } from "./api/formats";
+export type CliOptions = {
+    command: "run";
+    config: string;
+    mode?: string | undefined;
+    dryRun: boolean;
+    input?: string | undefined;
+    output?: string | undefined;
+} | {
+    command: "validate";
+    config: string;
+} | {
+    command: "init";
+    folder: string;
+    from?: string | undefined;
+    force: boolean;
+} | {
+    command: "convert";
+    input: string;
+    output: string;
+    read: ReadOptions;
+    write: WriteOptions;
+} | {
+    command: "dedupe";
+    input: string;
+    output: string;
+    by: string;
+    keep: "first" | "last";
+    normalizer?: string | undefined;
+    read: ReadOptions;
+    write: WriteOptions;
+} | {
+    command: "merge";
+    input: string;
+    output: string;
+    key: string;
+    normalizer?: string | undefined;
+    separator?: string | undefined;
+    overwrite: string[];
+    extraColumn: string[];
+    read: ReadOptions;
+    write: WriteOptions;
+} | {
+    command: "columns";
+    input: string;
+    read: ReadOptions;
+} | {
+    command: "preview";
+    input: string;
+    rows: number;
+    read: ReadOptions;
+} | {
+    command: "normalizers";
+} | {
+    command: "normalize";
+    name: string;
+    value: string;
+};
+export declare function dateraVersion(): string;
+export declare function buildProgram(onCommand: (options: CliOptions) => void): Command;
+export declare function parseCli(argv?: string[]): CliOptions;

package/dist/cli.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateraVersion = dateraVersion;
+exports.buildProgram = buildProgram;
+exports.parseCli = parseCli;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const DEFAULT_CONFIG = "./config.json";
+const DEFAULT_PREVIEW_ROWS = 10;
+function dateraVersion() {
+    const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, "..", "package.json"), "utf-8"));
+    return packageJson.version ?? "0.0.0";
+}
+function withReadFlags(command) {
+    return command
+        .option("--table <tabela>", "Tabela a ler, quando a entrada é SQLite.")
+        .option("--sheet <aba>", "Aba a ler, quando a entrada é Excel.")
+        .option("--records-path <caminho>", "Onde estão os registros no JSON ou XML (ex.: escola.alunos.aluno).")
+        .option("--delimiter <separador>", "Separador do CSV de entrada.")
+        .addOption(new commander_1.Option("--encoding <codificação>", "Codificação do CSV de entrada.").choices(["utf-8", "latin1"]));
+}
+function withWriteFlags(command) {
+    return command
+        .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.")
+        .option("--record <nome>", "Elemento de cada linha, quando a saída é XML.");
+}
+function readOptions(flags) {
+    return {
+        table: flags.table,
+        sheet: flags.sheet,
+        recordsPath: flags.recordsPath,
+        delimiter: flags.delimiter,
+        encoding: flags.encoding,
+    };
+}
+function writeOptions(flags) {
+    return {
+        sheet: flags.outputSheet,
+        delimiter: flags.outputDelimiter,
+        root: flags.root,
+        record: flags.record,
+    };
+}
+function list(value, previous = []) {
+    return [
+        ...previous,
+        ...value
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean),
+    ];
+}
+function positiveNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new commander_1.InvalidArgumentError("precisa ser um número inteiro maior que zero.");
+    }
+    return parsed;
+}
+const TITLES = {
+    "Usage:": "Uso:",
+    "Options:": "Opções:",
+    "Commands:": "Comandos:",
+    "Arguments:": "Argumentos:",
+};
+const ERRORS = [
+    [/^error: /, "erro: "],
+    [/missing required argument/, "faltou o argumento"],
+    [/required option (.+) not specified/, "faltou a opção $1"],
+    [/unknown command/, "comando desconhecido"],
+    [/unknown option/, "opção desconhecida"],
+    [/too many arguments/, "argumentos demais"],
+    [/Did you mean (.+)\?/, "Você quis dizer $1?"],
+    [/Allowed choices are/, "As opções aceitas são"],
+    [
+        /option '(.+)' argument '(.+)' is invalid\./,
+        "o valor '$2' da opção '$1' não vale:",
+    ],
+    [/is invalid\./, "não vale."],
+];
+function translateError(text) {
+    return ERRORS.reduce((current, [pattern, replacement]) => current.replace(pattern, replacement), text);
+}
+function buildProgram(onCommand) {
+    const program = new commander_1.Command();
+    program
+        .configureHelp({ styleTitle: (title) => TITLES[title] ?? title })
+        .configureOutput({
+        outputError: (text, write) => write(translateError(text)),
+    })
+        .name("datera")
+        .description("Limpa, junta, converte e organiza dados bagunçados de banco, planilha ou arquivo.")
+        .version(dateraVersion(), "-v, --version", "Mostra a versão.")
+        .helpOption("-h, --help", "Mostra essa ajuda.")
+        .helpCommand("help [comando]", "Mostra a ajuda de um comando.")
+        .showSuggestionAfterError();
+    program
+        .command("run", { isDefault: true })
+        .description("Roda uma config inteira: lê, aplica as regras e grava.")
+        .argument("[config]", "Caminho da config.")
+        .option("--config <caminho>", "Caminho da config (jeito antigo).")
+        .option("--mode <modo>", "Troca o modo da config (raw, dedupe ou merge).")
+        .option("--dry-run", "Roda tudo e mostra o resultado, sem gravar nada.")
+        .option("--input <arquivo>", "Lê desse arquivo em vez da fonte da config.")
+        .option("--output <arquivo>", "Grava nesse arquivo em vez do destino da config.")
+        .action((config, flags) => onCommand({
+        command: "run",
+        config: config ?? flags.config ?? DEFAULT_CONFIG,
+        mode: flags.mode,
+        dryRun: flags.dryRun ?? false,
+        input: flags.input,
+        output: flags.output,
+    }));
+    program
+        .command("validate")
+        .description("Confere a config e os arquivos que ela cita, sem ler dados.")
+        .argument("[config]", "Caminho da config.")
+        .action((config) => onCommand({
+        command: "validate",
+        config: config ?? DEFAULT_CONFIG,
+    }));
+    program
+        .command("init")
+        .description("Cria uma config.json pra começar.")
+        .argument("[pasta]", "Pasta onde criar a config.", ".")
+        .option("--from <arquivo>", "Já monta a config lendo desse arquivo.")
+        .option("--force", "Troca a config.json se ela já existir.")
+        .action((folder, flags) => onCommand({
+        command: "init",
+        folder,
+        from: flags.from,
+        force: flags.force ?? false,
+    }));
+    withWriteFlags(withReadFlags(program
+        .command("convert")
+        .description("Converte de um formato pra outro, sem mexer nos dados.")
+        .argument("<entrada>", "Arquivo de entrada.")
+        .argument("<saida>", "Arquivo de saída. O formato vem da extensão."))).action((input, output, flags) => onCommand({
+        command: "convert",
+        input,
+        output,
+        read: readOptions(flags),
+        write: writeOptions(flags),
+    }));
+    withWriteFlags(withReadFlags(program
+        .command("dedupe")
+        .description("Tira as linhas repetidas olhando uma coluna.")
+        .argument("<entrada>", "Arquivo de entrada.")
+        .argument("<saida>", "Arquivo de saída.")
+        .requiredOption("--by <coluna>", "Coluna que diz se a linha é repetida.")
+        .addOption(new commander_1.Option("--keep <qual>", "Qual linha manter.")
+        .choices(["first", "last"])
+        .default("first"))
+        .option("--normalizer <nome>", "Normalizador aplicado antes de comparar (ex.: lowercase)."))).action((input, output, flags) => onCommand({
+        command: "dedupe",
+        input,
+        output,
+        by: flags.by,
+        keep: flags.keep,
+        normalizer: flags.normalizer,
+        read: readOptions(flags),
+        write: writeOptions(flags),
+    }));
+    withWriteFlags(withReadFlags(program
+        .command("merge")
+        .description("Junta as linhas com a mesma chave sem perder informação.")
+        .argument("<entrada>", "Arquivo de entrada.")
+        .argument("<saida>", "Arquivo de saída.")
+        .requiredOption("--key <coluna>", "Coluna que identifica cada registro.")
+        .option("--normalizer <nome>", "Normalizador da chave (ex.: digitsOnly).")
+        .option("--separator <texto>", 'Separador quando junta valores diferentes (padrão " | ").')
+        .option("--overwrite <colunas>", "Colunas em que vale o último valor, separadas por vírgula.", list)
+        .option("--extra-column <colunas>", "Colunas em que cada valor diferente vira uma coluna nova.", list))).action((input, output, flags) => onCommand({
+        command: "merge",
+        input,
+        output,
+        key: flags.key,
+        normalizer: flags.normalizer,
+        separator: flags.separator,
+        overwrite: flags.overwrite ?? [],
+        extraColumn: flags.extraColumn ?? [],
+        read: readOptions(flags),
+        write: writeOptions(flags),
+    }));
+    withReadFlags(program
+        .command("columns")
+        .description("Mostra as colunas com quantas estão preenchidas, vazias e diferentes.")
+        .argument("<entrada>", "Arquivo de entrada.")).action((input, flags) => onCommand({ command: "columns", input, read: readOptions(flags) }));
+    withReadFlags(program
+        .command("preview")
+        .description("Mostra as primeiras linhas de um arquivo.")
+        .argument("<entrada>", "Arquivo de entrada.")
+        .option("-n, --rows <quantidade>", "Quantas linhas mostrar.", positiveNumber, DEFAULT_PREVIEW_ROWS)).action((input, flags) => onCommand({
+        command: "preview",
+        input,
+        rows: flags.rows,
+        read: readOptions(flags),
+    }));
+    program
+        .command("normalizers")
+        .description("Lista os normalizadores prontos.")
+        .action(() => onCommand({ command: "normalizers" }));
+    program
+        .command("normalize")
+        .description("Mostra como um normalizador transforma um valor.")
+        .argument("<nome>", "Nome do normalizador.")
+        .argument("<valor>", "Valor pra testar.")
+        .action((name, value) => onCommand({ command: "normalize", name, value }));
+    return program;
+}
+function parseCli(argv = process.argv) {
+    let result;
+    buildProgram((options) => {
+        result = options;
+    }).parse(argv);
+    if (!result)
+        throw new Error("Comando não reconhecido.");
+    return result;
+}

package/dist/commands.d.ts

@@ -0,0 +1,3 @@
+import { CliOptions } from "./cli";
+import { Logger } from "./logger";
+export declare function runCommand(cli: CliOptions, logger: Logger): Promise<number>;

package/dist/commands.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const config_1 = require("./config");
+const api_1 = require("./api");
+const safety_1 = require("./io/safety");
+const pipeline_1 = require("./pipeline");
+function plural(count, one, many) {
+    return `${count} ${count === 1 ? one : many}`;
+}
+async function runConfig(cli, logger) {
+    const configPath = path_1.default.resolve(cli.config);
+    if (!fs_1.default.existsSync(configPath)) {
+        throw new Error(`Não achei a config ${cli.config}. Se era pra ser um comando, veja a lista com "datera --help".`);
+    }
+    const folder = path_1.default.dirname(configPath);
+    const input = cli.input === undefined ? undefined : path_1.default.resolve(cli.input);
+    const output = cli.output === undefined ? undefined : path_1.default.resolve(cli.output);
+    dotenv_1.default.config({ path: path_1.default.join(folder, ".env"), quiet: true });
+    const raw = JSON.parse(fs_1.default.readFileSync(configPath, "utf-8"));
+    if (input)
+        raw.source = (0, api_1.sourceFromPath)(input);
+    if (output)
+        raw.destination = (0, api_1.destinationFromPath)(output);
+    process.chdir(folder);
+    const config = (0, config_1.parseConfig)(raw);
+    const report = await (0, pipeline_1.runEtl)(config, {
+        mode: cli.mode === undefined ? undefined : (0, pipeline_1.parseMode)(cli.mode),
+        dryRun: cli.dryRun,
+        logger,
+    });
+    if (report.dryRun && report.preview.length > 0) {
+        logger.info(`Primeiras ${report.preview.length} linhas do resultado:`);
+        console.table(report.preview);
+    }
+    logger.info("");
+    for (const line of (0, pipeline_1.formatReport)(report))
+        logger.info(line);
+    logger.info(report.written ? "ETL concluído com sucesso!" : "Teste concluído.");
+    return 0;
+}
+function relativeTo(folder, file) {
+    const relative = path_1.default.relative(folder, path_1.default.resolve(file));
+    if (path_1.default.isAbsolute(relative))
+        return relative;
+    const posix = relative.split(path_1.default.sep).join("/");
+    return posix.startsWith("..") ? posix : `./${posix}`;
+}
+function starterConfig(from) {
+    if (from === undefined) {
+        return {
+            source: { type: "csv", path: "./dados.csv" },
+            destination: {
+                type: "csv",
+                path: "./saida/resultado.csv",
+                delimiter: ";",
+            },
+            mode: "raw",
+        };
+    }
+    const format = (0, api_1.detectFormat)(from);
+    const extension = format === "sqlite" ? ".csv" : path_1.default.extname(from);
+    return {
+        source: (0, api_1.sourceFromPath)(from, { table: "NOME_DA_TABELA" }),
+        destination: (0, api_1.destinationFromPath)(`./saida/resultado${extension}`),
+        mode: "raw",
+    };
+}
+function init(cli, logger) {
+    const target = path_1.default.resolve(cli.folder, "config.json");
+    if (fs_1.default.existsSync(target) && !cli.force) {
+        logger.error(`Já existe uma config em ${target}. Use --force se quiser trocar.`);
+        return 1;
+    }
+    const from = cli.from === undefined
+        ? undefined
+        : relativeTo(path_1.default.dirname(target), cli.from);
+    fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+    fs_1.default.writeFileSync(target, JSON.stringify(starterConfig(from), null, 4) + "\n");
+    logger.info(`Config criada em ${target}.`);
+    logger.info('Confira com "datera validate", teste com "datera run --dry-run" e depois rode "datera run".');
+    return 0;
+}
+async function runCommand(cli, logger) {
+    switch (cli.command) {
+        case "run":
+            return runConfig(cli, logger);
+        case "validate": {
+            const check = (0, config_1.checkConfigFile)(cli.config);
+            for (const line of (0, config_1.formatCheck)(cli.config, check)) {
+                if (check.ok)
+                    logger.info(line);
+                else
+                    logger.error(line);
+            }
+            return check.ok ? 0 : 1;
+        }
+        case "init":
+            return init(cli, logger);
+        case "convert": {
+            const count = await (0, api_1.convert)(cli.input, cli.output, {
+                read: cli.read,
+                write: cli.write,
+            });
+            logger.info(`${plural(count, "linha convertida", "linhas convertidas")} de ${cli.input} pra ${cli.output}.`);
+            return 0;
+        }
+        case "dedupe": {
+            (0, safety_1.assertDifferentFiles)(cli.input, cli.output);
+            const rows = await (0, api_1.readRows)(cli.input, cli.read);
+            const result = (0, api_1.dedupe)(rows, cli.by, {
+                keep: cli.keep,
+                normalizer: cli.normalizer,
+            });
+            await (0, api_1.writeRows)(result, cli.output, cli.write);
+            logger.info(`${plural(rows.length, "linha lida", "linhas lidas")}, ${plural(rows.length - result.length, "repetida tirada", "repetidas tiradas")}, ${plural(result.length, "linha gravada", "linhas gravadas")} em ${cli.output}.`);
+            return 0;
+        }
+        case "merge": {
+            (0, safety_1.assertDifferentFiles)(cli.input, cli.output);
+            const rows = await (0, api_1.readRows)(cli.input, cli.read);
+            const result = (0, api_1.merge)(rows, cli.key, {
+                normalizer: cli.normalizer,
+                separator: cli.separator,
+                overwrite: cli.overwrite,
+                extraColumn: cli.extraColumn,
+            });
+            await (0, api_1.writeRows)(result, cli.output, cli.write);
+            logger.info(`${plural(rows.length, "linha lida", "linhas lidas")}, juntadas em ${plural(result.length, "registro", "registros")} gravados em ${cli.output}.`);
+            return 0;
+        }
+        case "columns": {
+            const rows = await (0, api_1.readRows)(cli.input, cli.read);
+            logger.info(`${cli.input}: ${plural(rows.length, "linha", "linhas")}.`);
+            console.table((0, api_1.describeColumns)(rows).map((column) => ({
+                coluna: column.name,
+                preenchidas: column.filled,
+                vazias: column.empty,
+                diferentes: column.distinct,
+                tipo: column.kind,
+                exemplos: column.examples.join(" · "),
+            })));
+            return 0;
+        }
+        case "preview": {
+            const rows = await (0, api_1.readRows)(cli.input, cli.read);
+            logger.info(`${cli.input}: ${plural(rows.length, "linha", "linhas")}. Mostrando ${Math.min(cli.rows, rows.length)}.`);
+            console.table(rows.slice(0, cli.rows));
+            return 0;
+        }
+        case "normalizers":
+            for (const name of (0, api_1.listNormalizers)())
+                logger.info(name);
+            return 0;
+        case "normalize": {
+            const key = (0, api_1.normalize)(cli.name, cli.value);
+            logger.info(key === null
+                ? `"${cli.value}" não vira chave nenhuma com ${cli.name} (a linha seria tratada como sem chave).`
+                : `"${cli.value}" → "${key}"`);
+            return 0;
+        }
+    }
+}

package/dist/config/check.d.ts

@@ -0,0 +1,11 @@
+export interface ConfigProblem {
+    where: string;
+    message: string;
+}
+export interface ConfigCheck {
+    ok: boolean;
+    problems: ConfigProblem[];
+}
+export declare function checkConfigText(text: string, folder: string): ConfigCheck;
+export declare function checkConfigFile(configPath: string): ConfigCheck;
+export declare function formatCheck(configPath: string, check: ConfigCheck): string[];

package/dist/config/check.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConfigText = checkConfigText;
+exports.checkConfigFile = checkConfigFile;
+exports.formatCheck = formatCheck;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const messages_1 = require("./messages");
+const schema_1 = require("./schema");
+function pathText(parts) {
+    return parts
+        .filter((part) => typeof part === "string" || typeof part === "number")
+        .map((part, index) => typeof part === "number"
+        ? `[${part}]`
+        : index === 0
+            ? part
+            : `.${part}`)
+        .join("");
+}
+function filePathOf(side) {
+    return typeof side === "object" &&
+        side !== null &&
+        "path" in side &&
+        typeof side.path === "string"
+        ? side.path
+        : undefined;
+}
+function missingFiles(config, folder) {
+    const files = [];
+    const sourcePath = filePathOf(config.source);
+    if (sourcePath)
+        files.push({ where: "source.path", file: sourcePath });
+    const credentials = (config.source?.type === "sheets"
+        ? config.source.credentialsPath
+        : undefined) ??
+        (config.destination?.type === "sheets"
+            ? config.destination.credentialsPath
+            : undefined) ??
+        config.credentialsPath;
+    if (credentials)
+        files.push({ where: "credentialsPath", file: credentials });
+    (config.normalizerModules ?? []).forEach((file, index) => files.push({ where: `normalizerModules[${index}]`, file }));
+    (config.adapterModules ?? []).forEach((file, index) => files.push({ where: `adapterModules[${index}]`, file }));
+    return files
+        .filter(({ file }) => !fs_1.default.existsSync(path_1.default.resolve(folder, file)))
+        .map(({ where, file }) => ({
+        where,
+        message: `Arquivo não encontrado: ${file}`,
+    }));
+}
+function checkConfigText(text, folder) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            problems: [{ where: "", message: `JSON inválido: ${reason}` }],
+        };
+    }
+    const result = schema_1.etlConfigSchema.safeParse(value);
+    if (!result.success) {
+        return {
+            ok: false,
+            problems: result.error.issues.map((issue) => ({
+                where: pathText(issue.path),
+                message: (0, messages_1.translateIssue)(issue),
+            })),
+        };
+    }
+    const problems = missingFiles(result.data, folder);
+    return { ok: problems.length === 0, problems };
+}
+function checkConfigFile(configPath) {
+    const resolved = path_1.default.resolve(configPath);
+    if (!fs_1.default.existsSync(resolved)) {
+        return {
+            ok: false,
+            problems: [
+                { where: "", message: `Arquivo não encontrado: ${configPath}` },
+            ],
+        };
+    }
+    return checkConfigText(fs_1.default.readFileSync(resolved, "utf-8"), path_1.default.dirname(resolved));
+}
+function formatCheck(configPath, check) {
+    if (check.ok)
+        return [`${configPath}: configuração válida.`];
+    const count = check.problems.length;
+    return [
+        `${configPath}: ${count} ${count === 1 ? "problema" : "problemas"}.`,
+        ...check.problems.map(({ where, message }) => where ? `  ${where}: ${message}` : `  ${message}`),
+    ];
+}