@flowblade/sqlduck 0.21.0 → 0.23.0

package/dist/file-system-utils-JhZ8_Dh7.mjs

@@ -0,0 +1,85 @@
+import { getLogger } from "@logtape/logtape";
+import fs from "node:fs";
+import { basename, dirname } from "node:path";
+//#region src/config/flowblade-logtape-sqlduck.config.ts
+const flowbladeLogtapeSqlduckConfig = { categories: ["flowblade", "sqlduck"] };
+//#endregion
+//#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
+export { sqlduckDefaultLogtapeLogger as n, flowbladeLogtapeSqlduckConfig as r, FileSystemUtils as t };

package/dist/filesystem/index.d.mts

@@ -0,0 +1,34 @@
+import { Logger } from "@logtape/logtape";
+
+//#region src/filesystem/file-system-utils.d.ts
+declare class FileSystemUtils {
+  #private;
+  constructor(params?: {
+    logger?: Logger;
+  });
+  /**
+   * Create a directory recursively if it doesn't exist
+   *
+   * @throws Error if it can't be created
+   */
+  createDirectory: (path: string) => void;
+  /**
+   * Create a directory recursively if it doesn't exist and ensure it's writable
+   */
+  createAndEnsureWritableDirectory: (label: string, path: string | undefined) => void;
+  /**
+   * Check if a path is a regular file and exists
+   */
+  isFile: (path: string) => boolean;
+  /**
+   * Check if a path is a directory and exists
+   */
+  isDirectory: (path: string) => boolean;
+  parsePath: (path: string) => {
+    directory: string;
+    filename: string;
+  };
+  removeFileIfExists: (path: string) => boolean;
+}
+//#endregion
+export { FileSystemUtils };

package/dist/filesystem/index.mjs

@@ -0,0 +1,2 @@
+import { t as FileSystemUtils } from "../file-system-utils-JhZ8_Dh7.mjs";
+export { FileSystemUtils };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { n as DuckConnectionParams } from "./types-BIe-pGY0.mjs";
+import { n as DuckConnectionParams } from "./types-C6EIVpFJ.mjs";
 import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
 import * as _$_logtape_logtape0 from "@logtape/logtape";
 import { Logger } from "@logtape/logtape";
@@ -266,6 +266,20 @@ declare class Database {
 declare const duckReservedKeywords: readonly ["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"];
 type DuckdbReservedKeywords = (typeof duckReservedKeywords)[number];
 //#endregion
+//#region src/validation/zod/manager/duck-database-manager-zod-schemas.d.ts
+declare const duckDatabaseManagerZodSchemas: {
+  getDatabases: z.ZodObject<{
+    comment: z.ZodNullable<z.ZodString>;
+    database_name: z.ZodString;
+    database_oid: z.ZodBigInt;
+    encrypted: z.ZodBoolean;
+    internal: z.ZodBoolean;
+    path: z.ZodNullable<z.ZodString>;
+    readonly: z.ZodBoolean;
+    type: z.ZodString;
+  }, z.core.$strict>;
+};
+//#endregion
 //#region src/manager/database/commands/duck-database-attach-command.d.ts
 type Behaviour = 'OR REPLACE' | 'IF NOT EXISTS';
 type DuckDatabaseAttachCommandOptions = {
@@ -273,6 +287,7 @@ type DuckDatabaseAttachCommandOptions = {
 };
 //#endregion
 //#region src/manager/database/duck-database-manager.d.ts
+type GetDatabaseInfo = z.infer<typeof duckDatabaseManagerZodSchemas.getDatabases>;
 declare class DuckDatabaseManager {
   #private;
   readonly className = "DuckDatabaseManager";
@@ -301,27 +316,26 @@ declare class DuckDatabaseManager {
    * Check whether a specific database name / alias is currently attached
    */
   isAttached: (dbAlias: string) => Promise<boolean>;
+  getDatabaseByName: (dbName: string) => Promise<GetDatabaseInfo | null>;
+  getDatabasesByPath: (path: string) => Promise<GetDatabaseInfo | null>;
   /**
    * Return information about attached databases
    */
   getDatabases: (params?: {
     includeInternal?: boolean;
-  }) => Promise<{
-    database_name: string;
-    database_oid: string;
-    path: string | null;
-    comment: string | null;
-    type: string;
-    readonly: boolean;
-    internal: boolean;
-    encrypted: boolean;
-  }[]>;
+  }) => Promise<GetDatabaseInfo[]>;
   /**
    * Get the currently attached database names
    */
   showDatabases: () => Promise<Record<string, unknown>[]>;
+  /**
+   * @throws Error if the database isn't attached
+   */
   detach: (dbAlias: string) => Promise<boolean>;
-  detachIfExists: (dbAlias: string) => Promise<boolean>;
+  /**
+   * @todo DETACH IF EXISTS is not supported in DuckDB as of v1.5.3
+   */
+  detachOrIgnore: (dbAlias: string) => Promise<boolean>;
   /**
    * The statistics recomputed by the ANALYZE statement are only used for join order optimization.
    *

package/dist/index.mjs

@@ -1,9 +1,7 @@
-import { t as duckReservedKeywords } from "./duck-reserved-keywords-B00l2sbi.mjs";
-import { c as duckValidatorsZod, r as assertValidAliasName, s as duckConnectionParamsZodSchema } from "./zod-BXgMoCLM.mjs";
+import { n as sqlduckDefaultLogtapeLogger, r as flowbladeLogtapeSqlduckConfig, t as FileSystemUtils } from "./file-system-utils-JhZ8_Dh7.mjs";
+import { t as duckReservedKeywords } from "./duck-reserved-keywords-D_yi_PVW.mjs";
+import { c as duckValidatorsZod, r as assertValidAliasName, s as duckConnectionParamsZodSchema } from "./zod-uQPzaK64.mjs";
 import { BIGINT, BOOLEAN, DOUBLE, DuckDBDataChunk, DuckDBInstanceCache, DuckDBTimestampMillisecondsValue, DuckDBTypeId, ENUM, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TIMESTAMP_MS, 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";
@@ -230,87 +228,6 @@ const createDuckColumnConverters = (duckTypes) => {
 	return convMap;
 };
 //#endregion
-//#region src/config/flowblade-logtape-sqlduck.config.ts
-const flowbladeLogtapeSqlduckConfig = { categories: ["flowblade", "sqlduck"] };
-//#endregion
-//#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;
@@ -331,6 +248,13 @@ var Database = class {
 	}
 };
 //#endregion
+//#region src/utils/quote-value.ts
+const quoteValue = (value) => {
+	if (value === null || value === void 0) return "NULL";
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return `'${value.replaceAll("'", "''")}'`;
+};
+//#endregion
 //#region src/manager/core/manager-query-executor.ts
 var ManagerQueryExecutor = class {
 	#conn;
@@ -475,13 +399,42 @@ var DuckDatabaseManager = class {
                 WHERE database_name = '${dbAlias}'
               ) AS is_attached;`))[0]?.is_attached ?? false;
 	};
+	getDatabaseByName = async (dbName) => {
+		assertValidAliasName(dbName);
+		const result = await this.#executor.getRowObjectsJS("getDatabaseByName", `select database_name,
+                     database_oid,
+                     path,
+                     comment,
+                     type,
+                     readonly,
+                     internal,
+                     encrypted
+              from duckdb_databases()
+              where database_name = '${dbName}'`);
+		if (result.length === 1) return result[0];
+		return null;
+	};
+	getDatabasesByPath = async (path) => {
+		const result = await this.#executor.getRowObjectsJS("getDatabaseByPath", `select database_name,
+                     database_oid,
+                     path,
+                     comment,
+                     type,
+                     readonly,
+                     internal,
+                     encrypted
+              from duckdb_databases()
+              where path = ${quoteValue(path)}`);
+		if (result.length === 1) return result[0];
+		return null;
+	};
 	/**
 	* Return information about attached databases
 	*/
 	getDatabases = async (params) => {
 		const { includeInternal = false } = params ?? {};
 		const internalFilter = includeInternal ? "1=1" : "internal = false";
-		return this.#executor.getRowObjectsJS("listDatabases", `select database_name,
+		return this.#executor.getRowObjectsJS("getDatabases", `select database_name,
                      database_oid,
                      path,
                      comment,
@@ -498,14 +451,24 @@ var DuckDatabaseManager = class {
 	showDatabases = async () => {
 		return await this.#executor.getRowObjectsJS("showDatabases()", `SHOW DATABASES`);
 	};
+	/**
+	* @throws Error if the database isn't attached
+	*/
 	detach = async (dbAlias) => {
 		assertValidAliasName(dbAlias);
 		await this.#executor.getRowObjectsJS(`detach(${dbAlias})`, `DETACH ${dbAlias}`);
 		return true;
 	};
-	detachIfExists = async (dbAlias) => {
+	/**
+	* @todo DETACH IF EXISTS is not supported in DuckDB as of v1.5.3
+	*/
+	detachOrIgnore = async (dbAlias) => {
 		assertValidAliasName(dbAlias);
-		await this.#executor.getRowObjectsJS(`detachIfExists(${dbAlias})`, `DETACH IF EXISTS ${dbAlias}`);
+		try {
+			await this.detach(dbAlias);
+		} catch {
+			return false;
+		}
 		return true;
 	};
 	/**

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-B00l2sbi.mjs";
+import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "../../duck-reserved-keywords-D_yi_PVW.mjs";
 import isSafeFilename from "is-safe-filename";
 import { parseDsn, parseDsnOrThrow } from "@httpx/dsn-parser";
 import * as v from "valibot";

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

@@ -1,4 +1,4 @@
-import { a as duckAllConnectionOptionsZodSchema, i as DuckTableName, o as duckConnectionParamsZodSchema, r as DuckSchemaName, t as DuckAliasName } from "../../types-BIe-pGY0.mjs";
+import { a as duckAllConnectionOptionsZodSchema, i as DuckTableName, o as duckConnectionParamsZodSchema, r as DuckSchemaName, t as DuckAliasName } from "../../types-C6EIVpFJ.mjs";
 import * as z from "zod";
 
 //#region src/validation/zod/duck-asserts-zod.d.ts

package/dist/validation/zod/index.mjs

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

package/dist/{zod-BXgMoCLM.mjs → zod-uQPzaK64.mjs}

@@ -1,4 +1,4 @@
-import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "./duck-reserved-keywords-B00l2sbi.mjs";
+import { a as duckStorageVersionRegexp, i as duckIdentifierNameRegex, n as duckdbReservedKeywordsSet, r as duckConnectionsOptions } from "./duck-reserved-keywords-D_yi_PVW.mjs";
 import isSafeFilename from "is-safe-filename";
 import * as z from "zod";
 import { parseDsn } from "@httpx/dsn-parser";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -8,6 +8,10 @@
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
     },
+    "./filesystem": {
+      "types": "./dist/filesystem/index.d.mts",
+      "default": "./dist/filesystem/index.mjs"
+    },
     "./zod": {
       "types": "./dist/validation/zod/index.d.mts",
       "default": "./dist/validation/zod/index.mjs"
@@ -44,6 +48,7 @@
     "test": "vitest run",
     "test-unit": "vitest run",
     "test-unit-bun": "bun --bun run vitest run",
+    "test-unit-deno": "deno run test-unit",
     "test-unit-watch": "vitest --ui",
     "test-e2e": "vitest -c vitest.e2e.config.ts run",
     "test-e2e-bun": "bun --bun run vitest -c vitest.e2e.config.ts run",
@@ -79,7 +84,7 @@
   },
   "devDependencies": {
     "@belgattitude/eslint-config-bases": "8.15.0",
-    "@dotenvx/dotenvx": "1.67.0",
+    "@dotenvx/dotenvx": "1.68.1",
     "@duckdb/node-api": "1.5.3-r.2",
     "@faker-js/faker": "10.4.0",
     "@flowblade/source-kysely": "^1.4.1",
@@ -92,7 +97,7 @@
     "@types/node": "25.9.1",
     "@typescript-eslint/eslint-plugin": "8.60.0",
     "@typescript-eslint/parser": "8.60.0",
-    "@typescript/native-preview": "7.0.0-dev.20260524.1",
+    "@typescript/native-preview": "7.0.0-dev.20260525.1",
     "@vitest/coverage-v8": "4.1.7",
     "@vitest/ui": "4.1.7",
     "ansis": "4.3.0",
@@ -100,7 +105,7 @@
     "core-js": "3.49.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.4",
-    "es-toolkit": "1.46.1",
+    "es-toolkit": "1.47.0",
     "esbuild": "0.28.0",
     "eslint": "8.57.1",
     "execa": "9.6.1",