@flowblade/sqlduck 0.31.0 → 0.33.0

package/dist/filesystem/index.d.mts

@@ -1,5 +1,4 @@
 import { Logger } from "@logtape/logtape";
-
 //#region src/filesystem/file-system-utils.d.ts
 declare class FileSystemUtils {
   #private;

package/dist/index-BKsJVkXZ.d.mts

@@ -0,0 +1,261 @@
+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";
+    MYSQL: "MYSQL";
+    PostgreSQL: "PostgreSQL";
+  }>>;
+  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";
+  }>>;
+  recoveryMode: z.ZodOptional<z.ZodEnum<{
+    no_wal_writes: "no_wal_writes";
+  }>>;
+}, 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";
+      MYSQL: "MYSQL";
+      PostgreSQL: "PostgreSQL";
+    }>>;
+    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";
+    }>>;
+    recoveryMode: z.ZodOptional<z.ZodEnum<{
+      no_wal_writes: "no_wal_writes";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"filesystem">;
+  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";
+      MYSQL: "MYSQL";
+      PostgreSQL: "PostgreSQL";
+    }>>;
+    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";
+    }>>;
+    recoveryMode: z.ZodOptional<z.ZodEnum<{
+      no_wal_writes: "no_wal_writes";
+    }>>;
+  }, 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
+//#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-dsn-zod-schema.d.ts
+declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<{
+  type: "memory";
+  alias: string;
+  options?: {
+    accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
+    compress?: boolean | undefined;
+    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
+    blockSize?: number | undefined;
+    rowGroupSize?: number | undefined;
+    storageVersion?: string | undefined;
+    encryptionKey?: string | undefined;
+    encryptionCipher?: "CBC" | "CTR" | "GCM" | undefined;
+    recoveryMode?: "no_wal_writes" | undefined;
+  } | undefined;
+} | {
+  type: "filesystem";
+  path: string;
+  alias: string;
+  options?: {
+    accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
+    compress?: boolean | undefined;
+    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
+    blockSize?: number | undefined;
+    rowGroupSize?: number | undefined;
+    storageVersion?: string | undefined;
+    encryptionKey?: string | undefined;
+    encryptionCipher?: "CBC" | "CTR" | "GCM" | undefined;
+    recoveryMode?: "no_wal_writes" | undefined;
+  } | undefined;
+}, string>>, 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";
+      MYSQL: "MYSQL";
+      PostgreSQL: "PostgreSQL";
+    }>>;
+    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";
+    }>>;
+    recoveryMode: z.ZodOptional<z.ZodEnum<{
+      no_wal_writes: "no_wal_writes";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"filesystem">;
+  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";
+      MYSQL: "MYSQL";
+      PostgreSQL: "PostgreSQL";
+    }>>;
+    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";
+    }>>;
+    recoveryMode: z.ZodOptional<z.ZodEnum<{
+      no_wal_writes: "no_wal_writes";
+    }>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>], "type">>;
+//#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: import("zod").ZodString;
+  readonly schemaName: import("zod").ZodString;
+  readonly tableName: import("zod").ZodString;
+};
+//#endregion
+//#region src/validation/zod/ensure-zod-table-schema.d.ts
+type TObject = Record<string, string | number | null | undefined | boolean | Date>;
+declare const EXPLICIT_GENERIC_REQUIRED: unique symbol;
+type RequireExplicitGeneric = TObject & {
+  [EXPLICIT_GENERIC_REQUIRED]: never;
+};
+/**
+ * Helper to ensure a zod table schema is compatible with the provided type definition
+ *
+ * @example
+ * ```typescript
+ * import { ensureZodTableSchema } from '@flowblade/sqlduck/zod';
+ *
+ * type Row = {
+ *   aNumber: number;
+ *   aString: string;
+ *   aNullableNumber: number | null;
+ *   aNullableString: string | null;
+ *   aBoolean: boolean;
+ *   aNullableBoolean: boolean | null;
+ *   aDate: Date;
+ *   aNullableDate: Date | null;
+ * };
+ *
+ * const schema = ensureZodTableSchema<Row>(z.strictObject({
+ *  aNumber: z.number(),
+ *  aString: z.string(),
+ *  aNullableNumber: z.nullable(z.number()),
+ *  aNullableString: z.nullable(z.string()),
+ *  aBoolean: z.boolean(),
+ *  aNullableBoolean: z.nullable(z.boolean()),
+ *  aDate: z.date(),
+ *  aNullableDate: z.nullable(z.date()),
+ * }));
+ *
+ * ```
+ */
+declare const ensureZodTableSchema: <T extends TObject = RequireExplicitGeneric>(schema: z.ZodObject<{ [K in keyof NoInfer<T>]-?: z.ZodType<NoInfer<T>[K]>; }>) => z.ZodObject<{ [K in keyof NoInfer<T>]-?: z.ZodType<NoInfer<T>[K], unknown, z.core.$ZodTypeInternals<NoInfer<T>[K], unknown>>; }, z.core.$strip>;
+//#endregion
+//#region src/validation/zod/infer-zod-relaxed-data-schema.d.ts
+type MapRelaxedZodSchemaField<T extends z.ZodTypeAny> = T extends z.ZodDate ? string | Date : T extends z.ZodISODate ? string | Date : T extends z.ZodOptional<any> ? MapRelaxedZodSchemaField<T['_def']['innerType']> | undefined : T extends z.ZodNullable<any> ? MapRelaxedZodSchemaField<T['_def']['innerType']> | null : z.infer<T>;
+/**
+ * Add string type to all Date properties so it makes it an union between
+ * Date | string
+ */
+type InferZodRelaxedDataSchema<T extends z.ZodObject<any>> = { [K in keyof T['shape']]: MapRelaxedZodSchemaField<T['shape'][K]>; };
+//#endregion
+//#region src/validation/zod/table-schema-zod.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 | z.ZodEnum;
+type TableSchemaZod = z.ZodObject<Record<string, ZodSchemaSupportedTypes | z.ZodNullable<ZodSchemaSupportedTypes> | z.ZodCodec | z.ZodNullable<z.ZodCodec>>>;
+//#endregion
+export { duckDsnZodSchema as a, assertValidTableName as c, duckConnectionParamsZodSchema as d, duckValidatorsZod as i, DuckConnectionParams as l, InferZodRelaxedDataSchema as n, assertValidAliasName as o, ensureZodTableSchema as r, assertValidSchemaName as s, TableSchemaZod as t, duckAllConnectionOptionsZodSchema as u };

package/dist/index.d.mts

@@ -1,9 +1,8 @@
-import { n as DuckConnectionParams } from "./types-BKI2f-Rk.mjs";
+import { l as DuckConnectionParams, n as InferZodRelaxedDataSchema, t as TableSchemaZod } from "./index-BKsJVkXZ.mjs";
 import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
 import { Logger } from "@logtape/logtape";
 import * as z from "zod";
 import { ZodObject } from "zod";
-
 //#region src/appender/data-appender-callback.d.ts
 type OnChunkAppendedStats = {
   /**
@@ -78,10 +77,6 @@ declare class 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 | z.ZodEnum;
-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';
@@ -124,7 +119,7 @@ type ToTableParams<TSchema extends TableSchemaZod> = {
    * An iterable (async or sync) or generator that yields rows to be inserted.
    * Each row must match the structure defined in the `schema`.
    */
-  rowStream: RowStream<z.infer<TSchema>>;
+  rowStream: RowStream<InferZodRelaxedDataSchema<TSchema>>;
   /**
    * The number of rows to accumulate before appending them to the DuckDB table as a single data chunk.
    * Tuning this value can impact memory usage and insertion performance.

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { n as sqlduckDefaultLogtapeLogger, r as flowbladeLogtapeSqlduckConfig, t as FileSystemUtils } from "./file-system-utils-DT6smf4C.mjs";
 import { t as duckReservedKeywords } from "./duck-reserved-keywords-BzYA7jvN.mjs";
 import { c as duckValidatorsZod, r as assertValidAliasName, s as duckConnectionParamsZodSchema } from "./zod-DB5FHzXW.mjs";
-import { BIGINT, BOOLEAN, DATE, DECIMAL, DOUBLE, DuckDBDataChunk, DuckDBDecimalType, DuckDBDecimalValue, DuckDBInstanceCache, DuckDBTimestampMillisecondsValue, DuckDBTypeId, ENUM, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TIMESTAMP_MS, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR } from "@duckdb/node-api";
+import { BIGINT, BOOLEAN, DATE, DECIMAL, DOUBLE, DuckDBDataChunk, DuckDBDateValue, DuckDBDecimalType, DuckDBDecimalValue, DuckDBInstanceCache, DuckDBTimestampMillisecondsValue, DuckDBTypeId, ENUM, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TIMESTAMP_MS, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR } from "@duckdb/node-api";
 import * as z from "zod";
 import { assertNever } from "@httpx/assert";
 import { isPlainObject } from "@httpx/plain-object";
@@ -127,6 +127,7 @@ const createOnChunkAppendedCollector = () => {
 //#region src/converter/duck-value-converter.ts
 const stringTimestampRegexp = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d{3,6})?Z?$/i;
 const dateRegexp = /^\d{4}-\d{2}-\d{2}$/;
+const msInDay = 864e5;
 const createDuckValueConverterTypeError = (params) => {
 	let serializableValue;
 	try {
@@ -137,6 +138,10 @@ const createDuckValueConverterTypeError = (params) => {
 	return /* @__PURE__ */ new TypeError(`[DuckValueConverter.${params.method}]: Unsupported type ${typeof params.value} with value ${serializableValue}`);
 };
 var DuckValueConverter = class {
+	/**
+	*
+	* @param value
+	*/
 	toUUID = (value) => {
 		if (typeof value === "bigint") return value;
 		else if (typeof value === "string") return BigInt("0x" + value.replaceAll("-", ""));
@@ -158,7 +163,24 @@ var DuckValueConverter = class {
 		if (value === void 0 || value === null) return null;
 		if (typeof value === "number") return DuckDBDecimalValue.fromDouble(value, width, scale);
 		if (typeof value === "bigint") return new DuckDBDecimalValue(value, width, scale);
-		throw new TypeError("Decimal converter require value to be a number or a bigint");
+		throw createDuckValueConverterTypeError({
+			method: "createDecimalConverter",
+			value
+		});
+	};
+	toDate = (value) => {
+		if (value === null || value === void 0) return null;
+		let dateInMs = null;
+		if (typeof value === "string" && value.length >= 10 && value.length < 30) {
+			const dateStr = value.slice(0, 10);
+			const utcDate = /* @__PURE__ */ new Date(`${dateStr}T00:00:00Z`);
+			dateInMs = Math.floor(utcDate.getTime());
+		} else if (value instanceof Date) dateInMs = Math.floor(value.getTime());
+		if (dateInMs !== null && !Number.isNaN(dateInMs)) return new DuckDBDateValue(Math.floor(dateInMs / msInDay));
+		throw createDuckValueConverterTypeError({
+			method: "toDate",
+			value
+		});
 	};
 	toBigIntString = (value) => {
 		if (typeof value === "string") return value;
@@ -233,6 +255,9 @@ const createDuckColumnConverters = (duckTypes) => {
 			case DuckDBTypeId.DECIMAL:
 				conv = converter.createDecimalConverter(18, 3);
 				break;
+			case DuckDBTypeId.DATE:
+				conv = converter.toDate;
+				break;
 			default: throw new Error(`Unsupported duck type ${duckTypeId} / ${duckType.toString()} for column '${key}'`);
 		}
 		if (conv !== false) convMap[key] = conv;
@@ -347,10 +372,7 @@ var DuckDatabaseAttachCommand = class {
 			case "encryptionKey":
 				options.push(`ENCRYPTION_KEY '${value}'`);
 				break;
-			case "recoveryMode":
-				options.push(`RECOVERY_MODE '${value}'`);
-				break;
-			default:
+			case "recoveryMode": options.push(`RECOVERY_MODE '${value}'`);
 		}
 		if (options.length > 0) parts.push(`(${options.join(", ")})`);
 		return parts.filter(Boolean).join(" ");
@@ -551,7 +573,10 @@ const getScale = (value) => {
 const getDuckdbNumberColumnType = (params) => {
 	const { minimum, maximum, multipleOf } = params;
 	if (minimum === void 0 || maximum === void 0) return BIGINT;
-	if (multipleOf !== void 0 && isFloatValue(multipleOf)) return DECIMAL(18, getScale(multipleOf));
+	if (multipleOf !== void 0 && isFloatValue(multipleOf)) {
+		const scale = getScale(multipleOf);
+		return DECIMAL(18, scale);
+	}
 	if (isFloatValue(minimum) || isFloatValue(maximum)) {
 		if (minimum >= -34028235e31 && maximum <= 34028235e31) return FLOAT;
 		return DOUBLE;
@@ -611,6 +636,9 @@ const getTableCreateFromZod = (params) => {
 			case "string":
 				if (Array.isArray(def.enum)) c.duckdbType = ENUM(def.enum);
 				else switch (format) {
+					case "date":
+						c.duckdbType = DATE;
+						break;
 					case "date-time":
 						c.duckdbType = TIMESTAMP_MS;
 						break;

package/dist/integrations/kysely/index.d.mts

@@ -1,5 +1,4 @@
 import { Kysely, SelectQueryBuilder } from "kysely";
-
 //#region src/integrations/kysely/compile-duck-query.d.ts
 type SqlTagInformation = {
   text: string;

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

@@ -1,5 +1,4 @@
 import * as v from "valibot";
-
 //#region src/validation/valibot/duck-connection-params-valibot-schema.d.ts
 declare const duckAllConnectionOptionsValibotSchema: v.ObjectSchema<{
   readonly accessMode: v.OptionalSchema<v.PicklistSchema<readonly ["READ_ONLY", "READ_WRITE"], undefined>, undefined>;

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

@@ -1,159 +1,2 @@
-import { a as duckAllConnectionOptionsZodSchema, i as DuckTableName, o as duckConnectionParamsZodSchema, r as DuckSchemaName, t as DuckAliasName } from "../../types-BKI2f-Rk.mjs";
-import * as z 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-dsn-zod-schema.d.ts
-declare const duckDsnZodSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<{
-  type: "memory";
-  alias: string;
-  options?: {
-    accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
-    compress?: boolean | undefined;
-    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
-    blockSize?: number | undefined;
-    rowGroupSize?: number | undefined;
-    storageVersion?: string | undefined;
-    encryptionKey?: string | undefined;
-    encryptionCipher?: "CBC" | "CTR" | "GCM" | undefined;
-    recoveryMode?: "no_wal_writes" | undefined;
-  } | undefined;
-} | {
-  type: "filesystem";
-  path: string;
-  alias: string;
-  options?: {
-    accessMode?: "READ_ONLY" | "READ_WRITE" | undefined;
-    compress?: boolean | undefined;
-    type?: "DUCKDB" | "SQLITE" | "MYSQL" | "PostgreSQL" | undefined;
-    blockSize?: number | undefined;
-    rowGroupSize?: number | undefined;
-    storageVersion?: string | undefined;
-    encryptionKey?: string | undefined;
-    encryptionCipher?: "CBC" | "CTR" | "GCM" | undefined;
-    recoveryMode?: "no_wal_writes" | undefined;
-  } | undefined;
-}, string>>, 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";
-      MYSQL: "MYSQL";
-      PostgreSQL: "PostgreSQL";
-    }>>;
-    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";
-    }>>;
-    recoveryMode: z.ZodOptional<z.ZodEnum<{
-      no_wal_writes: "no_wal_writes";
-    }>>;
-  }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodObject<{
-  type: z.ZodLiteral<"filesystem">;
-  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";
-      MYSQL: "MYSQL";
-      PostgreSQL: "PostgreSQL";
-    }>>;
-    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";
-    }>>;
-    recoveryMode: z.ZodOptional<z.ZodEnum<{
-      no_wal_writes: "no_wal_writes";
-    }>>;
-  }, z.core.$strict>>;
-}, z.core.$strict>], "type">>;
-//#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: import("zod").ZodString;
-  readonly schemaName: import("zod").ZodString;
-  readonly tableName: import("zod").ZodString;
-};
-//#endregion
-//#region src/validation/zod/ensure-zod-table-schema.d.ts
-type TObject = Record<string, string | number | null | undefined | boolean | Date>;
-declare const EXPLICIT_GENERIC_REQUIRED: unique symbol;
-type RequireExplicitGeneric = TObject & {
-  [EXPLICIT_GENERIC_REQUIRED]: never;
-};
-/**
- * Helper to ensure a zod table schema is compatible with the provided type definition
- *
- * @example
- * ```typescript
- * import { ensureZodTableSchema } from '@flowblade/sqlduck/zod';
- *
- * type Row = {
- *   aNumber: number;
- *   aString: string;
- *   aNullableNumber: number | null;
- *   aNullableString: string | null;
- *   aBoolean: boolean;
- *   aNullableBoolean: boolean | null;
- *   aDate: Date;
- *   aNullableDate: Date | null;
- * };
- *
- * const schema = ensureZodTableSchema<Row>(z.strictObject({
- *  aNumber: z.number(),
- *  aString: z.string(),
- *  aNullableNumber: z.nullable(z.number()),
- *  aNullableString: z.nullable(z.string()),
- *  aBoolean: z.boolean(),
- *  aNullableBoolean: z.nullable(z.boolean()),
- *  aDate: z.date(),
- *  aNullableDate: z.nullable(z.date()),
- * }));
- *
- * ```
- */
-declare const ensureZodTableSchema: <T extends TObject = RequireExplicitGeneric>(schema: z.ZodObject<{ [K in keyof NoInfer<T>]-?: z.ZodType<NoInfer<T>[K]> }>) => z.ZodObject<{ [K in keyof NoInfer<T>]-?: z.ZodType<NoInfer<T>[K], unknown, z.core.$ZodTypeInternals<NoInfer<T>[K], unknown>> }, z.core.$strip>;
-//#endregion
-export { assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckDsnZodSchema, duckValidatorsZod, ensureZodTableSchema };
+import { a as duckDsnZodSchema, c as assertValidTableName, d as duckConnectionParamsZodSchema, i as duckValidatorsZod, n as InferZodRelaxedDataSchema, o as assertValidAliasName, r as ensureZodTableSchema, s as assertValidSchemaName, t as TableSchemaZod, u as duckAllConnectionOptionsZodSchema } from "../../index-BKsJVkXZ.mjs";
+export { type InferZodRelaxedDataSchema, type TableSchemaZod, assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckDsnZodSchema, duckValidatorsZod, ensureZodTableSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -67,15 +67,15 @@
   },
   "dependencies": {
     "@flowblade/core": "^0.2.29",
-    "@flowblade/source-duckdb": "^0.25.1",
+    "@flowblade/source-duckdb": "^0.27.0",
     "@flowblade/sql-tag": "^0.3.4",
-    "@httpx/assert": "^0.17.1",
-    "@httpx/dsn-parser": "^1.9.11",
-    "@httpx/plain-object": "^2.1.11",
-    "@logtape/logtape": "^2.2.2",
+    "@httpx/assert": "^0.17.2",
+    "@httpx/dsn-parser": "^1.9.12",
+    "@httpx/plain-object": "^2.1.12",
+    "@logtape/logtape": "^2.3.0",
     "@standard-schema/spec": "^1.1.0",
     "is-safe-filename": "0.1.1",
-    "p-queue": "^9.3.0",
+    "p-queue": "^9.3.3",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
@@ -92,52 +92,52 @@
     }
   },
   "devDependencies": {
-    "@belgattitude/eslint-config-bases": "8.17.0",
-    "@dotenvx/dotenvx": "1.75.1",
-    "@duckdb/node-api": "1.5.4-r.1",
+    "@belgattitude/eslint-config-bases": "8.19.1",
+    "@dotenvx/dotenvx": "2.19.1",
+    "@duckdb/node-api": "1.5.5-r.3",
     "@faker-js/faker": "10.5.0",
-    "@flowblade/source-kysely": "^1.6.1",
-    "@httpx/assert": "0.17.1",
+    "@flowblade/source-kysely": "^1.7.0",
+    "@httpx/assert": "0.17.2",
     "@mitata/counters": "0.0.8",
-    "@size-limit/esbuild": "12.1.0",
-    "@size-limit/file": "12.1.0",
+    "@size-limit/esbuild": "13.0.3",
+    "@size-limit/file": "13.0.3",
     "@testcontainers/mssqlserver": "12.0.4",
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "26.0.1",
-    "@typescript-eslint/eslint-plugin": "8.62.1",
-    "@typescript-eslint/parser": "8.62.1",
-    "@typescript/native-preview": "7.0.0-dev.20260630.1",
-    "@vitest/coverage-v8": "4.1.9",
-    "@vitest/ui": "4.1.9",
+    "@types/node": "26.1.2",
+    "@typescript-eslint/eslint-plugin": "8.66.0",
+    "@typescript-eslint/parser": "8.66.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "@vitest/coverage-v8": "4.1.10",
+    "@vitest/ui": "4.1.10",
     "ansis": "4.3.1",
     "browserslist-to-esbuild": "2.1.1",
     "core-js": "3.49.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.4",
-    "es-toolkit": "1.49.0",
+    "es-toolkit": "1.50.0",
     "esbuild": "0.28.1",
     "eslint": "8.57.1",
-    "execa": "9.6.1",
+    "execa": "10.0.1",
     "is-in-ci": "2.0.0",
-    "kysely": "0.29.2",
+    "kysely": "0.29.4",
     "mitata": "1.0.34",
-    "npm-run-all2": "9.0.2",
-    "prettier": "3.9.4",
-    "publint": "0.3.21",
+    "npm-run-all2": "9.0.3",
+    "prettier": "3.9.6",
+    "publint": "0.3.22",
     "regexp.escape": "2.0.1",
     "rimraf": "6.1.3",
-    "size-limit": "12.1.0",
+    "size-limit": "13.0.3",
     "sql-formatter": "15.8.2",
-    "tarn": "3.1.0",
+    "tarn": "3.1.2",
     "tedious": "20.0.0",
     "testcontainers": "12.0.4",
-    "tsdown": "0.22.3",
-    "tsx": "4.22.4",
-    "typedoc": "0.28.19",
+    "tsdown": "0.22.14",
+    "tsx": "4.23.5",
+    "typedoc": "0.28.20",
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",
     "valibot": "1.4.2",
-    "vitest": "4.1.9"
+    "vitest": "4.1.10"
   },
   "files": [
     "dist"

package/dist/types-BKI2f-Rk.d.mts

@@ -1,95 +0,0 @@
-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";
-    MYSQL: "MYSQL";
-    PostgreSQL: "PostgreSQL";
-  }>>;
-  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";
-  }>>;
-  recoveryMode: z.ZodOptional<z.ZodEnum<{
-    no_wal_writes: "no_wal_writes";
-  }>>;
-}, 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";
-      MYSQL: "MYSQL";
-      PostgreSQL: "PostgreSQL";
-    }>>;
-    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";
-    }>>;
-    recoveryMode: z.ZodOptional<z.ZodEnum<{
-      no_wal_writes: "no_wal_writes";
-    }>>;
-  }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodObject<{
-  type: z.ZodLiteral<"filesystem">;
-  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";
-      MYSQL: "MYSQL";
-      PostgreSQL: "PostgreSQL";
-    }>>;
-    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";
-    }>>;
-    recoveryMode: z.ZodOptional<z.ZodEnum<{
-      no_wal_writes: "no_wal_writes";
-    }>>;
-  }, 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 };