@flowblade/sqlduck 0.17.2 → 0.17.3

package/README.md

@@ -128,76 +128,75 @@ const queryResult = await dbDuckDbMemoryConn.query<{
 
 ## Benchmarks
 
-### Node 24
+### Node 24.15
 
 ```
+ RUN  v4.1.5 /home/sebastien/github/flowblade/packages/sqlduck
 
- RUN  v4.1.4 /home/sebastien/github/flowblade/packages/sqlduck
 
+ ✓ bench/appender.bench.ts > appender benches 3477ms
+     name                                                        hz     min     max    mean     p75     p99    p995    p999      rme  samples
+   · duckdb appender memory, count: 100000, chunk size 2048  2.9578  336.81  339.37  338.09  339.37  339.37  339.37  339.37   ±4.82%        2
+   · duckdb appender file, count: 100000, chunk size 2048    1.5359  651.07  651.07  651.07  651.07  651.07  651.07  651.07   ±0.00%        1
+   · duckdb appender, count: 100000, chunk size 1024         2.8450  328.25  374.74  351.50  374.74  374.74  374.74  374.74  ±84.06%        2
 
- ✓ bench/appender.bench.ts > appender benches 2910ms
-     name                                                        hz     min     max    mean     p75     p99    p995    p999       rme  samples
-   · duckdb appender memory, count: 100000, chunk size 2048  3.5446  265.91  298.32  282.12  298.32  298.32  298.32  298.32   ±72.99%        2
-   · duckdb appender file, count: 100000, chunk size 2048    2.6130  355.30  410.10  382.70  410.10  410.10  410.10  410.10   ±91.00%        2
-   · duckdb appender, count: 100000, chunk size 1024         3.8027  226.52  299.42  262.97  299.42  299.42  299.42  299.42  ±176.17%        2
-
- ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 2998ms
+ ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 3514ms
      name                                                                         hz      min     max     mean      p75     p99    p995    p999      rme  samples
-   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   11.3182  60.6404  190.56  88.3532  79.4999  190.56  190.56  190.56  ±30.64%       10
-   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  13.4430  63.9716  102.73  74.3883  75.2151  102.73  102.73  102.73  ±10.40%       10
-   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    10.7785  84.3040  117.57  92.7773  97.1595  117.57  117.57  117.57   ±7.61%       10
+   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   10.6932  76.7549  197.03  93.5173  88.9991  197.03  197.03  197.03  ±28.09%       10
+   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  10.2660  87.8295  141.15  97.4092  97.0299  141.15  141.15  141.15  ±11.56%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 100000)                     8.3811   113.83  136.27   119.32   118.84  136.27  136.27  136.27   ±4.30%       10
 
- ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 615ms
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 614ms
      name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · getTableCreateFromZod  27,048.71  0.0239  3.2029  0.0370  0.0404  0.1310  0.1980  0.5674  ±2.08%    13525
+   · getTableCreateFromZod  20,399.65  0.0328  1.2897  0.0490  0.0425  0.1957  0.2681  0.6023  ±1.77%    10201
 
  BENCH  Summary
 
-  duckdb appender, count: 100000, chunk size 1024 - bench/appender.bench.ts > appender benches
-    1.07x faster than duckdb appender memory, count: 100000, chunk size 2048
-    1.46x faster than duckdb appender file, count: 100000, chunk size 2048
+  duckdb appender memory, count: 100000, chunk size 2048 - bench/appender.bench.ts > appender benches
+    1.04x faster than duckdb appender, count: 100000, chunk size 1024
+    1.93x faster than duckdb appender file, count: 100000, chunk size 2048
 
-  rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
-    1.19x faster than rowToColumnsChunk with chunkSize 2048 (count: 100000)
-    1.25x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
+  rowToColumnsChunk with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
+    1.04x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
+    1.28x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
 
   getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
+
 ```
 
-### Bun 1.3.12
+### Bun 1.3.13
 
 ```
- RUN  v4.1.4 /home/sebastien/github/flowblade/packages/sqlduck
+ RUN  v4.1.5 /home/sebastien/github/flowblade/packages/sqlduck
 
 
- ✓ bench/appender.bench.ts > appender benches 2811ms
+ ✓ bench/appender.bench.ts > appender benches 3382ms
      name                                                        hz     min     max    mean     p75     p99    p995    p999      rme  samples
-   · duckdb appender memory, count: 100000, chunk size 2048  3.9242  224.75  285.38  254.83  285.38  285.38  285.38  285.38  ±29.56%        3
-   · duckdb appender file, count: 100000, chunk size 2048    3.8209  256.09  267.34  261.72  267.34  267.34  267.34  267.34  ±27.31%        2
-   · duckdb appender, count: 100000, chunk size 1024         4.6118  196.77  234.22  216.84  234.22  234.22  234.22  234.22  ±21.62%        3
+   · duckdb appender memory, count: 100000, chunk size 2048  3.0570  310.57  343.67  327.12  343.67  343.67  343.67  343.67  ±64.30%        2
+   · duckdb appender file, count: 100000, chunk size 2048    2.6163  377.75  386.70  382.22  386.70  386.70  386.70  386.70  ±14.88%        2
+   · duckdb appender, count: 100000, chunk size 1024         3.0427  319.38  337.93  328.65  337.93  337.93  337.93  337.93  ±35.86%        2
 
- ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 2667ms
+ ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 3075ms
      name                                                                         hz      min      max     mean      p75      p99     p995     p999     rme  samples
-   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   14.4994  57.7717  81.8690  68.9683  78.5234  81.8690  81.8690  81.8690  ±9.43%       10
-   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  13.2052  68.7139  96.8400  75.7275  79.4380  96.8400  96.8400  96.8400  ±8.22%       10
-   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    12.7827  73.9127  85.0696  78.2310  82.5510  85.0696  85.0696  85.0696  ±3.69%       10
+   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   12.5039  68.9091  89.8222  79.9751  84.4430  89.8222  89.8222  89.8222  ±5.45%       10
+   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  10.9097  83.6090   124.66  91.6616  92.3154   124.66   124.66   124.66  ±9.42%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    10.2729  90.7410   104.18  97.3436   100.41   104.18   104.18   104.18  ±2.93%       10
 
- ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 624ms
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 629ms
      name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · getTableCreateFromZod  28,477.04  0.0191  6.4836  0.0351  0.0335  0.1071  0.1530  2.4823  ±6.21%    14239
+   · getTableCreateFromZod  20,285.23  0.0260  6.9886  0.0493  0.0466  0.1700  0.2249  2.6988  ±6.12%    10143
 
  BENCH  Summary
 
   rowToColumnsChunk with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
-    1.10x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
-    1.13x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
+    1.15x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
+    1.22x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
 
   getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
 
-  duckdb appender, count: 100000, chunk size 1024 - bench/appender.bench.ts > appender benches
-    1.18x faster than duckdb appender memory, count: 100000, chunk size 2048
-    1.21x faster than duckdb appender file, count: 100000, chunk size 2048
-
+  duckdb appender memory, count: 100000, chunk size 2048 - bench/appender.bench.ts > appender benches
+    1.00x faster than duckdb appender, count: 100000, chunk size 1024
+    1.17x faster than duckdb appender file, count: 100000, chunk size 2048
 ```
 
 ### Local scripts

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 import { n as DuckConnectionParams } from "./types-dnhcognF.mjs";
-import * as _$_duckdb_node_api0 from "@duckdb/node-api";
 import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
 import * as _$_logtape_logtape0 from "@logtape/logtape";
 import { Logger } from "@logtape/logtape";
@@ -276,6 +275,7 @@ type DuckDatabaseAttachCommandOptions = {
 //#region src/manager/database/duck-database-manager.d.ts
 declare class DuckDatabaseManager {
   #private;
+  readonly className = "DuckDatabaseManager";
   constructor(conn: DuckDBConnection, params?: {
     logger?: Logger;
   });
@@ -297,7 +297,7 @@ declare class DuckDatabaseManager {
   attach: (dbParams: DuckConnectionParams, options?: DuckDatabaseAttachCommandOptions) => Promise<Database>;
   attachOrReplace: (dbParams: DuckConnectionParams) => Promise<Database>;
   attachIfNotExists: (dbParams: DuckConnectionParams) => Promise<Database>;
-  showDatabases: () => Promise<Record<string, _$_duckdb_node_api0.JS>[]>;
+  showDatabases: () => Promise<Record<string, unknown>[]>;
   detach: (dbAlias: string) => Promise<boolean>;
   detachIfExists: (dbAlias: string) => Promise<boolean>;
   /**
@@ -322,6 +322,36 @@ declare class DuckDatabaseManager {
   }>;
 }
 //#endregion
+//#region src/manager/extensions/duck-extensions-manager.d.ts
+declare class DuckExtensionsManager {
+  #private;
+  readonly className = "DuckExtensionsManager";
+  constructor(conn: DuckDBConnection, params?: {
+    logger?: Logger;
+  });
+  install: (name: string, params?: {
+    force?: boolean;
+  }) => Promise<true>;
+  search: (filters?: {
+    installed?: boolean;
+    name?: string;
+  }) => Promise<{
+    extension_name: string;
+    installed: boolean;
+    description: string;
+  }[]>;
+}
+//#endregion
+//#region src/manager/settings/duck-settings-manager.d.ts
+declare class DuckSettingsManager {
+  #private;
+  readonly className = "DuckSettingsManager";
+  constructor(conn: DuckDBConnection, params?: {
+    logger?: Logger;
+  });
+  getCurrentSettings: <T extends string>(settings: T[]) => Promise<Record<T, string>>;
+}
+//#endregion
 //#region src/config/flowblade-logtape-sqlduck.config.d.ts
 declare const flowbladeLogtapeSqlduckConfig: {
   categories: string[];
@@ -330,4 +360,4 @@ declare const flowbladeLogtapeSqlduckConfig: {
 //#region src/logger/sqlduck-default-logtape-logger.d.ts
 declare const sqlduckDefaultLogtapeLogger: _$_logtape_logtape0.Logger;
 //#endregion
-export { Database, type DuckConnectionParams, DuckDatabaseManager, DuckMemory, type DuckMemoryTag, type DuckdbReservedKeywords, type OnChunkAppendedCb, type OnChunkAppendedStats, SqlDuck, type SqlDuckParams, Table, type ToTableParams, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };
+export { Database, type DuckConnectionParams, DuckDatabaseManager, DuckExtensionsManager, DuckMemory, type DuckMemoryTag, DuckSettingsManager, type DuckdbReservedKeywords, type OnChunkAppendedCb, type OnChunkAppendedStats, SqlDuck, type SqlDuckParams, Table, type ToTableParams, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as duckReservedKeywords } from "./duck-reserved-keywords-B8XUjnaY.mjs";
-import { c as duckValidatorsZod, r as assertValidAliasName, s as duckConnectionParamsZodSchema } from "./zod-D87TPB5c.mjs";
+import { c as duckValidatorsZod, r as assertValidAliasName, s as duckConnectionParamsZodSchema } from "./zod-CVF6XJKu.mjs";
 import { BIGINT, BOOLEAN, DOUBLE, DuckDBDataChunk, DuckDBInstanceCache, DuckDBTimestampMillisecondsValue, DuckDBTypeId, ENUM, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TIMESTAMP_MS, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR } from "@duckdb/node-api";
 import { getLogger } from "@logtape/logtape";
 import fs from "node:fs";
@@ -331,6 +331,38 @@ var Database = class {
 	}
 };
 //#endregion
+//#region src/manager/core/manager-query-executor.ts
+var ManagerQueryExecutor = class {
+	#conn;
+	#logger;
+	#className;
+	constructor(conn, className, params) {
+		this.#conn = conn;
+		this.#logger = params.logger;
+		this.#className = className;
+	}
+	getRowObjectsJS = async (name, rawSql) => {
+		const fnName = `${this.#className}.${name}`;
+		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.debug(`${fnName} in ${timeMs}ms`, { timeMs });
+			return data;
+		} catch (e) {
+			const msg = `Failed to run "${fnName}" - ${e?.message ?? ""}`;
+			const timeMs = Math.round(Date.now() - startTime);
+			this.#logger.error(msg, {
+				name: fnName,
+				sql: rawSql,
+				timeMs
+			});
+			throw new Error(msg, { cause: e });
+		}
+	};
+};
+//#endregion
 //#region src/manager/database/commands/duck-database-attach-command.ts
 var DuckDatabaseAttachCommand = class {
 	options;
@@ -391,9 +423,12 @@ var DuckDatabaseManager = class {
 	#conn;
 	#logger;
 	#fs;
+	#executor;
+	className = "DuckDatabaseManager";
 	constructor(conn, params) {
 		this.#conn = conn;
-		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: "DuckDatabaseManager" });
+		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: this.className });
+		this.#executor = new ManagerQueryExecutor(this.#conn, this.className, { logger: this.#logger });
 	}
 	/**
 	* Attach a database to the current connection
@@ -414,7 +449,7 @@ var DuckDatabaseManager = class {
 		const params = duckConnectionParamsZodSchema.parse(dbParams);
 		const rawSql = new DuckDatabaseAttachCommand(params, options).getRawSql();
 		const { behaviour } = options ?? {};
-		await this.#executeRawSqlCommand([
+		await this.#executor.getRowObjectsJS([
 			`attach(${params.alias}`,
 			behaviour ?? null,
 			")"
@@ -428,16 +463,16 @@ var DuckDatabaseManager = class {
 		return this.attach(dbParams, { behaviour: "IF NOT EXISTS" });
 	};
 	showDatabases = async () => {
-		return await this.#executeRawSqlCommand("showDatabases()", `SHOW DATABASES`);
+		return await this.#executor.getRowObjectsJS("showDatabases()", `SHOW DATABASES`);
 	};
 	detach = async (dbAlias) => {
 		assertValidAliasName(dbAlias);
-		await this.#executeRawSqlCommand(`detach(${dbAlias})`, `DETACH ${dbAlias}`);
+		await this.#executor.getRowObjectsJS(`detach(${dbAlias})`, `DETACH ${dbAlias}`);
 		return true;
 	};
 	detachIfExists = async (dbAlias) => {
 		assertValidAliasName(dbAlias);
-		await this.#executeRawSqlCommand(`detachIfExists(${dbAlias})`, `DETACH IF EXISTS ${dbAlias}`);
+		await this.#executor.getRowObjectsJS(`detachIfExists(${dbAlias})`, `DETACH IF EXISTS ${dbAlias}`);
 		return true;
 	};
 	/**
@@ -449,16 +484,16 @@ var DuckDatabaseManager = class {
 	* @link https://duckdb.org/docs/stable/sql/statements/analyze
 	*/
 	analyze = async () => {
-		await this.#executeRawSqlCommand("analyze()", "ANALYZE");
+		await this.#executor.getRowObjectsJS("analyze()", "ANALYZE");
 		return true;
 	};
 	checkpoint = async (dbAlias) => {
 		const safeAlias = duckValidatorsZod.aliasName.parse(dbAlias);
-		await this.#executeRawSqlCommand(`checkpoint(${safeAlias})`, `CHECKPOINT ${safeAlias}`);
+		await this.#executor.getRowObjectsJS(`checkpoint(${safeAlias})`, `CHECKPOINT ${safeAlias}`);
 		return true;
 	};
 	vacuum = async () => {
-		await this.#executeRawSqlCommand("vacuum()", "VACUUM");
+		await this.#executor.getRowObjectsJS("vacuum()", "VACUUM");
 		return true;
 	};
 	/**
@@ -487,25 +522,6 @@ var DuckDatabaseManager = class {
 		}
 		return { status: "created" };
 	};
-	#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.debug(`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 });
-		}
-	};
 	#getFs = () => {
 		if (this.#fs === void 0) this.#fs = new FileSystemUtils({ logger: this.#logger });
 		return this.#fs;
@@ -929,4 +945,61 @@ var Table = class Table {
 	};
 };
 //#endregion
-export { Database, DuckDatabaseManager, DuckMemory, SqlDuck, Table, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };
+//#region src/manager/extensions/duck-extensions-manager.ts
+var DuckExtensionsManager = class {
+	#conn;
+	#logger;
+	#executor;
+	className = "DuckExtensionsManager";
+	constructor(conn, params) {
+		this.#conn = conn;
+		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: this.className });
+		this.#executor = new ManagerQueryExecutor(this.#conn, this.className, { logger: this.#logger });
+	}
+	install = async (name, params) => {
+		const { force } = params ?? {};
+		await this.#executor.getRowObjectsJS("install", `${force ? "FORCE " : ""} INSTALL ${name}`);
+		return true;
+	};
+	search = async (filters) => {
+		const { installed, name } = filters ?? {};
+		const conditions = [installed === void 0 ? "" : `installed = ${installed ? "true" : "false"}`, name === void 0 ? "" : `extension_name = '${name}'`].filter(Boolean);
+		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+		return await this.#executor.getRowObjectsJS("showExtensions", `
+         SELECT extension_name, installed, description
+         FROM duckdb_extensions()
+         ${where}
+         ORDER BY extension_name
+      `);
+	};
+};
+//#endregion
+//#region src/manager/settings/duck-settings-manager.ts
+var DuckSettingsManager = class {
+	#conn;
+	#logger;
+	#executor;
+	className = "DuckSettingsManager";
+	constructor(conn, params) {
+		this.#conn = conn;
+		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: this.className });
+		this.#executor = new ManagerQueryExecutor(this.#conn, this.className, { logger: this.#logger });
+	}
+	getCurrentSettings = async (settings) => {
+		const fnName = `${this.className}.getCurrentSettings`;
+		const query = `SELECT ${settings.map((s) => {
+			return `current_setting('${s}') as '${s}'`;
+		}).join(",\n")}`;
+		const firstRow = (await this.#executor.getRowObjectsJS(fnName, query))[0];
+		if (firstRow === void 0) {
+			const msg = `Failed to get current settings - no rows returned`;
+			this.#logger.error(msg, { sql: query });
+			throw new Error(msg);
+		}
+		const currentSettings = {};
+		for (const [key, value] of Object.entries(firstRow)) currentSettings[key] = typeof value === "string" ? value : String(value);
+		return currentSettings;
+	};
+};
+//#endregion
+export { Database, DuckDatabaseManager, DuckExtensionsManager, DuckMemory, DuckSettingsManager, SqlDuck, Table, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };

package/dist/validation/valibot/index.mjs

@@ -19,6 +19,10 @@ const duckIdentifierValibotSchema = v.pipe(v.string(), v.minLength(1), v.maxLeng
 * ```
 */
 const duckValidatorsValibot = {
+	/**
+	* Validate duckdb objects names like table, alias, and schemas
+	* for validity.
+	*/
 	aliasName: duckIdentifierValibotSchema,
 	schemaName: duckIdentifierValibotSchema,
 	tableName: duckIdentifierValibotSchema

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

@@ -7,7 +7,7 @@ declare function assertValidSchemaName(schemaName: string): asserts schemaName i
 declare function assertValidTableName(tableName: string): asserts tableName is DuckTableName;
 //#endregion
 //#region src/validation/zod/duck-dsn-zod-schema.d.ts
-declare const duckDsnZodSchema: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodTransform<{
+declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<{
   type: "memory";
   alias: string;
   options?: {
@@ -34,7 +34,7 @@ declare const duckDsnZodSchema: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodTransform<
     encryptionKey?: string | undefined;
     encryptionCipher?: "CBC" | "CTR" | "GCM" | undefined;
   } | undefined;
-}, string>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+}, string>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
   type: z.ZodLiteral<"memory">;
   alias: z.ZodString;
   options: z.ZodOptional<z.ZodObject<{
@@ -85,7 +85,7 @@ declare const duckDsnZodSchema: z.ZodPipe<z.ZodString, z.ZodPipe<z.ZodTransform<
       GCM: "GCM";
     }>>;
   }, z.core.$strict>>;
-}, z.core.$strict>], "type">>>;
+}, z.core.$strict>], "type">>;
 //#endregion
 //#region src/validation/zod/duck-validators-zod.d.ts
 /**

package/dist/validation/zod/index.mjs

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

package/dist/{zod-D87TPB5c.mjs → zod-CVF6XJKu.mjs}

@@ -21,6 +21,10 @@ const duckIdentifierZodSchema = z.string().min(1).max(120).regex(duckIdentifierN
 * ```
 */
 const duckValidatorsZod = {
+	/**
+	* Validate duckdb objects names like table, alias, and schemas
+	* for validity.
+	*/
 	aliasName: duckIdentifierZodSchema,
 	schemaName: duckIdentifierZodSchema,
 	tableName: duckIdentifierZodSchema
@@ -75,26 +79,24 @@ function assertValidTableName(tableName) {
 }
 //#endregion
 //#region src/validation/zod/duck-dsn-zod-schema.ts
-const duckDsnZodSchema = z.string().pipe(z.preprocess((dsn, ctx) => {
+const duckDsnZodSchema = z.string().transform((dsn, ctx) => {
 	const result = parseDsn(dsn);
-	if (result.success) {
-		const parsed = result.value;
-		const { path, ...options } = parsed.params ?? {};
-		return {
-			type: parsed.host,
-			alias: parsed.db,
-			...path ? { path } : {},
-			options: { ...options }
-		};
-	} else {
-		ctx.issues.push({
+	if (!result.success) {
+		ctx.addIssue({
 			code: "custom",
-			message: result.message,
-			input: dsn
+			message: result.message
 		});
 		return z.NEVER;
 	}
-}, duckConnectionParamsZodSchema));
+	const parsed = result.value;
+	const { path, ...options } = parsed.params ?? {};
+	return {
+		type: parsed.host,
+		alias: parsed.db,
+		...path === void 0 ? {} : { path },
+		options: { ...options }
+	};
+}).pipe(duckConnectionParamsZodSchema);
 //#endregion
 //#region src/validation/zod/ensure-zod-table-schema.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.17.2",
+  "version": "0.17.3",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -59,14 +59,14 @@
     "@flowblade/core": "^0.2.28",
     "@flowblade/source-duckdb": "^0.20.5",
     "@flowblade/sql-tag": "^0.3.3",
-    "@httpx/assert": "^0.16.9",
-    "@httpx/dsn-parser": "^1.9.9",
+    "@httpx/assert": "^0.17.0",
+    "@httpx/dsn-parser": "^1.9.10",
     "@httpx/plain-object": "^2.1.9",
-    "@logtape/logtape": "^2.0.5",
+    "@logtape/logtape": "^2.0.6",
     "@standard-schema/spec": "^1.1.0",
     "is-safe-filename": "0.1.1",
-    "p-queue": "9.1.2",
-    "zod": "^4.3.6"
+    "p-queue": "9.2.0",
+    "zod": "^4.4.2"
   },
   "peerDependencies": {
     "@duckdb/node-api": "^1.5.2-r.1",
@@ -78,34 +78,34 @@
     }
   },
   "devDependencies": {
-    "@belgattitude/eslint-config-bases": "8.13.0",
-    "@dotenvx/dotenvx": "1.61.0",
+    "@belgattitude/eslint-config-bases": "8.14.0",
+    "@dotenvx/dotenvx": "1.64.0",
     "@duckdb/node-api": "1.5.2-r.1",
     "@faker-js/faker": "10.4.0",
     "@flowblade/source-kysely": "^1.3.3",
-    "@httpx/assert": "0.16.9",
+    "@httpx/assert": "0.17.0",
     "@mitata/counters": "0.0.8",
     "@size-limit/esbuild": "12.1.0",
     "@size-limit/file": "12.1.0",
     "@testcontainers/mssqlserver": "11.14.0",
     "@total-typescript/ts-reset": "0.6.1",
     "@types/node": "25.6.0",
-    "@typescript-eslint/eslint-plugin": "8.58.2",
-    "@typescript-eslint/parser": "8.58.2",
-    "@typescript/native-preview": "7.0.0-dev.20260415.1",
-    "@vitest/coverage-v8": "4.1.4",
-    "@vitest/ui": "4.1.4",
+    "@typescript-eslint/eslint-plugin": "8.59.1",
+    "@typescript-eslint/parser": "8.59.1",
+    "@typescript/native-preview": "7.0.0-dev.20260501.1",
+    "@vitest/coverage-v8": "4.1.5",
+    "@vitest/ui": "4.1.5",
     "ansis": "4.2.0",
     "browserslist-to-esbuild": "2.1.1",
     "core-js": "3.49.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.4",
-    "es-toolkit": "1.45.1",
+    "es-toolkit": "1.46.1",
     "esbuild": "0.28.0",
     "eslint": "8.57.1",
     "execa": "9.6.1",
     "is-in-ci": "2.0.0",
-    "kysely": "0.28.16",
+    "kysely": "0.28.17",
     "mitata": "1.0.34",
     "npm-run-all2": "8.0.4",
     "prettier": "3.8.3",
@@ -117,13 +117,13 @@
     "tarn": "3.0.2",
     "tedious": "19.2.1",
     "testcontainers": "11.14.0",
-    "tsdown": "0.21.9",
+    "tsdown": "0.21.10",
     "tsx": "4.21.0",
     "typedoc": "0.28.19",
     "typedoc-plugin-markdown": "4.11.0",
-    "typescript": "6.0.2",
+    "typescript": "6.0.3",
     "valibot": "1.3.1",
-    "vitest": "4.1.4"
+    "vitest": "4.1.5"
   },
   "files": [
     "dist"