datera 0.1.0 → 0.2.0

package/dist/io/sql/writer.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARK_PREFIX = exports.OLD_SUFFIX = exports.NEW_SUFFIX = exports.OWNED_TABLES = void 0;
+exports.newToken = newToken;
+exports.quoteName = quoteName;
+exports.tableParts = tableParts;
+exports.quoteTableName = quoteTableName;
+exports.nameRoom = nameRoom;
+exports.checkTableName = checkTableName;
+exports.checkColumns = checkColumns;
+exports.columnKind = columnKind;
+exports.writeTable = writeTable;
+const header_1 = require("../header");
+const cells_1 = require("../../cells");
+const crypto_1 = __importDefault(require("crypto"));
+exports.OWNED_TABLES = "datera_tabelas";
+exports.NEW_SUFFIX = "__datera_novo";
+exports.OLD_SUFFIX = "__datera_velho";
+exports.MARK_PREFIX = "datera:";
+function newToken() {
+    return `${exports.MARK_PREFIX}${crypto_1.default.randomUUID()}`;
+}
+function quoteName(dialect, name) {
+    const { open, close } = dialect;
+    return `${open}${name.split(close).join(close + close)}${close}`;
+}
+function tableParts(dialect, table) {
+    const trimmed = table.trim();
+    const parts = dialect.schemas
+        ? trimmed.split(".").map((part) => part.trim())
+        : [trimmed];
+    if (parts.length > 2 || parts.some((part) => part === "")) {
+        throw new Error(`Nome de tabela inválido: "${table}".`);
+    }
+    return parts;
+}
+function quoteTableName(dialect, table) {
+    return tableParts(dialect, table)
+        .map((part) => quoteName(dialect, part))
+        .join(".");
+}
+function nameRoom(dialect) {
+    return dialect.transactionalDdl ? 0 : exports.OLD_SUFFIX.length;
+}
+function checkName(dialect, name, what) {
+    if (/[\u0000-\u001f\u007f]/.test(name)) {
+        throw new Error(`${what} "${name.replace(/[\u0000-\u001f\u007f]/g, "?")}" tem um caractere invisível no nome (tipo quebra de linha ou tab). Tire ele antes de gravar no banco.`);
+    }
+    if (dialect.nameLength(name) > dialect.maxNameLength) {
+        throw new Error(`${what} "${name}" tem um nome comprido demais pro ${dialect.label}, que aceita até ${dialect.maxNameLength} caracteres. Use um nome mais curto.`);
+    }
+}
+function checkTableName(dialect, table, extra = 0) {
+    const parts = tableParts(dialect, table);
+    const last = parts[parts.length - 1];
+    if (dialect.nameLength(last) + extra > dialect.maxNameLength) {
+        throw new Error(`A tabela "${table}" tem um nome comprido demais pro ${dialect.label}. Use um nome de até ${dialect.maxNameLength - extra} caracteres.`);
+    }
+    for (const part of parts)
+        checkName(dialect, part, "A tabela");
+}
+function checkColumns(dialect, header) {
+    const seen = new Map();
+    for (const column of header) {
+        if (column.trim() === "") {
+            throw new Error("Tem uma coluna sem nome. Dê um nome pra ela antes de gravar no banco.");
+        }
+        checkName(dialect, column, "A coluna");
+        const key = column.toLowerCase();
+        const other = seen.get(key);
+        if (other !== undefined) {
+            throw new Error(`As colunas "${other}" e "${column}" só mudam nas maiúsculas, e o ${dialect.label} pode achar que são a mesma. Troque o nome de uma delas.`);
+        }
+        seen.set(key, column);
+    }
+}
+function columnKind(rows, column) {
+    let kind = null;
+    for (const row of rows) {
+        const value = (0, cells_1.cellOf)(row, column);
+        if (value === null || value === undefined || value === "")
+            continue;
+        if (typeof value !== "number")
+            return "text";
+        kind =
+            kind === "number" || !Number.isSafeInteger(value)
+                ? "number"
+                : "integer";
+    }
+    return kind ?? "text";
+}
+function valueFor(kind, value) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    if (typeof value === "number" && !Number.isFinite(value))
+        return null;
+    return kind === "text" ? String(value) : value;
+}
+function createTableSql(dialect, table, header, kinds, token) {
+    const columns = header.map((column, index) => `${quoteName(dialect, column)} ${dialect.types[kinds[index]]}`);
+    const mark = dialect.tableMark(token);
+    return `CREATE TABLE ${quoteTableName(dialect, table)} (${mark.inside}${columns.join(", ")})${dialect.tableSuffix}${mark.after}`;
+}
+async function insertRows(session, dialect, table, header, kinds, rows) {
+    const perInsert = Math.max(1, Math.min(dialect.maxRowsPerInsert, Math.floor(dialect.maxParams / header.length)));
+    const columns = header.map((column) => quoteName(dialect, column));
+    const target = quoteTableName(dialect, table);
+    for (let start = 0; start < rows.length; start += perInsert) {
+        const batch = rows.slice(start, start + perInsert);
+        const params = [];
+        const tuples = batch.map((row) => {
+            const marks = header.map((column, index) => {
+                params.push(valueFor(kinds[index], (0, cells_1.cellOf)(row, column)));
+                return dialect.param(params.length);
+            });
+            return `(${marks.join(", ")})`;
+        });
+        await session.run(`INSERT INTO ${target} (${columns.join(", ")}) VALUES ${tuples.join(", ")}`, params);
+    }
+}
+function ownedTablesName(dialect) {
+    return quoteName(dialect, exports.OWNED_TABLES);
+}
+async function ensureOwnedTables(session, dialect) {
+    if (await dialect.tableExists(session, exports.OWNED_TABLES)) {
+        if (dialect.ownsTable &&
+            !(await dialect.ownsTable(session, exports.OWNED_TABLES))) {
+            throw new Error(`A tabela "${exports.OWNED_TABLES}", onde o Datera anota as tabelas que ele criou, foi criada por outro usuário do ${dialect.label}. Por segurança, ele não confia nela. Use outro banco ou schema, ou peça pra quem cuida do banco apagar essa tabela.`);
+        }
+        return;
+    }
+    await session.run(`CREATE TABLE ${ownedTablesName(dialect)} (${quoteName(dialect, "tabela")} ${dialect.keyType} PRIMARY KEY, ${quoteName(dialect, "identificador")} ${dialect.types.text}, ${quoteName(dialect, "atualizada_em")} ${dialect.types.text})${dialect.tableSuffix}`);
+}
+async function isOwned(session, dialect, table) {
+    const found = await session.all(`SELECT ${quoteName(dialect, "identificador")} AS ${quoteName(dialect, "identificador")} FROM ${ownedTablesName(dialect)} WHERE ${quoteName(dialect, "tabela")} = ${dialect.param(1)}`, [table]);
+    const saved = found[0]?.identificador;
+    if (typeof saved !== "string" || saved === "")
+        return false;
+    const current = await dialect.tableId(session, table);
+    return current !== null && current === saved;
+}
+async function markOwned(session, dialect, table, id) {
+    await unmarkOwned(session, dialect, table);
+    await session.run(`INSERT INTO ${ownedTablesName(dialect)} (${quoteName(dialect, "tabela")}, ${quoteName(dialect, "identificador")}, ${quoteName(dialect, "atualizada_em")}) VALUES (${dialect.param(1)}, ${dialect.param(2)}, ${dialect.param(3)})`, [table, id, new Date().toISOString()]);
+}
+async function unmarkOwned(session, dialect, table) {
+    await session.run(`DELETE FROM ${ownedTablesName(dialect)} WHERE ${quoteName(dialect, "tabela")} = ${dialect.param(1)}`, [table]);
+}
+async function markCurrent(session, dialect, table) {
+    const id = await dialect.tableId(session, table);
+    if (id === null) {
+        throw new Error(`Não consegui confirmar que a tabela "${table}" foi criada no ${dialect.label}.`);
+    }
+    await markOwned(session, dialect, table, id);
+}
+function notOwned(dialect, table) {
+    return new Error(`A tabela "${table}" já existe no ${dialect.label} e não foi o Datera que criou (ou foi apagada e criada de novo por outra pessoa). Pra não apagar nada seu, ele só grava em tabela nova ou em tabela que ele mesmo criou antes. Escolha outro nome.`);
+}
+async function inTransaction(session, work) {
+    await session.begin();
+    try {
+        await work();
+        await session.commit();
+    }
+    catch (error) {
+        await session.rollback().catch(() => undefined);
+        throw error;
+    }
+}
+async function replaceInTransaction(session, dialect, table, rows, header, kinds) {
+    let created = true;
+    await inTransaction(session, async () => {
+        await ensureOwnedTables(session, dialect);
+        const exists = await dialect.tableExists(session, table);
+        if (exists && !(await isOwned(session, dialect, table))) {
+            throw notOwned(dialect, table);
+        }
+        if (header.length === 0) {
+            created = exists;
+            if (exists) {
+                await session.run(`DELETE FROM ${quoteTableName(dialect, table)}`);
+            }
+            return;
+        }
+        if (exists) {
+            await session.run(`DROP TABLE ${quoteTableName(dialect, table)}`);
+        }
+        await session.run(createTableSql(dialect, table, header, kinds, newToken()));
+        await insertRows(session, dialect, table, header, kinds, rows);
+        await markCurrent(session, dialect, table);
+    });
+    return created;
+}
+async function dropOwned(session, dialect, table) {
+    if (!(await dialect.tableExists(session, table)))
+        return;
+    if (!(await isOwned(session, dialect, table))) {
+        throw notOwned(dialect, table);
+    }
+    await session.run(`DROP TABLE ${quoteTableName(dialect, table)}`);
+    await inTransaction(session, () => unmarkOwned(session, dialect, table));
+}
+async function replaceBySwap(session, dialect, table, rows, header, kinds) {
+    checkTableName(dialect, table, nameRoom(dialect));
+    await ensureOwnedTables(session, dialect);
+    const exists = await dialect.tableExists(session, table);
+    if (exists && !(await isOwned(session, dialect, table))) {
+        throw notOwned(dialect, table);
+    }
+    if (header.length === 0) {
+        if (!exists)
+            return false;
+        await inTransaction(session, async () => {
+            await session.run(`DELETE FROM ${quoteTableName(dialect, table)}`);
+        });
+        return true;
+    }
+    const fresh = `${table}${exports.NEW_SUFFIX}`;
+    const old = `${table}${exports.OLD_SUFFIX}`;
+    await dropOwned(session, dialect, fresh);
+    await dropOwned(session, dialect, old);
+    const token = newToken();
+    await inTransaction(session, () => markOwned(session, dialect, fresh, token));
+    try {
+        await session.run(createTableSql(dialect, fresh, header, kinds, token));
+        const oldId = exists ? await dialect.tableId(session, table) : null;
+        await inTransaction(session, async () => {
+            await insertRows(session, dialect, fresh, header, kinds, rows);
+            if (oldId !== null)
+                await markOwned(session, dialect, old, oldId);
+        });
+        const target = quoteTableName(dialect, table);
+        const freshName = quoteTableName(dialect, fresh);
+        await session.run(exists
+            ? `RENAME TABLE ${target} TO ${quoteTableName(dialect, old)}, ${freshName} TO ${target}`
+            : `RENAME TABLE ${freshName} TO ${target}`);
+    }
+    catch (error) {
+        await dropOwned(session, dialect, fresh).catch(() => undefined);
+        throw error;
+    }
+    await inTransaction(session, async () => {
+        await unmarkOwned(session, dialect, fresh);
+        await markOwned(session, dialect, table, token);
+    });
+    await dropOwned(session, dialect, old);
+    return true;
+}
+async function writeTable(session, dialect, table, rows, logger) {
+    const name = table.trim();
+    checkTableName(dialect, name);
+    const header = (0, header_1.buildHeader)(rows);
+    checkColumns(dialect, header);
+    const kinds = header.map((column) => columnKind(rows, column));
+    const created = dialect.transactionalDdl
+        ? await replaceInTransaction(session, dialect, name, rows, header, kinds)
+        : await replaceBySwap(session, dialect, name, rows, header, kinds);
+    logger.info(created
+        ? `${rows.length} ${rows.length === 1 ? "linha gravada" : "linhas gravadas"} na tabela "${name}" (${dialect.label}).`
+        : `Nenhuma linha pra tabela "${name}" (${dialect.label}), então ela não foi criada.`);
+}

package/dist/io/sqlite/sqlite.d.ts

@@ -0,0 +1,3 @@
+type SqliteModule = typeof import("node:sqlite");
+export declare function loadSqlite(): SqliteModule;
+export {};

package/dist/io/sqlite/sqlite.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSqlite = loadSqlite;
+function loadSqlite() {
+    try {
+        return require("node:sqlite");
+    }
+    catch {
+        throw new Error("Essa versão do Node não sabe usar SQLite. Atualize pro Node 22.13 ou mais novo.");
+    }
+}

package/dist/io/sqlite/sqliteSink.d.ts

@@ -0,0 +1,17 @@
+import type { DatabaseSync } from "node:sqlite";
+import { TableRow } from "../../types";
+import { Sink, SinkWriteOptions } from "../types";
+import { Logger } from "../../logger";
+import { SqlDialect, SqlSession } from "../sql/writer";
+import { TableTarget } from "../sql/target";
+export interface SqliteSinkOptions extends TableTarget {
+    path: string;
+}
+export declare const SQLITE_DIALECT: SqlDialect;
+export declare function sqliteSession(database: DatabaseSync): SqlSession;
+export declare class SqliteSink implements Sink {
+    private readonly options;
+    private readonly logger;
+    constructor(options: SqliteSinkOptions, logger?: Logger);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/sqlite/sqliteSink.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSink = exports.SQLITE_DIALECT = void 0;
+exports.sqliteSession = sqliteSession;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../../logger");
+const writer_1 = require("../sql/writer");
+const target_1 = require("../sql/target");
+const sqlite_1 = require("./sqlite");
+exports.SQLITE_DIALECT = {
+    label: "SQLite",
+    open: '"',
+    close: '"',
+    schemas: false,
+    maxNameLength: 1000,
+    nameLength: (name) => name.length,
+    maxParams: 999,
+    maxRowsPerInsert: 500,
+    transactionalDdl: true,
+    types: { integer: "INTEGER", number: "REAL", text: "TEXT" },
+    keyType: "TEXT",
+    tableSuffix: "",
+    param: () => "?",
+    tableMark: (token) => ({ inside: `/* ${token} */ `, after: "" }),
+    tableId: async (session, table) => {
+        const [found] = await session.all("SELECT sql FROM sqlite_master WHERE type = 'table' AND lower(name) = lower(?)", [table.trim()]);
+        const sql = typeof found?.sql === "string" ? found.sql : "";
+        return sql.match(/\/\* (datera:[0-9a-f-]+) \*\//)?.[1] ?? null;
+    },
+    tableExists: async (session, table) => (await session.all("SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND lower(name) = lower(?)", [table.trim()])).length > 0,
+};
+function sqliteSession(database) {
+    const params = (values = []) => values;
+    return {
+        run: async (sql, values) => {
+            database.prepare(sql).run(...params(values));
+        },
+        all: async (sql, values) => database.prepare(sql).all(...params(values)),
+        begin: async () => database.exec("BEGIN IMMEDIATE"),
+        commit: async () => database.exec("COMMIT"),
+        rollback: async () => database.exec("ROLLBACK"),
+    };
+}
+class SqliteSink {
+    options;
+    logger;
+    constructor(options, logger = logger_1.consoleLogger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    async write(rows, options = {}) {
+        const folder = path_1.default.dirname(this.options.path);
+        if (folder)
+            fs_1.default.mkdirSync(folder, { recursive: true });
+        const { DatabaseSync } = (0, sqlite_1.loadSqlite)();
+        const database = new DatabaseSync(this.options.path);
+        try {
+            await (0, writer_1.writeTable)(sqliteSession(database), exports.SQLITE_DIALECT, (0, target_1.tableFor)(this.options, options), rows, this.logger);
+        }
+        finally {
+            database.close();
+        }
+    }
+}
+exports.SqliteSink = SqliteSink;

package/dist/io/sqlite/sqliteSource.js

@@ -7,14 +7,7 @@ exports.SqliteSource = void 0;
 const fs_1 = __importDefault(require("fs"));
 const names_1 = require("../sql/names");
 const cell_1 = require("../sql/cell");
-function loadSqlite() {
-    try {
-        return require("node:sqlite");
-    }
-    catch {
-        throw new Error("Essa versão do Node não sabe ler SQLite. Atualize pro Node 22.13 ou mais novo.");
-    }
-}
+const sqlite_1 = require("./sqlite");
 class SqliteSource {
     options;
     constructor(options) {
@@ -24,7 +17,7 @@ class SqliteSource {
         if (!fs_1.default.existsSync(this.options.path)) {
             throw new Error(`Arquivo não encontrado: ${this.options.path}`);
         }
-        const { DatabaseSync } = loadSqlite();
+        const { DatabaseSync } = (0, sqlite_1.loadSqlite)();
         const database = new DatabaseSync(this.options.path, {
             readOnly: true,
         });

package/dist/io/sqlserver/sqlServerSink.d.ts

@@ -0,0 +1,20 @@
+import { TableRow } from "../../types";
+import { Sink, SinkWriteOptions } from "../types";
+import { Logger } from "../../logger";
+import { SqlDialect, SqlSession } from "../sql/writer";
+import { TableTarget } from "../sql/target";
+import { SqlServerConnection } from "./sqlServerSource";
+export declare const SQLSERVER_DIALECT: SqlDialect;
+export interface SqlServerSession extends SqlSession {
+    close(): Promise<void>;
+}
+export type SqlServerSessionFactory = (connection: SqlServerConnection) => Promise<SqlServerSession>;
+export declare const createSqlServerSession: SqlServerSessionFactory;
+export declare class SqlServerSink implements Sink {
+    private readonly connection;
+    private readonly target;
+    private readonly logger;
+    private readonly createSession;
+    constructor(connection: SqlServerConnection, target: TableTarget, logger?: Logger, createSession?: SqlServerSessionFactory);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/sqlserver/sqlServerSink.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlServerSink = exports.createSqlServerSession = exports.SQLSERVER_DIALECT = void 0;
+const logger_1 = require("../../logger");
+const optional_1 = require("../optional");
+const writer_1 = require("../sql/writer");
+const target_1 = require("../sql/target");
+exports.SQLSERVER_DIALECT = {
+    label: "SQL Server",
+    open: "[",
+    close: "]",
+    schemas: true,
+    maxNameLength: 128,
+    nameLength: (name) => name.length,
+    maxParams: 2000,
+    maxRowsPerInsert: 1000,
+    transactionalDdl: true,
+    types: { integer: "BIGINT", number: "FLOAT", text: "NVARCHAR(MAX)" },
+    keyType: "NVARCHAR(450) COLLATE Latin1_General_BIN2",
+    tableSuffix: "",
+    param: (index) => `@p${index}`,
+    tableMark: () => ({ inside: "", after: "" }),
+    tableId: async (session, table) => {
+        const [found] = await session.all("SELECT CAST(OBJECT_ID(@p1, 'U') AS NVARCHAR(20)) AS id", [(0, writer_1.quoteTableName)(exports.SQLSERVER_DIALECT, table)]);
+        return typeof found?.id === "string" ? found.id : null;
+    },
+    tableExists: async (session, table) => {
+        const [found] = await session.all("SELECT OBJECT_ID(@p1) AS id", [
+            (0, writer_1.quoteTableName)(exports.SQLSERVER_DIALECT, table),
+        ]);
+        return found?.id !== null && found?.id !== undefined;
+    },
+};
+function typeOf(mssql, value) {
+    if (typeof value === "number") {
+        return Number.isSafeInteger(value) ? mssql.BigInt : mssql.Float;
+    }
+    return mssql.NVarChar(mssql.MAX);
+}
+const createSqlServerSession = async (connection) => {
+    const mssql = (0, optional_1.requireOptional)(() => require("mssql"), ["mssql"], "SQL Server");
+    const pool = new mssql.ConnectionPool({
+        server: connection.host,
+        port: connection.port,
+        user: connection.user,
+        ...(connection.password !== undefined
+            ? { password: connection.password }
+            : {}),
+        database: connection.database,
+        options: {
+            encrypt: connection.encrypt ?? true,
+            trustServerCertificate: connection.trustServerCertificate ?? false,
+        },
+    });
+    await pool.connect();
+    let transaction;
+    const request = (sql, values = []) => {
+        const next = new mssql.Request(transaction ?? pool);
+        values.forEach((value, index) => next.input(`p${index + 1}`, typeOf(mssql, value), value));
+        return next.query(sql);
+    };
+    return {
+        run: async (sql, values) => {
+            await request(sql, values);
+        },
+        all: async (sql, values) => (await request(sql, values)).recordset ?? [],
+        begin: async () => {
+            transaction = new mssql.Transaction(pool);
+            await transaction.begin();
+        },
+        commit: async () => {
+            await transaction?.commit();
+            transaction = undefined;
+        },
+        rollback: async () => {
+            const current = transaction;
+            transaction = undefined;
+            await current?.rollback();
+        },
+        close: async () => {
+            await pool.close();
+        },
+    };
+};
+exports.createSqlServerSession = createSqlServerSession;
+class SqlServerSink {
+    connection;
+    target;
+    logger;
+    createSession;
+    constructor(connection, target, logger = logger_1.consoleLogger, createSession = exports.createSqlServerSession) {
+        this.connection = connection;
+        this.target = target;
+        this.logger = logger;
+        this.createSession = createSession;
+    }
+    async write(rows, options = {}) {
+        const session = await this.createSession(this.connection);
+        try {
+            await (0, writer_1.writeTable)(session, exports.SQLSERVER_DIALECT, (0, target_1.tableFor)(this.target, options), rows, this.logger);
+        }
+        finally {
+            await session.close();
+        }
+    }
+}
+exports.SqlServerSink = SqlServerSink;

package/dist/io/xml/xmlParse.js

@@ -78,7 +78,9 @@ function decode(value, reader, at) {
     return value.replace(/&([^;&\s]*);?/g, (whole, entity) => {
         if (!whole.endsWith(";"))
             reader.fail("Tem um & solto no texto", at);
-        const named = NAMED_ENTITIES[entity];
+        const named = Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, entity)
+            ? NAMED_ENTITIES[entity]
+            : undefined;
         if (named !== undefined)
             return named;
         const code = entity.startsWith("#x")
@@ -110,7 +112,7 @@ function readElement(reader) {
     reader.skip("<");
     const element = {
         name: reader.name(),
-        attributes: {},
+        attributes: Object.create(null),
         children: [],
         text: "",
     };

package/dist/io/xml/xmlSource.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.XmlSource = void 0;
 const files_1 = require("../files");
 const xmlParse_1 = require("./xmlParse");
+const cells_1 = require("../../cells");
 function join(prefix, name) {
     return prefix ? `${prefix}.${name}` : name;
 }
@@ -21,13 +22,13 @@ function groupByName(elements) {
 }
 function flatten(element, prefix, row) {
     for (const [name, value] of Object.entries(element.attributes)) {
-        row[join(prefix, name)] = value === "" ? null : value;
+        (0, cells_1.setCell)(row, join(prefix, name), value === "" ? null : value);
     }
     if (prefix && element.children.length === 0) {
         if (element.text !== "")
-            row[prefix] = element.text;
+            (0, cells_1.setCell)(row, prefix, element.text);
         else if (isSimple(element))
-            row[prefix] = null;
+            (0, cells_1.setCell)(row, prefix, null);
     }
     for (const [name, group] of groupByName(element.children)) {
         const key = join(prefix, name);
@@ -36,14 +37,14 @@ function flatten(element, prefix, row) {
             flatten(first, key, row);
         }
         else if (group.every(isSimple)) {
-            row[key] = group.map((item) => item.text).join(", ");
+            (0, cells_1.setCell)(row, key, group.map((item) => item.text).join(", "));
         }
         else {
-            row[key] = JSON.stringify(group.map((item) => {
+            (0, cells_1.setCell)(row, key, JSON.stringify(group.map((item) => {
                 const inner = {};
                 flatten(item, "", inner);
                 return inner;
-            }));
+            })));
         }
     }
 }

package/dist/pipeline/runEtl.js

@@ -10,11 +10,12 @@ const validate_1 = require("../filters/validate");
 const normalizers_1 = require("../normalizers");
 const logger_1 = require("../logger");
 const steps_1 = require("./steps");
+const cells_1 = require("../cells");
 exports.DEFAULT_PREVIEW_SIZE = 5;
 function countPendingReasons(pending, reasonColumn = validate_1.DEFAULT_REASON_COLUMN) {
     const counts = new Map();
     for (const row of pending) {
-        const text = row[reasonColumn];
+        const text = (0, cells_1.cellOf)(row, reasonColumn);
         if (text === null || text === undefined)
             continue;
         for (const part of String(text).split(";")) {

package/package.json

@@ -1,14 +1,15 @@
 {
     "name": "datera",
-    "version": "0.1.0",
-    "description": "Limpa, unifica e organiza dados bagunçados de bancos de dados, planilhas, CSV, JSON, XML e Parquet, e exporta pro Google Sheets, Excel, CSV, JSON, XML ou Parquet.",
+    "version": "0.2.0",
+    "description": "Limpa, unifica e organiza dados bagunçados de bancos de dados, planilhas, CSV, JSON, XML e Parquet, e grava em bancos de dados, Google Sheets, Excel, CSV, JSON, XML ou Parquet.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "bin": {
         "datera": "dist/main.js"
     },
     "files": [
-        "dist"
+        "dist",
+        "CHANGELOG.md"
     ],
     "workspaces": [
         "apps/*"
@@ -16,6 +17,7 @@
     "scripts": {
         "build": "tsc -p tsconfig.build.json",
         "prepublishOnly": "npm run build && npm test",
+        "release:prepare": "tsx scripts/prepareRelease.ts",
         "start": "tsx src/main.ts",
         "validate": "tsx src/main.ts validate",
         "example": "tsx src/main.ts --config examples/config.csv.json",
@@ -26,8 +28,9 @@
         "test": "vitest run",
         "test:watch": "vitest",
         "typecheck": "tsc --noEmit",
-        "test:connection": "tsx scripts/testConnection.ts",
-        "test:config": "tsx scripts/testConfig.ts",
+        "typecheck:telas": "tsc -p e2e",
+        "test:telas": "playwright test",
+        "test:telas:ver": "playwright test --headed --project=claro --workers=1",
         "test:sheet": "tsx scripts/testSheetFake.ts",
         "prepare": "husky"
     },
@@ -38,6 +41,7 @@
         "xml",
         "parquet",
         "sqlite",
+        "sqlserver",
         "postgres",
         "mysql",
         "dedupe",
@@ -61,6 +65,7 @@
         "@commitlint/cli": "^21.2.3",
         "@commitlint/config-conventional": "^21.2.3",
         "@googleapis/sheets": "^18.0.1",
+        "@playwright/test": "^1.63.0",
         "@types/node": "^22.20.3",
         "exceljs": "^4.4.0",
         "husky": "^9.1.7",