@flowblade/sqlduck 0.34.0 → 0.36.0

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
@@ -381,6 +383,14 @@ declare class DuckDatabaseManager {
   analyze: () => Promise<boolean>;
   checkpoint: (dbAlias: string) => Promise<boolean>;
   vacuum: () => Promise<boolean>;
+  getCurrentDatabase: () => Promise<string | null>;
+  getCurrentSchema: () => Promise<string | null>;
+  getCurrentCatalog: () => Promise<string | null>;
+  /**
+   * Set the default database to use
+   * @throws if the database alias does not exist
+   */
+  use: (dbAlias: string) => Promise<true>;
   /**
    * Helper to create an initial database file.
    */
@@ -430,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 } from "@duckdb/node-api";
 import * as z from "zod";
 import { assertNever } from "@httpx/assert";
 import { isPlainObject } from "@httpx/plain-object";
@@ -425,22 +425,33 @@ var DuckDatabaseManager = class {
 	*/
 	attach = async (dbParams, options) => {
 		const params = duckConnectionParamsZodSchema.parse(dbParams);
-		const rawSql = new DuckDatabaseAttachCommand(params, options).getRawSql();
-		const { behaviour } = options ?? {};
+		const rawSql = new DuckDatabaseAttachCommand(params, { behaviour: options?.behaviour }).getRawSql();
+		const restoreCurrentDb = await this.getCurrentDatabase();
+		const tempDbNameHack = "temp_run_detach_if_attached_hack_db";
+		let isTempDbNameHackCreated = false;
 		try {
-			await this.#executor.getRowObjectsJS([
-				`attach(${params.alias}`,
-				behaviour ?? null,
-				")"
-			].filter(Boolean).join(","), rawSql);
+			await this.#executor.getRowObjectsJS([`attach(${params.alias}`, options === void 0 ? null : JSON.stringify(options)].filter(Boolean).join(",") + ")", rawSql);
 		} catch (e) {
 			if (options?.behaviour === "OR REPLACE" && options?.runDetachIfAttachOrReplaceFailWithAlreadyAttached === true) {
 				const alreadyAttached = getAlreadyAttachedDatabaseFromError(e);
 				if (alreadyAttached.isAlreadyAttached === true) {
+					if (alreadyAttached.dbAlias === restoreCurrentDb) {
+						await this.attachIfNotExists({
+							type: "memory",
+							alias: tempDbNameHack
+						});
+						await this.use(tempDbNameHack);
+						isTempDbNameHackCreated = true;
+					}
 					await this.detachOrIgnore(alreadyAttached.dbAlias);
 					await this.attach(dbParams);
 				} else throw e;
 			} else throw e;
+		} finally {
+			if (restoreCurrentDb !== null && isTempDbNameHackCreated) {
+				await this.use(restoreCurrentDb);
+				await this.detachOrIgnore(tempDbNameHack);
+			}
 		}
 		return new Database({ alias: params.alias });
 	};
@@ -576,6 +587,24 @@ var DuckDatabaseManager = class {
 		await this.#executor.getRowObjectsJS("vacuum()", "VACUUM");
 		return true;
 	};
+	getCurrentDatabase = async () => {
+		return (await this.#executor.getRowObjectsJS("getCurrentDatabase()", "SELECT current_database() as current_database"))[0]?.current_database ?? null;
+	};
+	getCurrentSchema = async () => {
+		return (await this.#executor.getRowObjectsJS("getCurrentSchema()", "SELECT current_schema() as current_schema"))?.[0]?.current_schema ?? null;
+	};
+	getCurrentCatalog = async () => {
+		return (await this.#executor.getRowObjectsJS("getCurrentCatalog()", "SELECT current_catalog() as current_catalog"))?.[0]?.current_catalog ?? null;
+	};
+	/**
+	* Set the default database to use
+	* @throws if the database alias does not exist
+	*/
+	use = async (dbAlias) => {
+		const safeAlias = duckValidatorsZod.aliasName.parse(dbAlias);
+		await this.#executor.getRowObjectsJS(`use(${safeAlias})`, `USE ${safeAlias}`);
+		return true;
+	};
 	/**
 	* Helper to create an initial database file.
 	*/
@@ -664,7 +693,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) => {
@@ -681,8 +721,23 @@ 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 "number":
+						c.duckdbType = LIST(INTEGER);
+						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) {
@@ -719,6 +774,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.34.0",
+  "version": "0.36.0",
   "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",