datera 0.1.0 → 0.2.1

package/dist/filters/fillEmpty.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FillEmptyFilter = void 0;
+const cells_1 = require("../cells");
 class FillEmptyFilter {
     rules;
     constructor(rules) {
@@ -10,16 +11,16 @@ class FillEmptyFilter {
         return rows.map((row) => {
             const result = { ...row };
             for (const { column, fallbackColumns = [], default: fallbackValue, } of this.rules) {
-                if (!this.isEmpty(row[column]))
+                if (!this.isEmpty((0, cells_1.cellOf)(row, column)))
                     continue;
                 const fromColumn = fallbackColumns
-                    .map((fallback) => row[fallback])
+                    .map((fallback) => (0, cells_1.cellOf)(row, fallback))
                     .find((value) => !this.isEmpty(value));
                 if (fromColumn !== undefined) {
-                    result[column] = fromColumn;
+                    (0, cells_1.setCell)(result, column, fromColumn);
                 }
                 else if (fallbackValue !== undefined) {
-                    result[column] = fallbackValue;
+                    (0, cells_1.setCell)(result, column, fallbackValue);
                 }
             }
             return result;

package/dist/filters/merge.js

@@ -4,6 +4,7 @@ exports.MergeFilter = void 0;
 const mergeStrategies_1 = require("./mergeStrategies");
 const mergeUnkeyed_1 = require("./mergeUnkeyed");
 const registry_1 = require("../normalizers/registry");
+const cells_1 = require("../cells");
 const identityNormalizer = (raw) => ({
     key: typeof raw === "string" ? raw.trim() : raw,
 });
@@ -30,7 +31,7 @@ class MergeFilter {
         const emptyKeyRows = [];
         const rejectedKeyRows = [];
         for (const row of rows) {
-            const rawKey = row[this.keyColumn];
+            const rawKey = (0, cells_1.cellOf)(row, this.keyColumn);
             if (rawKey === null ||
                 rawKey === undefined ||
                 (typeof rawKey === "string" && rawKey.trim() === "")) {
@@ -95,10 +96,10 @@ class MergeFilter {
             }
             switch (resolvedStrategy) {
                 case "overwrite":
-                    merged[target] = (0, mergeStrategies_1.mergeOverwrite)(group, column);
+                    (0, cells_1.setCell)(merged, target, (0, mergeStrategies_1.mergeOverwrite)(group, column));
                     break;
                 case "concat":
-                    merged[target] = (0, mergeStrategies_1.mergeConcat)(group, column, finalSeparator);
+                    (0, cells_1.setCell)(merged, target, (0, mergeStrategies_1.mergeConcat)(group, column, finalSeparator));
                     break;
                 case "extra-column":
                     (0, mergeStrategies_1.mergeExtraColumns)(group, column, merged, target);

package/dist/filters/mergeStrategies.js

@@ -7,16 +7,17 @@ exports.mergeConcat = mergeConcat;
 exports.mergeConcatDistributed = mergeConcatDistributed;
 exports.findFreeOverflowColumnName = findFreeOverflowColumnName;
 exports.mergeExtraColumns = mergeExtraColumns;
+const cells_1 = require("../cells");
 exports.DEFAULT_SEPARATOR = "; ";
 function presentValues(rows, column) {
     return rows
-        .map((row) => row[column])
+        .map((row) => (0, cells_1.cellOf)(row, column))
         .filter((v) => v !== null && v !== undefined && v !== "");
 }
 function mergeOverwrite(group, column) {
-    let result = group[0]?.[column] ?? null;
+    let result = (group[0] ? (0, cells_1.cellOf)(group[0], column) : null) ?? null;
     for (const row of group) {
-        const value = row[column];
+        const value = (0, cells_1.cellOf)(row, column);
         if (value !== null && value !== undefined) {
             result = value;
         }
@@ -32,18 +33,18 @@ function mergeConcatDistributed(group, column, merged, distribute, separator) {
     const sourceColumns = [column, ...sources];
     const uniqueValues = Array.from(new Set(group.flatMap((row) => sourceColumns.flatMap((source) => presentValues([row], source).map(String)))));
     for (const destination of columns) {
-        if (destination in merged)
-            merged[destination] = null;
+        if ((0, cells_1.hasCell)(merged, destination))
+            (0, cells_1.setCell)(merged, destination, null);
     }
     uniqueValues.forEach((value, index) => {
         if (index < columns.length) {
-            merged[columns[index]] = value;
+            (0, cells_1.setCell)(merged, columns[index], value);
         }
     });
     const overflowValues = uniqueValues.slice(columns.length);
     if (overflowValues.length > 0) {
         const overflowColumn = overflowInto ?? findFreeOverflowColumnName(column, merged);
-        merged[overflowColumn] = overflowValues.join(separator);
+        (0, cells_1.setCell)(merged, overflowColumn, overflowValues.join(separator));
     }
     for (const source of sourceColumns) {
         if (!columns.includes(source))
@@ -52,18 +53,18 @@ function mergeConcatDistributed(group, column, merged, distribute, separator) {
 }
 function findFreeOverflowColumnName(column, merged) {
     const base = `${column}_overflow`;
-    if (merged[base] === undefined)
+    if (!(0, cells_1.hasCell)(merged, base))
         return base;
     let suffix = 2;
-    while (merged[`${base}_${suffix}`] !== undefined) {
+    while ((0, cells_1.hasCell)(merged, `${base}_${suffix}`)) {
         suffix++;
     }
     return `${base}_${suffix}`;
 }
 function mergeExtraColumns(group, column, merged, target = column) {
     const values = presentValues(group, column);
-    merged[target] = values[0] ?? null;
+    (0, cells_1.setCell)(merged, target, values[0] ?? null);
     for (let i = 1; i < values.length; i++) {
-        merged[`${target}_${i + 1}`] = values[i] ?? null;
+        (0, cells_1.setCell)(merged, `${target}_${i + 1}`, values[i] ?? null);
     }
 }

package/dist/filters/mergeUnkeyed.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildUnkeyedRows = buildUnkeyedRows;
 const mergeStrategies_1 = require("./mergeStrategies");
+const cells_1 = require("../cells");
 function buildUnkeyedRows(rows, label, keyColumn, columns) {
     if (rows.length === 0)
         return [];
@@ -13,9 +14,7 @@ function buildUnkeyedRows(rows, label, keyColumn, columns) {
     for (const { column, unkeyed } of collapsing) {
         const target = unkeyed?.into ?? `${column} ${label}`;
         const separator = unkeyed?.separator ?? mergeStrategies_1.DEFAULT_SEPARATOR;
-        collapsed[target] = (0, mergeStrategies_1.presentValues)(rows, column)
-            .map(String)
-            .join(separator);
+        (0, cells_1.setCell)(collapsed, target, (0, mergeStrategies_1.presentValues)(rows, column).map(String).join(separator));
     }
     return [collapsed];
 }

package/dist/filters/validate.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RowValidator = exports.DEFAULT_REASON_COLUMN = exports.DEFAULT_PENDING_SHEET = void 0;
 const registry_1 = require("../normalizers/registry");
+const cells_1 = require("../cells");
 exports.DEFAULT_PENDING_SHEET = "Pendências";
 exports.DEFAULT_REASON_COLUMN = "Motivo";
 class RowValidator {
@@ -16,14 +17,14 @@ class RowValidator {
         const pending = [];
         for (const row of rows) {
             const reasons = this.checks
-                .filter((check) => !this.passes(check, row[check.column]))
+                .filter((check) => !this.passes(check, (0, cells_1.cellOf)(row, check.column)))
                 .map((check) => check.message);
             if (reasons.length === 0) {
                 valid.push(row);
                 continue;
             }
             const withReason = { [this.reasonColumn]: null, ...row };
-            withReason[this.reasonColumn] = Array.from(new Set(reasons)).join("; ");
+            (0, cells_1.setCell)(withReason, this.reasonColumn, Array.from(new Set(reasons)).join("; "));
             pending.push(withReason);
         }
         return { valid, pending };

package/dist/filters/validateTypes.d.ts

@@ -20,9 +20,4 @@ export interface NormalizerRule extends BaseRule {
     normalizer: string;
 }
 export type ValidationRule = RequiredRule | PatternRule | OneOfRule | NormalizerRule;
-export interface ValidationConfig {
-    rules: ValidationRule[];
-    pendingSheet?: string | undefined;
-    reasonColumn?: string | undefined;
-}
 export {};

package/dist/io/csv/csvFormat.d.ts

@@ -1,4 +1,5 @@
 export declare function stripBom(text: string): string;
 export declare function detectDelimiter(text: string): string;
 export declare function parseCsv(text: string, delimiter: string): string[][];
+export declare function escapeFormula(value: string): string;
 export declare function toCsv(rows: string[][], delimiter: string): string;

package/dist/io/csv/csvFormat.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripBom = stripBom;
 exports.detectDelimiter = detectDelimiter;
 exports.parseCsv = parseCsv;
+exports.escapeFormula = escapeFormula;
 exports.toCsv = toCsv;
 const BOM = "\uFEFF";
 const CANDIDATE_DELIMITERS = [",", ";", "\t", "|"];
@@ -79,6 +80,13 @@ function parseCsv(text, delimiter) {
     }
     return rows.filter((r) => !(r.length === 1 && r[0] === ""));
 }
+const FORMULA_START = /^\s*[=+\-@\t\r\uFF1D\uFF0B\uFF0D\uFF20]/;
+const PLAIN_NUMBER = /^\s*[+-]?\d+([.,]\d+)*\s*$/;
+function escapeFormula(value) {
+    return FORMULA_START.test(value) && !PLAIN_NUMBER.test(value)
+        ? `'${value}`
+        : value;
+}
 function escapeField(value, delimiter) {
     const needsQuotes = value.includes(delimiter) ||
         value.includes('"') ||

package/dist/io/csv/csvSink.d.ts

@@ -5,6 +5,7 @@ export interface CsvSinkOptions {
     path: string;
     delimiter?: string | undefined;
     bom?: boolean | undefined;
+    escapeFormulas?: boolean | undefined;
 }
 export declare class CsvSink implements Sink {
     private readonly options;

package/dist/io/csv/csvSink.js

@@ -5,6 +5,7 @@ const header_1 = require("../header");
 const csvFormat_1 = require("./csvFormat");
 const files_1 = require("../files");
 const logger_1 = require("../../logger");
+const cells_1 = require("../../cells");
 class CsvSink {
     options;
     logger;
@@ -14,16 +15,19 @@ class CsvSink {
     }
     async write(rows, options = {}) {
         const filePath = (0, files_1.extraOutputPath)(this.options.path, options.name);
+        const safe = (this.options.escapeFormulas ?? true)
+            ? csvFormat_1.escapeFormula
+            : (value) => value;
         const header = (0, header_1.buildHeader)(rows);
         const lines = rows.map((row) => header.map((column) => {
-            const value = row[column];
-            return value === null || value === undefined
-                ? ""
-                : String(value);
+            const value = (0, cells_1.cellOf)(row, column);
+            if (value === null || value === undefined)
+                return "";
+            return typeof value === "number" ? String(value) : safe(value);
         }));
         const content = rows.length === 0
             ? ""
-            : (0, csvFormat_1.toCsv)([header, ...lines], this.options.delimiter ?? ",");
+            : (0, csvFormat_1.toCsv)([header.map(safe), ...lines], this.options.delimiter ?? ",");
         const bom = (this.options.bom ?? true) ? "\uFEFF" : "";
         (0, files_1.writeTextFile)(filePath, bom + content + (content ? "\r\n" : ""));
         this.logger.info(`${rows.length} linhas escritas em ${filePath}.`);

package/dist/io/csv/csvSource.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CsvSource = void 0;
 const csvFormat_1 = require("./csvFormat");
 const files_1 = require("../files");
+const cells_1 = require("../../cells");
 class CsvSource {
     options;
     constructor(options) {
@@ -19,8 +20,7 @@ class CsvSource {
             const row = {};
             columns.forEach((column, index) => {
                 const value = values[index];
-                row[column] =
-                    value === undefined || value === "" ? null : value;
+                (0, cells_1.setCell)(row, column, value === undefined || value === "" ? null : value);
             });
             return row;
         });

package/dist/io/excel/excelSink.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const header_1 = require("../header");
 const workbook_1 = require("./workbook");
 const logger_1 = require("../../logger");
+const cells_1 = require("../../cells");
 const DEFAULT_SHEET = "Dados";
 const MAX_SHEET_NAME = 31;
 function safeSheetName(name) {
@@ -43,10 +44,10 @@ class ExcelSink {
         if (header.length > 0) {
             worksheet.addRow(header).font = { bold: true };
             for (const row of rows) {
-                worksheet.addRow(header.map((column) => row[column] ?? null));
+                worksheet.addRow(header.map((column) => (0, cells_1.cellOf)(row, column) ?? null));
             }
             header.forEach((column, index) => {
-                const longest = Math.max(column.length, ...rows.map((row) => String(row[column] ?? "").length));
+                const longest = Math.max(column.length, ...rows.map((row) => String((0, cells_1.cellOf)(row, column) ?? "").length));
                 worksheet.getColumn(index + 1).width = Math.min(Math.max(longest + 2, 10), 50);
             });
         }

package/dist/io/excel/excelSource.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExcelSource = void 0;
 const workbook_1 = require("./workbook");
 const excelCell_1 = require("./excelCell");
+const cells_1 = require("../../cells");
 class ExcelSource {
     options;
     constructor(options) {
@@ -34,7 +35,7 @@ class ExcelSource {
             let hasValue = false;
             for (const [column, name] of header) {
                 const value = (0, excelCell_1.fromExcelCell)(excelRow.getCell(column).value);
-                row[name] = value;
+                (0, cells_1.setCell)(row, name, value);
                 if (value !== null)
                     hasValue = true;
             }

package/dist/io/factory.js

@@ -13,6 +13,10 @@ const xmlSource_1 = require("./xml/xmlSource");
 const postgresSource_1 = require("./postgres/postgresSource");
 const sqlServerSource_1 = require("./sqlserver/sqlServerSource");
 const sqliteSource_1 = require("./sqlite/sqliteSource");
+const sqliteSink_1 = require("./sqlite/sqliteSink");
+const postgresSink_1 = require("./postgres/postgresSink");
+const sqlServerSink_1 = require("./sqlserver/sqlServerSink");
+const mysqlSink_1 = require("./mysql/mysqlSink");
 const xmlSink_1 = require("./xml/xmlSink");
 const parquetSource_1 = require("./parquet/parquetSource");
 const parquetSink_1 = require("./parquet/parquetSink");
@@ -22,9 +26,12 @@ const sheetsSource_1 = require("./sheets/sheetsSource");
 const registry_1 = require("./custom/registry");
 const logger_1 = require("../logger");
 const safety_1 = require("./safety");
-const DEFAULT_MYSQL_PORT = 3306;
-const DEFAULT_POSTGRES_PORT = 5432;
-const DEFAULT_SQLSERVER_PORT = 1433;
+const servers_1 = require("./servers");
+const SERVER_NAMES = {
+    mysql: "MySQL",
+    postgres: "PostgreSQL",
+    sqlserver: "SQL Server",
+};
 function required(value, what) {
     if (value === undefined || value === "") {
         throw new Error(`Faltou configurar ${what}.`);
@@ -37,15 +44,16 @@ function createSource(config, logger = logger_1.consoleLogger) {
         case "mysql":
             return new mysqlSource_1.MysqlSource({
                 host: required(source.host ?? config.dbHost, "o host do MySQL"),
-                port: source.port ?? config.dbPort ?? DEFAULT_MYSQL_PORT,
+                port: (0, servers_1.serverOf)(config, "source").port,
                 user: required(source.user ?? config.dbUser, "o usuário do MySQL"),
                 password: source.password ?? config.dbPassword,
                 database: required(source.database ?? config.dbName, "o banco do MySQL"),
+                ssl: source.ssl,
             }, required(source.table ?? config.tableName, "a tabela do MySQL"), logger);
         case "postgres":
             return new postgresSource_1.PostgresSource({
                 host: required(source.host, "o host do PostgreSQL"),
-                port: source.port ?? DEFAULT_POSTGRES_PORT,
+                port: (0, servers_1.serverOf)(config, "source").port,
                 user: required(source.user, "o usuário do PostgreSQL"),
                 password: source.password,
                 database: required(source.database, "o banco do PostgreSQL"),
@@ -54,7 +62,7 @@ function createSource(config, logger = logger_1.consoleLogger) {
         case "sqlserver":
             return new sqlServerSource_1.SqlServerSource({
                 host: required(source.host, "o servidor do SQL Server"),
-                port: source.port ?? DEFAULT_SQLSERVER_PORT,
+                port: (0, servers_1.serverOf)(config, "source").port,
                 user: required(source.user, "o usuário do SQL Server"),
                 password: source.password,
                 database: required(source.database, "o banco do SQL Server"),
@@ -85,6 +93,49 @@ function createSink(config, logger = logger_1.consoleLogger) {
     (0, safety_1.assertSourceIsSafe)(config);
     const destination = config.destination ?? { type: "sheets" };
     switch (destination.type) {
+        case "mysql":
+        case "postgres":
+        case "sqlserver": {
+            const server = (0, servers_1.serverOf)(config, "destination");
+            const what = SERVER_NAMES[destination.type];
+            const connection = {
+                host: required(server.host, `o host do ${what} de destino`),
+                port: server.port,
+                user: required(server.user, `o usuário do ${what} de destino`),
+                password: server.password,
+                database: required(server.database, `o banco do ${what} de destino`),
+            };
+            const target = {
+                table: required(destination.table, `a tabela do ${what} onde gravar`),
+                pendingTable: destination.pendingTable,
+            };
+            if (destination.type === "mysql") {
+                const same = config.source?.type === "mysql" &&
+                    (0, servers_1.destinationSharesSource)(config)
+                    ? config.source
+                    : undefined;
+                return new mysqlSink_1.MysqlSink({ ...connection, ssl: destination.ssl ?? same?.ssl }, target, logger);
+            }
+            if (destination.type === "postgres") {
+                const same = config.source?.type === "postgres" &&
+                    (0, servers_1.destinationSharesSource)(config)
+                    ? config.source
+                    : undefined;
+                return new postgresSink_1.PostgresSink({ ...connection, ssl: destination.ssl ?? same?.ssl }, target, logger);
+            }
+            const same = config.source?.type === "sqlserver" &&
+                (0, servers_1.destinationSharesSource)(config)
+                ? config.source
+                : undefined;
+            return new sqlServerSink_1.SqlServerSink({
+                ...connection,
+                encrypt: destination.encrypt ?? same?.encrypt,
+                trustServerCertificate: destination.trustServerCertificate ??
+                    same?.trustServerCertificate,
+            }, target, logger);
+        }
+        case "sqlite":
+            return new sqliteSink_1.SqliteSink(destination, logger);
         case "sheets": {
             const credentialsPath = required(destination.credentialsPath ?? config.credentialsPath, "o caminho das credenciais do Google");
             const spreadsheetId = required(destination.spreadsheetId ?? config.spreadsheetId, "o id da planilha");

package/dist/io/json/jsonSource.js

@@ -2,14 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonSource = void 0;
 const files_1 = require("../files");
+const cells_1 = require("../../cells");
 function flatten(value, prefix, row) {
     if (value === null || value === undefined) {
-        row[prefix] = null;
+        (0, cells_1.setCell)(row, prefix, null);
     }
     else if (Array.isArray(value)) {
-        row[prefix] = value.every((item) => typeof item !== "object" || item === null)
+        (0, cells_1.setCell)(row, prefix, value.every((item) => typeof item !== "object" || item === null)
             ? value.map((item) => String(item ?? "")).join(", ")
-            : JSON.stringify(value);
+            : JSON.stringify(value));
     }
     else if (typeof value === "object") {
         for (const [key, inner] of Object.entries(value)) {
@@ -17,10 +18,10 @@ function flatten(value, prefix, row) {
         }
     }
     else if (typeof value === "number" || typeof value === "string") {
-        row[prefix] = value;
+        (0, cells_1.setCell)(row, prefix, value);
     }
     else {
-        row[prefix] = String(value);
+        (0, cells_1.setCell)(row, prefix, String(value));
     }
 }
 class JsonSource {

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

@@ -7,6 +7,7 @@ export interface MysqlConnection {
     user: string;
     password?: string | undefined;
     database: string;
+    ssl?: boolean | undefined;
 }
 export declare function createPool(connection: MysqlConnection): Pool;
 export declare function readTableInBatches(pool: Pool, tableName: string, batchSize?: number, logger?: Logger): AsyncGenerator<TableRow[]>;

package/dist/io/mysql/client.js

@@ -15,6 +15,7 @@ function createPool(connection) {
             ? { password: connection.password }
             : {}),
         database: connection.database,
+        ...(connection.ssl ? { ssl: { rejectUnauthorized: true } } : {}),
     });
 }
 const RETRYABLE_ERROR_CODES = new Set([

package/dist/io/mysql/mysqlSink.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 { MysqlConnection } from "./client";
+export declare const MYSQL_DIALECT: SqlDialect;
+export interface MysqlSession extends SqlSession {
+    close(): Promise<void>;
+}
+export type MysqlSessionFactory = (connection: MysqlConnection) => Promise<MysqlSession>;
+export declare const createMysqlSession: MysqlSessionFactory;
+export declare class MysqlSink implements Sink {
+    private readonly connection;
+    private readonly target;
+    private readonly logger;
+    private readonly createSession;
+    constructor(connection: MysqlConnection, target: TableTarget, logger?: Logger, createSession?: MysqlSessionFactory);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/mysql/mysqlSink.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSink = exports.createMysqlSession = exports.MYSQL_DIALECT = void 0;
+const logger_1 = require("../../logger");
+const writer_1 = require("../sql/writer");
+const target_1 = require("../sql/target");
+const client_1 = require("./client");
+exports.MYSQL_DIALECT = {
+    label: "MySQL",
+    open: "`",
+    close: "`",
+    schemas: true,
+    maxNameLength: 64,
+    nameLength: (name) => name.length,
+    maxParams: 60000,
+    maxRowsPerInsert: 1000,
+    transactionalDdl: false,
+    types: { integer: "BIGINT", number: "DOUBLE", text: "LONGTEXT" },
+    keyType: "VARCHAR(191) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin",
+    tableSuffix: " DEFAULT CHARSET=utf8mb4",
+    param: () => "?",
+    tableMark: (token) => ({ inside: "", after: ` COMMENT='${token}'` }),
+    tableId: async (session, table) => {
+        const parts = (0, writer_1.tableParts)(exports.MYSQL_DIALECT, table);
+        const name = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : null;
+        const [found] = await session.all("SELECT TABLE_COMMENT AS id FROM information_schema.tables WHERE table_schema = COALESCE(?, DATABASE()) AND table_name = ? AND table_type = 'BASE TABLE'", [schema, name]);
+        const id = found?.id;
+        return typeof id === "string" && id.startsWith(writer_1.MARK_PREFIX) ? id : null;
+    },
+    tableExists: async (session, table) => {
+        const parts = (0, writer_1.tableParts)(exports.MYSQL_DIALECT, table);
+        const name = parts[parts.length - 1];
+        const schema = parts.length > 1 ? parts[0] : null;
+        const [found] = await session.all("SELECT COUNT(*) AS total FROM information_schema.tables WHERE table_schema = COALESCE(?, DATABASE()) AND table_name = ?", [schema, name]);
+        return Number(found?.total ?? 0) > 0;
+    },
+};
+const createMysqlSession = async (connection) => {
+    const pool = (0, client_1.createPool)(connection);
+    let handle;
+    try {
+        handle =
+            (await pool.getConnection());
+    }
+    catch (error) {
+        await pool.end();
+        throw error;
+    }
+    return {
+        run: async (sql, values) => {
+            await handle.query(sql, values);
+        },
+        all: async (sql, values) => {
+            const [rows] = await handle.query(sql, values);
+            return rows;
+        },
+        begin: () => handle.beginTransaction(),
+        commit: () => handle.commit(),
+        rollback: () => handle.rollback(),
+        close: async () => {
+            handle.release();
+            await pool.end();
+        },
+    };
+};
+exports.createMysqlSession = createMysqlSession;
+class MysqlSink {
+    connection;
+    target;
+    logger;
+    createSession;
+    constructor(connection, target, logger = logger_1.consoleLogger, createSession = exports.createMysqlSession) {
+        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.MYSQL_DIALECT, (0, target_1.tableFor)(this.target, options), rows, this.logger);
+        }
+        finally {
+            await session.close();
+        }
+    }
+}
+exports.MysqlSink = MysqlSink;

package/dist/io/parquet/parquetSink.js

@@ -10,6 +10,7 @@ const files_1 = require("../files");
 const header_1 = require("../header");
 const logger_1 = require("../../logger");
 const parquetLibrary_1 = require("./parquetLibrary");
+const cells_1 = require("../../cells");
 const INT32_MIN = -(2 ** 31);
 const INT32_MAX = 2 ** 31 - 1;
 function typeOf(values) {
@@ -23,7 +24,7 @@ function typeOf(values) {
 }
 function parquetColumns(rows) {
     return (0, header_1.buildHeader)(rows).map((name) => {
-        const values = rows.map((row) => row[name] ?? null);
+        const values = rows.map((row) => (0, cells_1.cellOf)(row, name) ?? null);
         const type = typeOf(values);
         return {
             name,

package/dist/io/parquet/parquetSource.js

@@ -8,6 +8,7 @@ exports.parquetRow = parquetRow;
 const fs_1 = __importDefault(require("fs"));
 const cell_1 = require("../sql/cell");
 const parquetLibrary_1 = require("./parquetLibrary");
+const cells_1 = require("../../cells");
 function join(prefix, name) {
     return prefix ? `${prefix}.${name}` : name;
 }
@@ -28,12 +29,10 @@ function flatten(value, prefix, row) {
         }
     }
     else if (Array.isArray(value) && value.every(isSimple)) {
-        row[prefix] = value
-            .map((item) => String((0, cell_1.toCell)(item) ?? ""))
-            .join(", ");
+        (0, cells_1.setCell)(row, prefix, value.map((item) => String((0, cell_1.toCell)(item) ?? "")).join(", "));
     }
     else {
-        row[prefix] = (0, cell_1.toCell)(value);
+        (0, cells_1.setCell)(row, prefix, (0, cell_1.toCell)(value));
     }
 }
 function parquetRow(record) {

package/dist/io/postgres/postgresSink.d.ts

@@ -0,0 +1,16 @@
+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 { PostgresClient, PostgresClientFactory, PostgresConnection } from "./postgresSource";
+export declare const POSTGRES_DIALECT: SqlDialect;
+export declare function postgresSession(client: PostgresClient): SqlSession;
+export declare class PostgresSink implements Sink {
+    private readonly connection;
+    private readonly target;
+    private readonly logger;
+    private readonly createClient;
+    constructor(connection: PostgresConnection, target: TableTarget, logger?: Logger, createClient?: PostgresClientFactory);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}