datera 0.2.1 → 0.3.0

package/dist/commands.js

@@ -21,21 +21,29 @@ function assertSafeOutput(cli) {
 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".`);
+function isBatch(cli) {
+    if (cli.outDir !== undefined || cli.to !== undefined)
+        return true;
+    if (cli.input === undefined)
+        return false;
+    return (/[*?]/.test(cli.input) ||
+        (fs_1.default.existsSync(cli.input) && fs_1.default.statSync(cli.input).isDirectory()));
+}
+function sameType(base, next) {
+    if (typeof base === "object" &&
+        base !== null &&
+        base.type === next.type) {
+        return { ...base, path: next.path };
     }
-    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);
+    return next;
+}
+function configTarget(raw) {
+    const destination = raw.destination;
+    return typeof destination?.path === "string"
+        ? path_1.default.extname(destination.path)
+        : undefined;
+}
+async function runOnce(raw, cli, logger) {
     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),
@@ -49,6 +57,53 @@ async function runConfig(cli, logger) {
     logger.info("");
     for (const line of (0, pipeline_1.formatReport)(report))
         logger.info(line);
+    return report;
+}
+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);
+    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 (isBatch(cli)) {
+        if (cli.input === undefined) {
+            throw new Error('Com --out-dir ou --to, diga os arquivos com --input (tipo --input "matriculas/*.xlsx").');
+        }
+        if (cli.output !== undefined) {
+            throw new Error("Com vários arquivos, use --out-dir em vez de --output, porque cada arquivo ganha o seu resultado.");
+        }
+        const target = cli.to ?? configTarget(raw);
+        if (target === undefined) {
+            throw new Error("O destino da config não é um arquivo, então diga o formato de cada resultado com --to (tipo --to xlsx).");
+        }
+        const plan = (0, api_1.planOutputs)((0, api_1.findFiles)(path_1.default.resolve(cli.input)), target, cli.outDir === undefined ? undefined : path_1.default.resolve(cli.outDir));
+        process.chdir(folder);
+        let rows = 0;
+        for (const [index, item] of plan.entries()) {
+            logger.info("");
+            logger.info(`Arquivo ${index + 1} de ${plan.length}: ${item.input}`);
+            const report = await runOnce({
+                ...raw,
+                source: sameType(raw.source, (0, api_1.sourceFromPath)(item.input, (raw.source ?? {}))),
+                destination: sameType(raw.destination, (0, api_1.destinationFromPath)(item.output, (raw.destination ?? {}))),
+            }, cli, logger);
+            rows += report.rowsOut;
+        }
+        logger.info("");
+        logger.info(`${plural(plan.length, "arquivo processado", "arquivos processados")}, ${plural(rows, "linha no resultado", "linhas no resultado")} ao todo.`);
+        logger.info(cli.dryRun ? "Teste concluído." : "ETL concluído com sucesso!");
+        return 0;
+    }
+    const input = cli.input === undefined ? undefined : path_1.default.resolve(cli.input);
+    const output = cli.output === undefined ? undefined : path_1.default.resolve(cli.output);
+    if (input)
+        raw.source = (0, api_1.sourceFromPath)(input);
+    if (output)
+        raw.destination = (0, api_1.destinationFromPath)(output);
+    process.chdir(folder);
+    const report = await runOnce(raw, cli, logger);
     logger.info(report.written ? "ETL concluído com sucesso!" : "Teste concluído.");
     return 0;
 }
@@ -118,6 +173,22 @@ async function runCommand(cli, logger) {
             logger.info(`${plural(count, "linha convertida", "linhas convertidas")} de ${cli.input} pra ${cli.output}.`);
             return 0;
         }
+        case "convert-many": {
+            const results = await (0, api_1.convertMany)(cli.inputs, {
+                to: cli.to,
+                outDir: cli.outDir,
+                read: cli.read,
+                write: cli.write,
+            });
+            for (const item of results) {
+                const from = item.sheet === undefined
+                    ? item.input
+                    : `${item.input} (aba ${item.sheet})`;
+                logger.info(`${from} → ${item.output} (${plural(item.rows, "linha", "linhas")})`);
+            }
+            logger.info(`${plural(results.length, "arquivo convertido", "arquivos convertidos")}.`);
+            return 0;
+        }
         case "dedupe": {
             assertSafeOutput(cli);
             const rows = await (0, api_1.readRows)(cli.input, cli.read);
@@ -145,6 +216,9 @@ async function runCommand(cli, logger) {
         case "columns": {
             const rows = await (0, api_1.readRows)(cli.input, cli.read);
             logger.info(`${cli.input}: ${plural(rows.length, "linha", "linhas")}.`);
+            for (const group of (0, api_1.findSimilarColumns)(rows)) {
+                logger.warn(`As colunas ${group.map((name) => `"${name}"`).join(", ")} parecem a mesma. Pra juntar, use --align-columns.`);
+            }
             console.table((0, api_1.describeColumns)(rows).map((column) => ({
                 coluna: column.name,
                 preenchidas: column.filled,

package/dist/config/ioSchema.d.ts

@@ -51,10 +51,14 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"parquet">;
     path: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
+    allSheets: z.ZodOptional<z.ZodBoolean>;
+    sheetColumn: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"excel">;
     path: z.ZodString;
     sheet: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
+    allSheets: z.ZodOptional<z.ZodBoolean>;
+    sheetColumn: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"sheets">;
     spreadsheetId: z.ZodString;
     credentialsPath: z.ZodOptional<z.ZodString>;

package/dist/config/ioSchema.js

@@ -13,6 +13,10 @@ const serverFields = {
     database: zod_1.z.string().optional(),
     table: zod_1.z.string().optional(),
 };
+const tabFields = {
+    allSheets: zod_1.z.boolean().optional(),
+    sheetColumn: zod_1.z.string().trim().min(1).optional(),
+};
 exports.sourceSchema = zod_1.z.discriminatedUnion("type", [
     zod_1.z.object({
         type: zod_1.z.literal("mysql"),
@@ -59,12 +63,14 @@ exports.sourceSchema = zod_1.z.discriminatedUnion("type", [
         type: zod_1.z.literal("excel"),
         path: zod_1.z.string(),
         sheet: zod_1.z.string().min(1).optional(),
+        ...tabFields,
     }),
     zod_1.z.object({
         type: zod_1.z.literal("sheets"),
         spreadsheetId: zod_1.z.string().min(1),
         credentialsPath: zod_1.z.string().optional(),
         sheet: zod_1.z.string().min(1).optional(),
+        ...tabFields,
     }),
     zod_1.z.object({
         type: zod_1.z.literal("custom"),

package/dist/config/prepareSchema.d.ts

@@ -4,6 +4,10 @@ export declare const fillEmptySchema: z.ZodObject<{
     fallbackColumns: z.ZodOptional<z.ZodArray<z.ZodString>>;
     default: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const alignColumnsSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    auto: z.ZodOptional<z.ZodBoolean>;
+    rename: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>]>;
 export declare const combineColumnsSchema: z.ZodObject<{
     into: z.ZodString;
     columns: z.ZodArray<z.ZodString>;

package/dist/config/prepareSchema.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.combineColumnsSchema = exports.fillEmptySchema = void 0;
+exports.combineColumnsSchema = exports.alignColumnsSchema = exports.fillEmptySchema = void 0;
 const zod_1 = require("zod");
 exports.fillEmptySchema = zod_1.z.object({
     column: zod_1.z.string(),
     fallbackColumns: zod_1.z.array(zod_1.z.string()).optional(),
     default: zod_1.z.string().optional(),
 });
+exports.alignColumnsSchema = zod_1.z.union([
+    zod_1.z.boolean(),
+    zod_1.z.object({
+        auto: zod_1.z.boolean().optional(),
+        rename: zod_1.z.record(zod_1.z.string(), zod_1.z.string().trim().min(1)).optional(),
+    }),
+]);
 exports.combineColumnsSchema = zod_1.z.object({
     into: zod_1.z.string(),
     columns: zod_1.z.array(zod_1.z.string()).min(1),

package/dist/config/schema.d.ts

@@ -52,10 +52,14 @@ export declare const etlConfigSchema: z.ZodObject<{
         type: z.ZodLiteral<"parquet">;
         path: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
+        allSheets: z.ZodOptional<z.ZodBoolean>;
+        sheetColumn: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"excel">;
         path: z.ZodString;
         sheet: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
+        allSheets: z.ZodOptional<z.ZodBoolean>;
+        sheetColumn: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"sheets">;
         spreadsheetId: z.ZodString;
         credentialsPath: z.ZodOptional<z.ZodString>;
@@ -192,6 +196,10 @@ export declare const etlConfigSchema: z.ZodObject<{
     mergeKeyNormalizer: z.ZodOptional<z.ZodString>;
     normalizerModules: z.ZodOptional<z.ZodArray<z.ZodString>>;
     adapterModules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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>>;

package/dist/config/schema.js

@@ -29,6 +29,7 @@ exports.etlConfigSchema = zod_1.z
     mergeKeyNormalizer: zod_1.z.string().optional(),
     normalizerModules: zod_1.z.array(zod_1.z.string()).optional(),
     adapterModules: zod_1.z.array(zod_1.z.string()).optional(),
+    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(),
@@ -36,6 +37,13 @@ exports.etlConfigSchema = zod_1.z
     .refine((config) => config.source !== undefined || config.tableName !== undefined, {
     message: 'Faltou dizer de onde ler: coloque "source" ou os campos antigos do MySQL.',
     path: ["source"],
+})
+    .refine((config) => !((config.source?.type === "excel" ||
+    config.source?.type === "sheets") &&
+    config.source.allSheets === true &&
+    config.source.sheet !== undefined), {
+    message: 'Use "sheet" pra ler uma aba só ou "allSheets": true pra ler todas, mas não os dois juntos.',
+    path: ["source", "allSheets"],
 })
     .refine((config) => config.destination !== undefined ||
     config.spreadsheetId !== undefined, {

package/dist/filters/align.d.ts

@@ -0,0 +1,11 @@
+import { TableRow } from "../types";
+export interface AlignOptions {
+    auto?: boolean | undefined;
+    rename?: Record<string, string> | undefined;
+}
+export declare const ALIGN_SEPARATOR = " | ";
+export declare function columnKey(name: string): string;
+export declare function columnMapping(names: string[], options?: AlignOptions): Map<string, string>;
+export declare function similarColumns(names: string[]): string[][];
+export declare function alignRows(rows: TableRow[], options?: AlignOptions): TableRow[];
+export declare function alignOptionsOf(value: boolean | AlignOptions | undefined): AlignOptions | undefined;

package/dist/filters/align.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALIGN_SEPARATOR = void 0;
+exports.columnKey = columnKey;
+exports.columnMapping = columnMapping;
+exports.similarColumns = similarColumns;
+exports.alignRows = alignRows;
+exports.alignOptionsOf = alignOptionsOf;
+const cells_1 = require("../cells");
+exports.ALIGN_SEPARATOR = " | ";
+function columnKey(name) {
+    const key = name
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, "");
+    return key === "" ? `=${name}` : key;
+}
+function columnNames(rows) {
+    const seen = new Set();
+    for (const row of rows) {
+        for (const name of Object.keys(row))
+            seen.add(name);
+    }
+    return [...seen];
+}
+function columnMapping(names, options = {}) {
+    const auto = options.auto ?? true;
+    const renameByKey = new Map();
+    for (const [from, to] of Object.entries(options.rename ?? {})) {
+        const target = to.trim();
+        const key = columnKey(from);
+        const other = renameByKey.get(key);
+        if (other !== undefined && other !== target) {
+            throw new Error(`A coluna "${from}" está no rename duas vezes, uma indo pra "${other}" e outra pra "${target}". Deixe só uma.`);
+        }
+        renameByKey.set(key, target);
+    }
+    const canonical = new Map();
+    for (const target of renameByKey.values()) {
+        const key = columnKey(target);
+        if (!canonical.has(key))
+            canonical.set(key, target);
+    }
+    const mapping = new Map();
+    for (const name of names) {
+        const renamed = renameByKey.get(columnKey(name));
+        if (renamed !== undefined) {
+            mapping.set(name, auto ? (canonical.get(columnKey(renamed)) ?? renamed) : renamed);
+            continue;
+        }
+        if (!auto) {
+            mapping.set(name, name);
+            continue;
+        }
+        const key = columnKey(name);
+        const first = canonical.get(key);
+        if (first === undefined)
+            canonical.set(key, name);
+        mapping.set(name, first ?? name);
+    }
+    return mapping;
+}
+function similarColumns(names) {
+    const groups = new Map();
+    for (const name of names) {
+        const key = columnKey(name);
+        groups.set(key, [...(groups.get(key) ?? []), name]);
+    }
+    return [...groups.values()].filter((group) => group.length > 1);
+}
+function isEmpty(value) {
+    return value === null || value === undefined || value === "";
+}
+function alignRows(rows, options = {}) {
+    const mapping = columnMapping(columnNames(rows), options);
+    if ([...mapping].every(([from, to]) => from === to))
+        return rows;
+    return rows.map((row) => {
+        const next = {};
+        for (const [name, value] of Object.entries(row)) {
+            const target = mapping.get(name) ?? name;
+            if (!(0, cells_1.hasCell)(next, target)) {
+                (0, cells_1.setCell)(next, target, value);
+                continue;
+            }
+            const current = (0, cells_1.cellOf)(next, target);
+            if (isEmpty(current)) {
+                (0, cells_1.setCell)(next, target, value);
+            }
+            else if (!isEmpty(value) && String(value) !== String(current)) {
+                (0, cells_1.setCell)(next, target, `${String(current)}${exports.ALIGN_SEPARATOR}${String(value)}`);
+            }
+        }
+        return next;
+    });
+}
+function alignOptionsOf(value) {
+    if (value === undefined || value === false)
+        return undefined;
+    return value === true ? {} : value;
+}

package/dist/io/excel/excelSource.d.ts

@@ -1,11 +1,13 @@
 import { TableRow } from "../../types";
 import { Source } from "../types";
-export interface ExcelSourceOptions {
+import { SheetRows, TabOptions } from "../tabs";
+export interface ExcelSourceOptions extends TabOptions {
     path: string;
     sheet?: string | undefined;
 }
 export declare class ExcelSource implements Source {
     private readonly options;
     constructor(options: ExcelSourceOptions);
+    readTabs(): Promise<SheetRows[]>;
     read(): Promise<TableRow[]>;
 }

package/dist/io/excel/excelSource.js

@@ -4,12 +4,51 @@ exports.ExcelSource = void 0;
 const workbook_1 = require("./workbook");
 const excelCell_1 = require("./excelCell");
 const cells_1 = require("../../cells");
+const tabs_1 = require("../tabs");
+function readWorksheet(worksheet) {
+    const header = new Map();
+    worksheet.getRow(1).eachCell((cell, column) => {
+        const name = (0, excelCell_1.fromExcelCell)(cell.value);
+        if (name !== null)
+            header.set(column, String(name).trim());
+    });
+    const rows = [];
+    worksheet.eachRow((excelRow, rowNumber) => {
+        if (rowNumber === 1)
+            return;
+        const row = {};
+        let hasValue = false;
+        for (const [column, name] of header) {
+            const value = (0, excelCell_1.fromExcelCell)(excelRow.getCell(column).value);
+            (0, cells_1.setCell)(row, name, value);
+            if (value !== null)
+                hasValue = true;
+        }
+        if (hasValue)
+            rows.push(row);
+    });
+    return rows;
+}
 class ExcelSource {
     options;
     constructor(options) {
         this.options = options;
     }
+    async readTabs() {
+        const workbook = await (0, workbook_1.openWorkbook)(this.options.path);
+        const visible = workbook.worksheets.filter((worksheet) => worksheet.state === undefined || worksheet.state === "visible");
+        if (visible.length === 0) {
+            throw new Error(`O arquivo ${this.options.path} não tem nenhuma aba visível.`);
+        }
+        return visible.map((worksheet) => ({
+            sheet: worksheet.name,
+            rows: readWorksheet(worksheet),
+        }));
+    }
     async read() {
+        if (this.options.allSheets) {
+            return (0, tabs_1.joinTabs)(await this.readTabs(), this.options.sheetColumn ?? tabs_1.DEFAULT_SHEET_COLUMN, this.options.path);
+        }
         const workbook = await (0, workbook_1.openWorkbook)(this.options.path);
         const sheetName = this.options.sheet;
         const worksheet = sheetName === undefined
@@ -21,28 +60,7 @@ class ExcelSource {
                 ? `O arquivo ${this.options.path} não tem nenhuma aba.`
                 : `Aba "${sheetName}" não encontrada em ${this.options.path}. Abas: ${names}`);
         }
-        const header = new Map();
-        worksheet.getRow(1).eachCell((cell, column) => {
-            const name = (0, excelCell_1.fromExcelCell)(cell.value);
-            if (name !== null)
-                header.set(column, String(name).trim());
-        });
-        const rows = [];
-        worksheet.eachRow((excelRow, rowNumber) => {
-            if (rowNumber === 1)
-                return;
-            const row = {};
-            let hasValue = false;
-            for (const [column, name] of header) {
-                const value = (0, excelCell_1.fromExcelCell)(excelRow.getCell(column).value);
-                (0, cells_1.setCell)(row, name, value);
-                if (value !== null)
-                    hasValue = true;
-            }
-            if (hasValue)
-                rows.push(row);
-        });
-        return rows;
+        return readWorksheet(worksheet);
     }
 }
 exports.ExcelSource = ExcelSource;

package/dist/io/factory.js

@@ -83,7 +83,10 @@ function createSource(config, logger = logger_1.consoleLogger) {
             return new excelSource_1.ExcelSource(source);
         case "sheets": {
             const credentialsPath = required(source.credentialsPath ?? config.credentialsPath, "o caminho das credenciais do Google");
-            return new sheetsSource_1.SheetsSource((0, client_1.createSheetsClient)(credentialsPath), source.spreadsheetId, source.sheet);
+            return new sheetsSource_1.SheetsSource((0, client_1.createSheetsClient)(credentialsPath), source.spreadsheetId, source.sheet, {
+                allSheets: source.allSheets,
+                sheetColumn: source.sheetColumn,
+            });
         }
         case "custom":
             return (0, registry_1.createCustomSource)(source.adapter, source.options ?? {}, logger);

package/dist/io/safety.js

@@ -32,6 +32,9 @@ function assertSheetsAreSafe(config) {
     const destinationId = destination.spreadsheetId ?? config.spreadsheetId;
     if (source.spreadsheetId !== destinationId)
         return;
+    if (source.allSheets) {
+        throw new Error("A fonte lê todas as abas, então o resultado precisa ir pra outra planilha. Senão ele leria também a aba do resultado.");
+    }
     if (source.sheet === undefined) {
         throw new Error('A fonte e o destino são a mesma planilha. Coloque "sheet" na fonte com o nome da aba dos dados originais, senão ele pode ler e apagar a mesma aba.');
     }

package/dist/io/sheets/client.d.ts

@@ -6,5 +6,6 @@ export interface WriteOptions {
     sheetName?: string | undefined;
     logger?: Logger | undefined;
 }
+export declare function visibleSheetTitles(sheets: sheets_v4.Sheets, spreadsheetId: string): Promise<string[]>;
 export declare function readSheet(sheets: sheets_v4.Sheets, spreadsheetId: string, sheetName?: string): Promise<unknown[][]>;
 export declare function writeData(sheets: sheets_v4.Sheets, spreadsheetId: string, data: TableRow[], options?: WriteOptions): Promise<void>;

package/dist/io/sheets/client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSheetsClient = createSheetsClient;
+exports.visibleSheetTitles = visibleSheetTitles;
 exports.readSheet = readSheet;
 exports.writeData = writeData;
 const optional_1 = require("../optional");
@@ -21,17 +22,22 @@ function quoteSheetTitle(title) {
 async function listSheets(sheets, spreadsheetId) {
     const response = await sheets.spreadsheets.get({
         spreadsheetId,
-        fields: "sheets.properties(sheetId,title)",
+        fields: "sheets.properties(sheetId,title,hidden)",
     });
     const found = [];
     for (const sheet of response.data.sheets ?? []) {
-        const { title, sheetId } = sheet.properties ?? {};
+        const { title, sheetId, hidden } = sheet.properties ?? {};
         if (title && sheetId !== null && sheetId !== undefined) {
-            found.push({ title, sheetId });
+            found.push({ title, sheetId, hidden: hidden === true });
         }
     }
     return found;
 }
+async function visibleSheetTitles(sheets, spreadsheetId) {
+    return (await listSheets(sheets, spreadsheetId))
+        .filter((sheet) => !sheet.hidden)
+        .map((sheet) => sheet.title);
+}
 async function resolveSheet(sheets, spreadsheetId, sheetName, logger = logger_1.consoleLogger) {
     const existing = await listSheets(sheets, spreadsheetId);
     const found = sheetName === undefined

package/dist/io/sheets/sheetsSource.d.ts

@@ -1,10 +1,13 @@
 import type { sheets_v4 } from "@googleapis/sheets";
 import { TableRow } from "../../types";
 import { Source } from "../types";
+import { SheetRows, TabOptions } from "../tabs";
 export declare class SheetsSource implements Source {
     private readonly sheets;
     private readonly spreadsheetId;
     private readonly sheet?;
-    constructor(sheets: sheets_v4.Sheets, spreadsheetId: string, sheet?: string | undefined);
+    private readonly tabs;
+    constructor(sheets: sheets_v4.Sheets, spreadsheetId: string, sheet?: string | undefined, tabs?: TabOptions);
+    readTabs(): Promise<SheetRows[]>;
     read(): Promise<TableRow[]>;
 }

package/dist/io/sheets/sheetsSource.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SheetsSource = void 0;
 const client_1 = require("./client");
 const cells_1 = require("../../cells");
+const tabs_1 = require("../tabs");
 function fromSheetCell(value) {
     if (value === null || value === undefined || value === "")
         return null;
@@ -10,39 +11,61 @@ function fromSheetCell(value) {
         return value;
     return String(value);
 }
+function rowsFrom(values) {
+    const [header, ...lines] = values;
+    if (!header)
+        return [];
+    const columns = header.map((cell) => {
+        const name = fromSheetCell(cell);
+        return name === null ? null : String(name).trim();
+    });
+    const rows = [];
+    for (const line of lines) {
+        const row = {};
+        let hasValue = false;
+        columns.forEach((column, index) => {
+            if (column === null)
+                return;
+            const value = fromSheetCell(line[index]);
+            (0, cells_1.setCell)(row, column, value);
+            if (value !== null)
+                hasValue = true;
+        });
+        if (hasValue)
+            rows.push(row);
+    }
+    return rows;
+}
 class SheetsSource {
     sheets;
     spreadsheetId;
     sheet;
-    constructor(sheets, spreadsheetId, sheet) {
+    tabs;
+    constructor(sheets, spreadsheetId, sheet, tabs = {}) {
         this.sheets = sheets;
         this.spreadsheetId = spreadsheetId;
         this.sheet = sheet;
+        this.tabs = tabs;
     }
-    async read() {
-        const [header, ...lines] = await (0, client_1.readSheet)(this.sheets, this.spreadsheetId, this.sheet);
-        if (!header)
-            return [];
-        const columns = header.map((cell) => {
-            const name = fromSheetCell(cell);
-            return name === null ? null : String(name).trim();
-        });
-        const rows = [];
-        for (const values of lines) {
-            const row = {};
-            let hasValue = false;
-            columns.forEach((column, index) => {
-                if (column === null)
-                    return;
-                const value = fromSheetCell(values[index]);
-                (0, cells_1.setCell)(row, column, value);
-                if (value !== null)
-                    hasValue = true;
+    async readTabs() {
+        const titles = await (0, client_1.visibleSheetTitles)(this.sheets, this.spreadsheetId);
+        if (titles.length === 0) {
+            throw new Error("A planilha não tem nenhuma aba visível pra ler.");
+        }
+        const tabs = [];
+        for (const title of titles) {
+            tabs.push({
+                sheet: title,
+                rows: rowsFrom(await (0, client_1.readSheet)(this.sheets, this.spreadsheetId, title)),
             });
-            if (hasValue)
-                rows.push(row);
         }
-        return rows;
+        return tabs;
+    }
+    async read() {
+        if (this.tabs.allSheets) {
+            return (0, tabs_1.joinTabs)(await this.readTabs(), this.tabs.sheetColumn ?? tabs_1.DEFAULT_SHEET_COLUMN, "a planilha do Google");
+        }
+        return rowsFrom(await (0, client_1.readSheet)(this.sheets, this.spreadsheetId, this.sheet));
     }
 }
 exports.SheetsSource = SheetsSource;

package/dist/io/tabs.d.ts

@@ -0,0 +1,11 @@
+import { TableRow } from "../types";
+export declare const DEFAULT_SHEET_COLUMN = "aba";
+export interface SheetRows {
+    sheet: string;
+    rows: TableRow[];
+}
+export interface TabOptions {
+    allSheets?: boolean | undefined;
+    sheetColumn?: string | undefined;
+}
+export declare function joinTabs(tabs: SheetRows[], column: string, where: string): TableRow[];