@flowblade/sqlduck 0.10.0 → 0.12.0

package/dist/index.cjs

@@ -1,486 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let _logtape_logtape = require("@logtape/logtape");
-let _duckdb_node_api = require("@duckdb/node-api");
-let zod = require("zod");
-zod = __toESM(zod);
-//#region src/config/flowblade-logtape-sqlduck.config.ts
-const flowbladeLogtapeSqlduckConfig = { categories: ["flowblade", "sqlduck"] };
-//#endregion
-//#region src/helpers/duck-exec.ts
-var DuckExec = class {
-	#conn;
-	constructor(duckConn) {
-		this.#conn = duckConn;
-	}
-	getRowObjectJS = async (sql) => {
-		return (await this.#conn.run(sql)).getRowObjectsJS();
-	};
-	getRowObjectJson = async (sql) => {
-		return (await this.#conn.run(sql)).getRowObjectsJson();
-	};
-	getOneRowObjectJS = async (sql) => {
-		const rows = await this.getRowObjectJS(sql);
-		if (rows.length === 0) return null;
-		this.#ensureOneRow(rows);
-		return rows[0];
-	};
-	getOneRowObjectJson = async (sql) => {
-		const rows = await this.getRowObjectJson(sql);
-		if (rows.length === 0) return null;
-		this.#ensureOneRow(rows);
-		return rows[0];
-	};
-	#ensureOneRow = (rows) => {
-		if (rows.length > 1) throw new Error("Expected one row, but got multiple rows");
-	};
-};
-//#endregion
-//#region src/helpers/duck-memory.ts
-const duckMemoryTags = [
-	"BASE_TABLE",
-	"HASH_TABLE",
-	"PARQUET_READER",
-	"CSV_READER",
-	"ORDER_BY",
-	"ART_INDEX",
-	"COLUMN_DATA",
-	"METADATA",
-	"OVERFLOW_STRINGS",
-	"IN_MEMORY_TABLE",
-	"ALLOCATOR",
-	"EXTENSION",
-	"TRANSACTION",
-	"EXTERNAL_FILE_CACHE",
-	"WINDOW",
-	"OBJECT_CACHE"
-];
-const orderByParams = {
-	memory_usage_bytes_desc: "memory_usage_bytes DESC",
-	tag_desc: "tag DESC",
-	tag_asc: "tag ASC"
-};
-var DuckMemory = class {
-	#conn;
-	#exec;
-	constructor(duckdbConn) {
-		this.#conn = duckdbConn;
-		this.#exec = new DuckExec(duckdbConn);
-	}
-	getAll = async (params) => {
-		const { orderBy } = params ?? {};
-		const query = this.#applyOrderBy(`SELECT tag, memory_usage_bytes, temporary_storage_bytes 
-             FROM duckdb_memory() as m`, orderBy);
-		return (await this.#conn.run(query)).getRowObjectsJS();
-	};
-	getByTag = async (tag) => {
-		if (!duckMemoryTags.includes(tag)) throw new Error(`Invalid DuckDB memory tag: ${tag}`);
-		const query = `SELECT tag, memory_usage_bytes, temporary_storage_bytes
-                   FROM duckdb_memory() as m
-                   WHERE tag = '${tag}'`;
-		return this.#exec.getOneRowObjectJS(query);
-	};
-	getSummary = async () => {
-		const rows = await this.getAll();
-		const summaryInBytes = {
-			total: 0n,
-			totalTemp: 0n
-		};
-		for (const row of rows) {
-			summaryInBytes.total += row.memory_usage_bytes;
-			summaryInBytes.totalTemp += row.temporary_storage_bytes;
-		}
-		return {
-			totalMB: Math.round(Number(summaryInBytes.total / 1048576n)),
-			totalTempMB: Math.round(Number(summaryInBytes.totalTemp / 1048576n))
-		};
-	};
-	#applyOrderBy = (query, orderBy) => {
-		if (orderBy === void 0) return query;
-		const orderByClause = orderByParams[orderBy];
-		if (orderByClause === void 0) throw new Error(`Invalid orderBy parameter: ${orderBy}`);
-		return `${query} ORDER BY ${orderByClause}`;
-	};
-};
-//#endregion
-//#region src/logger/sqlduck-default-logtape-logger.ts
-const sqlduckDefaultLogtapeLogger = (0, _logtape_logtape.getLogger)(flowbladeLogtapeSqlduckConfig.categories);
-//#endregion
-//#region src/appender/data-appender-callback.ts
-const isOnDataAppendedAsyncCb = (v) => {
-	return v.constructor.name === "AsyncFunction";
-};
-const createOnDataAppendedCollector = () => {
-	let lastCallbackTimeStart = Date.now();
-	let appendedTotalRows = 0;
-	return (currentTotalRows) => {
-		const cbTimeMs = Math.round(Date.now() - lastCallbackTimeStart);
-		const cbTotalRows = currentTotalRows - appendedTotalRows;
-		const stats = {
-			totalRows: currentTotalRows,
-			timeMs: cbTimeMs,
-			rowsPerSecond: Math.round(cbTotalRows / cbTimeMs * 1e3)
-		};
-		appendedTotalRows = currentTotalRows;
-		lastCallbackTimeStart = Date.now();
-		return stats;
-	};
-};
-//#endregion
-//#region src/table/get-duckdb-number-column-type.ts
-const isFloatValue = (value) => {
-	if (!Number.isFinite(value)) return true;
-	if (Math.abs(value) > Number.MAX_SAFE_INTEGER) return true;
-	return !Number.isInteger(value);
-};
-const getDuckdbNumberColumnType = (params) => {
-	const { minimum, maximum } = params;
-	if (minimum === void 0 || maximum === void 0) return _duckdb_node_api.BIGINT;
-	if (isFloatValue(minimum) || isFloatValue(maximum)) {
-		if (minimum >= -34028235e31 && maximum <= 34028235e31) return _duckdb_node_api.FLOAT;
-		return _duckdb_node_api.DOUBLE;
-	}
-	if (minimum >= 0) {
-		if (maximum <= 255) return _duckdb_node_api.UTINYINT;
-		if (maximum <= 65535) return _duckdb_node_api.USMALLINT;
-		if (maximum <= 4294967295) return _duckdb_node_api.UINTEGER;
-		if (maximum <= 18446744073709551615n) return _duckdb_node_api.UBIGINT;
-		return _duckdb_node_api.UHUGEINT;
-	}
-	if (minimum >= -128 && maximum <= 127) return _duckdb_node_api.TINYINT;
-	if (minimum >= -32768 && maximum <= 32767) return _duckdb_node_api.SMALLINT;
-	if (minimum >= -2147483648 && maximum <= 2147483647) return _duckdb_node_api.INTEGER;
-	if (minimum >= -9223372036854775808n && maximum <= 9223372036854775807n) return _duckdb_node_api.BIGINT;
-	return _duckdb_node_api.HUGEINT;
-};
-//#endregion
-//#region src/table/get-table-create-from-zod.ts
-const createOptions = {
-	CREATE: "CREATE TABLE",
-	CREATE_OR_REPLACE: "CREATE OR REPLACE TABLE",
-	IF_NOT_EXISTS: "CREATE TABLE IF NOT EXISTS"
-};
-const duckDbTypes = [
-	["VARCHAR", _duckdb_node_api.VARCHAR],
-	["BIGINT", _duckdb_node_api.BIGINT],
-	["TIMESTAMP", _duckdb_node_api.TIMESTAMP],
-	["UUID", _duckdb_node_api.UUID],
-	["BOOLEAN", _duckdb_node_api.BOOLEAN],
-	["INTEGER", _duckdb_node_api.INTEGER],
-	["DOUBLE", _duckdb_node_api.DOUBLE],
-	["FLOAT", _duckdb_node_api.FLOAT]
-];
-const duckDbTypesMap = new Map(duckDbTypes);
-const getTableCreateFromZod = (params) => {
-	const { table, schema, options } = params;
-	const { create = "CREATE" } = options ?? {};
-	const fqTable = table.getFullName();
-	const json = schema.toJSONSchema({
-		target: "openapi-3.0",
-		unrepresentable: "throw"
-	});
-	const columns = [];
-	if (json.properties === void 0) throw new TypeError("Schema must have at least one property");
-	const columnTypesMap = /* @__PURE__ */ new Map();
-	for (const [columnName, def] of Object.entries(json.properties)) {
-		const { type, duckdbType, nullable, format, primaryKey, minimum, maximum } = def;
-		const c = { name: columnName };
-		if (duckdbType !== void 0 && duckDbTypesMap.has(duckdbType)) c.duckdbType = duckDbTypesMap.get(duckdbType);
-		else switch (type) {
-			case "string":
-				switch (format) {
-					case "date-time":
-						c.duckdbType = _duckdb_node_api.TIMESTAMP;
-						break;
-					case "int64":
-						c.duckdbType = _duckdb_node_api.BIGINT;
-						break;
-					case "uuid":
-						c.duckdbType = _duckdb_node_api.UUID;
-						break;
-					default: c.duckdbType = _duckdb_node_api.VARCHAR;
-				}
-				break;
-			case "number":
-				c.duckdbType = getDuckdbNumberColumnType({
-					minimum,
-					maximum
-				});
-				break;
-			case "integer":
-				c.duckdbType = getDuckdbNumberColumnType({
-					minimum,
-					maximum
-				});
-				break;
-			case "boolean":
-				c.duckdbType = _duckdb_node_api.BOOLEAN;
-				break;
-			default: throw new Error(`Cannot guess '${columnName}' type - ${JSON.stringify(def)}`);
-		}
-		if (primaryKey === true) c.constraint = "PRIMARY KEY";
-		else if (nullable !== true) c.constraint = "NOT NULL";
-		columnTypesMap.set(columnName, c.duckdbType);
-		columns.push(c);
-	}
-	return {
-		ddl: [
-			`${createOptions[create]} ${fqTable} (\n`,
-			columns.map((colDDL) => {
-				const { name, duckdbType, constraint } = colDDL;
-				return `  ${[
-					name,
-					duckdbType.toString(),
-					constraint
-				].filter(Boolean).join(" ")}`;
-			}).join(",\n"),
-			"\n)"
-		].join(""),
-		columnTypes: columnTypesMap
-	};
-};
-//#endregion
-//#region src/table/create-table-from-zod.ts
-const createTableFromZod = async (params) => {
-	const { conn, table, schema, options, logger = sqlduckDefaultLogtapeLogger } = params;
-	const { ddl, columnTypes } = getTableCreateFromZod({
-		table,
-		schema,
-		options
-	});
-	logger.debug(`Generate DDL for table '${table.getFullName()}'`, { ddl });
-	try {
-		await conn.run(ddl);
-		logger.info(`Table '${table.getFullName()}' successfully created`, { ddl });
-	} catch (e) {
-		logger.error(`Failed to create table '${table.getFullName()}': ${e.message}`, { ddl });
-		throw new Error(`Failed to create table '${table.getFullName()}': ${e.message}`, { cause: e });
-	}
-	return {
-		ddl,
-		columnTypes
-	};
-};
-//#endregion
-//#region src/utils/rows-to-columns-chunks.ts
-const toDuckValue = (value) => {
-	if (value instanceof Date) return new _duckdb_node_api.DuckDBTimestampValue(BigInt(value.getTime() * 1e3));
-	if (typeof value === "bigint") return value.toString(10);
-	return value === void 0 ? null : value;
-};
-/**
-* Similar to `rowsToColumns` but yields results in chunks to avoid buffering
-* the entire dataset in memory. Each yielded item is a columns array for up to
-* `chunkSize` rows.
-*
-* Example for chunkSize = 2:
-*   input rows: [{id:'1',name:'A'}, {id:'2',name:'B'}, {id:'3',name:'C'}]
-*   yields: [[['1','2'], ['A','B']], [['3'], ['C']]]
-*/
-async function* rowsToColumnsChunks(params) {
-	const { rows, chunkSize } = params;
-	if (!Number.isSafeInteger(chunkSize) || chunkSize <= 0) throw new Error(`chunkSize must be a positive integer, got ${chunkSize}`);
-	const first = await rows.next();
-	if (first.done) return;
-	const keys = Object.keys(first.value);
-	let columns = keys.map(() => []);
-	let rowsInChunk = 0;
-	keys.forEach((k, i) => columns[i].push(toDuckValue(first.value[k])));
-	rowsInChunk++;
-	if (rowsInChunk >= chunkSize) {
-		yield columns;
-		columns = keys.map(() => []);
-		rowsInChunk = 0;
-	}
-	for await (const row of rows) {
-		keys.forEach((k, i) => columns[i].push(toDuckValue(row[k])));
-		rowsInChunk++;
-		if (rowsInChunk >= chunkSize) {
-			yield columns;
-			columns = keys.map(() => []);
-			rowsInChunk = 0;
-		}
-	}
-	if (rowsInChunk > 0) yield columns;
-}
-//#endregion
-//#region src/sql-duck.ts
-var SqlDuck = class {
-	#duck;
-	#logger;
-	constructor(params) {
-		this.#duck = params.conn;
-		this.#logger = params.logger ?? sqlduckDefaultLogtapeLogger;
-	}
-	/**
-	* Create a table from a Zod schema and fill it with data from a row stream.
-	*
-	* @example
-	* ```typescript
-	* import * as z from 'zod';
-	*
-	* const sqlDuck = new SqlDuck({ conn: duckDbConnection });
-	*
-	* // Schema of the table, not that you can use meta to add information
-	* const userSchema = z.object({
-	*  id: z.number().int().meta({ primaryKey: true }),
-	*  name: z.string(),
-	* });
-	*
-	* // Async generator function that yields rows to insert
-	* async function* getUserRows(): AsyncIterableIterator<z.infer<typeof userSchema>> {
-	*   // database or api call
-	* }
-	*
-	* const result = sqlDuck.toTable({
-	*  table: new Table({ name: 'user', database: 'mydb' }),
-	*  schema: userSchema,
-	*  rowStream: getUserRows(),
-	*  chunkSize: 2048,
-	*  onDataAppended: ({ total }) => {
-	*    console.log(`Appended ${total} rows so far`);
-	*  },
-	*  createOptions: {
-	*    create: 'CREATE_OR_REPLACE',
-	*  },
-	* });
-	*
-	* console.log(`Inserted ${result.totalRows} rows in ${result.timeMs}ms`);
-	* console.log(`Table created with DDL: ${result.createTableDDL}`);
-	* ```
-	*/
-	toTable = async (params) => {
-		const { table, schema, chunkSize = 2048, rowStream, createOptions, onDataAppended } = params;
-		if (!Number.isSafeInteger(chunkSize) || chunkSize < 1 || chunkSize > 2048) throw new Error("chunkSize must be a number between 1 and 2048");
-		const timeStart = Date.now();
-		const { columnTypes, ddl } = await createTableFromZod({
-			conn: this.#duck,
-			schema,
-			table,
-			options: createOptions
-		});
-		const appender = await this.#duck.createAppender(table.tableName, table.schemaName, table.databaseName);
-		const chunkTypes = Array.from(columnTypes.values());
-		let totalRows = 0;
-		const dataAppendedCollector = createOnDataAppendedCollector();
-		const columnStream = rowsToColumnsChunks({
-			rows: rowStream,
-			chunkSize
-		});
-		try {
-			for await (const dataChunk of columnStream) {
-				const chunk = _duckdb_node_api.DuckDBDataChunk.create(chunkTypes);
-				this.#logger.debug(`Inserting chunk of ${dataChunk.length} rows`, { table: table.getFullName() });
-				totalRows += dataChunk?.[0]?.length ?? 0;
-				chunk.setColumns(dataChunk);
-				appender.appendDataChunk(chunk);
-				appender.flushSync();
-				if (onDataAppended !== void 0) {
-					const payload = dataAppendedCollector(totalRows);
-					if (isOnDataAppendedAsyncCb(onDataAppended)) await onDataAppended(payload);
-					else onDataAppended(payload);
-				}
-			}
-			appender.closeSync();
-			const timeMs = Math.round(Date.now() - timeStart);
-			this.#logger.info(`Successfully appended ${totalRows} rows into '${table.getFullName()}' in ${timeMs}ms`, {
-				table: table.getFullName(),
-				timeMs,
-				totalRows
-			});
-			return {
-				timeMs,
-				totalRows,
-				createTableDDL: ddl
-			};
-		} catch (e) {
-			appender.closeSync();
-			const msg = `Failed to append data into table '${table.getFullName()}' - ${e?.message ?? ""}`;
-			this.#logger.error(msg, { table: table.getFullName() });
-			throw new Error(msg, { cause: e });
-		}
-	};
-};
-//#endregion
-//#region src/table/table.ts
-var Table = class Table {
-	#fqTable;
-	get tableName() {
-		return this.#fqTable.name;
-	}
-	get schemaName() {
-		return this.#fqTable.schema;
-	}
-	get databaseName() {
-		return this.#fqTable.database;
-	}
-	constructor(fqTableOrName) {
-		this.#fqTable = typeof fqTableOrName === "string" ? { name: fqTableOrName } : fqTableOrName;
-	}
-	/**
-	* Return fully qualified table name by concatenating
-	* database, schema and table with a 'dot' separator.
-	*/
-	getFullName = (options) => {
-		const { defaultDatabase, defaultSchema } = options ?? {};
-		const { name, database = defaultDatabase, schema = defaultSchema } = this.#fqTable;
-		return [
-			database,
-			schema,
-			name
-		].filter(Boolean).join(".");
-	};
-	withDatabase = (database) => {
-		return new Table({
-			...this.#fqTable,
-			database
-		});
-	};
-	withSchema = (schema) => {
-		return new Table({
-			...this.#fqTable,
-			schema
-		});
-	};
-};
-//#endregion
-//#region src/utils/zod-codecs.ts
-const zodCodecs = {
-	dateToString: zod.codec(zod.date(), zod.iso.datetime(), {
-		decode: (date) => date.toISOString(),
-		encode: (isoString) => new Date(isoString)
-	}),
-	bigintToString: zod.codec(zod.bigint(), zod.string().meta({ format: "int64" }), {
-		decode: (bigint) => bigint.toString(),
-		encode: BigInt
-	})
-};
-//#endregion
-exports.DuckMemory = DuckMemory;
-exports.SqlDuck = SqlDuck;
-exports.Table = Table;
-exports.flowbladeLogtapeSqlduckConfig = flowbladeLogtapeSqlduckConfig;
-exports.getTableCreateFromZod = getTableCreateFromZod;
-exports.sqlduckDefaultLogtapeLogger = sqlduckDefaultLogtapeLogger;
-exports.zodCodecs = zodCodecs;

package/dist/index.d.cts

@@ -1,211 +0,0 @@
-import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
-import * as _logtape_logtape0 from "@logtape/logtape";
-import { Logger } from "@logtape/logtape";
-import * as z from "zod";
-import { ZodObject } from "zod";
-
-//#region src/appender/data-appender-callback.d.ts
-type OnDataAppendedStats = {
-  /**
-   * Total number of rows appended so far (all batches included)
-   */
-  totalRows: number;
-  /**
-   * Time taken to append the last batch in milliseconds
-   */
-  timeMs: number;
-  /**
-   * Estimated rows per seconds based on the current batch
-   */
-  rowsPerSecond: number;
-};
-type OnDataAppendedSyncCb = (stats: OnDataAppendedStats) => void;
-type OnDataAppendedAsyncCb = (stats: OnDataAppendedStats) => Promise<void>;
-type OnDataAppendedCb = OnDataAppendedSyncCb | OnDataAppendedAsyncCb;
-//#endregion
-//#region src/config/flowblade-logtape-sqlduck.config.d.ts
-declare const flowbladeLogtapeSqlduckConfig: {
-  categories: string[];
-};
-//#endregion
-//#region src/helpers/duck-memory.d.ts
-declare const duckMemoryTags: readonly ["BASE_TABLE", "HASH_TABLE", "PARQUET_READER", "CSV_READER", "ORDER_BY", "ART_INDEX", "COLUMN_DATA", "METADATA", "OVERFLOW_STRINGS", "IN_MEMORY_TABLE", "ALLOCATOR", "EXTENSION", "TRANSACTION", "EXTERNAL_FILE_CACHE", "WINDOW", "OBJECT_CACHE"];
-type DuckMemoryTag = (typeof duckMemoryTags)[number];
-type DuckMemoryRow = {
-  tag: DuckMemoryTag;
-  memory_usage_bytes: bigint;
-  temporary_storage_bytes: bigint;
-};
-declare const orderByParams: {
-  memory_usage_bytes_desc: string;
-  tag_desc: string;
-  tag_asc: string;
-};
-type OrderByParams = keyof typeof orderByParams;
-type DuckMemorySummary = {
-  totalMB: number;
-  totalTempMB: number;
-};
-declare class DuckMemory {
-  #private;
-  constructor(duckdbConn: DuckDBConnection);
-  getAll: (params?: {
-    orderBy?: OrderByParams;
-  }) => Promise<DuckMemoryRow[]>;
-  getByTag: (tag: DuckMemoryTag) => Promise<DuckMemoryRow | null>;
-  getSummary: () => Promise<DuckMemorySummary>;
-}
-//#endregion
-//#region src/logger/sqlduck-default-logtape-logger.d.ts
-declare const sqlduckDefaultLogtapeLogger: _logtape_logtape0.Logger;
-//#endregion
-//#region src/table/table.d.ts
-/**
- * Fully qualified table information
- */
-type FQTable = {
-  name: string;
-  schema?: string;
-  database?: string;
-};
-declare class Table {
-  #private;
-  get tableName(): string;
-  get schemaName(): string | undefined;
-  get databaseName(): string | undefined;
-  constructor(fqTableOrName: FQTable | string);
-  /**
-   * Return fully qualified table name by concatenating
-   * database, schema and table with a 'dot' separator.
-   */
-  getFullName: (options?: {
-    defaultDatabase?: string;
-    defaultSchema?: string;
-  }) => string;
-  withDatabase: (database: string) => Table;
-  withSchema: (schema: string) => Table;
-}
-//#endregion
-//#region src/table/table-schema-zod.type.d.ts
-type ZodSchemaSupportedTypes = z.ZodString | z.ZodNumber | z.ZodInt | z.ZodInt32 | z.ZodUInt32 | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodISODateTime | z.ZodISOTime | z.ZodISODate | z.ZodEmail | z.ZodURL | z.ZodUUID | z.ZodCUID | z.ZodCUID2 | z.ZodULID;
-type TableSchemaZod = z.ZodObject<Record<string, ZodSchemaSupportedTypes | z.ZodNullable<ZodSchemaSupportedTypes> | z.ZodCodec | z.ZodNullable<z.ZodCodec>>>;
-//#endregion
-//#region src/table/get-table-create-from-zod.d.ts
-type TableCreateOptions = {
-  create?: 'CREATE' | 'CREATE_OR_REPLACE' | 'IF_NOT_EXISTS';
-};
-type DuckdbColumnTypeMap<TKeys extends string> = Map<TKeys, DuckDBType>;
-type TableCreateFromZodResult<TSchema extends TableSchemaZod> = {
-  ddl: string;
-  columnTypes: DuckdbColumnTypeMap<Exclude<keyof TSchema['shape'], symbol | number>>;
-};
-type GetTableCreateFromZodParams<TSchema extends TableSchemaZod> = {
-  table: Table;
-  schema: TSchema;
-  options?: TableCreateOptions;
-};
-declare const getTableCreateFromZod: <TSchema extends TableSchemaZod>(params: GetTableCreateFromZodParams<TSchema>) => TableCreateFromZodResult<TSchema>;
-//#endregion
-//#region src/sql-duck.d.ts
-type SqlDuckParams = {
-  conn: DuckDBConnection;
-  /**
-   * Optional logtape/logger to use for logging.
-   * If not provided, a default logger will be used.
-   * @see {@link https://github.com/logtape/logtape}
-   */
-  logger?: Logger;
-};
-type RowStream<T> = AsyncIterableIterator<T> | AsyncGenerator<T> | Generator<T>;
-type ToTableParams<TSchema extends TableSchemaZod> = {
-  /**
-   * Used to create and fill the data into the table
-   */
-  table: Table;
-  /**
-   * Schema describing the table structure and rowStream content
-   */
-  schema: TSchema;
-  /**
-   * Stream of rows to insert into the table
-   */
-  rowStream: RowStream<z.infer<TSchema>>;
-  /**
-   * Chunk size when using appender to insert data.
-   * Valid numbers between 1 and 2048.
-   * @default 2048
-   */
-  chunkSize?: number;
-  /**
-   * Extra options when creating the table
-   */
-  createOptions?: TableCreateOptions;
-  /**
-   * Callback called each time a datachunk is appended to the table
-   */
-  onDataAppended?: OnDataAppendedCb;
-};
-type ToTableResult = {
-  /**
-   * Total time taken to insert the data in milliseconds.
-   */
-  timeMs: number;
-  /**
-   * Total number of rows inserted into the table.
-   */
-  totalRows: number;
-  /**
-   * The DDL statement used to create the table.
-   */
-  createTableDDL: string;
-};
-declare class SqlDuck {
-  #private;
-  constructor(params: SqlDuckParams);
-  /**
-   * Create a table from a Zod schema and fill it with data from a row stream.
-   *
-   * @example
-   * ```typescript
-   * import * as z from 'zod';
-   *
-   * const sqlDuck = new SqlDuck({ conn: duckDbConnection });
-   *
-   * // Schema of the table, not that you can use meta to add information
-   * const userSchema = z.object({
-   *  id: z.number().int().meta({ primaryKey: true }),
-   *  name: z.string(),
-   * });
-   *
-   * // Async generator function that yields rows to insert
-   * async function* getUserRows(): AsyncIterableIterator<z.infer<typeof userSchema>> {
-   *   // database or api call
-   * }
-   *
-   * const result = sqlDuck.toTable({
-   *  table: new Table({ name: 'user', database: 'mydb' }),
-   *  schema: userSchema,
-   *  rowStream: getUserRows(),
-   *  chunkSize: 2048,
-   *  onDataAppended: ({ total }) => {
-   *    console.log(`Appended ${total} rows so far`);
-   *  },
-   *  createOptions: {
-   *    create: 'CREATE_OR_REPLACE',
-   *  },
-   * });
-   *
-   * console.log(`Inserted ${result.totalRows} rows in ${result.timeMs}ms`);
-   * console.log(`Table created with DDL: ${result.createTableDDL}`);
-   * ```
-   */
-  toTable: <TSchema extends ZodObject>(params: ToTableParams<TSchema>) => Promise<ToTableResult>;
-}
-//#endregion
-//#region src/utils/zod-codecs.d.ts
-declare const zodCodecs: {
-  readonly dateToString: z.ZodCodec<z.ZodDate, z.ZodISODateTime>;
-  readonly bigintToString: z.ZodCodec<z.ZodBigInt, z.ZodString>;
-};
-//#endregion
-export { DuckMemory, DuckMemoryTag, type OnDataAppendedCb, type OnDataAppendedStats, SqlDuck, type SqlDuckParams, Table, type ToTableParams, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };