@flowblade/sqlduck 0.11.0 → 0.12.0

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { a as assertValidAliasName, c as duckValidatorsZod, i as duckConnectionParamsZodSchema, l as duckReservedKeywords } from "./zod-CwR_oehs.mjs";
 import { BIGINT, BOOLEAN, DOUBLE, DuckDBDataChunk, DuckDBTimestampValue, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR } from "@duckdb/node-api";
 import { getLogger } from "@logtape/logtape";
 import * as z from "zod";
@@ -126,6 +127,171 @@ const flowbladeLogtapeSqlduckConfig = { categories: ["flowblade", "sqlduck"] };
 //#region src/logger/sqlduck-default-logtape-logger.ts
 const sqlduckDefaultLogtapeLogger = getLogger(flowbladeLogtapeSqlduckConfig.categories);
 //#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/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: assertNever(type);
+		}
+		if (alias !== null) parts.push("AS", `${alias}`);
+		const options = [];
+		if (isPlainObject(dbParams.options)) for (const [key, value] of Object.entries(dbParams.options)) switch (key) {
+			case "accessMode":
+				options.push(`${value}`);
+				break;
+			case "compress":
+				if (value === true) options.push("COMPRESS");
+				break;
+			case "blockSize":
+				options.push(`BLOCK_SIZE ${value}`);
+				break;
+			case "rowGroupSize":
+				options.push(`ROW_GROUP_SIZE ${value}`);
+				break;
+			case "type":
+				options.push(`TYPE ${value}`);
+				break;
+			case "storageVersion":
+				options.push(`STORAGE_VERSION '${value}'`);
+				break;
+			case "encryptionCipher":
+				options.push(`ENCRYPTION_CIPHER '${value}'`);
+				break;
+			case "encryptionKey":
+				options.push(`ENCRYPTION_KEY '${value}'`);
+				break;
+			default:
+		}
+		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 = duckConnectionParamsZodSchema.parse(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) => {
+		assertValidAliasName(dbAlias);
+		await this.#executeRawSqlCommand(`detach(${dbAlias})`, `DETACH ${dbAlias}`);
+		return true;
+	};
+	detachIfExists = async (dbAlias) => {
+		assertValidAliasName(dbAlias);
+		await this.#executeRawSqlCommand(`detachIfExists(${dbAlias})`, `DETACH IF EXISTS ${dbAlias}`);
+		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 = duckValidatorsZod.aliasName.parse(dbAlias);
+		await this.#executeRawSqlCommand(`checkpoint(${safeAlias})`, `CHECKPOINT ${safeAlias}`);
+		return true;
+	};
+	vacuum = async () => {
+		await this.#executeRawSqlCommand("vacuum()", "VACUUM");
+		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
 //#region src/table/get-duckdb-number-column-type.ts
 const isFloatValue = (value) => {
 	if (!Number.isFinite(value)) return true;
@@ -348,7 +514,7 @@ var SqlDuck = class {
 	* ```
 	*/
 	toTable = async (params) => {
-		const { table, schema, chunkSize = 2048, rowStream, createOptions, onDataAppended } = params;
+		const { table, schema, chunkSize = 2048, rowStream, createOptions, onDataAppended, autoCheckpoint = true } = 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({
@@ -380,6 +546,14 @@ var SqlDuck = class {
 				}
 			}
 			appender.closeSync();
+			if (autoCheckpoint && typeof table.databaseName === "string") {
+				const dbManager = new DuckDatabaseManager(this.#conn);
+				try {
+					await dbManager.checkpoint(table.databaseName);
+				} catch (e) {
+					this.#logger.warning(`Failed to checkpoint database '${table.databaseName}' after appending data into table '${table.getFullName()}' - ${e?.message ?? ""}`, { table: table.getFullName() });
+				}
+			}
 			const timeMs = Math.round(Date.now() - timeStart);
 			this.#logger.info(`Successfully appended ${totalRows} rows into '${table.getFullName()}' in ${timeMs}ms`, {
 				table: table.getFullName(),
@@ -412,26 +586,6 @@ const zodCodecs = {
 	})
 };
 //#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;
@@ -474,261 +628,4 @@ var Table = class Table {
 	};
 };
 //#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 = z.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 = z.strictObject({
-	ACCESS_MODE: z.optional(z.enum([
-		"READ_ONLY",
-		"READ_WRITE",
-		"AUTOMATIC"
-	])),
-	COMPRESS: z.optional(z.enum(["true", "false"])),
-	TYPE: z.optional(z.enum(["DUCKDB", "SQLITE"])),
-	BLOCK_SIZE: z.optional(z.int32().min(16384).max(262144)),
-	ROW_GROUP_SIZE: z.optional(z.int32().positive()),
-	STORAGE_VERSION: z.optional(z.string().startsWith("v").regex(/^v?\d{1,4}\.\d{1,4}\.\d{1,4}$/)),
-	ENCRYPTION_KEY: z.optional(z.string().min(8)),
-	ENCRYPTION_CIPHER: z.optional(z.enum([
-		"CBC",
-		"CTR",
-		"GCM"
-	]))
-});
-const duckDatabaseManagerDbParamsSchema = z.discriminatedUnion("type", [z.strictObject({
-	type: z.literal(":memory:"),
-	alias: duckTableAliasSchema,
-	options: z.optional(duckdbAttachOptionsSchema)
-}), z.strictObject({
-	type: z.literal("duckdb"),
-	path: z.string().min(4).endsWith(".db"),
-	alias: duckTableAliasSchema,
-	options: z.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: assertNever(type);
-		}
-		if (alias !== null) parts.push("AS", `${alias}`);
-		const options = 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 = z.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 = z.parse(duckTableAliasSchema, dbAlias);
-		await this.#executeRawSqlCommand(`detach(${safeAlias})`, `DETACH ${safeAlias}`);
-		return true;
-	};
-	detachIfExists = async (dbAlias) => {
-		const safeAlias = z.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 = z.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
-export { Database, DuckDatabaseManager, DuckMemory, SqlDuck, Table, duckDatabaseManagerDbParamsSchema, duckTableAliasSchema, duckTableNameSchema, duckdbReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };
+export { Database, DuckDatabaseManager, DuckMemory, SqlDuck, Table, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };

package/dist/types-DCqYqEsa.d.mts

@@ -0,0 +1,80 @@
+import * as z from "zod";
+
+//#region src/validation/zod/duck-connection-params-zod-schema.d.ts
+declare const duckAllConnectionOptionsZodSchema: z.ZodObject<{
+  accessMode: z.ZodOptional<z.ZodEnum<{
+    READ_ONLY: "READ_ONLY";
+    READ_WRITE: "READ_WRITE";
+  }>>;
+  compress: z.ZodOptional<z.ZodBoolean>;
+  type: z.ZodOptional<z.ZodEnum<{
+    DUCKDB: "DUCKDB";
+    SQLITE: "SQLITE";
+  }>>;
+  blockSize: z.ZodOptional<z.ZodInt32>;
+  rowGroupSize: z.ZodOptional<z.ZodInt32>;
+  storageVersion: z.ZodOptional<z.ZodString>;
+  encryptionKey: z.ZodOptional<z.ZodString>;
+  encryptionCipher: z.ZodOptional<z.ZodEnum<{
+    CBC: "CBC";
+    CTR: "CTR";
+    GCM: "GCM";
+  }>>;
+}, z.core.$strict>;
+declare const duckConnectionParamsZodSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"memory">;
+  alias: z.ZodString;
+  options: z.ZodOptional<z.ZodObject<{
+    accessMode: z.ZodOptional<z.ZodEnum<{
+      READ_ONLY: "READ_ONLY";
+      READ_WRITE: "READ_WRITE";
+    }>>;
+    compress: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodOptional<z.ZodEnum<{
+      DUCKDB: "DUCKDB";
+      SQLITE: "SQLITE";
+    }>>;
+    blockSize: z.ZodOptional<z.ZodInt32>;
+    rowGroupSize: z.ZodOptional<z.ZodInt32>;
+    storageVersion: z.ZodOptional<z.ZodString>;
+    encryptionKey: z.ZodOptional<z.ZodString>;
+    encryptionCipher: z.ZodOptional<z.ZodEnum<{
+      CBC: "CBC";
+      CTR: "CTR";
+      GCM: "GCM";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"duckdb">;
+  path: z.ZodString;
+  alias: z.ZodString;
+  options: z.ZodOptional<z.ZodObject<{
+    accessMode: z.ZodOptional<z.ZodEnum<{
+      READ_ONLY: "READ_ONLY";
+      READ_WRITE: "READ_WRITE";
+    }>>;
+    compress: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodOptional<z.ZodEnum<{
+      DUCKDB: "DUCKDB";
+      SQLITE: "SQLITE";
+    }>>;
+    blockSize: z.ZodOptional<z.ZodInt32>;
+    rowGroupSize: z.ZodOptional<z.ZodInt32>;
+    storageVersion: z.ZodOptional<z.ZodString>;
+    encryptionKey: z.ZodOptional<z.ZodString>;
+    encryptionCipher: z.ZodOptional<z.ZodEnum<{
+      CBC: "CBC";
+      CTR: "CTR";
+      GCM: "GCM";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>], "type">;
+type DuckConnectionParamsZodSchema = z.infer<typeof duckConnectionParamsZodSchema>;
+//#endregion
+//#region src/validation/core/types.d.ts
+type DuckAliasName = string;
+type DuckTableName = string;
+type DuckSchemaName = string;
+type DuckConnectionParams = DuckConnectionParamsZodSchema;
+//#endregion
+export { duckAllConnectionOptionsZodSchema as a, DuckTableName as i, DuckConnectionParams as n, duckConnectionParamsZodSchema as o, DuckSchemaName as r, DuckAliasName as t };

package/dist/validation/zod/index.d.mts

@@ -0,0 +1,37 @@
+import { a as duckAllConnectionOptionsZodSchema, i as DuckTableName, n as DuckConnectionParams, o as duckConnectionParamsZodSchema, r as DuckSchemaName, t as DuckAliasName } from "../../types-DCqYqEsa.mjs";
+import * as _$zod from "zod";
+
+//#region src/validation/zod/duck-asserts-zod.d.ts
+declare function assertValidAliasName(aliasName: string): asserts aliasName is DuckAliasName;
+declare function assertValidSchemaName(schemaName: string): asserts schemaName is DuckSchemaName;
+declare function assertValidTableName(tableName: string): asserts tableName is DuckTableName;
+//#endregion
+//#region src/validation/zod/duck-validators-zod.d.ts
+/**
+ * Common validators for duckdb parameters, tables...
+ *
+ * @example
+ * ```typescript
+ * import { duckValidatorsZod } from '@flowblade/sqlduck/zod';
+ *
+ * duckValidatorsZod.tableName.parse('my_table'); // valid
+ * duckValidatorsZod.tableName.parse('my table'); // invalid
+ * ```
+ */
+declare const duckValidatorsZod: {
+  /**
+   * Validate duckdb objects names like table, alias, and schemas
+   * for validity.
+   */
+  readonly aliasName: _$zod.ZodString;
+  readonly schemaName: _$zod.ZodString;
+  readonly tableName: _$zod.ZodString;
+};
+//#endregion
+//#region src/validation/zod/is-parsable-duck-dsn-zod.d.ts
+declare const isParsableDuckDsnZod: (dsn: unknown) => boolean;
+//#endregion
+//#region src/validation/zod/parse-duck-dsn-zod.d.ts
+declare const parseDuckDSNZod: (dsn: string) => DuckConnectionParams;
+//#endregion
+export { assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckValidatorsZod, isParsableDuckDsnZod, parseDuckDSNZod };

package/dist/validation/zod/index.mjs

@@ -0,0 +1,2 @@
+import { a as assertValidAliasName, c as duckValidatorsZod, i as duckConnectionParamsZodSchema, n as parseDuckDSNZod, o as assertValidSchemaName, r as duckAllConnectionOptionsZodSchema, s as assertValidTableName, t as isParsableDuckDsnZod } from "../../zod-CwR_oehs.mjs";
+export { assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckValidatorsZod, isParsableDuckDsnZod, parseDuckDSNZod };