@flowblade/sqlduck 0.31.0 → 0.32.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-CvC0hHHa.d.mts

@@ -0,0 +1,257 @@
+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
+export { assertValidAliasName as a, DuckConnectionParams as c, duckDsnZodSchema as i, duckAllConnectionOptionsZodSchema as l, ensureZodTableSchema as n, assertValidSchemaName as o, duckValidatorsZod as r, assertValidTableName as s, InferZodRelaxedDataSchema as t, duckConnectionParamsZodSchema as u };

package/dist/index.d.mts

@@ -1,9 +1,8 @@
-import { n as DuckConnectionParams } from "./types-BKI2f-Rk.mjs";
+import { c as DuckConnectionParams, t as InferZodRelaxedDataSchema } from "./index-CvC0hHHa.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 = {
   /**
@@ -124,7 +123,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 assertValidAliasName, i as duckDsnZodSchema, l as duckAllConnectionOptionsZodSchema, n as ensureZodTableSchema, o as assertValidSchemaName, r as duckValidatorsZod, s as assertValidTableName, t as InferZodRelaxedDataSchema, u as duckConnectionParamsZodSchema } from "../../index-CvC0hHHa.mjs";
+export { type InferZodRelaxedDataSchema, assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckDsnZodSchema, duckValidatorsZod, ensureZodTableSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.31.0",
+  "version": "0.32.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.26.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.2.4",
     "@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.0",
+    "@dotenvx/dotenvx": "2.19.0",
+    "@duckdb/node-api": "1.5.5-r.2",
     "@faker-js/faker": "10.5.0",
-    "@flowblade/source-kysely": "^1.6.1",
-    "@httpx/assert": "0.17.1",
+    "@flowblade/source-kysely": "^1.6.2",
+    "@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.1",
+    "@size-limit/file": "13.0.1",
     "@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.1",
+    "@typescript-eslint/eslint-plugin": "8.65.0",
+    "@typescript-eslint/parser": "8.65.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.0",
     "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",
+    "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.1",
     "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.1",
+    "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 };