datera 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -10,6 +10,15 @@ Os números seguem o [versionamento semântico](https://semver.org/lang/pt-BR/):
 
 ## [Não lançado]
 
+## [0.3.0] - 2026-09-30
+
+### Adicionado
+
+- converter vários arquivos de uma vez: `datera convert "matriculas/*.xlsx" --to csv --out-dir convertidos`, aceitando pasta, `*` no nome e lista de arquivos, e o `convertMany` na API (com `findFiles` e `planOutputs`)
+- ler todas as abas de um Excel ou de uma planilha do Google de uma vez (`"allSheets": true`, `--all-sheets`), com uma coluna dizendo de qual aba veio cada linha. Com `--to`, cada aba vira um arquivo. Na API, o `readSheets` devolve aba por aba. No app, a opção **Ler todas as abas** no passo a passo, e no Datera Dev, os trechos na paleta
+- alinhar colunas com nomes diferentes (`E-mail`, `email`, `Email`) com `"alignColumns": true`, e dizer na mão que uma coluna é outra com `rename`. No terminal, `--align-columns` e `--rename "Email do aluno=email"`, e o `datera columns` avisa quando tem colunas parecidas. Na API, o `alignColumns`, o `findSimilarColumns` e a opção nas regras do `clean` e no `readRows`, `convert` e `convertMany`. No Datera Dev, o trecho na paleta
+- `datera run regras.json --input "matriculas/*.xlsx" --out-dir limpos` aplica as mesmas regras em cada arquivo, cada um com o seu resultado
+
 ## [0.2.1] - 2026-09-30
 
 ### Corrigido

package/README.md

@@ -82,6 +82,7 @@ Hoje ele consegue:
 - 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
+- converter uma pasta inteira de uma vez, ou aplicar as mesmas regras em cada planilha do mês
 - 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
 

package/dist/api/clean.d.ts

@@ -2,10 +2,15 @@ import { z } from "zod";
 import { etlConfigSchema } from "../config";
 import { mergeColumnSchema } from "../config/mergeSchema";
 import { combineColumnsSchema, fillEmptySchema } from "../config/prepareSchema";
+import { AlignOptions } from "../filters/align";
 import { validationSchema } from "../config/validationSchema";
 import { PendingReason, StepReport } from "../pipeline";
 import { TableRow } from "../types";
 export declare const rulesSchema: z.ZodObject<{
+    alignColumns: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        auto: z.ZodOptional<z.ZodBoolean>;
+        rename: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>;
     fillEmpty: z.ZodOptional<z.ZodArray<z.ZodObject<{
         column: z.ZodString;
         fallbackColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -114,6 +119,8 @@ type Validation = z.input<typeof validationSchema>;
 type ValidationRule = Validation["rules"][number];
 type MergeColumn = z.input<typeof mergeColumnSchema>;
 export declare function fillEmpty(rows: TableRow[], rules: FillEmptyRule[]): TableRow[];
+export declare function alignColumns(rows: TableRow[], options?: AlignOptions): TableRow[];
+export declare function findSimilarColumns(rows: TableRow[]): string[][];
 export declare function combineColumns(rows: TableRow[], rules: CombineRule[]): TableRow[];
 export declare function validate(rows: TableRow[], rules: ValidationRule[] | Validation): {
     valid: TableRow[];

package/dist/api/clean.js

@@ -5,6 +5,8 @@ exports.defineConfig = defineConfig;
 exports.defineRules = defineRules;
 exports.clean = clean;
 exports.fillEmpty = fillEmpty;
+exports.alignColumns = alignColumns;
+exports.findSimilarColumns = findSimilarColumns;
 exports.combineColumns = combineColumns;
 exports.validate = validate;
 exports.dedupe = dedupe;
@@ -13,12 +15,14 @@ exports.merge = merge;
 const zod_1 = require("zod");
 const mergeSchema_1 = require("../config/mergeSchema");
 const prepareSchema_1 = require("../config/prepareSchema");
+const align_1 = require("../filters/align");
 const validationSchema_1 = require("../config/validationSchema");
 const normalizers_1 = require("../normalizers");
 const pipeline_1 = require("../pipeline");
 const parse_1 = require("./parse");
 exports.rulesSchema = zod_1.z
     .object({
+    alignColumns: prepareSchema_1.alignColumnsSchema.optional(),
     fillEmpty: zod_1.z.array(prepareSchema_1.fillEmptySchema).optional(),
     combineColumns: zod_1.z.array(prepareSchema_1.combineColumnsSchema).optional(),
     validation: validationSchema_1.validationSchema.optional(),
@@ -53,6 +57,7 @@ function configOf(rules) {
     const mode = rules.merge ? "merge" : rules.dedupe ? "dedupe" : "raw";
     const config = {
         mode,
+        alignColumns: rules.alignColumns,
         fillEmpty: rules.fillEmpty,
         combineColumns: rules.combineColumns,
         validation: rules.validation,
@@ -84,6 +89,17 @@ function clean(rows, rules = {}, options = {}) {
 function fillEmpty(rows, rules) {
     return clean(rows, { fillEmpty: rules }).rows;
 }
+function alignColumns(rows, options = {}) {
+    return clean(rows, { alignColumns: options }).rows;
+}
+function findSimilarColumns(rows) {
+    const names = new Set();
+    for (const row of rows) {
+        for (const name of Object.keys(row))
+            names.add(name);
+    }
+    return (0, align_1.similarColumns)([...names]);
+}
 function combineColumns(rows, rules) {
     return clean(rows, { combineColumns: rules }).rows;
 }

package/dist/api/files.d.ts

@@ -0,0 +1,10 @@
+export interface PlannedFile {
+    input: string;
+    output: string;
+    sheet?: string | undefined;
+}
+export declare function findFiles(inputs: string | string[]): string[];
+export declare function extensionFor(target: string): string;
+export declare function checkPlan(plan: PlannedFile[]): PlannedFile[];
+export declare function planOutputs(files: string[], target: string, outDir?: string): PlannedFile[];
+export declare function planSheetOutputs(input: string, sheets: string[], target: string, outDir?: string): PlannedFile[];

package/dist/api/files.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFiles = findFiles;
+exports.extensionFor = extensionFor;
+exports.checkPlan = checkPlan;
+exports.planOutputs = planOutputs;
+exports.planSheetOutputs = planSheetOutputs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const safety_1 = require("../io/safety");
+const formats_1 = require("./formats");
+const TARGETS = {
+    csv: ".csv",
+    tsv: ".tsv",
+    json: ".json",
+    xml: ".xml",
+    xlsx: ".xlsx",
+    excel: ".xlsx",
+    parquet: ".parquet",
+    db: ".db",
+    sqlite: ".db",
+    sqlite3: ".sqlite3",
+};
+function hasWildcard(text) {
+    return /[*?]/.test(text);
+}
+function patternToRegExp(pattern) {
+    const source = pattern
+        .split("")
+        .map((char) => {
+        if (char === "*")
+            return ".*";
+        if (char === "?")
+            return ".";
+        return char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    })
+        .join("");
+    const flags = process.platform === "win32" ? "i" : "";
+    return new RegExp(`^${source}$`, flags);
+}
+function isKnownFormat(file) {
+    try {
+        (0, formats_1.detectFormat)(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function filesIn(folder, accept) {
+    if (!fs_1.default.existsSync(folder) || !fs_1.default.statSync(folder).isDirectory()) {
+        throw new Error(`Não achei a pasta ${folder}.`);
+    }
+    return fs_1.default
+        .readdirSync(folder, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && !entry.name.startsWith("."))
+        .map((entry) => entry.name)
+        .filter((name) => accept(name) && isKnownFormat(name))
+        .map((name) => path_1.default.join(folder, name));
+}
+function expand(input) {
+    if (hasWildcard(input)) {
+        const folder = path_1.default.dirname(input);
+        if (hasWildcard(folder)) {
+            throw new Error(`Em "${input}", o * só pode estar no nome do arquivo, não no nome da pasta.`);
+        }
+        const pattern = patternToRegExp(path_1.default.basename(input));
+        return filesIn(folder, (name) => pattern.test(name));
+    }
+    if (fs_1.default.existsSync(input) && fs_1.default.statSync(input).isDirectory()) {
+        return filesIn(input, () => true);
+    }
+    if (!fs_1.default.existsSync(input)) {
+        throw new Error(`Não achei o arquivo ${input}.`);
+    }
+    return [input];
+}
+function findFiles(inputs) {
+    const list = Array.isArray(inputs) ? inputs : [inputs];
+    const found = [];
+    for (const input of list) {
+        for (const file of expand(input)) {
+            if (!found.some((other) => (0, safety_1.isSameFile)(other, file))) {
+                found.push(file);
+            }
+        }
+    }
+    if (found.length === 0) {
+        throw new Error(`Nenhum arquivo encontrado em ${list.join(", ")}. Confira o caminho e a extensão.`);
+    }
+    return found.sort((a, b) => a.localeCompare(b, "pt-BR", { numeric: true }));
+}
+function extensionFor(target) {
+    const key = target.trim().toLowerCase().replace(/^\./, "");
+    if (!Object.hasOwn(TARGETS, key)) {
+        throw new Error(`Não conheço o formato "${target}". Os que dá pra usar: ${Object.keys(TARGETS).join(", ")}.`);
+    }
+    return TARGETS[key];
+}
+function fileSafe(name) {
+    const clean = name
+        .replace(/[\\/:*?"<>|\u0000-\u001f]/g, "_")
+        .trim()
+        .replace(/[. ]+$/, "");
+    if (clean === "")
+        return "aba";
+    return /^(con|prn|aux|nul|com\d|lpt\d)$/i.test(clean) ? `_${clean}` : clean;
+}
+function checkPlan(plan) {
+    const label = (item) => item.sheet === undefined
+        ? item.input
+        : `a aba "${item.sheet}" de ${item.input}`;
+    plan.forEach((item, index) => {
+        const twin = plan.find((other, otherIndex) => otherIndex < index && (0, safety_1.isSameFile)(other.output, item.output));
+        if (twin) {
+            throw new Error(`${label(twin)} e ${label(item)} iam virar o mesmo arquivo (${item.output}). Renomeie um deles ou converta em pastas separadas.`);
+        }
+        const overwritten = plan.find((other) => (0, safety_1.isSameFile)(other.input, item.output));
+        if (overwritten) {
+            throw new Error(`Converter ${label(item)} ia gravar por cima de ${overwritten.input}, que é uma das entradas. Escolha outro formato ou use --out-dir com outra pasta.`);
+        }
+    });
+    return plan;
+}
+function outputPath(input, extension, outDir, suffix = "") {
+    return path_1.default.join(outDir ?? path_1.default.dirname(input), `${path_1.default.basename(input, path_1.default.extname(input))}${suffix}${extension}`);
+}
+function planOutputs(files, target, outDir) {
+    const extension = extensionFor(target);
+    return checkPlan(files.map((input) => ({
+        input,
+        output: outputPath(input, extension, outDir),
+    })));
+}
+function planSheetOutputs(input, sheets, target, outDir) {
+    const extension = extensionFor(target);
+    return sheets.map((sheet) => ({
+        input,
+        sheet,
+        output: outputPath(input, extension, outDir, `-${fileSafe(sheet)}`),
+    }));
+}

package/dist/api/formats.d.ts

@@ -1,8 +1,12 @@
 import { DestinationConfig, SourceConfig } from "../config/ioSchema";
+import { AlignOptions } from "../filters/align";
 export type FileFormat = "csv" | "json" | "xml" | "excel" | "parquet" | "sqlite";
 export interface ReadOptions {
     table?: string | undefined;
     sheet?: string | undefined;
+    allSheets?: boolean | undefined;
+    sheetColumn?: string | undefined;
+    alignColumns?: boolean | AlignOptions | undefined;
     recordsPath?: string | undefined;
     delimiter?: string | undefined;
     encoding?: "utf-8" | "latin1" | undefined;

package/dist/api/formats.js

@@ -61,7 +61,11 @@ function sourceFromPath(filePath, options = {}) {
             return defined({
                 type: "excel",
                 path: filePath,
-                sheet: options.sheet,
+                sheet: options.allSheets ? undefined : options.sheet,
+                allSheets: options.allSheets || undefined,
+                sheetColumn: options.allSheets
+                    ? options.sheetColumn
+                    : undefined,
             });
         case "parquet":
             return { type: "parquet", path: filePath };

package/dist/api/index.d.ts

@@ -1,8 +1,13 @@
 export { detectFormat, sourceFromPath, destinationFromPath } from "./formats";
 export type { FileFormat, ReadOptions, WriteOptions } from "./formats";
-export { readRows, writeRows, convert, DEFAULT_PENDING_NAME } from "./rows";
-export type { Input, Output, ReadRowsOptions, WriteRowsOptions, ConvertOptions, } from "./rows";
-export { clean, fillEmpty, combineColumns, validate, dedupe, merge, mergeColumnsFor, defineConfig, defineRules, rulesSchema, } from "./clean";
+export { readRows, writeRows, convert, convertMany, readSheets, DEFAULT_PENDING_NAME, } from "./rows";
+export { findFiles, planOutputs, planSheetOutputs, extensionFor, } from "./files";
+export { DEFAULT_SHEET_COLUMN } from "../io/tabs";
+export type { SheetRows } from "../io/tabs";
+export type { PlannedFile } from "./files";
+export type { Input, Output, ReadRowsOptions, WriteRowsOptions, ConvertOptions, ConvertManyOptions, ConvertedFile, } from "./rows";
+export { clean, alignColumns, findSimilarColumns, fillEmpty, combineColumns, validate, dedupe, merge, mergeColumnsFor, defineConfig, defineRules, rulesSchema, } from "./clean";
 export type { Rules, ConfigInput, CleanOptions, CleanResult, DedupeOptions, MergeOptions, } from "./clean";
 export { describeColumns, listNormalizers, normalize } from "./inspect";
 export type { ColumnInfo, ColumnKind } from "./inspect";
+export type { AlignOptions } from "../filters/align";

package/dist/api/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize = exports.listNormalizers = exports.describeColumns = exports.rulesSchema = exports.defineRules = exports.defineConfig = exports.mergeColumnsFor = exports.merge = exports.dedupe = exports.validate = exports.combineColumns = exports.fillEmpty = exports.clean = exports.DEFAULT_PENDING_NAME = exports.convert = exports.writeRows = exports.readRows = exports.destinationFromPath = exports.sourceFromPath = exports.detectFormat = void 0;
+exports.normalize = exports.listNormalizers = exports.describeColumns = exports.rulesSchema = exports.defineRules = exports.defineConfig = exports.mergeColumnsFor = exports.merge = exports.dedupe = exports.validate = exports.combineColumns = exports.fillEmpty = exports.findSimilarColumns = exports.alignColumns = exports.clean = exports.DEFAULT_SHEET_COLUMN = exports.extensionFor = exports.planSheetOutputs = exports.planOutputs = exports.findFiles = exports.DEFAULT_PENDING_NAME = exports.readSheets = exports.convertMany = exports.convert = exports.writeRows = exports.readRows = exports.destinationFromPath = exports.sourceFromPath = exports.detectFormat = void 0;
 var formats_1 = require("./formats");
 Object.defineProperty(exports, "detectFormat", { enumerable: true, get: function () { return formats_1.detectFormat; } });
 Object.defineProperty(exports, "sourceFromPath", { enumerable: true, get: function () { return formats_1.sourceFromPath; } });
@@ -9,9 +9,20 @@ var rows_1 = require("./rows");
 Object.defineProperty(exports, "readRows", { enumerable: true, get: function () { return rows_1.readRows; } });
 Object.defineProperty(exports, "writeRows", { enumerable: true, get: function () { return rows_1.writeRows; } });
 Object.defineProperty(exports, "convert", { enumerable: true, get: function () { return rows_1.convert; } });
+Object.defineProperty(exports, "convertMany", { enumerable: true, get: function () { return rows_1.convertMany; } });
+Object.defineProperty(exports, "readSheets", { enumerable: true, get: function () { return rows_1.readSheets; } });
 Object.defineProperty(exports, "DEFAULT_PENDING_NAME", { enumerable: true, get: function () { return rows_1.DEFAULT_PENDING_NAME; } });
+var files_1 = require("./files");
+Object.defineProperty(exports, "findFiles", { enumerable: true, get: function () { return files_1.findFiles; } });
+Object.defineProperty(exports, "planOutputs", { enumerable: true, get: function () { return files_1.planOutputs; } });
+Object.defineProperty(exports, "planSheetOutputs", { enumerable: true, get: function () { return files_1.planSheetOutputs; } });
+Object.defineProperty(exports, "extensionFor", { enumerable: true, get: function () { return files_1.extensionFor; } });
+var tabs_1 = require("../io/tabs");
+Object.defineProperty(exports, "DEFAULT_SHEET_COLUMN", { enumerable: true, get: function () { return tabs_1.DEFAULT_SHEET_COLUMN; } });
 var clean_1 = require("./clean");
 Object.defineProperty(exports, "clean", { enumerable: true, get: function () { return clean_1.clean; } });
+Object.defineProperty(exports, "alignColumns", { enumerable: true, get: function () { return clean_1.alignColumns; } });
+Object.defineProperty(exports, "findSimilarColumns", { enumerable: true, get: function () { return clean_1.findSimilarColumns; } });
 Object.defineProperty(exports, "fillEmpty", { enumerable: true, get: function () { return clean_1.fillEmpty; } });
 Object.defineProperty(exports, "combineColumns", { enumerable: true, get: function () { return clean_1.combineColumns; } });
 Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return clean_1.validate; } });

package/dist/api/rows.d.ts

@@ -2,6 +2,7 @@ import { DestinationConfig, SourceConfig } from "../config/ioSchema";
 import { Logger } from "../logger";
 import { TableRow } from "../types";
 import { ReadOptions, WriteOptions } from "./formats";
+import { SheetRows } from "../io/tabs";
 export type Input = string | SourceConfig;
 export type Output = string | DestinationConfig;
 export interface ReadRowsOptions extends ReadOptions {
@@ -21,3 +22,15 @@ export interface ConvertOptions {
     logger?: Logger | undefined;
 }
 export declare function convert(input: Input, output: Output, options?: ConvertOptions): Promise<number>;
+export declare function readSheets(input: Input, options?: ReadRowsOptions): Promise<SheetRows[]>;
+export interface ConvertManyOptions extends ConvertOptions {
+    to: string;
+    outDir?: string | undefined;
+}
+export interface ConvertedFile {
+    input: string;
+    output: string;
+    rows: number;
+    sheet?: string | undefined;
+}
+export declare function convertMany(inputs: string | string[], options: ConvertManyOptions): Promise<ConvertedFile[]>;

package/dist/api/rows.js

@@ -4,12 +4,21 @@ exports.DEFAULT_PENDING_NAME = void 0;
 exports.readRows = readRows;
 exports.writeRows = writeRows;
 exports.convert = convert;
+exports.readSheets = readSheets;
+exports.convertMany = convertMany;
 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");
+const files_1 = require("./files");
+const formats_2 = require("./formats");
+const align_1 = require("../filters/align");
+function aligned(rows, options) {
+    const align = (0, align_1.alignOptionsOf)(options.alignColumns);
+    return align ? (0, align_1.alignRows)(rows, align) : rows;
+}
 exports.DEFAULT_PENDING_NAME = "Pendências";
 function sourceOf(input, options) {
     return typeof input === "string"
@@ -26,7 +35,7 @@ async function readRows(input, options = {}) {
     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();
+        return aligned(await source.read(), options);
     }
     finally {
         await source.close?.();
@@ -53,7 +62,7 @@ async function convert(input, output, options = {}) {
     const reader = (0, factory_1.createSource)(config, logger);
     const sink = (0, factory_1.createSink)(config, logger);
     try {
-        const rows = await reader.read();
+        const rows = aligned(await reader.read(), options.read ?? {});
         await sink.write(rows);
         return rows.length;
     }
@@ -61,3 +70,74 @@ async function convert(input, output, options = {}) {
         await reader.close?.();
     }
 }
+async function readSheets(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 {
+        if (!source.readTabs) {
+            throw new Error("Só dá pra ler aba por aba de um arquivo Excel ou de uma planilha do Google.");
+        }
+        return (await source.readTabs()).map((tab) => ({
+            sheet: tab.sheet,
+            rows: aligned(tab.rows, options),
+        }));
+    }
+    finally {
+        await source.close?.();
+    }
+}
+async function convertMany(inputs, options) {
+    const files = (0, files_1.findFiles)(inputs);
+    const byTab = options.read?.allSheets === true;
+    if (!byTab) {
+        return convertPlan((0, files_1.planOutputs)(files, options.to, options.outDir), options, new Map());
+    }
+    (0, files_1.extensionFor)(options.to);
+    const tabs = new Map();
+    const plan = [];
+    for (const file of files) {
+        if ((0, formats_2.detectFormat)(file) !== "excel") {
+            plan.push(...(0, files_1.planOutputs)([file], options.to, options.outDir));
+            continue;
+        }
+        const sheets = await readSheets(file, {
+            ...options.read,
+            logger: options.logger,
+        });
+        const planned = (0, files_1.planSheetOutputs)(file, sheets.map((tab) => tab.sheet), options.to, options.outDir);
+        planned.forEach((item, index) => tabs.set(item.output, sheets[index]));
+        plan.push(...planned);
+    }
+    return convertPlan((0, files_1.checkPlan)(plan), options, tabs);
+}
+async function convertPlan(plan, options, tabs) {
+    const read = { ...options.read, allSheets: undefined };
+    const results = [];
+    for (const { input, output, sheet } of plan) {
+        try {
+            const tab = tabs.get(output);
+            let rows;
+            if (tab) {
+                await writeRows(tab.rows, output, {
+                    ...options.write,
+                    logger: options.logger,
+                });
+                rows = tab.rows.length;
+            }
+            else {
+                rows = await convert(input, output, { ...options, read });
+            }
+            results.push({ input, output, rows, sheet });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            const done = results.length === 0
+                ? ""
+                : ` Os ${results.length} anteriores já foram convertidos.`;
+            const where = sheet === undefined ? input : `${input} (aba ${sheet})`;
+            throw new Error(`Parei em ${where}: ${reason}${done}`);
+        }
+    }
+    return results;
+}

package/dist/cli.d.ts

@@ -6,6 +6,8 @@ export type CliOptions = {
     mode?: string | undefined;
     dryRun: boolean;
     input?: string | undefined;
+    outDir?: string | undefined;
+    to?: string | undefined;
     output?: string | undefined;
 } | {
     command: "validate";
@@ -21,6 +23,13 @@ export type CliOptions = {
     output: string;
     read: ReadOptions;
     write: WriteOptions;
+} | {
+    command: "convert-many";
+    inputs: string[];
+    to: string;
+    outDir?: string | undefined;
+    read: ReadOptions;
+    write: WriteOptions;
 } | {
     command: "dedupe";
     input: string;
@@ -58,5 +67,28 @@ export type CliOptions = {
     value: string;
 };
 export declare function dateraVersion(): string;
+interface ReadFlags {
+    table?: string;
+    sheet?: string;
+    allSheets?: boolean;
+    sheetColumn?: string;
+    alignColumns?: boolean;
+    rename?: [string, string][];
+    recordsPath?: string;
+    delimiter?: string;
+    encoding?: "utf-8" | "latin1";
+}
+interface WriteFlags {
+    outputTable?: string;
+    outputSheet?: string;
+    outputDelimiter?: string;
+    root?: string;
+    record?: string;
+}
+export declare function convertRequest(files: string[], flags: ReadFlags & WriteFlags & {
+    to?: string;
+    outDir?: string;
+}): CliOptions;
 export declare function buildProgram(onCommand: (options: CliOptions) => void): Command;
 export declare function parseCli(argv?: string[]): CliOptions;
+export {};

package/dist/cli.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dateraVersion = dateraVersion;
+exports.convertRequest = convertRequest;
 exports.buildProgram = buildProgram;
 exports.parseCli = parseCli;
 const fs_1 = __importDefault(require("fs"));
@@ -19,6 +20,10 @@ 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("--all-sheets", 'Lê todas as abas do Excel, com uma coluna "aba" dizendo de onde veio cada linha. Com --to, cada aba vira um arquivo.')
+        .option("--sheet-column <nome>", 'Nome da coluna que guarda a aba, com --all-sheets (padrão: "aba").')
+        .option("--align-columns", "Junta as colunas que só mudam em maiúscula, acento ou espaço (E-mail, email, Email).")
+        .option("--rename <de=para>", 'Diz que uma coluna é outra (tipo --rename "Email do aluno=email"). Pode repetir.', renamePair)
         .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"]));
@@ -35,6 +40,16 @@ function readOptions(flags) {
     return {
         table: flags.table,
         sheet: flags.sheet,
+        allSheets: flags.allSheets,
+        sheetColumn: flags.sheetColumn,
+        alignColumns: flags.alignColumns || flags.rename
+            ? {
+                auto: flags.alignColumns ?? false,
+                ...(flags.rename
+                    ? { rename: Object.fromEntries(flags.rename) }
+                    : {}),
+            }
+            : undefined,
         recordsPath: flags.recordsPath,
         delimiter: flags.delimiter,
         encoding: flags.encoding,
@@ -49,6 +64,15 @@ function writeOptions(flags) {
         record: flags.record,
     };
 }
+function renamePair(value, previous = []) {
+    const index = value.indexOf("=");
+    const from = index < 0 ? "" : value.slice(0, index).trim();
+    const to = index < 0 ? "" : value.slice(index + 1).trim();
+    if (from === "" || to === "") {
+        throw new commander_1.InvalidArgumentError('use o formato "coluna antiga=coluna nova", tipo "Email do aluno=email".');
+    }
+    return [...previous, [from, to]];
+}
 function list(value, previous = []) {
     return [
         ...previous,
@@ -89,6 +113,36 @@ const ERRORS = [
 function translateError(text) {
     return ERRORS.reduce((current, [pattern, replacement]) => current.replace(pattern, replacement), text);
 }
+function convertRequest(files, flags) {
+    const read = readOptions(flags);
+    const write = writeOptions(flags);
+    if (flags.to !== undefined) {
+        return {
+            command: "convert-many",
+            inputs: files,
+            to: flags.to,
+            outDir: flags.outDir,
+            read,
+            write,
+        };
+    }
+    if (flags.outDir !== undefined) {
+        throw new Error("Com --out-dir, diga também o formato da saída com --to (tipo --to csv).");
+    }
+    if (files.length === 1) {
+        throw new Error('Faltou dizer a saída. Use "datera convert entrada.csv saida.xlsx" ou "datera convert entrada.csv --to xlsx".');
+    }
+    if (files.length > 2) {
+        throw new Error("Pra converter vários arquivos, use --to com o formato (e --out-dir se quiser outra pasta).");
+    }
+    return {
+        command: "convert",
+        input: files[0],
+        output: files[1],
+        read,
+        write,
+    };
+}
 function buildProgram(onCommand) {
     const program = new commander_1.Command();
     program
@@ -111,6 +165,8 @@ function buildProgram(onCommand) {
         .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.")
+        .option("--out-dir <pasta>", 'Com vários arquivos no --input (tipo "matriculas/*.xlsx"), grava um resultado pra cada um nessa pasta.')
+        .option("--to <formato>", "Formato de cada resultado quando são vários arquivos (csv, xlsx, json, xml, parquet ou db).")
         .action((config, flags) => onCommand({
         command: "run",
         config: config ?? flags.config ?? DEFAULT_CONFIG,
@@ -118,6 +174,8 @@ function buildProgram(onCommand) {
         dryRun: flags.dryRun ?? false,
         input: flags.input,
         output: flags.output,
+        outDir: flags.outDir,
+        to: flags.to,
     }));
     program
         .command("validate")
@@ -141,15 +199,17 @@ function buildProgram(onCommand) {
     }));
     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),
-    }));
+        .description('Converte de um formato pra outro, sem mexer nos dados. Com --to, converte vários de uma vez (tipo "matriculas/*.xlsx").')
+        .argument("<arquivos...>", "A entrada e a saída, ou só as entradas quando usar --to. Aceita pasta e * no nome do arquivo.")
+        .option("--to <formato>", "Formato da saída de cada arquivo (csv, xlsx, json, xml, parquet ou db).")
+        .option("--out-dir <pasta>", "Pasta onde gravar os convertidos. Sem ela, ficam do lado de cada entrada."))).action((files, flags, command) => {
+        try {
+            onCommand(convertRequest(files, flags));
+        }
+        catch (error) {
+            command.error(`erro: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
     withWriteFlags(withReadFlags(program
         .command("dedupe")
         .description("Tira as linhas repetidas olhando uma coluna.")