@leonardovida-md/drizzle-neo-duckdb 1.0.1 → 1.0.2

package/dist/duckdb-introspect.mjs

@@ -747,12 +747,13 @@ import { sql as sql4 } from "drizzle-orm";
 var SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog"]);
 var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb";
 async function introspect(db, opts = {}) {
-  const schemas = await resolveSchemas(db, opts.schemas);
+  const database = await resolveDatabase(db, opts.database, opts.allDatabases);
+  const schemas = await resolveSchemas(db, database, opts.schemas);
   const includeViews = opts.includeViews ?? false;
-  const tables = await loadTables(db, schemas, includeViews);
-  const columns = await loadColumns(db, schemas);
-  const constraints = await loadConstraints(db, schemas);
-  const indexes = await loadIndexes(db, schemas);
+  const tables = await loadTables(db, database, schemas, includeViews);
+  const columns = await loadColumns(db, database, schemas);
+  const constraints = await loadConstraints(db, database, schemas);
+  const indexes = await loadIndexes(db, database, schemas);
   const grouped = buildTables(tables, columns, constraints, indexes);
   const schemaTs = emitSchema(grouped, {
     useCustomTimeTypes: opts.useCustomTimeTypes ?? true,
@@ -766,27 +767,41 @@ async function introspect(db, opts = {}) {
     }
   };
 }
-async function resolveSchemas(db, targetSchemas) {
+async function resolveDatabase(db, targetDatabase, allDatabases) {
+  if (allDatabases) {
+    return null;
+  }
+  if (targetDatabase) {
+    return targetDatabase;
+  }
+  const rows = await db.execute(sql4`SELECT current_database() as current_database`);
+  return rows[0]?.current_database ?? null;
+}
+async function resolveSchemas(db, database, targetSchemas) {
   if (targetSchemas?.length) {
     return targetSchemas;
   }
-  const rows = await db.execute(sql4`select schema_name from information_schema.schemata`);
+  const databaseFilter = database ? sql4`catalog_name = ${database}` : sql4`1 = 1`;
+  const rows = await db.execute(sql4`SELECT schema_name FROM information_schema.schemata WHERE ${databaseFilter}`);
   return rows.map((row) => row.schema_name).filter((name) => !SYSTEM_SCHEMAS.has(name));
 }
-async function loadTables(db, schemas, includeViews) {
+async function loadTables(db, database, schemas, includeViews) {
   const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`table_catalog = ${database}` : sql4`1 = 1`;
   return await db.execute(sql4`
-      select table_schema as schema_name, table_name, table_type
-      from information_schema.tables
-      where table_schema in (${sql4.join(schemaFragments, sql4.raw(", "))})
-      and ${includeViews ? sql4`1 = 1` : sql4`table_type = 'BASE TABLE'`}
-      order by table_schema, table_name
+      SELECT table_schema as schema_name, table_name, table_type
+      FROM information_schema.tables
+      WHERE ${databaseFilter}
+      AND table_schema IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      AND ${includeViews ? sql4`1 = 1` : sql4`table_type = 'BASE TABLE'`}
+      ORDER BY table_schema, table_name
     `);
 }
-async function loadColumns(db, schemas) {
+async function loadColumns(db, database, schemas) {
   const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`database_name = ${database}` : sql4`1 = 1`;
   return await db.execute(sql4`
-      select
+      SELECT
         schema_name,
         table_name,
         column_name,
@@ -798,15 +813,17 @@ async function loadColumns(db, schemas) {
         numeric_precision,
         numeric_scale,
         internal
-      from duckdb_columns()
-      where schema_name in (${sql4.join(schemaFragments, sql4.raw(", "))})
-      order by schema_name, table_name, column_index
+      FROM duckdb_columns()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      ORDER BY schema_name, table_name, column_index
     `);
 }
-async function loadConstraints(db, schemas) {
+async function loadConstraints(db, database, schemas) {
   const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`database_name = ${database}` : sql4`1 = 1`;
   return await db.execute(sql4`
-      select
+      SELECT
         schema_name,
         table_name,
         constraint_name,
@@ -815,23 +832,26 @@ async function loadConstraints(db, schemas) {
         constraint_column_names,
         referenced_table,
         referenced_column_names
-      from duckdb_constraints()
-      where schema_name in (${sql4.join(schemaFragments, sql4.raw(", "))})
-      order by schema_name, table_name, constraint_index
+      FROM duckdb_constraints()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      ORDER BY schema_name, table_name, constraint_index
     `);
 }
-async function loadIndexes(db, schemas) {
+async function loadIndexes(db, database, schemas) {
   const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  const databaseFilter = database ? sql4`database_name = ${database}` : sql4`1 = 1`;
   return await db.execute(sql4`
-      select
+      SELECT
         schema_name,
         table_name,
         index_name,
         is_unique,
         expressions
-      from duckdb_indexes()
-      where schema_name in (${sql4.join(schemaFragments, sql4.raw(", "))})
-      order by schema_name, table_name, index_name
+      FROM duckdb_indexes()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql4.join(schemaFragments, sql4.raw(", "))})
+      ORDER BY schema_name, table_name, index_name
     `);
 }
 function buildTables(tables, columns, constraints, indexes) {
@@ -1278,6 +1298,7 @@ function renderImports(imports, importBasePath) {
 function parseArgs(argv) {
   const options = {
     outFile: path.resolve(process.cwd(), "drizzle/schema.ts"),
+    allDatabases: false,
     includeViews: false,
     useCustomTimeTypes: true
   };
@@ -1287,6 +1308,13 @@ function parseArgs(argv) {
       case "--url":
         options.url = argv[++i];
         break;
+      case "--database":
+      case "--db":
+        options.database = argv[++i];
+        break;
+      case "--all-databases":
+        options.allDatabases = true;
+        break;
       case "--schema":
       case "--schemas":
         options.schemas = argv[++i]?.split(",").map((s) => s.trim()).filter(Boolean);
@@ -1325,11 +1353,27 @@ Usage:
 
 Options:
   --url            DuckDB database path (e.g. :memory:, ./local.duckdb, md:)
+  --database, --db Database/catalog to introspect (default: current database)
+  --all-databases  Introspect all attached databases (not just current)
   --schema         Comma separated schema list (defaults to all non-system schemas)
   --out            Output file (default: ./drizzle/schema.ts)
   --include-views  Include views in the generated schema
   --use-pg-time    Use pg-core timestamp/date/time instead of DuckDB custom helpers
   --import-base    Override import path for duckdb helpers (default: package name)
+
+Database Filtering:
+  By default, only tables from the current database are introspected. This prevents
+  returning tables from all attached databases in MotherDuck workspaces.
+
+  Use --database to specify a different database, or --all-databases to introspect
+  all attached databases.
+
+Examples:
+  # Local DuckDB file
+  bun x duckdb-introspect --url ./my-database.duckdb --out ./schema.ts
+
+  # MotherDuck (requires MOTHERDUCK_TOKEN env var)
+  MOTHERDUCK_TOKEN=xxx bun x duckdb-introspect --url md: --database my_cloud_db --out ./schema.ts
 `);
 }
 async function main() {
@@ -1344,6 +1388,8 @@ async function main() {
   const db = drizzle(connection);
   try {
     const result = await introspect(db, {
+      database: options.database,
+      allDatabases: options.allDatabases,
       schemas: options.schemas,
       includeViews: options.includeViews,
       useCustomTimeTypes: options.useCustomTimeTypes,

package/dist/index.mjs

@@ -1012,12 +1012,13 @@ import { sql as sql5 } from "drizzle-orm";
 var SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog"]);
 var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb";
 async function introspect(db, opts = {}) {
-  const schemas = await resolveSchemas(db, opts.schemas);
+  const database = await resolveDatabase(db, opts.database, opts.allDatabases);
+  const schemas = await resolveSchemas(db, database, opts.schemas);
   const includeViews = opts.includeViews ?? false;
-  const tables = await loadTables(db, schemas, includeViews);
-  const columns = await loadColumns(db, schemas);
-  const constraints = await loadConstraints(db, schemas);
-  const indexes = await loadIndexes(db, schemas);
+  const tables = await loadTables(db, database, schemas, includeViews);
+  const columns = await loadColumns(db, database, schemas);
+  const constraints = await loadConstraints(db, database, schemas);
+  const indexes = await loadIndexes(db, database, schemas);
   const grouped = buildTables(tables, columns, constraints, indexes);
   const schemaTs = emitSchema(grouped, {
     useCustomTimeTypes: opts.useCustomTimeTypes ?? true,
@@ -1031,27 +1032,41 @@ async function introspect(db, opts = {}) {
     }
   };
 }
-async function resolveSchemas(db, targetSchemas) {
+async function resolveDatabase(db, targetDatabase, allDatabases) {
+  if (allDatabases) {
+    return null;
+  }
+  if (targetDatabase) {
+    return targetDatabase;
+  }
+  const rows = await db.execute(sql5`SELECT current_database() as current_database`);
+  return rows[0]?.current_database ?? null;
+}
+async function resolveSchemas(db, database, targetSchemas) {
   if (targetSchemas?.length) {
     return targetSchemas;
   }
-  const rows = await db.execute(sql5`select schema_name from information_schema.schemata`);
+  const databaseFilter = database ? sql5`catalog_name = ${database}` : sql5`1 = 1`;
+  const rows = await db.execute(sql5`SELECT schema_name FROM information_schema.schemata WHERE ${databaseFilter}`);
   return rows.map((row) => row.schema_name).filter((name) => !SYSTEM_SCHEMAS.has(name));
 }
-async function loadTables(db, schemas, includeViews) {
+async function loadTables(db, database, schemas, includeViews) {
   const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`table_catalog = ${database}` : sql5`1 = 1`;
   return await db.execute(sql5`
-      select table_schema as schema_name, table_name, table_type
-      from information_schema.tables
-      where table_schema in (${sql5.join(schemaFragments, sql5.raw(", "))})
-      and ${includeViews ? sql5`1 = 1` : sql5`table_type = 'BASE TABLE'`}
-      order by table_schema, table_name
+      SELECT table_schema as schema_name, table_name, table_type
+      FROM information_schema.tables
+      WHERE ${databaseFilter}
+      AND table_schema IN (${sql5.join(schemaFragments, sql5.raw(", "))})
+      AND ${includeViews ? sql5`1 = 1` : sql5`table_type = 'BASE TABLE'`}
+      ORDER BY table_schema, table_name
     `);
 }
-async function loadColumns(db, schemas) {
+async function loadColumns(db, database, schemas) {
   const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`database_name = ${database}` : sql5`1 = 1`;
   return await db.execute(sql5`
-      select
+      SELECT
         schema_name,
         table_name,
         column_name,
@@ -1063,15 +1078,17 @@ async function loadColumns(db, schemas) {
         numeric_precision,
         numeric_scale,
         internal
-      from duckdb_columns()
-      where schema_name in (${sql5.join(schemaFragments, sql5.raw(", "))})
-      order by schema_name, table_name, column_index
+      FROM duckdb_columns()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql5.join(schemaFragments, sql5.raw(", "))})
+      ORDER BY schema_name, table_name, column_index
     `);
 }
-async function loadConstraints(db, schemas) {
+async function loadConstraints(db, database, schemas) {
   const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`database_name = ${database}` : sql5`1 = 1`;
   return await db.execute(sql5`
-      select
+      SELECT
         schema_name,
         table_name,
         constraint_name,
@@ -1080,23 +1097,26 @@ async function loadConstraints(db, schemas) {
         constraint_column_names,
         referenced_table,
         referenced_column_names
-      from duckdb_constraints()
-      where schema_name in (${sql5.join(schemaFragments, sql5.raw(", "))})
-      order by schema_name, table_name, constraint_index
+      FROM duckdb_constraints()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql5.join(schemaFragments, sql5.raw(", "))})
+      ORDER BY schema_name, table_name, constraint_index
     `);
 }
-async function loadIndexes(db, schemas) {
+async function loadIndexes(db, database, schemas) {
   const schemaFragments = schemas.map((schema) => sql5`${schema}`);
+  const databaseFilter = database ? sql5`database_name = ${database}` : sql5`1 = 1`;
   return await db.execute(sql5`
-      select
+      SELECT
         schema_name,
         table_name,
         index_name,
         is_unique,
         expressions
-      from duckdb_indexes()
-      where schema_name in (${sql5.join(schemaFragments, sql5.raw(", "))})
-      order by schema_name, table_name, index_name
+      FROM duckdb_indexes()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql5.join(schemaFragments, sql5.raw(", "))})
+      ORDER BY schema_name, table_name, index_name
     `);
 }
 function buildTables(tables, columns, constraints, indexes) {

package/dist/introspect.d.ts

@@ -1,6 +1,18 @@
 import type { RowData } from './client.ts';
 import type { DuckDBDatabase } from './driver.ts';
 export interface IntrospectOptions {
+    /**
+     * Database/catalog to introspect. If not specified, uses the current database
+     * (via `SELECT current_database()`). This prevents returning tables from all
+     * attached databases in MotherDuck workspaces.
+     */
+    database?: string;
+    /**
+     * When true, introspects all attached databases instead of just the current one.
+     * Ignored if `database` is explicitly set.
+     * @default false
+     */
+    allDatabases?: boolean;
     schemas?: string[];
     includeViews?: boolean;
     useCustomTimeTypes?: boolean;

package/package.json

@@ -3,7 +3,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {

package/src/bin/duckdb-introspect.ts

@@ -8,6 +8,8 @@ import { introspect } from '../introspect.ts';
 
 interface CliOptions {
   url?: string;
+  database?: string;
+  allDatabases: boolean;
   schemas?: string[];
   outFile: string;
   includeViews: boolean;
@@ -18,6 +20,7 @@ interface CliOptions {
 function parseArgs(argv: string[]): CliOptions {
   const options: CliOptions = {
     outFile: path.resolve(process.cwd(), 'drizzle/schema.ts'),
+    allDatabases: false,
     includeViews: false,
     useCustomTimeTypes: true,
   };
@@ -28,6 +31,13 @@ function parseArgs(argv: string[]): CliOptions {
       case '--url':
         options.url = argv[++i];
         break;
+      case '--database':
+      case '--db':
+        options.database = argv[++i];
+        break;
+      case '--all-databases':
+        options.allDatabases = true;
+        break;
       case '--schema':
       case '--schemas':
         options.schemas = argv[++i]?.split(',').map((s) => s.trim()).filter(Boolean);
@@ -68,11 +78,27 @@ Usage:
 
 Options:
   --url            DuckDB database path (e.g. :memory:, ./local.duckdb, md:)
+  --database, --db Database/catalog to introspect (default: current database)
+  --all-databases  Introspect all attached databases (not just current)
   --schema         Comma separated schema list (defaults to all non-system schemas)
   --out            Output file (default: ./drizzle/schema.ts)
   --include-views  Include views in the generated schema
   --use-pg-time    Use pg-core timestamp/date/time instead of DuckDB custom helpers
   --import-base    Override import path for duckdb helpers (default: package name)
+
+Database Filtering:
+  By default, only tables from the current database are introspected. This prevents
+  returning tables from all attached databases in MotherDuck workspaces.
+
+  Use --database to specify a different database, or --all-databases to introspect
+  all attached databases.
+
+Examples:
+  # Local DuckDB file
+  bun x duckdb-introspect --url ./my-database.duckdb --out ./schema.ts
+
+  # MotherDuck (requires MOTHERDUCK_TOKEN env var)
+  MOTHERDUCK_TOKEN=xxx bun x duckdb-introspect --url md: --database my_cloud_db --out ./schema.ts
 `);
 }
 
@@ -94,6 +120,8 @@ async function main() {
 
   try {
     const result = await introspect(db, {
+      database: options.database,
+      allDatabases: options.allDatabases,
       schemas: options.schemas,
       includeViews: options.includeViews,
       useCustomTimeTypes: options.useCustomTimeTypes,

package/src/introspect.ts

@@ -5,6 +5,18 @@ import type { DuckDBDatabase } from './driver.ts';
 const SYSTEM_SCHEMAS = new Set(['information_schema', 'pg_catalog']);
 
 export interface IntrospectOptions {
+  /**
+   * Database/catalog to introspect. If not specified, uses the current database
+   * (via `SELECT current_database()`). This prevents returning tables from all
+   * attached databases in MotherDuck workspaces.
+   */
+  database?: string;
+  /**
+   * When true, introspects all attached databases instead of just the current one.
+   * Ignored if `database` is explicitly set.
+   * @default false
+   */
+  allDatabases?: boolean;
   schemas?: string[];
   includeViews?: boolean;
   useCustomTimeTypes?: boolean;
@@ -102,13 +114,14 @@ export async function introspect(
   db: DuckDBDatabase,
   opts: IntrospectOptions = {}
 ): Promise<IntrospectResult> {
-  const schemas = await resolveSchemas(db, opts.schemas);
+  const database = await resolveDatabase(db, opts.database, opts.allDatabases);
+  const schemas = await resolveSchemas(db, database, opts.schemas);
   const includeViews = opts.includeViews ?? false;
 
-  const tables = await loadTables(db, schemas, includeViews);
-  const columns = await loadColumns(db, schemas);
-  const constraints = await loadConstraints(db, schemas);
-  const indexes = await loadIndexes(db, schemas);
+  const tables = await loadTables(db, database, schemas, includeViews);
+  const columns = await loadColumns(db, database, schemas);
+  const constraints = await loadConstraints(db, database, schemas);
+  const indexes = await loadIndexes(db, database, schemas);
 
   const grouped = buildTables(tables, columns, constraints, indexes);
 
@@ -126,16 +139,39 @@ export async function introspect(
   };
 }
 
+async function resolveDatabase(
+  db: DuckDBDatabase,
+  targetDatabase?: string,
+  allDatabases?: boolean
+): Promise<string | null> {
+  if (allDatabases) {
+    return null;
+  }
+  if (targetDatabase) {
+    return targetDatabase;
+  }
+
+  const rows = await db.execute<{ current_database: string }>(
+    sql`SELECT current_database() as current_database`
+  );
+  return rows[0]?.current_database ?? null;
+}
+
 async function resolveSchemas(
   db: DuckDBDatabase,
+  database: string | null,
   targetSchemas?: string[]
 ): Promise<string[]> {
   if (targetSchemas?.length) {
     return targetSchemas;
   }
 
+  const databaseFilter = database
+    ? sql`catalog_name = ${database}`
+    : sql`1 = 1`;
+
   const rows = await db.execute<{ schema_name: string }>(
-    sql`select schema_name from information_schema.schemata`
+    sql`SELECT schema_name FROM information_schema.schemata WHERE ${databaseFilter}`
   );
 
   return rows
@@ -145,30 +181,40 @@ async function resolveSchemas(
 
 async function loadTables(
   db: DuckDBDatabase,
+  database: string | null,
   schemas: string[],
   includeViews: boolean
 ): Promise<DuckDbTableRow[]> {
   const schemaFragments = schemas.map((schema) => sql`${schema}`);
+  const databaseFilter = database
+    ? sql`table_catalog = ${database}`
+    : sql`1 = 1`;
 
   return await db.execute<DuckDbTableRow>(
     sql`
-      select table_schema as schema_name, table_name, table_type
-      from information_schema.tables
-      where table_schema in (${sql.join(schemaFragments, sql.raw(', '))})
-      and ${includeViews ? sql`1 = 1` : sql`table_type = 'BASE TABLE'`}
-      order by table_schema, table_name
+      SELECT table_schema as schema_name, table_name, table_type
+      FROM information_schema.tables
+      WHERE ${databaseFilter}
+      AND table_schema IN (${sql.join(schemaFragments, sql.raw(', '))})
+      AND ${includeViews ? sql`1 = 1` : sql`table_type = 'BASE TABLE'`}
+      ORDER BY table_schema, table_name
     `
   );
 }
 
 async function loadColumns(
   db: DuckDBDatabase,
+  database: string | null,
   schemas: string[]
 ): Promise<DuckDbColumnRow[]> {
   const schemaFragments = schemas.map((schema) => sql`${schema}`);
+  const databaseFilter = database
+    ? sql`database_name = ${database}`
+    : sql`1 = 1`;
+
   return await db.execute<DuckDbColumnRow>(
     sql`
-      select
+      SELECT
         schema_name,
         table_name,
         column_name,
@@ -180,21 +226,27 @@ async function loadColumns(
         numeric_precision,
         numeric_scale,
         internal
-      from duckdb_columns()
-      where schema_name in (${sql.join(schemaFragments, sql.raw(', '))})
-      order by schema_name, table_name, column_index
+      FROM duckdb_columns()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql.join(schemaFragments, sql.raw(', '))})
+      ORDER BY schema_name, table_name, column_index
     `
   );
 }
 
 async function loadConstraints(
   db: DuckDBDatabase,
+  database: string | null,
   schemas: string[]
 ): Promise<DuckDbConstraintRow[]> {
   const schemaFragments = schemas.map((schema) => sql`${schema}`);
+  const databaseFilter = database
+    ? sql`database_name = ${database}`
+    : sql`1 = 1`;
+
   return await db.execute<DuckDbConstraintRow>(
     sql`
-      select
+      SELECT
         schema_name,
         table_name,
         constraint_name,
@@ -203,29 +255,36 @@ async function loadConstraints(
         constraint_column_names,
         referenced_table,
         referenced_column_names
-      from duckdb_constraints()
-      where schema_name in (${sql.join(schemaFragments, sql.raw(', '))})
-      order by schema_name, table_name, constraint_index
+      FROM duckdb_constraints()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql.join(schemaFragments, sql.raw(', '))})
+      ORDER BY schema_name, table_name, constraint_index
     `
   );
 }
 
 async function loadIndexes(
   db: DuckDBDatabase,
+  database: string | null,
   schemas: string[]
 ): Promise<DuckDbIndexRow[]> {
   const schemaFragments = schemas.map((schema) => sql`${schema}`);
+  const databaseFilter = database
+    ? sql`database_name = ${database}`
+    : sql`1 = 1`;
+
   return await db.execute<DuckDbIndexRow>(
     sql`
-      select
+      SELECT
         schema_name,
         table_name,
         index_name,
         is_unique,
         expressions
-      from duckdb_indexes()
-      where schema_name in (${sql.join(schemaFragments, sql.raw(', '))})
-      order by schema_name, table_name, index_name
+      FROM duckdb_indexes()
+      WHERE ${databaseFilter}
+      AND schema_name IN (${sql.join(schemaFragments, sql.raw(', '))})
+      ORDER BY schema_name, table_name, index_name
     `
   );
 }