@flowblade/sqlduck 0.10.0 → 0.12.0

package/dist/types-DCqYqEsa.d.mts

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

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

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

package/dist/validation/zod/index.mjs

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

package/dist/zod-CwR_oehs.mjs

@@ -0,0 +1,207 @@
+import * as z from "zod";
+import { parseDsn } from "@httpx/dsn-parser";
+//#region src/validation/core/create-assert-error.ts
+const createAssertError = (msgOrErrorFactory, fallbackMsg) => {
+	if (typeof msgOrErrorFactory === "string" || msgOrErrorFactory === void 0) return new TypeError(msgOrErrorFactory ?? fallbackMsg ?? "Assertion did not pass.");
+	return msgOrErrorFactory();
+};
+//#endregion
+//#region src/validation/core/base-validators.ts
+const duckIdentifierNameRegex = /^[a-z_]\w*$/i;
+const duckStorageVersionRegexp = /^v?\d{1,4}\.\d{1,4}\.\d{1,4}$/;
+//#endregion
+//#region src/validation/core/duck-reserved-keywords.ts
+/**
+* DuckDB reserved keywords that cannot be used as unquoted identifiers.
+* @see https://duckdb.org/docs/sql/keywords-and-identifiers.html
+*/
+const duckReservedKeywords = [
+	"ALL",
+	"ANALYSE",
+	"ANALYZE",
+	"AND",
+	"ANY",
+	"ARRAY",
+	"AS",
+	"ASC",
+	"ASYMMETRIC",
+	"BOTH",
+	"CASE",
+	"CAST",
+	"CHECK",
+	"COLLATE",
+	"COLUMN",
+	"CONSTRAINT",
+	"CREATE",
+	"CROSS",
+	"CURRENT_CATALOG",
+	"CURRENT_DATE",
+	"CURRENT_ROLE",
+	"CURRENT_SCHEMA",
+	"CURRENT_TIME",
+	"CURRENT_TIMESTAMP",
+	"CURRENT_USER",
+	"DEFAULT",
+	"DEFERRABLE",
+	"DESC",
+	"DISTINCT",
+	"DO",
+	"ELSE",
+	"END",
+	"EXCEPT",
+	"EXISTS",
+	"EXTRACT",
+	"FALSE",
+	"FETCH",
+	"FOR",
+	"FOREIGN",
+	"FROM",
+	"GRANT",
+	"GROUP",
+	"HAVING",
+	"IF",
+	"ILIKE",
+	"IN",
+	"INITIALLY",
+	"INNER",
+	"INTERSECT",
+	"INTO",
+	"IS",
+	"ISNULL",
+	"JOIN",
+	"LATERAL",
+	"LEADING",
+	"LEFT",
+	"LIKE",
+	"LIMIT",
+	"LOCALTIME",
+	"LOCALTIMESTAMP",
+	"NATURAL",
+	"NOT",
+	"NOTNULL",
+	"NULL",
+	"OFFSET",
+	"ON",
+	"ONLY",
+	"OR",
+	"ORDER",
+	"OUTER",
+	"OVERLAPS",
+	"PLACING",
+	"PRIMARY",
+	"REFERENCES",
+	"RETURNING",
+	"RIGHT",
+	"ROW",
+	"SELECT",
+	"SESSION_USER",
+	"SIMILAR",
+	"SOME",
+	"SYMMETRIC",
+	"TABLE",
+	"THEN",
+	"TO",
+	"TRAILING",
+	"TRUE",
+	"UNION",
+	"UNIQUE",
+	"USING",
+	"VARIADIC",
+	"VERBOSE",
+	"WHEN",
+	"WHERE",
+	"WINDOW",
+	"WITH"
+];
+//#endregion
+//#region src/validation/zod/duck-identifier-zod-schema.ts
+const duckdbReservedKeywordsSet = new Set(duckReservedKeywords.map((k) => k.toUpperCase()));
+/**
+* Check whether a table name identifier is valid
+*/
+const duckIdentifierZodSchema = z.string().min(1).max(120).regex(duckIdentifierNameRegex, "Identifier must start with a letter or underscore, and contain only letters, numbers and underscores").refine((value) => !duckdbReservedKeywordsSet.has(value.toUpperCase()), { message: `Identifier value is a DuckDB reserved keyword and cannot be used as an identifier` });
+//#endregion
+//#region src/validation/zod/duck-validators-zod.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
+* ```
+*/
+const duckValidatorsZod = {
+	aliasName: duckIdentifierZodSchema,
+	schemaName: duckIdentifierZodSchema,
+	tableName: duckIdentifierZodSchema
+};
+//#endregion
+//#region src/validation/zod/duck-asserts-zod.ts
+function assertValidAliasName(aliasName) {
+	const parsed = z.safeParse(duckValidatorsZod.aliasName, aliasName);
+	if (parsed.error) throw createAssertError(`'${aliasName}' is not a valid alias name: ${parsed.error.message}`);
+}
+function assertValidSchemaName(schemaName) {
+	const parsed = z.safeParse(duckValidatorsZod.schemaName, schemaName);
+	if (parsed.error) throw createAssertError(`'${schemaName}' is not a valid schema name: ${parsed.error.message}`);
+}
+function assertValidTableName(tableName) {
+	const parsed = z.safeParse(duckValidatorsZod.tableName, tableName);
+	if (parsed.error) throw createAssertError(`'${tableName}' is not a valid table name: ${parsed.error.message}`);
+}
+//#endregion
+//#region src/validation/zod/duck-connection-params-zod-schema.ts
+const duckAllConnectionOptionsZodSchema = z.strictObject({
+	accessMode: z.optional(z.enum(["READ_ONLY", "READ_WRITE"])),
+	compress: z.optional(z.boolean()),
+	type: z.optional(z.enum(["DUCKDB", "SQLITE"])),
+	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"
+	]))
+});
+const duckConnectionParamsZodSchema = z.discriminatedUnion("type", [z.strictObject({
+	type: z.literal("memory"),
+	alias: duckValidatorsZod.aliasName,
+	options: z.optional(duckAllConnectionOptionsZodSchema)
+}), z.strictObject({
+	type: z.literal("duckdb"),
+	path: z.string().min(4).endsWith(".db"),
+	alias: duckValidatorsZod.aliasName,
+	options: z.optional(duckAllConnectionOptionsZodSchema)
+})]);
+//#endregion
+//#region src/validation/zod/parse-duck-dsn-zod.ts
+const parseDuckDSNZod = (dsn) => {
+	const result = parseDsn(dsn);
+	if (!result.success) throw new Error(`Invalid DuckDB DSN - ${result.message}`);
+	const parsed = result.value;
+	const { path, ...options } = parsed.params ?? {};
+	return duckConnectionParamsZodSchema.parse({
+		type: parsed.host,
+		alias: parsed.db,
+		...path ? { path } : {},
+		options: { ...options }
+	});
+};
+//#endregion
+//#region src/validation/zod/is-parsable-duck-dsn-zod.ts
+const isParsableDuckDsnZod = (dsn) => {
+	if (typeof dsn !== "string") return false;
+	try {
+		parseDuckDSNZod(dsn);
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+export { assertValidAliasName as a, duckValidatorsZod as c, duckConnectionParamsZodSchema as i, duckReservedKeywords as l, parseDuckDSNZod as n, assertValidSchemaName as o, duckAllConnectionOptionsZodSchema as r, assertValidTableName as s, isParsableDuckDsnZod as t };

package/package.json

@@ -1,18 +1,16 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./zod": {
+      "types": "./dist/validation/zod/index.d.mts",
+      "default": "./dist/validation/zod/index.mjs"
     },
     "./package.json": "./package.json"
   },
@@ -57,10 +55,12 @@
     "@flowblade/core": "^0.2.26",
     "@flowblade/source-duckdb": "^0.20.1",
     "@flowblade/sql-tag": "^0.3.2",
-    "@logtape/logtape": "2.0.4",
+    "@httpx/assert": "^0.16.8",
+    "@httpx/dsn-parser": "^1.9.9",
+    "@httpx/plain-object": "^2.1.8",
+    "@logtape/logtape": "^2.0.5",
     "@standard-schema/spec": "^1.1.0",
-    "p-mutex": "^1.0.0",
-    "valibot": "^1.3.1",
+    "p-queue": "9.1.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
@@ -68,9 +68,9 @@
   },
   "devDependencies": {
     "@belgattitude/eslint-config-bases": "8.10.0",
-    "@dotenvx/dotenvx": "1.57.2",
+    "@dotenvx/dotenvx": "1.59.1",
     "@duckdb/node-api": "1.5.1-r.1",
-    "@faker-js/faker": "10.3.0",
+    "@faker-js/faker": "10.4.0",
     "@flowblade/source-kysely": "^1.3.0",
     "@httpx/assert": "0.16.8",
     "@mitata/counters": "0.0.8",
@@ -78,23 +78,23 @@
     "@size-limit/file": "12.0.1",
     "@testcontainers/mssqlserver": "11.13.0",
     "@total-typescript/ts-reset": "0.6.1",
-    "@traversable/zod": "0.0.57",
     "@types/node": "25.5.0",
-    "@typescript-eslint/eslint-plugin": "8.57.2",
-    "@typescript-eslint/parser": "8.57.2",
-    "@typescript/native-preview": "7.0.0-dev.20260316.1",
-    "@vitest/coverage-v8": "4.1.1",
-    "@vitest/ui": "4.1.1",
+    "@typescript-eslint/eslint-plugin": "8.58.0",
+    "@typescript-eslint/parser": "8.58.0",
+    "@typescript/native-preview": "7.0.0-dev.20260324.1",
+    "@vitest/coverage-v8": "4.1.2",
+    "@vitest/ui": "4.1.2",
     "ansis": "4.2.0",
     "browserslist-to-esbuild": "2.1.1",
     "core-js": "3.49.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.3",
+    "es-toolkit": "1.45.1",
     "esbuild": "0.27.4",
     "eslint": "8.57.1",
     "execa": "9.6.1",
     "is-in-ci": "2.0.0",
-    "kysely": "0.28.14",
+    "kysely": "0.28.15",
     "mitata": "1.0.34",
     "npm-run-all2": "8.0.4",
     "prettier": "3.8.1",
@@ -102,16 +102,16 @@
     "regexp.escape": "2.0.1",
     "rimraf": "6.1.3",
     "size-limit": "12.0.1",
-    "sql-formatter": "15.7.2",
+    "sql-formatter": "15.7.3",
     "tarn": "3.0.2",
     "tedious": "19.2.1",
     "testcontainers": "11.13.0",
-    "tsdown": "0.21.4",
+    "tsdown": "0.21.7",
     "tsx": "4.21.0",
-    "typedoc": "0.28.17",
+    "typedoc": "0.28.18",
     "typedoc-plugin-markdown": "4.11.0",
-    "typescript": "5.9.3",
-    "vitest": "4.1.1"
+    "typescript": "6.0.2",
+    "vitest": "4.1.2"
   },
   "files": [
     "dist"