@flowblade/sqlduck 0.14.0 → 0.15.0

package/dist/{duck-reserved-keywords-CUmaTbrD.mjs → duck-reserved-keywords-B8XUjnaY.mjs}

@@ -3,12 +3,20 @@ const duckIdentifierNameRegex = /^[a-z_]\w*$/i;
 const duckStorageVersionRegexp = /^v?\d{1,4}\.\d{1,4}\.\d{1,4}$/;
 //#endregion
 //#region src/validation/core/duck-connections-options.ts
-const duckConnectionsOptions = { types: [
-	"DUCKDB",
-	"SQLITE",
-	"MYSQL",
-	"PostgreSQL"
-] };
+const duckConnectionsOptions = {
+	types: [
+		"DUCKDB",
+		"SQLITE",
+		"MYSQL",
+		"PostgreSQL"
+	],
+	accessModes: ["READ_ONLY", "READ_WRITE"],
+	encryptionCiphers: [
+		"CBC",
+		"CTR",
+		"GCM"
+	]
+};
 //#endregion
 //#region src/validation/core/duck-reserved-keywords.ts
 /**

package/dist/index.d.mts

@@ -283,6 +283,15 @@ declare class DuckDatabaseManager {
   analyze: () => Promise<boolean>;
   checkpoint: (dbAlias: string) => Promise<boolean>;
   vacuum: () => Promise<boolean>;
+  /**
+   * Helper to create an initial database file.
+   */
+  createDatabaseFile: (params: {
+    path: string;
+    createDirectory?: boolean;
+  }) => Promise<{
+    status: "exists" | "created";
+  }>;
 }
 //#endregion
 //#region src/config/flowblade-logtape-sqlduck.config.d.ts

package/dist/index.mjs

@@ -1,7 +1,9 @@
-import { t as duckReservedKeywords } from "./duck-reserved-keywords-CUmaTbrD.mjs";
-import { n as assertValidAliasName, o as duckConnectionParamsZodSchema, s as duckValidatorsZod } from "./zod-BRUUIdGW.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 { t as duckReservedKeywords } from "./duck-reserved-keywords-B8XUjnaY.mjs";
+import { n as assertValidAliasName, o as duckConnectionParamsZodSchema, s as duckValidatorsZod } from "./zod-CuPjTLv8.mjs";
+import { BIGINT, BOOLEAN, DOUBLE, DuckDBDataChunk, DuckDBInstanceCache, DuckDBTimestampValue, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR } from "@duckdb/node-api";
 import { getLogger } from "@logtape/logtape";
+import fs from "node:fs";
+import { basename, dirname } from "node:path";
 import * as z from "zod";
 import { assertNever } from "@httpx/assert";
 import { isPlainObject } from "@httpx/plain-object";
@@ -128,6 +130,81 @@ const flowbladeLogtapeSqlduckConfig = { categories: ["flowblade", "sqlduck"] };
 //#region src/logger/sqlduck-default-logtape-logger.ts
 const sqlduckDefaultLogtapeLogger = getLogger(flowbladeLogtapeSqlduckConfig.categories);
 //#endregion
+//#region src/filesystem/file-system-utils.ts
+var FileSystemUtils = class {
+	#logger;
+	constructor(params) {
+		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: "FileSystemUtils" });
+	}
+	/**
+	* Create a directory recursively if it doesn't exist
+	*
+	* @throws Error if it can't be created
+	*/
+	createDirectory = (path) => {
+		try {
+			fs.mkdirSync(path, { recursive: true });
+		} catch (err) {
+			if (err.code !== "EEXIST") throw err;
+		}
+	};
+	/**
+	* Create a directory recursively if it doesn't exist and ensure it's writable
+	*/
+	createAndEnsureWritableDirectory = (label, path) => {
+		if (path === void 0) return;
+		if (!fs.existsSync(path)) try {
+			this.createDirectory(path);
+		} catch (e) {
+			throw new Error(`Failed to create ${label} '${path}' - ${e?.message ?? ""}`);
+		}
+		if (!fs.statSync(path).isDirectory()) throw new Error(`${label} '${path}' must be a directory`);
+		try {
+			fs.accessSync(path, fs.constants.W_OK);
+		} catch {
+			throw new Error(`${label} '${path}' must be writable`);
+		}
+	};
+	/**
+	* Check if a path is a regular file and exists
+	*/
+	isFile = (path) => {
+		try {
+			return fs.statSync(path).isFile();
+		} catch {
+			return false;
+		}
+	};
+	/**
+	* Check if a path is a directory and exists
+	*/
+	isDirectory = (path) => {
+		try {
+			return fs.statSync(path).isDirectory();
+		} catch {
+			return false;
+		}
+	};
+	parsePath = (path) => {
+		const dir = dirname(path);
+		if (dir.trim() === "") throw new Error(`Invalid path, missing directory '${path}'`);
+		const base = basename(path);
+		if (base.trim() === "") throw new Error(`Invalid path, missing filename '${path}'`);
+		return {
+			directory: dir,
+			filename: base
+		};
+	};
+	removeFileIfExists = (path) => {
+		try {
+			fs.rmSync(path);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+};
+//#endregion
 //#region src/objects/database.ts
 var Database = class {
 	#params;
@@ -207,6 +284,7 @@ var DuckDatabaseAttachCommand = class {
 var DuckDatabaseManager = class {
 	#conn;
 	#logger;
+	#fs;
 	constructor(conn, params) {
 		this.#conn = conn;
 		this.#logger = params?.logger ?? sqlduckDefaultLogtapeLogger.with({ source: "DuckDatabaseManager" });
@@ -229,7 +307,12 @@ var DuckDatabaseManager = class {
 	attach = async (dbParams, options) => {
 		const params = duckConnectionParamsZodSchema.parse(dbParams);
 		const rawSql = new DuckDatabaseAttachCommand(params, options).getRawSql();
-		await this.#executeRawSqlCommand(`attach(${params.alias})`, rawSql);
+		const { behaviour } = options ?? {};
+		await this.#executeRawSqlCommand([
+			`attach(${params.alias}`,
+			behaviour ?? null,
+			")"
+		].filter(Boolean).join(","), rawSql);
 		return new Database({ alias: params.alias });
 	};
 	attachOrReplace = async (dbParams) => {
@@ -272,6 +355,32 @@ var DuckDatabaseManager = class {
 		await this.#executeRawSqlCommand("vacuum()", "VACUUM");
 		return true;
 	};
+	/**
+	* Helper to create an initial database file.
+	*/
+	createDatabaseFile = async (params) => {
+		const startTime = Date.now();
+		const { path, createDirectory = true } = params;
+		const fs = this.#getFs();
+		if (fs.isFile(path)) return { status: "exists" };
+		if (createDirectory) {
+			const { directory } = fs.parsePath(path);
+			fs.createAndEnsureWritableDirectory("database file directory", directory);
+		}
+		const instanceCache = new DuckDBInstanceCache();
+		try {
+			(await (await instanceCache.getOrCreateInstance(path)).connect()).closeSync();
+			const timeMs = Math.round(Date.now() - startTime);
+			this.#logger.info(`DuckDatabaseManager.createDatabaseFile('${path}') in ${timeMs}ms`, {
+				timeMs,
+				path
+			});
+		} catch (e) {
+			this.#logger.error(`DuckDatabaseManager.createDatabaseFile('${path}') failed - ${e?.message ?? ""}`, { path });
+			throw e;
+		}
+		return { status: "created" };
+	};
 	#executeRawSqlCommand = async (name, rawSql) => {
 		const startTime = Date.now();
 		try {
@@ -291,6 +400,10 @@ var DuckDatabaseManager = class {
 			throw new Error(msg, { cause: e });
 		}
 	};
+	#getFs = () => {
+		if (this.#fs === void 0) this.#fs = new FileSystemUtils({ logger: this.#logger });
+		return this.#fs;
+	};
 };
 //#endregion
 //#region src/table/get-duckdb-number-column-type.ts

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

@@ -2,42 +2,42 @@ 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<["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
+  readonly accessMode: v.OptionalSchema<v.PicklistSchema<readonly ["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
   readonly compress: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
   readonly type: v.OptionalSchema<v.PicklistSchema<readonly ["DUCKDB", "SQLITE", "MYSQL", "PostgreSQL"], undefined>, undefined>;
   readonly blockSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 16384, undefined>, v.MaxValueAction<number, 262144, undefined>]>, undefined>;
   readonly rowGroupSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
   readonly storageVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "v", undefined>, v.RegexAction<string, undefined>]>, undefined>;
   readonly encryptionKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, undefined>]>, undefined>;
-  readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<["CBC", "CTR", "GCM"], undefined>, undefined>;
+  readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<readonly ["CBC", "CTR", "GCM"], undefined>, undefined>;
 }, undefined>;
 type DuckAllConnectionOptionsValibotSchema = v.InferOutput<typeof duckAllConnectionOptionsValibotSchema>;
 declare const duckConnectionParamsValibotSchema: v.VariantSchema<"type", [v.ObjectSchema<{
   readonly type: v.LiteralSchema<"memory", undefined>;
   readonly alias: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>, v.RegexAction<string, "Identifier must start with a letter or underscore, and contain only letters, numbers and underscores">, v.CheckAction<string, "Identifier value is a DuckDB reserved keyword and cannot be used as an identifier">]>;
   readonly options: v.OptionalSchema<v.ObjectSchema<{
-    readonly accessMode: v.OptionalSchema<v.PicklistSchema<["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
+    readonly accessMode: v.OptionalSchema<v.PicklistSchema<readonly ["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
     readonly compress: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly type: v.OptionalSchema<v.PicklistSchema<readonly ["DUCKDB", "SQLITE", "MYSQL", "PostgreSQL"], undefined>, undefined>;
     readonly blockSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 16384, undefined>, v.MaxValueAction<number, 262144, undefined>]>, undefined>;
     readonly rowGroupSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
     readonly storageVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "v", undefined>, v.RegexAction<string, undefined>]>, undefined>;
     readonly encryptionKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, undefined>]>, undefined>;
-    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<["CBC", "CTR", "GCM"], undefined>, undefined>;
+    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<readonly ["CBC", "CTR", "GCM"], undefined>, undefined>;
   }, undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
   readonly type: v.LiteralSchema<"filesystem", undefined>;
   readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid database filename - it must be a safe filename (no path traversal, no absolute paths, no reserved names, etc.)">, v.CheckAction<string, "Invalid database pathname - it must be an absolute path with no traversal">]>;
   readonly alias: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>, v.RegexAction<string, "Identifier must start with a letter or underscore, and contain only letters, numbers and underscores">, v.CheckAction<string, "Identifier value is a DuckDB reserved keyword and cannot be used as an identifier">]>;
   readonly options: v.OptionalSchema<v.ObjectSchema<{
-    readonly accessMode: v.OptionalSchema<v.PicklistSchema<["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
+    readonly accessMode: v.OptionalSchema<v.PicklistSchema<readonly ["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
     readonly compress: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly type: v.OptionalSchema<v.PicklistSchema<readonly ["DUCKDB", "SQLITE", "MYSQL", "PostgreSQL"], undefined>, undefined>;
     readonly blockSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 16384, undefined>, v.MaxValueAction<number, 262144, undefined>]>, undefined>;
     readonly rowGroupSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
     readonly storageVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "v", undefined>, v.RegexAction<string, undefined>]>, undefined>;
     readonly encryptionKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, undefined>]>, undefined>;
-    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<["CBC", "CTR", "GCM"], undefined>, undefined>;
+    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<readonly ["CBC", "CTR", "GCM"], undefined>, undefined>;
   }, undefined>, undefined>;
 }, undefined>], undefined>;
 //#endregion
@@ -73,28 +73,28 @@ declare const duckDsnValibotSchema: v.SchemaWithPipe<readonly [v.StringSchema<un
   readonly type: v.LiteralSchema<"memory", undefined>;
   readonly alias: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>, v.RegexAction<string, "Identifier must start with a letter or underscore, and contain only letters, numbers and underscores">, v.CheckAction<string, "Identifier value is a DuckDB reserved keyword and cannot be used as an identifier">]>;
   readonly options: v.OptionalSchema<v.ObjectSchema<{
-    readonly accessMode: v.OptionalSchema<v.PicklistSchema<["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
+    readonly accessMode: v.OptionalSchema<v.PicklistSchema<readonly ["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
     readonly compress: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly type: v.OptionalSchema<v.PicklistSchema<readonly ["DUCKDB", "SQLITE", "MYSQL", "PostgreSQL"], undefined>, undefined>;
     readonly blockSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 16384, undefined>, v.MaxValueAction<number, 262144, undefined>]>, undefined>;
     readonly rowGroupSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
     readonly storageVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "v", undefined>, v.RegexAction<string, undefined>]>, undefined>;
     readonly encryptionKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, undefined>]>, undefined>;
-    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<["CBC", "CTR", "GCM"], undefined>, undefined>;
+    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<readonly ["CBC", "CTR", "GCM"], undefined>, undefined>;
   }, undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
   readonly type: v.LiteralSchema<"filesystem", undefined>;
   readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid database filename - it must be a safe filename (no path traversal, no absolute paths, no reserved names, etc.)">, v.CheckAction<string, "Invalid database pathname - it must be an absolute path with no traversal">]>;
   readonly alias: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 120, undefined>, v.RegexAction<string, "Identifier must start with a letter or underscore, and contain only letters, numbers and underscores">, v.CheckAction<string, "Identifier value is a DuckDB reserved keyword and cannot be used as an identifier">]>;
   readonly options: v.OptionalSchema<v.ObjectSchema<{
-    readonly accessMode: v.OptionalSchema<v.PicklistSchema<["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
+    readonly accessMode: v.OptionalSchema<v.PicklistSchema<readonly ["READ_ONLY", "READ_WRITE"], undefined>, undefined>;
     readonly compress: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly type: v.OptionalSchema<v.PicklistSchema<readonly ["DUCKDB", "SQLITE", "MYSQL", "PostgreSQL"], undefined>, undefined>;
     readonly blockSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 16384, undefined>, v.MaxValueAction<number, 262144, undefined>]>, undefined>;
     readonly rowGroupSize: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
     readonly storageVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.StartsWithAction<string, "v", undefined>, v.RegexAction<string, undefined>]>, undefined>;
     readonly encryptionKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, undefined>]>, undefined>;
-    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<["CBC", "CTR", "GCM"], undefined>, undefined>;
+    readonly encryptionCipher: v.OptionalSchema<v.PicklistSchema<readonly ["CBC", "CTR", "GCM"], undefined>, undefined>;
   }, undefined>, undefined>;
 }, undefined>], undefined>]>;
 //#endregion

package/dist/validation/valibot/index.mjs

@@ -1,4 +1,4 @@
-import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "../../duck-reserved-keywords-CUmaTbrD.mjs";
+import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "../../duck-reserved-keywords-B8XUjnaY.mjs";
 import isSafeFilename from "is-safe-filename";
 import { parseDsn, parseDsnOrThrow } from "@httpx/dsn-parser";
 import * as v from "valibot";
@@ -26,18 +26,14 @@ const duckValidatorsValibot = {
 //#endregion
 //#region src/validation/valibot/duck-connection-params-valibot-schema.ts
 const duckAllConnectionOptionsValibotSchema = v.object({
-	accessMode: v.optional(v.picklist(["READ_ONLY", "READ_WRITE"])),
+	accessMode: v.optional(v.picklist(duckConnectionsOptions.accessModes)),
 	compress: v.optional(v.boolean()),
 	type: v.optional(v.picklist(duckConnectionsOptions.types)),
 	blockSize: v.optional(v.pipe(v.number(), v.integer(), v.minValue(16384), v.maxValue(262144))),
 	rowGroupSize: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
 	storageVersion: v.optional(v.pipe(v.string(), v.startsWith("v"), v.regex(duckStorageVersionRegexp))),
 	encryptionKey: v.optional(v.pipe(v.string(), v.minLength(8))),
-	encryptionCipher: v.optional(v.picklist([
-		"CBC",
-		"CTR",
-		"GCM"
-	]))
+	encryptionCipher: v.optional(v.picklist(duckConnectionsOptions.encryptionCiphers))
 });
 const duckConnectionParamsValibotSchema = v.variant("type", [v.object({
 	type: v.literal("memory"),

package/dist/validation/zod/index.mjs

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

package/dist/{zod-BRUUIdGW.mjs → zod-CuPjTLv8.mjs}

@@ -1,4 +1,4 @@
-import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "./duck-reserved-keywords-CUmaTbrD.mjs";
+import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "./duck-reserved-keywords-B8XUjnaY.mjs";
 import isSafeFilename from "is-safe-filename";
 import * as z from "zod";
 import { parseDsn } from "@httpx/dsn-parser";
@@ -28,18 +28,14 @@ const duckValidatorsZod = {
 //#endregion
 //#region src/validation/zod/duck-connection-params-zod-schema.ts
 const duckAllConnectionOptionsZodSchema = z.strictObject({
-	accessMode: z.optional(z.enum(["READ_ONLY", "READ_WRITE"])),
+	accessMode: z.optional(z.enum(duckConnectionsOptions.accessModes)),
 	compress: z.optional(z.boolean()),
 	type: z.optional(z.enum(duckConnectionsOptions.types)),
 	blockSize: z.optional(z.int32().min(16384).max(262144)),
 	rowGroupSize: z.optional(z.int32().positive()),
 	storageVersion: z.optional(z.string().startsWith("v").regex(duckStorageVersionRegexp)),
 	encryptionKey: z.optional(z.string().min(8)),
-	encryptionCipher: z.optional(z.enum([
-		"CBC",
-		"CTR",
-		"GCM"
-	]))
+	encryptionCipher: z.optional(z.enum(duckConnectionsOptions.encryptionCiphers))
 });
 const duckConnectionParamsZodSchema = z.discriminatedUnion("type", [z.strictObject({
 	type: z.literal("memory"),
@@ -52,7 +48,7 @@ const duckConnectionParamsZodSchema = z.discriminatedUnion("type", [z.strictObje
 		return typeof filename === "string" && isSafeFilename(filename);
 	}, { message: "Invalid database filename - it must be a safe filename (no path traversal, no absolute paths, no reserved names, etc.)" }).refine((path) => {
 		const pathname = "/" + path.replace("\\", "/").split("/").slice(0, -1).filter(Boolean).join("/");
-		return pathname.length > 0 && pathname.startsWith("/") && pathname.includes("..") === false;
+		return pathname.length > 0 && pathname.startsWith("/") && !pathname.includes("..");
 	}, { message: "Invalid database pathname - it must be an absolute path with no traversal" }),
 	alias: duckValidatorsZod.aliasName,
 	options: z.optional(duckAllConnectionOptionsZodSchema)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -53,7 +53,7 @@
     "fix-staged": "lint-staged --allow-empty",
     "check-dist": "es-check --config=.escheckrc.json",
     "check-pub": "publint",
-    "check-size": "size-limit"
+    "check-size-disabled": "size-limit"
   },
   "dependencies": {
     "@flowblade/core": "^0.2.26",
@@ -90,11 +90,11 @@
     "@testcontainers/mssqlserver": "11.13.0",
     "@total-typescript/ts-reset": "0.6.1",
     "@types/node": "25.5.2",
-    "@typescript-eslint/eslint-plugin": "8.58.0",
-    "@typescript-eslint/parser": "8.58.0",
+    "@typescript-eslint/eslint-plugin": "8.58.1",
+    "@typescript-eslint/parser": "8.58.1",
     "@typescript/native-preview": "7.0.0-dev.20260406.1",
-    "@vitest/coverage-v8": "4.1.2",
-    "@vitest/ui": "4.1.2",
+    "@vitest/coverage-v8": "4.1.3",
+    "@vitest/ui": "4.1.3",
     "ansis": "4.2.0",
     "browserslist-to-esbuild": "2.1.1",
     "core-js": "3.49.0",
@@ -123,7 +123,7 @@
     "typedoc-plugin-markdown": "4.11.0",
     "typescript": "6.0.2",
     "valibot": "1.3.1",
-    "vitest": "4.1.2"
+    "vitest": "4.1.3"
   },
   "files": [
     "dist"