@flowblade/sqlduck 0.11.0 → 0.12.0

package/dist/index.cjs

@@ -1,770 +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 _duckdb_node_api = require("@duckdb/node-api");
-let _logtape_logtape = require("@logtape/logtape");
-let zod = require("zod");
-zod = __toESM(zod);
-let _httpx_assert = require("@httpx/assert");
-let _httpx_plain_object = require("@httpx/plain-object");
-//#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/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/config/flowblade-logtape-sqlduck.config.ts
-const flowbladeLogtapeSqlduckConfig = { categories: ["flowblade", "sqlduck"] };
-//#endregion
-//#region src/logger/sqlduck-default-logtape-logger.ts
-const sqlduckDefaultLogtapeLogger = (0, _logtape_logtape.getLogger)(flowbladeLogtapeSqlduckConfig.categories);
-//#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 duckDbTypesMap = new Map([
-	["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 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 {
-	#conn;
-	#logger;
-	constructor(params) {
-		this.#conn = 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.#conn,
-			schema,
-			table,
-			options: createOptions
-		});
-		const appender = await this.#conn.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/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
-//#region src/objects/database.ts
-var Database = class {
-	#params;
-	get alias() {
-		return this.#params.alias;
-	}
-	constructor(params) {
-		this.#params = params;
-	}
-	toJson() {
-		return {
-			type: "database",
-			params: { alias: this.#params.alias }
-		};
-	}
-	[Symbol.toStringTag]() {
-		return this.alias;
-	}
-};
-//#endregion
-//#region src/objects/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/validation/core/duckdb-reserved-keywords.ts
-/**
-* DuckDB reserved keywords that cannot be used as unquoted identifiers.
-* @see https://duckdb.org/docs/sql/keywords-and-identifiers.html
-*/
-const duckdbReservedKeywords = [
-	"ALL",
-	"ANALYSE",
-	"ANALYZE",
-	"AND",
-	"ANY",
-	"ARRAY",
-	"AS",
-	"ASC",
-	"ASYMMETRIC",
-	"BOTH",
-	"CASE",
-	"CAST",
-	"CHECK",
-	"COLLATE",
-	"COLUMN",
-	"CONSTRAINT",
-	"CREATE",
-	"CROSS",
-	"CURRENT_CATALOG",
-	"CURRENT_DATE",
-	"CURRENT_ROLE",
-	"CURRENT_SCHEMA",
-	"CURRENT_TIME",
-	"CURRENT_TIMESTAMP",
-	"CURRENT_USER",
-	"DEFAULT",
-	"DEFERRABLE",
-	"DESC",
-	"DISTINCT",
-	"DO",
-	"ELSE",
-	"END",
-	"EXCEPT",
-	"EXISTS",
-	"EXTRACT",
-	"FALSE",
-	"FETCH",
-	"FOR",
-	"FOREIGN",
-	"FROM",
-	"GRANT",
-	"GROUP",
-	"HAVING",
-	"IF",
-	"ILIKE",
-	"IN",
-	"INITIALLY",
-	"INNER",
-	"INTERSECT",
-	"INTO",
-	"IS",
-	"ISNULL",
-	"JOIN",
-	"LATERAL",
-	"LEADING",
-	"LEFT",
-	"LIKE",
-	"LIMIT",
-	"LOCALTIME",
-	"LOCALTIMESTAMP",
-	"NATURAL",
-	"NOT",
-	"NOTNULL",
-	"NULL",
-	"OFFSET",
-	"ON",
-	"ONLY",
-	"OR",
-	"ORDER",
-	"OUTER",
-	"OVERLAPS",
-	"PLACING",
-	"PRIMARY",
-	"REFERENCES",
-	"RETURNING",
-	"RIGHT",
-	"ROW",
-	"SELECT",
-	"SESSION_USER",
-	"SIMILAR",
-	"SOME",
-	"SYMMETRIC",
-	"TABLE",
-	"THEN",
-	"TO",
-	"TRAILING",
-	"TRUE",
-	"UNION",
-	"UNIQUE",
-	"USING",
-	"VARIADIC",
-	"VERBOSE",
-	"WHEN",
-	"WHERE",
-	"WINDOW",
-	"WITH"
-];
-//#endregion
-//#region src/validation/zod/duckdb-valid-names.schemas.ts
-const duckdbMaximumObjectNameLength = 120;
-const duckDbObjectNameRegex = /^[a-z_]\w*$/i;
-const duckdbReservedKeywordsSet = new Set(duckdbReservedKeywords.map((k) => k.toUpperCase()));
-const duckTableNameSchema = zod.string().min(1).max(duckdbMaximumObjectNameLength).regex(duckDbObjectNameRegex, "Table name must start with a letter or underscore, and contain only letters, numbers and underscores").refine((value) => !duckdbReservedKeywordsSet.has(value.toUpperCase()), { error: `Value is a DuckDB reserved keyword and cannot be used as a table name` });
-const duckTableAliasSchema = duckTableNameSchema;
-//#endregion
-//#region src/manager/database/duck-database-manager.schemas.ts
-const duckdbAttachOptionsSchema = zod.strictObject({
-	ACCESS_MODE: zod.optional(zod.enum([
-		"READ_ONLY",
-		"READ_WRITE",
-		"AUTOMATIC"
-	])),
-	COMPRESS: zod.optional(zod.enum(["true", "false"])),
-	TYPE: zod.optional(zod.enum(["DUCKDB", "SQLITE"])),
-	BLOCK_SIZE: zod.optional(zod.int32().min(16384).max(262144)),
-	ROW_GROUP_SIZE: zod.optional(zod.int32().positive()),
-	STORAGE_VERSION: zod.optional(zod.string().startsWith("v").regex(/^v?\d{1,4}\.\d{1,4}\.\d{1,4}$/)),
-	ENCRYPTION_KEY: zod.optional(zod.string().min(8)),
-	ENCRYPTION_CIPHER: zod.optional(zod.enum([
-		"CBC",
-		"CTR",
-		"GCM"
-	]))
-});
-const duckDatabaseManagerDbParamsSchema = zod.discriminatedUnion("type", [zod.strictObject({
-	type: zod.literal(":memory:"),
-	alias: duckTableAliasSchema,
-	options: zod.optional(duckdbAttachOptionsSchema)
-}), zod.strictObject({
-	type: zod.literal("duckdb"),
-	path: zod.string().min(4).endsWith(".db"),
-	alias: duckTableAliasSchema,
-	options: zod.optional(duckdbAttachOptionsSchema)
-})]);
-//#endregion
-//#region src/manager/database/commands/duck-database-attach-command.ts
-var DuckDatabaseAttachCommand = class {
-	options;
-	dbParams;
-	constructor(dbParams, options) {
-		this.dbParams = dbParams;
-		this.options = options ?? {};
-	}
-	getRawSql = () => {
-		const dbParams = this.dbParams;
-		const parts = ["ATTACH", this.options.behaviour].filter(Boolean);
-		const { type, alias } = dbParams;
-		switch (type) {
-			case ":memory:":
-				parts.push("':memory:'");
-				break;
-			case "duckdb":
-				parts.push(`'${dbParams.path}'`);
-				break;
-			default: (0, _httpx_assert.assertNever)(type);
-		}
-		if (alias !== null) parts.push("AS", `${alias}`);
-		const options = (0, _httpx_plain_object.isPlainObject)(dbParams.options) ? Object.entries(dbParams.options).map(([key, value]) => {
-			return key === "ACCESS_MODE" ? value : `${key} '${value}'`;
-		}) : [];
-		if (options.length > 0) parts.push(`(${options.join(", ")})`);
-		return parts.filter(Boolean).join(" ");
-	};
-};
-//#endregion
-//#region src/manager/database/duck-database-manager.ts
-var DuckDatabaseManager = class {
-	#conn;
-	#logger;
-	constructor(conn, params) {
-		this.#conn = conn;
-		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: "DuckDatabaseManager" });
-	}
-	/**
-	* Attach a database to the current connection
-	*
-	* @example
-	* ```typescript
-	* const dbManager = new DuckDatabaseManager(conn);
-	* const database = dbManager.attach({
-	*   type: ':memory:', // can be 'duckdb', 's3'...
-	*   alias: 'mydb',
-	*   options: { COMPRESS: 'true' }
-	* });
-	*
-	* console.log(database.alias); // 'mydb'
-	* ```
-	*/
-	attach = async (dbParams, options) => {
-		const params = zod.parse(duckDatabaseManagerDbParamsSchema, dbParams);
-		const rawSql = new DuckDatabaseAttachCommand(params, options).getRawSql();
-		await this.#executeRawSqlCommand(`attach(${params.alias})`, rawSql);
-		return new Database({ alias: params.alias });
-	};
-	attachOrReplace = async (dbParams) => {
-		return this.attach(dbParams, { behaviour: "OR REPLACE" });
-	};
-	attachIfNotExists = async (dbParams) => {
-		return this.attach(dbParams, { behaviour: "IF NOT EXISTS" });
-	};
-	showDatabases = async () => {
-		return await this.#executeRawSqlCommand("showDatabases()", `SHOW DATABASES`);
-	};
-	detach = async (dbAlias) => {
-		const safeAlias = zod.parse(duckTableAliasSchema, dbAlias);
-		await this.#executeRawSqlCommand(`detach(${safeAlias})`, `DETACH ${safeAlias}`);
-		return true;
-	};
-	detachIfExists = async (dbAlias) => {
-		const safeAlias = zod.parse(duckTableAliasSchema, dbAlias);
-		await this.#executeRawSqlCommand(`detachIfExists(${safeAlias})`, `DETACH IF EXISTS ${safeAlias}`);
-		return true;
-	};
-	/**
-	* The statistics recomputed by the ANALYZE statement are only used for join order optimization.
-	*
-	* It is therefore recommended to recompute these statistics for improved join orders,
-	* especially after performing large updates (inserts and/or deletes).
-	*
-	* @link https://duckdb.org/docs/stable/sql/statements/analyze
-	*/
-	analyze = async () => {
-		await this.#executeRawSqlCommand("analyze()", "ANALYZE");
-		return true;
-	};
-	checkpoint = async (dbAlias) => {
-		const safeAlias = zod.parse(duckTableAliasSchema, dbAlias);
-		await this.#executeRawSqlCommand(`checkpoint(${safeAlias})`, `CHECKPOINT ${safeAlias}`);
-		return true;
-	};
-	#executeRawSqlCommand = async (name, rawSql) => {
-		const startTime = Date.now();
-		try {
-			const result = await this.#conn.runAndReadAll(rawSql);
-			const timeMs = Math.round(Date.now() - startTime);
-			const data = result.getRowObjectsJS();
-			this.#logger.info(`DuckDatabaseManager.${name} in ${timeMs}ms`, { timeMs });
-			return data;
-		} catch (e) {
-			const msg = `DuckDatabaseManager: failed to run "${name}" - ${e?.message ?? ""}`;
-			const timeMs = Math.round(Date.now() - startTime);
-			this.#logger.error(msg, {
-				name,
-				sql: rawSql,
-				timeMs
-			});
-			throw new Error(msg, { cause: e });
-		}
-	};
-};
-//#endregion
-exports.Database = Database;
-exports.DuckDatabaseManager = DuckDatabaseManager;
-exports.DuckMemory = DuckMemory;
-exports.SqlDuck = SqlDuck;
-exports.Table = Table;
-exports.duckDatabaseManagerDbParamsSchema = duckDatabaseManagerDbParamsSchema;
-exports.duckTableAliasSchema = duckTableAliasSchema;
-exports.duckTableNameSchema = duckTableNameSchema;
-exports.duckdbReservedKeywords = duckdbReservedKeywords;
-exports.flowbladeLogtapeSqlduckConfig = flowbladeLogtapeSqlduckConfig;
-exports.getTableCreateFromZod = getTableCreateFromZod;
-exports.sqlduckDefaultLogtapeLogger = sqlduckDefaultLogtapeLogger;
-exports.zodCodecs = zodCodecs;