@flowblade/sqlduck 0.35.0 → 0.36.1

package/dist/{index-BKsJVkXZ.d.mts → index-Z9LfGsCV.d.mts}

@@ -255,7 +255,7 @@ type MapRelaxedZodSchemaField<T extends z.ZodTypeAny> = T extends z.ZodDate ? st
 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 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 | z.ZodArray;
 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,5 +1,5 @@
-import { l as DuckConnectionParams, n as InferZodRelaxedDataSchema, t as TableSchemaZod } from "./index-BKsJVkXZ.mjs";
-import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
+import { l as DuckConnectionParams, n as InferZodRelaxedDataSchema, t as TableSchemaZod } from "./index-Z9LfGsCV.mjs";
+import { DuckDBConnection, DuckDBDecimalType, DuckDBListType, DuckDBType } from "@duckdb/node-api";
 import { Logger } from "@logtape/logtape";
 import * as z from "zod";
 import { ZodObject } from "zod";
@@ -91,6 +91,8 @@ type GetTableCreateFromZodParams<TSchema extends TableSchemaZod> = {
   schema: TSchema;
   options?: TableCreateOptions;
 };
+declare const duckDbTypes: [["VARCHAR", import("@duckdb/node-api").DuckDBVarCharType], ["BIGINT", import("@duckdb/node-api").DuckDBBigIntType], ["UBIGINT", import("@duckdb/node-api").DuckDBUBigIntType], ["HUGEINT", import("@duckdb/node-api").DuckDBHugeIntType], ["TIMESTAMP", import("@duckdb/node-api").DuckDBTimestampType], ["TIMESTAMP_MS", import("@duckdb/node-api").DuckDBTimestampMillisecondsType], ["UUID", import("@duckdb/node-api").DuckDBUUIDType], ["BOOLEAN", import("@duckdb/node-api").DuckDBBooleanType], ["INTEGER", import("@duckdb/node-api").DuckDBIntegerType], ["DOUBLE", import("@duckdb/node-api").DuckDBDoubleType], ["FLOAT", import("@duckdb/node-api").DuckDBFloatType], ["DATE", import("@duckdb/node-api").DuckDBDateType], ["DECIMAL", DuckDBDecimalType], ["VARCHAR[]", DuckDBListType], ["INTEGER[]", DuckDBListType], ["BOOLEAN[]", DuckDBListType], ["BIGINT[]", DuckDBListType], ["UBIGINT[]", DuckDBListType], ["UUID[]", DuckDBListType], ["DATE[]", DuckDBListType], ["TIMESTAMP[]", DuckDBListType], ["TIMESTAMP_MS[]", DuckDBListType], ["DOUBLE[]", DuckDBListType], ["FLOAT[]", DuckDBListType]];
+type SupportedCustomDuckDbTypes = (typeof duckDbTypes)[number][0];
 declare const getTableCreateFromZod: <TSchema extends TableSchemaZod>(params: GetTableCreateFromZodParams<TSchema>) => TableCreateFromZodResult<TSchema>;
 //#endregion
 //#region src/sql-duck.d.ts
@@ -438,4 +440,4 @@ declare const flowbladeLogtapeSqlduckConfig: {
 //#region src/logger/sqlduck-default-logtape-logger.d.ts
 declare const sqlduckDefaultLogtapeLogger: import("@logtape/logtape").Logger;
 //#endregion
-export { Database, type DuckConnectionParams, DuckDatabaseManager, DuckExtensionsManager, DuckMemory, type DuckMemoryTag, DuckSettingsManager, type DuckdbReservedKeywords, type OnChunkAppendedCb, type OnChunkAppendedStats, SqlDuck, type SqlDuckParams, Table, type ToTableParams, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };
+export { Database, type DuckConnectionParams, DuckDatabaseManager, DuckExtensionsManager, DuckMemory, type DuckMemoryTag, DuckSettingsManager, type DuckdbReservedKeywords, type OnChunkAppendedCb, type OnChunkAppendedStats, SqlDuck, type SqlDuckParams, type SupportedCustomDuckDbTypes, Table, type ToTableParams, duckReservedKeywords, flowbladeLogtapeSqlduckConfig, getTableCreateFromZod, sqlduckDefaultLogtapeLogger, zodCodecs };

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, 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 { BIGINT, BOOLEAN, DATE, DECIMAL, DOUBLE, DuckDBDataChunk, DuckDBDateValue, DuckDBDecimalType, DuckDBDecimalValue, DuckDBInstanceCache, DuckDBListType, DuckDBTimestampMillisecondsValue, DuckDBTypeId, ENUM, FLOAT, HUGEINT, INTEGER, LIST, SMALLINT, TIMESTAMP, TIMESTAMP_MS, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR, listValue } from "@duckdb/node-api";
 import * as z from "zod";
 import { assertNever } from "@httpx/assert";
 import { isPlainObject } from "@httpx/plain-object";
@@ -191,6 +191,10 @@ var DuckValueConverter = class {
 			value
 		});
 	};
+	toList = (arrayValue) => {
+		if (arrayValue === void 0 || arrayValue === null) return null;
+		return listValue(arrayValue);
+	};
 	toTimestampMs = (value) => {
 		if (value instanceof Date) return new DuckDBTimestampMillisecondsValue(BigInt(value.getTime()));
 		if (value === void 0 || value === null) return null;
@@ -258,6 +262,9 @@ const createDuckColumnConverters = (duckTypes) => {
 			case DuckDBTypeId.DATE:
 				conv = converter.toDate;
 				break;
+			case DuckDBTypeId.LIST:
+				conv = converter.toList;
+				break;
 			default: throw new Error(`Unsupported duck type ${duckTypeId} / ${duckType.toString()} for column '${key}'`);
 		}
 		if (conv !== false) convMap[key] = conv;
@@ -651,11 +658,11 @@ 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)) {
 		const scale = getScale(multipleOf);
 		return DECIMAL(18, scale);
 	}
+	if (minimum === void 0 || maximum === void 0) return BIGINT;
 	if (isFloatValue(minimum) || isFloatValue(maximum)) {
 		if (minimum >= -34028235e31 && maximum <= 34028235e31) return FLOAT;
 		return DOUBLE;
@@ -693,7 +700,18 @@ const duckDbTypes = [
 	["DOUBLE", DOUBLE],
 	["FLOAT", FLOAT],
 	["DATE", DATE],
-	["DECIMAL", new DuckDBDecimalType(18, 3)]
+	["DECIMAL", new DuckDBDecimalType(18, 3)],
+	["VARCHAR[]", new DuckDBListType(VARCHAR)],
+	["INTEGER[]", new DuckDBListType(INTEGER)],
+	["BOOLEAN[]", new DuckDBListType(BOOLEAN)],
+	["BIGINT[]", new DuckDBListType(BIGINT)],
+	["UBIGINT[]", new DuckDBListType(UBIGINT)],
+	["UUID[]", new DuckDBListType(UUID)],
+	["DATE[]", new DuckDBListType(DATE)],
+	["TIMESTAMP[]", new DuckDBListType(TIMESTAMP)],
+	["TIMESTAMP_MS[]", new DuckDBListType(TIMESTAMP_MS)],
+	["DOUBLE[]", new DuckDBListType(DOUBLE)],
+	["FLOAT[]", new DuckDBListType(FLOAT)]
 ];
 const duckDbTypesMap = new Map(duckDbTypes);
 const getTableCreateFromZod = (params) => {
@@ -710,8 +728,33 @@ const getTableCreateFromZod = (params) => {
 	for (const [columnName, def] of Object.entries(json.properties)) {
 		const { type, duckdbType, nullable, format, primaryKey, minimum, maximum, multipleOf } = def;
 		const c = { name: columnName };
-		if (duckdbType !== void 0 && duckDbTypesMap.has(duckdbType)) c.duckdbType = duckDbTypesMap.get(duckdbType);
-		else switch (type) {
+		if (duckdbType !== void 0 && !duckDbTypesMap.has(duckdbType)) throw new Error(`The provided "duckdbType: '${duckdbType}'" for '${columnName}' isn't currently supported - ${JSON.stringify(def)}`);
+		const customDuckDbType = duckdbType === void 0 ? void 0 : duckDbTypesMap.get(duckdbType);
+		if (customDuckDbType === void 0) switch (type) {
+			case "array":
+				switch (def?.items?.type) {
+					case "string":
+						c.duckdbType = LIST(VARCHAR);
+						break;
+					case "integer":
+						c.duckdbType = LIST(getDuckdbNumberColumnType({
+							minimum: def?.items?.minimum,
+							maximum: def?.items?.maximum
+						}));
+						break;
+					case "number":
+						c.duckdbType = LIST(getDuckdbNumberColumnType({
+							minimum: def?.items?.minimum,
+							maximum: def?.items?.maximum,
+							multipleOf: def?.items?.multipleOf
+						}));
+						break;
+					case "boolean":
+						c.duckdbType = LIST(BOOLEAN);
+						break;
+					default: throw new Error(`The inferred duckdb array for '${columnName}' is not supported - ${JSON.stringify(def)}`);
+				}
+				break;
 			case "string":
 				if (Array.isArray(def.enum)) c.duckdbType = ENUM(def.enum);
 				else switch (format) {
@@ -748,6 +791,7 @@ const getTableCreateFromZod = (params) => {
 				break;
 			default: throw new Error(`Cannot guess '${columnName}' type - ${JSON.stringify(def)}`);
 		}
+		else c.duckdbType = customDuckDbType;
 		if (primaryKey === true) c.constraint = "PRIMARY KEY";
 		else if (nullable !== true) c.constraint = "NOT NULL";
 		columnTypesMap.set(columnName, c.duckdbType);

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

@@ -1,2 +1,2 @@
-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";
+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-Z9LfGsCV.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.35.0",
+  "version": "0.36.1",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -95,7 +95,7 @@
     "@belgattitude/eslint-config-bases": "8.19.1",
     "@dotenvx/dotenvx": "2.21.0",
     "@duckdb/node-api": "1.5.5-r.4",
-    "@faker-js/faker": "10.5.0",
+    "@faker-js/faker": "10.6.0",
     "@flowblade/source-kysely": "^1.7.0",
     "@httpx/assert": "0.18.0",
     "@mitata/counters": "0.0.8",
@@ -107,8 +107,8 @@
     "@typescript-eslint/eslint-plugin": "8.67.0",
     "@typescript-eslint/parser": "8.67.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "@vitest/coverage-v8": "4.1.10",
-    "@vitest/ui": "4.1.10",
+    "@vitest/coverage-v8": "4.1.11",
+    "@vitest/ui": "4.1.11",
     "ansis": "4.3.1",
     "browserslist-to-esbuild": "2.1.1",
     "core-js": "3.50.0",
@@ -137,7 +137,7 @@
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",
     "valibot": "1.4.2",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "files": [
     "dist"