@leonardovida-md/drizzle-neo-duckdb 1.1.0 → 1.1.1

package/dist/duckdb-introspect.mjs

@@ -24,83 +24,159 @@ import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
 import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
 
 // src/sql/query-rewriters.ts
-function adaptArrayOperators(query) {
-  const operators = [
-    { token: "@>", fn: "array_has_all" },
-    { token: "<@", fn: "array_has_all", swap: true },
-    { token: "&&", fn: "array_has_any" }
-  ];
-  const isWhitespace = (char) => char !== undefined && /\s/.test(char);
-  const walkLeft = (source, start) => {
-    let idx = start;
-    while (idx >= 0 && isWhitespace(source[idx])) {
-      idx--;
-    }
-    let depth = 0;
-    let inString = false;
-    for (;idx >= 0; idx--) {
-      const ch = source[idx];
-      if (ch === undefined)
-        break;
-      if (ch === "'" && source[idx - 1] !== "\\") {
-        inString = !inString;
+var OPERATORS = [
+  { token: "@>", fn: "array_has_all" },
+  { token: "<@", fn: "array_has_all", swap: true },
+  { token: "&&", fn: "array_has_any" }
+];
+var isWhitespace = (char) => char !== undefined && /\s/.test(char);
+function scrubForRewrite(query) {
+  let scrubbed = "";
+  let state = "code";
+  for (let i = 0;i < query.length; i += 1) {
+    const char = query[i];
+    const next = query[i + 1];
+    if (state === "code") {
+      if (char === "'") {
+        scrubbed += "'";
+        state = "single";
+        continue;
       }
-      if (inString)
+      if (char === '"') {
+        scrubbed += '"';
+        state = "double";
+        continue;
+      }
+      if (char === "-" && next === "-") {
+        scrubbed += "  ";
+        i += 1;
+        state = "lineComment";
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        scrubbed += "  ";
+        i += 1;
+        state = "blockComment";
         continue;
-      if (ch === ")" || ch === "]") {
-        depth++;
-      } else if (ch === "(" || ch === "[") {
-        depth--;
-        if (depth < 0) {
-          return [idx + 1, source.slice(idx + 1, start + 1)];
-        }
-      } else if (depth === 0 && isWhitespace(ch)) {
-        return [idx + 1, source.slice(idx + 1, start + 1)];
       }
+      scrubbed += char;
+      continue;
     }
-    return [0, source.slice(0, start + 1)];
-  };
-  const walkRight = (source, start) => {
-    let idx = start;
-    while (idx < source.length && isWhitespace(source[idx])) {
-      idx++;
-    }
-    let depth = 0;
-    let inString = false;
-    for (;idx < source.length; idx++) {
-      const ch = source[idx];
-      if (ch === undefined)
-        break;
-      if (ch === "'" && source[idx - 1] !== "\\") {
-        inString = !inString;
+    if (state === "single") {
+      if (char === "'" && next === "'") {
+        scrubbed += "''";
+        i += 1;
+        continue;
       }
-      if (inString)
+      scrubbed += char === "'" ? "'" : ".";
+      if (char === "'") {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "double") {
+      if (char === '"' && next === '"') {
+        scrubbed += '""';
+        i += 1;
         continue;
-      if (ch === "(" || ch === "[") {
-        depth++;
-      } else if (ch === ")" || ch === "]") {
-        depth--;
-        if (depth < 0) {
-          return [idx, source.slice(start, idx)];
-        }
-      } else if (depth === 0 && isWhitespace(ch)) {
+      }
+      scrubbed += char === '"' ? '"' : ".";
+      if (char === '"') {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "lineComment") {
+      scrubbed += char === `
+` ? `
+` : " ";
+      if (char === `
+`) {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "blockComment") {
+      if (char === "*" && next === "/") {
+        scrubbed += "  ";
+        i += 1;
+        state = "code";
+      } else {
+        scrubbed += " ";
+      }
+    }
+  }
+  return scrubbed;
+}
+function findNextOperator(scrubbed, start) {
+  for (let idx = start;idx < scrubbed.length; idx += 1) {
+    for (const operator of OPERATORS) {
+      if (scrubbed.startsWith(operator.token, idx)) {
+        return { index: idx, operator };
+      }
+    }
+  }
+  return null;
+}
+function walkLeft(source, scrubbed, start) {
+  let idx = start;
+  while (idx >= 0 && isWhitespace(scrubbed[idx])) {
+    idx -= 1;
+  }
+  let depth = 0;
+  for (;idx >= 0; idx -= 1) {
+    const ch = scrubbed[idx];
+    if (ch === ")" || ch === "]") {
+      depth += 1;
+    } else if (ch === "(" || ch === "[") {
+      if (depth === 0) {
+        return [idx + 1, source.slice(idx + 1, start + 1)];
+      }
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0 && isWhitespace(ch)) {
+      return [idx + 1, source.slice(idx + 1, start + 1)];
+    }
+  }
+  return [0, source.slice(0, start + 1)];
+}
+function walkRight(source, scrubbed, start) {
+  let idx = start;
+  while (idx < scrubbed.length && isWhitespace(scrubbed[idx])) {
+    idx += 1;
+  }
+  let depth = 0;
+  for (;idx < scrubbed.length; idx += 1) {
+    const ch = scrubbed[idx];
+    if (ch === "(" || ch === "[") {
+      depth += 1;
+    } else if (ch === ")" || ch === "]") {
+      if (depth === 0) {
         return [idx, source.slice(start, idx)];
       }
+      depth = Math.max(0, depth - 1);
+    } else if (depth === 0 && isWhitespace(ch)) {
+      return [idx, source.slice(start, idx)];
     }
-    return [source.length, source.slice(start)];
-  };
+  }
+  return [scrubbed.length, source.slice(start)];
+}
+function adaptArrayOperators(query) {
   let rewritten = query;
-  for (const { token, fn, swap } of operators) {
-    let idx = rewritten.indexOf(token);
-    while (idx !== -1) {
-      const [leftStart, leftExpr] = walkLeft(rewritten, idx - 1);
-      const [rightEnd, rightExpr] = walkRight(rewritten, idx + token.length);
-      const left = leftExpr.trim();
-      const right = rightExpr.trim();
-      const replacement = `${fn}(${swap ? right : left}, ${swap ? left : right})`;
-      rewritten = rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
-      idx = rewritten.indexOf(token, leftStart + replacement.length);
-    }
+  let scrubbed = scrubForRewrite(query);
+  let searchStart = 0;
+  while (true) {
+    const next = findNextOperator(scrubbed, searchStart);
+    if (!next)
+      break;
+    const { index, operator } = next;
+    const [leftStart, leftExpr] = walkLeft(rewritten, scrubbed, index - 1);
+    const [rightEnd, rightExpr] = walkRight(rewritten, scrubbed, index + operator.token.length);
+    const left = leftExpr.trim();
+    const right = rightExpr.trim();
+    const replacement = `${operator.fn}(${operator.swap ? right : left}, ${operator.swap ? left : right})`;
+    rewritten = rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
+    scrubbed = scrubForRewrite(rewritten);
+    searchStart = leftStart + replacement.length;
   }
   return rewritten;
 }
@@ -335,6 +411,12 @@ function dateToMicros(value) {
   if (value instanceof Date) {
     return BigInt(value.getTime()) * 1000n;
   }
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return BigInt(Math.trunc(value)) * 1000n;
+  }
   let normalized = value;
   if (!value.includes("T") && value.includes(" ")) {
     normalized = value.replace(" ", "T");
@@ -404,14 +486,17 @@ function parsePgArrayLiteral(value) {
 }
 function prepareParams(params, options = {}) {
   return params.map((param) => {
-    if (typeof param === "string" && isPgArrayLiteral(param)) {
-      if (options.rejectStringArrayLiterals) {
-        throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
-      }
-      if (options.warnOnStringArrayLiteral) {
-        options.warnOnStringArrayLiteral();
+    if (typeof param === "string") {
+      const trimmed = param.trim();
+      if (trimmed && isPgArrayLiteral(trimmed)) {
+        if (options.rejectStringArrayLiterals) {
+          throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
+        }
+        if (options.warnOnStringArrayLiteral) {
+          options.warnOnStringArrayLiteral();
+        }
+        return parsePgArrayLiteral(trimmed);
       }
-      return parsePgArrayLiteral(param);
     }
     return param;
   });
@@ -529,6 +614,13 @@ async function executeArrowOnClient(client, query, params) {
 }
 
 // src/session.ts
+function isSavepointSyntaxError(error) {
+  if (!(error instanceof Error) || !error.message) {
+    return false;
+  }
+  return error.message.toLowerCase().includes("savepoint") && error.message.toLowerCase().includes("syntax error");
+}
+
 class DuckDBPreparedQuery extends PgPreparedQuery {
   client;
   dialect;
@@ -593,6 +685,7 @@ class DuckDBSession extends PgSession {
   rewriteArrays;
   rejectStringArrayLiterals;
   hasWarnedArrayLiteral = false;
+  rollbackOnly = false;
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
     this.client = client;
@@ -606,7 +699,15 @@ class DuckDBSession extends PgSession {
   prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
     return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArrays, this.rejectStringArrayLiterals, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
   }
-  async transaction(transaction) {
+  execute(query) {
+    this.dialect.resetPgJsonFlag();
+    return super.execute(query);
+  }
+  all(query) {
+    this.dialect.resetPgJsonFlag();
+    return super.all(query);
+  }
+  async transaction(transaction, config) {
     let pinnedConnection;
     let pool;
     let clientForTx = this.client;
@@ -619,8 +720,15 @@ class DuckDBSession extends PgSession {
     const tx = new DuckDBTransaction(this.dialect, session, this.schema);
     try {
       await tx.execute(sql`BEGIN TRANSACTION;`);
+      if (config) {
+        await tx.setTransaction(config);
+      }
       try {
         const result = await transaction(tx);
+        if (session.isRollbackOnly()) {
+          await tx.execute(sql`rollback`);
+          throw new TransactionRollbackError;
+        }
         await tx.execute(sql`commit`);
         return result;
       } catch (error) {
@@ -642,7 +750,9 @@ class DuckDBSession extends PgSession {
 query: ${query}`, []);
   };
   executeBatches(query, options = {}) {
+    this.dialect.resetPgJsonFlag();
     const builtQuery = this.dialect.sqlToQuery(query);
+    this.dialect.assertNoPgJsonColumns();
     const params = prepareParams(builtQuery.params, {
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
@@ -655,7 +765,9 @@ query: ${query}`, []);
     return executeInBatches(this.client, rewrittenQuery, params, options);
   }
   async executeArrow(query) {
+    this.dialect.resetPgJsonFlag();
     const builtQuery = this.dialect.sqlToQuery(query);
+    this.dialect.assertNoPgJsonColumns();
     const params = prepareParams(builtQuery.params, {
       rejectStringArrayLiterals: this.rejectStringArrayLiterals,
       warnOnStringArrayLiteral: this.rejectStringArrayLiterals ? undefined : () => this.warnOnStringArrayLiteral(builtQuery.sql)
@@ -667,6 +779,12 @@ query: ${query}`, []);
     this.logger.logQuery(rewrittenQuery, params);
     return executeArrowOnClient(this.client, rewrittenQuery, params);
   }
+  markRollbackOnly() {
+    this.rollbackOnly = true;
+  }
+  isRollbackOnly() {
+    return this.rollbackOnly;
+  }
 }
 
 class DuckDBTransaction extends PgTransaction {
@@ -697,8 +815,46 @@ class DuckDBTransaction extends PgTransaction {
     return this.session.executeArrow(query);
   }
   async transaction(transaction) {
-    const nestedTx = new DuckDBTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
-    return transaction(nestedTx);
+    const internals = this;
+    const savepoint = `drizzle_savepoint_${this.nestedIndex + 1}`;
+    const savepointSql = sql.raw(`savepoint ${savepoint}`);
+    const releaseSql = sql.raw(`release savepoint ${savepoint}`);
+    const rollbackSql = sql.raw(`rollback to savepoint ${savepoint}`);
+    const nestedTx = new DuckDBTransaction(internals.dialect, internals.session, this.schema, this.nestedIndex + 1);
+    if (internals.dialect.areSavepointsUnsupported()) {
+      return this.runNestedWithoutSavepoint(transaction, nestedTx, internals);
+    }
+    let createdSavepoint = false;
+    try {
+      await internals.session.execute(savepointSql);
+      internals.dialect.markSavepointsSupported();
+      createdSavepoint = true;
+    } catch (error) {
+      if (!isSavepointSyntaxError(error)) {
+        throw error;
+      }
+      internals.dialect.markSavepointsUnsupported();
+      return this.runNestedWithoutSavepoint(transaction, nestedTx, internals);
+    }
+    try {
+      const result = await transaction(nestedTx);
+      if (createdSavepoint) {
+        await internals.session.execute(releaseSql);
+      }
+      return result;
+    } catch (error) {
+      if (createdSavepoint) {
+        await internals.session.execute(rollbackSql);
+      }
+      internals.session.markRollbackOnly();
+      throw error;
+    }
+  }
+  runNestedWithoutSavepoint(transaction, nestedTx, internals) {
+    return transaction(nestedTx).catch((error) => {
+      internals.session.markRollbackOnly();
+      throw error;
+    });
   }
 }
 var arrayLiteralWarning = "Received a stringified Postgres-style array literal. Use duckDbList()/duckDbArray() or pass native arrays instead. You can also set rejectStringArrayLiterals=true to throw.";
@@ -720,15 +876,30 @@ import {
 import {
   sql as sql2
 } from "drizzle-orm";
-
 class DuckDBDialect extends PgDialect {
   static [entityKind2] = "DuckDBPgDialect";
   hasPgJsonColumn = false;
+  savepointsSupported = 0 /* Unknown */;
+  resetPgJsonFlag() {
+    this.hasPgJsonColumn = false;
+  }
+  markPgJsonDetected() {
+    this.hasPgJsonColumn = true;
+  }
   assertNoPgJsonColumns() {
     if (this.hasPgJsonColumn) {
-      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB’s native JSON type.");
+      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type.");
     }
   }
+  areSavepointsUnsupported() {
+    return this.savepointsSupported === 2 /* No */;
+  }
+  markSavepointsSupported() {
+    this.savepointsSupported = 1 /* Yes */;
+  }
+  markSavepointsUnsupported() {
+    this.savepointsSupported = 2 /* No */;
+  }
   async migrate(migrations, session, config) {
     const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
     const migrationsSchema = migrationConfig.migrationsSchema ?? "drizzle";
@@ -765,8 +936,8 @@ class DuckDBDialect extends PgDialect {
   }
   prepareTyping(encoder) {
     if (is2(encoder, PgJsonb) || is2(encoder, PgJson)) {
-      this.hasPgJsonColumn = true;
-      return "none";
+      this.markPgJsonDetected();
+      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB's native JSON type.");
     } else if (is2(encoder, PgNumeric)) {
       return "decimal";
     } else if (is2(encoder, PgTime2)) {
@@ -900,41 +1071,148 @@ function resolvePoolSize(pool) {
 }
 function createDuckDBConnectionPool(instance, options = {}) {
   const size = options.size && options.size > 0 ? options.size : 4;
+  const acquireTimeout = options.acquireTimeout ?? 30000;
+  const maxWaitingRequests = options.maxWaitingRequests ?? 100;
+  const maxLifetimeMs = options.maxLifetimeMs;
+  const idleTimeoutMs = options.idleTimeoutMs;
+  const metadata = new WeakMap;
   const idle = [];
   const waiting = [];
   let total = 0;
   let closed = false;
+  let pendingAcquires = 0;
+  const shouldRecycle = (conn, now) => {
+    if (maxLifetimeMs !== undefined && now - conn.createdAt >= maxLifetimeMs) {
+      return true;
+    }
+    if (idleTimeoutMs !== undefined && now - conn.lastUsedAt >= idleTimeoutMs) {
+      return true;
+    }
+    return false;
+  };
   const acquire = async () => {
     if (closed) {
       throw new Error("DuckDB connection pool is closed");
     }
-    if (idle.length > 0) {
-      return idle.pop();
+    while (idle.length > 0) {
+      const pooled = idle.pop();
+      const now = Date.now();
+      if (shouldRecycle(pooled, now)) {
+        await closeClientConnection(pooled.connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(pooled.connection);
+        continue;
+      }
+      pooled.lastUsedAt = now;
+      metadata.set(pooled.connection, {
+        createdAt: pooled.createdAt,
+        lastUsedAt: pooled.lastUsedAt
+      });
+      return pooled.connection;
     }
     if (total < size) {
+      pendingAcquires += 1;
       total += 1;
-      return await DuckDBConnection.create(instance);
+      try {
+        const connection = await DuckDBConnection.create(instance);
+        if (closed) {
+          await closeClientConnection(connection);
+          total -= 1;
+          throw new Error("DuckDB connection pool is closed");
+        }
+        const now = Date.now();
+        metadata.set(connection, { createdAt: now, lastUsedAt: now });
+        return connection;
+      } catch (error) {
+        total -= 1;
+        throw error;
+      } finally {
+        pendingAcquires -= 1;
+      }
     }
-    return await new Promise((resolve) => {
-      waiting.push(resolve);
+    if (waiting.length >= maxWaitingRequests) {
+      throw new Error(`DuckDB connection pool queue is full (max ${maxWaitingRequests} waiting requests)`);
+    }
+    return await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = waiting.findIndex((w) => w.timeoutId === timeoutId);
+        if (idx !== -1) {
+          waiting.splice(idx, 1);
+        }
+        reject(new Error(`DuckDB connection pool acquire timeout after ${acquireTimeout}ms`));
+      }, acquireTimeout);
+      waiting.push({ resolve, reject, timeoutId });
     });
   };
   const release = async (connection) => {
+    const waiter = waiting.shift();
+    if (waiter) {
+      clearTimeout(waiter.timeoutId);
+      const now2 = Date.now();
+      const meta = metadata.get(connection) ?? { createdAt: now2, lastUsedAt: now2 };
+      const expired = maxLifetimeMs !== undefined && now2 - meta.createdAt >= maxLifetimeMs;
+      if (closed) {
+        await closeClientConnection(connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(connection);
+        waiter.reject(new Error("DuckDB connection pool is closed"));
+        return;
+      }
+      if (expired) {
+        await closeClientConnection(connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(connection);
+        try {
+          const replacement = await acquire();
+          waiter.resolve(replacement);
+        } catch (error) {
+          waiter.reject(error);
+        }
+        return;
+      }
+      meta.lastUsedAt = now2;
+      metadata.set(connection, meta);
+      waiter.resolve(connection);
+      return;
+    }
     if (closed) {
       await closeClientConnection(connection);
+      metadata.delete(connection);
+      total = Math.max(0, total - 1);
       return;
     }
-    const waiter = waiting.shift();
-    if (waiter) {
-      waiter(connection);
+    const now = Date.now();
+    const existingMeta = metadata.get(connection) ?? { createdAt: now, lastUsedAt: now };
+    existingMeta.lastUsedAt = now;
+    metadata.set(connection, existingMeta);
+    if (maxLifetimeMs !== undefined && now - existingMeta.createdAt >= maxLifetimeMs) {
+      await closeClientConnection(connection);
+      total -= 1;
+      metadata.delete(connection);
       return;
     }
-    idle.push(connection);
+    idle.push({
+      connection,
+      createdAt: existingMeta.createdAt,
+      lastUsedAt: existingMeta.lastUsedAt
+    });
   };
   const close = async () => {
     closed = true;
+    const waiters = waiting.splice(0, waiting.length);
+    for (const waiter of waiters) {
+      clearTimeout(waiter.timeoutId);
+      waiter.reject(new Error("DuckDB connection pool is closed"));
+    }
     const toClose = idle.splice(0, idle.length);
-    await Promise.all(toClose.map((conn) => closeClientConnection(conn)));
+    await Promise.allSettled(toClose.map((item) => closeClientConnection(item.connection)));
+    total = Math.max(0, total - toClose.length);
+    toClose.forEach((item) => metadata.delete(item.connection));
+    const maxWait = 5000;
+    const start = Date.now();
+    while (pendingAcquires > 0 && Date.now() - start < maxWait) {
+      await new Promise((r) => setTimeout(r, 10));
+    }
   };
   return {
     acquire,
@@ -1042,6 +1320,17 @@ class DuckDBDatabase extends PgDatabase {
     if (isPool(this.$client) && this.$client.close) {
       await this.$client.close();
     }
+    if (!isPool(this.$client)) {
+      await closeClientConnection(this.$client);
+    }
+    if (this.$instance) {
+      const maybeClosable = this.$instance;
+      if (typeof maybeClosable.close === "function") {
+        await maybeClosable.close();
+      } else if (typeof maybeClosable.closeSync === "function") {
+        maybeClosable.closeSync();
+      }
+    }
   }
   select(fields) {
     const selectedFields = fields ? aliasFields(fields) : undefined;
@@ -1445,6 +1734,20 @@ function mapDuckDbType(column, imports, options) {
     imports.pgCore.add("text");
     return { builder: `text(${columnName(column.name)}) /* JSON */` };
   }
+  if (upper.startsWith("ENUM")) {
+    imports.pgCore.add("text");
+    const enumLiteral = raw.replace(/^ENUM\s*/i, "").trim();
+    return {
+      builder: `text(${columnName(column.name)}) /* ENUM ${enumLiteral} */`
+    };
+  }
+  if (upper.startsWith("UNION")) {
+    imports.pgCore.add("text");
+    const unionLiteral = raw.replace(/^UNION\s*/i, "").trim();
+    return {
+      builder: `text(${columnName(column.name)}) /* UNION ${unionLiteral} */`
+    };
+  }
   if (upper === "INET") {
     imports.local.add("duckDbInet");
     return { builder: `duckDbInet(${columnName(column.name)})` };
@@ -1510,7 +1813,7 @@ function mapDuckDbType(column, imports, options) {
   }
   imports.pgCore.add("text");
   return {
-    builder: `text(${columnName(column.name)}) /* TODO: verify type ${upper} */`
+    builder: `text(${columnName(column.name)}) /* unsupported DuckDB type: ${upper} */`
   };
 }
 function parseStructFields(inner) {
@@ -1620,6 +1923,7 @@ function renderImports(imports, importBasePath) {
 function parseArgs(argv) {
   const options = {
     outFile: path.resolve(process.cwd(), "drizzle/schema.ts"),
+    outMeta: undefined,
     allDatabases: false,
     includeViews: false,
     useCustomTimeTypes: true
@@ -1645,6 +1949,11 @@ function parseArgs(argv) {
       case "--outFile":
         options.outFile = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.ts");
         break;
+      case "--out-json":
+      case "--outJson":
+      case "--json":
+        options.outMeta = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.meta.json");
+        break;
       case "--include-views":
       case "--includeViews":
         options.includeViews = true;
@@ -1679,6 +1988,7 @@ Options:
   --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)
+  --json           Optional JSON metadata output (default: ./drizzle/schema.meta.json)
   --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)
@@ -1719,11 +2029,23 @@ async function main() {
     });
     await mkdir(path.dirname(options.outFile), { recursive: true });
     await writeFile(options.outFile, result.files.schemaTs, "utf8");
+    if (options.outMeta) {
+      await mkdir(path.dirname(options.outMeta), { recursive: true });
+      await writeFile(options.outMeta, JSON.stringify(result.files.metaJson, null, 2), "utf8");
+    }
     console.log(`Wrote schema to ${options.outFile}`);
+    if (options.outMeta) {
+      console.log(`Wrote metadata to ${options.outMeta}`);
+    }
   } finally {
     if ("closeSync" in connection && typeof connection.closeSync === "function") {
       connection.closeSync();
     }
+    if ("closeSync" in instance && typeof instance.closeSync === "function") {
+      instance.closeSync();
+    } else if ("close" in instance && typeof instance.close === "function") {
+      await instance.close();
+    }
   }
 }
 main().catch((err) => {