datera 0.1.0

package/dist/io/factory.d.ts

@@ -0,0 +1,5 @@
+import { EtlConfig } from "../config";
+import { Sink, Source } from "./types";
+import { Logger } from "../logger";
+export declare function createSource(config: EtlConfig, logger?: Logger): Source;
+export declare function createSink(config: EtlConfig, logger?: Logger): Sink;

package/dist/io/factory.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSource = createSource;
+exports.createSink = createSink;
+const client_1 = require("./sheets/client");
+const mysqlSource_1 = require("./mysql/mysqlSource");
+const csvSource_1 = require("./csv/csvSource");
+const jsonSource_1 = require("./json/jsonSource");
+const sheetsSink_1 = require("./sheets/sheetsSink");
+const csvSink_1 = require("./csv/csvSink");
+const jsonSink_1 = require("./json/jsonSink");
+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 xmlSink_1 = require("./xml/xmlSink");
+const parquetSource_1 = require("./parquet/parquetSource");
+const parquetSink_1 = require("./parquet/parquetSink");
+const excelSource_1 = require("./excel/excelSource");
+const excelSink_1 = require("./excel/excelSink");
+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;
+function required(value, what) {
+    if (value === undefined || value === "") {
+        throw new Error(`Faltou configurar ${what}.`);
+    }
+    return value;
+}
+function createSource(config, logger = logger_1.consoleLogger) {
+    const source = config.source ?? { type: "mysql" };
+    switch (source.type) {
+        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,
+                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"),
+            }, 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,
+                user: required(source.user, "o usuário do PostgreSQL"),
+                password: source.password,
+                database: required(source.database, "o banco do PostgreSQL"),
+                ssl: source.ssl,
+            }, required(source.table, "a tabela do PostgreSQL"));
+        case "sqlserver":
+            return new sqlServerSource_1.SqlServerSource({
+                host: required(source.host, "o servidor do SQL Server"),
+                port: source.port ?? DEFAULT_SQLSERVER_PORT,
+                user: required(source.user, "o usuário do SQL Server"),
+                password: source.password,
+                database: required(source.database, "o banco do SQL Server"),
+                encrypt: source.encrypt,
+                trustServerCertificate: source.trustServerCertificate,
+            }, required(source.table, "a tabela do SQL Server"));
+        case "sqlite":
+            return new sqliteSource_1.SqliteSource(source);
+        case "csv":
+            return new csvSource_1.CsvSource(source);
+        case "json":
+            return new jsonSource_1.JsonSource(source);
+        case "xml":
+            return new xmlSource_1.XmlSource(source);
+        case "parquet":
+            return new parquetSource_1.ParquetSource(source);
+        case "excel":
+            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);
+        }
+        case "custom":
+            return (0, registry_1.createCustomSource)(source.adapter, source.options ?? {}, logger);
+    }
+}
+function createSink(config, logger = logger_1.consoleLogger) {
+    (0, safety_1.assertSourceIsSafe)(config);
+    const destination = config.destination ?? { type: "sheets" };
+    switch (destination.type) {
+        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");
+            return new sheetsSink_1.SheetsSink((0, client_1.createSheetsClient)(credentialsPath), spreadsheetId, destination.sheet, logger);
+        }
+        case "csv":
+            return new csvSink_1.CsvSink(destination, logger);
+        case "json":
+            return new jsonSink_1.JsonSink(destination, logger);
+        case "xml":
+            return new xmlSink_1.XmlSink(destination, logger);
+        case "parquet":
+            return new parquetSink_1.ParquetSink(destination, logger);
+        case "excel":
+            return new excelSink_1.ExcelSink(destination, logger);
+        case "custom":
+            return (0, registry_1.createCustomSink)(destination.adapter, destination.options ?? {}, logger);
+    }
+}

package/dist/io/files.d.ts

@@ -0,0 +1,7 @@
+export type FileEncoding = "utf-8" | "latin1";
+export declare function slugify(name: string): string;
+export declare function extraOutputPath(mainPath: string, name: string | undefined): string;
+export declare function readTextFile(filePath: string, encoding?: FileEncoding): string;
+export declare function writeTextFile(filePath: string, content: string): void;
+export declare function readBinaryFile(filePath: string): Buffer;
+export declare function writeBinaryFile(filePath: string, content: Buffer): void;

package/dist/io/files.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = slugify;
+exports.extraOutputPath = extraOutputPath;
+exports.readTextFile = readTextFile;
+exports.writeTextFile = writeTextFile;
+exports.readBinaryFile = readBinaryFile;
+exports.writeBinaryFile = writeBinaryFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function slugify(name) {
+    return name
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function extraOutputPath(mainPath, name) {
+    if (name === undefined)
+        return mainPath;
+    const ext = path_1.default.extname(mainPath);
+    const base = mainPath.slice(0, mainPath.length - ext.length);
+    return `${base}.${slugify(name) || "extra"}${ext}`;
+}
+function readTextFile(filePath, encoding = "utf-8") {
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`Arquivo não encontrado: ${filePath}`);
+    }
+    return fs_1.default.readFileSync(filePath, encoding === "latin1" ? "latin1" : "utf8");
+}
+function writeTextFile(filePath, content) {
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs_1.default.writeFileSync(filePath, content, "utf8");
+}
+function readBinaryFile(filePath) {
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`Arquivo não encontrado: ${filePath}`);
+    }
+    return fs_1.default.readFileSync(filePath);
+}
+function writeBinaryFile(filePath, content) {
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs_1.default.writeFileSync(filePath, content);
+}

package/dist/io/header.d.ts

@@ -0,0 +1,2 @@
+import { TableRow } from "../types";
+export declare function buildHeader(data: TableRow[]): string[];

package/dist/io/header.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHeader = buildHeader;
+function buildHeader(data) {
+    const seen = new Set();
+    const orderedKeys = [];
+    for (const row of data) {
+        for (const key of Object.keys(row)) {
+            if (!seen.has(key)) {
+                seen.add(key);
+                orderedKeys.push(key);
+            }
+        }
+    }
+    const suffixPattern = /^(.+)_(\d+)$/;
+    const variantsByBase = new Map();
+    const baseKeys = [];
+    for (const key of orderedKeys) {
+        const match = key.match(suffixPattern);
+        if (match && seen.has(match[1])) {
+            const base = match[1];
+            const n = Number(match[2]);
+            if (!variantsByBase.has(base))
+                variantsByBase.set(base, []);
+            variantsByBase.get(base).push(n);
+        }
+        else {
+            baseKeys.push(key);
+        }
+    }
+    const header = [];
+    for (const base of baseKeys) {
+        header.push(base);
+        const variants = variantsByBase.get(base);
+        if (variants) {
+            variants.sort((a, b) => a - b);
+            for (const n of variants)
+                header.push(`${base}_${n}`);
+        }
+    }
+    return header;
+}

package/dist/io/json/jsonSink.d.ts

@@ -0,0 +1,12 @@
+import { TableRow } from "../../types";
+import { Sink, SinkWriteOptions } from "../types";
+import { Logger } from "../../logger";
+export interface JsonSinkOptions {
+    path: string;
+}
+export declare class JsonSink implements Sink {
+    private readonly options;
+    private readonly logger;
+    constructor(options: JsonSinkOptions, logger?: Logger);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/json/jsonSink.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSink = void 0;
+const files_1 = require("../files");
+const logger_1 = require("../../logger");
+class JsonSink {
+    options;
+    logger;
+    constructor(options, logger = logger_1.consoleLogger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    async write(rows, options = {}) {
+        const filePath = (0, files_1.extraOutputPath)(this.options.path, options.name);
+        (0, files_1.writeTextFile)(filePath, JSON.stringify(rows, null, 2) + "\n");
+        this.logger.info(`${rows.length} linhas escritas em ${filePath}.`);
+    }
+}
+exports.JsonSink = JsonSink;

package/dist/io/json/jsonSource.d.ts

@@ -0,0 +1,11 @@
+import { TableRow } from "../../types";
+import { Source } from "../types";
+export interface JsonSourceOptions {
+    path: string;
+    recordsPath?: string | undefined;
+}
+export declare class JsonSource implements Source {
+    private readonly options;
+    constructor(options: JsonSourceOptions);
+    read(): Promise<TableRow[]>;
+}

package/dist/io/json/jsonSource.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSource = void 0;
+const files_1 = require("../files");
+function flatten(value, prefix, row) {
+    if (value === null || value === undefined) {
+        row[prefix] = null;
+    }
+    else if (Array.isArray(value)) {
+        row[prefix] = value.every((item) => typeof item !== "object" || item === null)
+            ? value.map((item) => String(item ?? "")).join(", ")
+            : JSON.stringify(value);
+    }
+    else if (typeof value === "object") {
+        for (const [key, inner] of Object.entries(value)) {
+            flatten(inner, prefix ? `${prefix}.${key}` : key, row);
+        }
+    }
+    else if (typeof value === "number" || typeof value === "string") {
+        row[prefix] = value;
+    }
+    else {
+        row[prefix] = String(value);
+    }
+}
+class JsonSource {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async read() {
+        let data;
+        try {
+            data = JSON.parse((0, files_1.readTextFile)(this.options.path));
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`JSON inválido em ${this.options.path}: ${error.message}`);
+            }
+            throw error;
+        }
+        for (const key of this.options.recordsPath?.split(".") ?? []) {
+            data =
+                typeof data === "object" && data !== null
+                    ? data[key]
+                    : undefined;
+        }
+        if (!Array.isArray(data)) {
+            throw new Error(`O JSON em ${this.options.path} precisa ser uma lista de objetos` +
+                (this.options.recordsPath
+                    ? ` em "${this.options.recordsPath}".`
+                    : "."));
+        }
+        return data.map((item, index) => {
+            if (typeof item !== "object" ||
+                item === null ||
+                Array.isArray(item)) {
+                throw new Error(`O item ${index} do JSON não é um objeto.`);
+            }
+            const row = {};
+            flatten(item, "", row);
+            return row;
+        });
+    }
+}
+exports.JsonSource = JsonSource;

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

@@ -0,0 +1,13 @@
+import type { Pool } from "mysql2/promise";
+import { TableRow } from "../../types";
+import { Logger } from "../../logger";
+export interface MysqlConnection {
+    host: string;
+    port: number;
+    user: string;
+    password?: string | undefined;
+    database: string;
+}
+export declare function createPool(connection: MysqlConnection): Pool;
+export declare function readTableInBatches(pool: Pool, tableName: string, batchSize?: number, logger?: Logger): AsyncGenerator<TableRow[]>;
+export declare function readTable(pool: Pool, tableName: string, logger?: Logger): Promise<TableRow[]>;

package/dist/io/mysql/client.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPool = createPool;
+exports.readTableInBatches = readTableInBatches;
+exports.readTable = readTable;
+const optional_1 = require("../optional");
+const logger_1 = require("../../logger");
+function createPool(connection) {
+    const mysql = (0, optional_1.requireOptional)(() => require("mysql2/promise"), ["mysql2"], "MySQL");
+    return mysql.createPool({
+        host: connection.host,
+        port: connection.port,
+        user: connection.user,
+        ...(connection.password !== undefined
+            ? { password: connection.password }
+            : {}),
+        database: connection.database,
+    });
+}
+const RETRYABLE_ERROR_CODES = new Set([
+    "PROTOCOL_CONNECTION_LOST",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ECONNRESET",
+]);
+function isRetryableError(error) {
+    const code = error?.code;
+    return typeof code === "string" && RETRYABLE_ERROR_CODES.has(code);
+}
+async function withRetry(fn, logger, maxRetries = 3, baseDelayMs = 500) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const isLastAttempt = attempt === maxRetries;
+            if (!isRetryableError(error) || isLastAttempt) {
+                throw error;
+            }
+            const delay = baseDelayMs * 2 ** attempt;
+            logger.warn(`Erro de conexão com o banco. Tentando de novo em ${delay}ms (tentativa ${attempt + 1}/${maxRetries})...`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw new Error("withRetry: número de tentativas esgotado sem sucesso e sem erro capturado.");
+}
+const DEFAULT_BATCH_SIZE = 1000;
+async function* readTableInBatches(pool, tableName, batchSize = DEFAULT_BATCH_SIZE, logger = logger_1.consoleLogger) {
+    let offset = 0;
+    while (true) {
+        const [rows] = await withRetry(() => pool.query(`SELECT * FROM ?? LIMIT ? OFFSET ?`, [
+            tableName,
+            batchSize,
+            offset,
+        ]), logger);
+        const batch = rows;
+        if (batch.length === 0) {
+            break;
+        }
+        yield batch;
+        if (batch.length < batchSize) {
+            break;
+        }
+        offset += batchSize;
+    }
+}
+async function readTable(pool, tableName, logger = logger_1.consoleLogger) {
+    const allRows = [];
+    for await (const batch of readTableInBatches(pool, tableName, DEFAULT_BATCH_SIZE, logger)) {
+        allRows.push(...batch);
+    }
+    return allRows;
+}

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

@@ -0,0 +1,13 @@
+import { MysqlConnection } from "./client";
+import { TableRow } from "../../types";
+import { Source } from "../types";
+import { Logger } from "../../logger";
+export declare class MysqlSource implements Source {
+    private readonly connection;
+    private readonly table;
+    private readonly logger;
+    private pool;
+    constructor(connection: MysqlConnection, table: string, logger?: Logger);
+    read(): Promise<TableRow[]>;
+    close(): Promise<void>;
+}

package/dist/io/mysql/mysqlSource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSource = void 0;
+const client_1 = require("./client");
+const logger_1 = require("../../logger");
+class MysqlSource {
+    connection;
+    table;
+    logger;
+    pool;
+    constructor(connection, table, logger = logger_1.consoleLogger) {
+        this.connection = connection;
+        this.table = table;
+        this.logger = logger;
+    }
+    async read() {
+        this.pool ??= (0, client_1.createPool)(this.connection);
+        return (0, client_1.readTable)(this.pool, this.table, this.logger);
+    }
+    async close() {
+        await this.pool?.end();
+        this.pool = undefined;
+    }
+}
+exports.MysqlSource = MysqlSource;

package/dist/io/optional.d.ts

@@ -0,0 +1,2 @@
+export declare function requireOptional<T>(load: () => unknown, packages: string[], feature: string): T;
+export declare function importOptional<T>(load: () => Promise<T>, packages: string[], feature: string): Promise<T>;

package/dist/io/optional.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireOptional = requireOptional;
+exports.importOptional = importOptional;
+const NOT_FOUND = new Set(["MODULE_NOT_FOUND", "ERR_MODULE_NOT_FOUND"]);
+function missing(packages, feature) {
+    const list = packages.join(" ");
+    return new Error(`Pra usar ${feature}, o Datera precisa do pacote ${packages.map((name) => `"${name}"`).join(" e ")}. Rode "npm install ${list}" no seu projeto (ou "npm install -g ${list}" se você usa o comando datera instalado com -g).`);
+}
+function isNotFound(error, packages) {
+    const code = error?.code;
+    const message = error instanceof Error ? error.message : "";
+    return (typeof code === "string" &&
+        NOT_FOUND.has(code) &&
+        packages.some((name) => message.includes(name)));
+}
+function requireOptional(load, packages, feature) {
+    try {
+        return load();
+    }
+    catch (error) {
+        if (isNotFound(error, packages))
+            throw missing(packages, feature);
+        throw error;
+    }
+}
+async function importOptional(load, packages, feature) {
+    try {
+        return await load();
+    }
+    catch (error) {
+        if (isNotFound(error, packages))
+            throw missing(packages, feature);
+        throw error;
+    }
+}

package/dist/io/parquet/parquetLibrary.d.ts

@@ -0,0 +1,11 @@
+export type ParquetColumnType = "STRING" | "INT32" | "DOUBLE";
+export interface ParquetColumn {
+    name: string;
+    type: ParquetColumnType;
+    data: (string | number | null)[];
+}
+export interface ParquetLibrary {
+    read(filePath: string): Promise<Record<string, unknown>[]>;
+    write(filePath: string, columns: ParquetColumn[]): Promise<void>;
+}
+export declare const parquetLibrary: ParquetLibrary;

package/dist/io/parquet/parquetLibrary.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parquetLibrary = void 0;
+const files_1 = require("../files");
+const optional_1 = require("../optional");
+const READ_PACKAGES = ["hyparquet", "hyparquet-compressors"];
+const WRITE_PACKAGES = ["hyparquet-writer"];
+exports.parquetLibrary = {
+    async read(filePath) {
+        const { asyncBufferFromFile, parquetReadObjects } = await (0, optional_1.importOptional)(() => import("hyparquet"), READ_PACKAGES, "Parquet");
+        const { compressors } = await (0, optional_1.importOptional)(() => import("hyparquet-compressors"), READ_PACKAGES, "Parquet");
+        const file = await asyncBufferFromFile(filePath);
+        return (await parquetReadObjects({ file, compressors }));
+    },
+    async write(filePath, columns) {
+        const { parquetWriteBuffer } = await (0, optional_1.importOptional)(() => import("hyparquet-writer"), WRITE_PACKAGES, "Parquet");
+        const buffer = parquetWriteBuffer({ columnData: columns });
+        (0, files_1.writeBinaryFile)(filePath, Buffer.from(buffer));
+    },
+};

package/dist/io/parquet/parquetSink.d.ts

@@ -0,0 +1,15 @@
+import { TableRow } from "../../types";
+import { Sink, SinkWriteOptions } from "../types";
+import { Logger } from "../../logger";
+import { ParquetColumn, ParquetLibrary } from "./parquetLibrary";
+export interface ParquetSinkOptions {
+    path: string;
+}
+export declare function parquetColumns(rows: TableRow[]): ParquetColumn[];
+export declare class ParquetSink implements Sink {
+    private readonly options;
+    private readonly logger;
+    private readonly library;
+    constructor(options: ParquetSinkOptions, logger?: Logger, library?: ParquetLibrary);
+    write(rows: TableRow[], options?: SinkWriteOptions): Promise<void>;
+}

package/dist/io/parquet/parquetSink.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParquetSink = void 0;
+exports.parquetColumns = parquetColumns;
+const fs_1 = __importDefault(require("fs"));
+const files_1 = require("../files");
+const header_1 = require("../header");
+const logger_1 = require("../../logger");
+const parquetLibrary_1 = require("./parquetLibrary");
+const INT32_MIN = -(2 ** 31);
+const INT32_MAX = 2 ** 31 - 1;
+function typeOf(values) {
+    const present = values.filter((value) => value !== null);
+    if (present.length === 0)
+        return "STRING";
+    if (!present.every((value) => typeof value === "number"))
+        return "STRING";
+    const integers = present.every((value) => Number.isInteger(value) && value >= INT32_MIN && value <= INT32_MAX);
+    return integers ? "INT32" : "DOUBLE";
+}
+function parquetColumns(rows) {
+    return (0, header_1.buildHeader)(rows).map((name) => {
+        const values = rows.map((row) => row[name] ?? null);
+        const type = typeOf(values);
+        return {
+            name,
+            type,
+            data: type === "STRING"
+                ? values.map((value) => value === null ? null : String(value))
+                : values,
+        };
+    });
+}
+class ParquetSink {
+    options;
+    logger;
+    library;
+    constructor(options, logger = logger_1.consoleLogger, library = parquetLibrary_1.parquetLibrary) {
+        this.options = options;
+        this.logger = logger;
+        this.library = library;
+    }
+    async write(rows, options = {}) {
+        const filePath = (0, files_1.extraOutputPath)(this.options.path, options.name);
+        const columns = parquetColumns(rows);
+        if (columns.length === 0) {
+            fs_1.default.rmSync(filePath, { force: true });
+            this.logger.info(`Nenhuma linha pra escrever em ${filePath}.`);
+            return;
+        }
+        await this.library.write(filePath, columns);
+        this.logger.info(`${rows.length} linhas escritas em ${filePath}.`);
+    }
+}
+exports.ParquetSink = ParquetSink;

package/dist/io/parquet/parquetSource.d.ts

@@ -0,0 +1,13 @@
+import { TableRow } from "../../types";
+import { Source } from "../types";
+import { ParquetLibrary } from "./parquetLibrary";
+export interface ParquetSourceOptions {
+    path: string;
+}
+export declare function parquetRow(record: Record<string, unknown>): TableRow;
+export declare class ParquetSource implements Source {
+    private readonly options;
+    private readonly library;
+    constructor(options: ParquetSourceOptions, library?: ParquetLibrary);
+    read(): Promise<TableRow[]>;
+}