@vibeorm/sql 2.1.0 → 2.2.0

package/dist/index.js

@@ -1,7 +1,4 @@
 // @bun
-// packages/sql/src/composable.ts
-import { VibeError } from "@vibeorm/schema";
-
 // packages/sql/src/params.ts
 class ParamCollector {
   dialect;
@@ -19,7 +16,47 @@ class ParamCollector {
   }
 }
 
+// packages/sql/src/module-journal.ts
+var MODULE_JOURNAL_COLUMN = "module_origin";
+function renderModuleJournal(params) {
+  const { dialect, operation } = params;
+  const q = (name) => dialect.quoteIdent({ name });
+  const table = q(params.table);
+  const column = q(MODULE_JOURNAL_COLUMN);
+  const collector = new ParamCollector(dialect);
+  let text;
+  switch (operation.kind) {
+    case "columns":
+      text = dialect.name === "sqlite" ? `PRAGMA table_info(${table})` : `SELECT column_name AS name FROM information_schema.columns WHERE table_schema = ${dialect.name === "postgres" ? "current_schema()" : "DATABASE()"} AND table_name = ${collector.add(params.table)}`;
+      break;
+    case "addColumn":
+      text = `ALTER TABLE ${table} ADD COLUMN ${column} ${dialect.name === "mysql" ? "LONGTEXT" : "TEXT"}`;
+      break;
+    case "read":
+      text = `SELECT * FROM ${table} ORDER BY ${q("id")}`;
+      break;
+    case "insert":
+      text = `INSERT INTO ${table} (${["name", "checksum", "statement_index", MODULE_JOURNAL_COLUMN].map(q).join(", ")}) VALUES (${collector.addMany([operation.name, operation.checksum, operation.index, operation.entry]).join(", ")})`;
+      break;
+    case "complete":
+      text = `UPDATE ${table} SET ${column} = ${collector.add(operation.entry)} WHERE ${q("name")} = ${collector.add(operation.name)}`;
+      break;
+  }
+  return { text, values: collector.values };
+}
+// packages/sql/src/dialects/sqlite-session.ts
+var SQLITE_SESSION_SQL = Object.freeze({
+  lockingMode: "PRAGMA main.locking_mode",
+  exclusive: "PRAGMA main.locking_mode = EXCLUSIVE",
+  normal: "PRAGMA main.locking_mode = NORMAL",
+  acquire: "BEGIN EXCLUSIVE",
+  commit: "COMMIT",
+  rollback: "ROLLBACK",
+  touch: "SELECT name FROM main.sqlite_schema LIMIT 1",
+  foreignKeysOn: "PRAGMA foreign_keys = ON"
+});
 // packages/sql/src/composable.ts
+import { VibeError } from "@vibeorm/schema";
 var fragments = new WeakMap;
 function invalid(message) {
   throw new VibeError({ code: "VIBE_VALIDATION", message });
@@ -246,9 +283,11 @@ var bigIntCodec = {
   decode: (value) => {
     if (typeof value === "bigint")
       return value;
-    if (typeof value === "string" || typeof value === "number")
+    if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim()))
+      return BigInt(value.trim());
+    if (typeof value === "number" && Number.isSafeInteger(value))
       return BigInt(value);
-    return value;
+    throw new VibeError2({ code: "VIBE_DATA_INVALID", message: "BigInt requires an integer string or a safe integer", meta: { value } });
   }
 };
 var decimalCodec = {
@@ -292,7 +331,10 @@ var dateNativeCodec = {
 var dateTextCodec = {
   encode: (value) => {
     dateNativeCodec.encode(value);
-    return value instanceof Date ? value.toISOString() : value;
+    const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
+    if (date !== undefined && Number.isFinite(date.getTime()))
+      return date.toISOString();
+    throw new VibeError2({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
   },
   decode: dateNativeCodec.decode
 };
@@ -879,10 +921,12 @@ function isSetOperation(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return false;
   const keys = Object.keys(value);
-  if (keys.length !== 2 || !keys.includes("__op") || !keys.includes("value"))
+  if (!keys.includes("__op") || !keys.includes("value"))
     return false;
   const candidate = value;
-  return typeof candidate.__op === "string" && SET_OPERATORS.includes(candidate.__op) && typeof candidate.value === "number" && Number.isFinite(candidate.value);
+  if (keys.length !== 2 && !(keys.length === 3 && keys.includes("numericType") && candidate.numericType === "Decimal"))
+    return false;
+  return typeof candidate.__op === "string" && SET_OPERATORS.includes(candidate.__op) && (typeof candidate.value === "number" && Number.isFinite(candidate.value) || typeof candidate.value === "string" || typeof candidate.value === "bigint");
 }
 var LIST_SET_OPERATORS = ["append", "concat"];
 function isListSetOperation(value) {
@@ -1454,7 +1498,7 @@ function renderRlsRole(params) {
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
 var NATIVE_RLS_PROBE_POLICY = "vibeorm_probe";
-var RLS_READINESS_SQL = Object.freeze({
+var CATALOG_READS = Object.freeze({
   identity: `SELECT current_user::text AS "currentUser",
        session_user::text AS "sessionUser",
        r.rolsuper AS "super",
@@ -1517,17 +1561,6 @@ FROM pg_catalog.pg_policy p
 JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
 WHERE n.nspname = $1
-ORDER BY c.relname, p.polname`,
-  expressions: `SELECT c.relname::text AS "table",
-       p.polname::text AS "name",
-       (n.nspname <> $1) AS "probe",
-       pg_catalog.pg_get_expr(p.polqual, p.polrelid) AS "using",
-       pg_catalog.pg_get_expr(p.polwithcheck, p.polrelid) AS "withCheck"
-FROM pg_catalog.pg_policy p
-JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
-JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-WHERE (n.nspname = $1 AND p.polname = $2)
-   OR (c.relnamespace = pg_catalog.pg_my_temp_schema() AND p.polname = $3)
 ORDER BY c.relname, p.polname`,
   views: `SELECT n.nspname::text AS "schema",
        c.relname::text AS "name",
@@ -1575,7 +1608,35 @@ JOIN pg_catalog.pg_proc f ON f.oid = t.tgfoid
 WHERE n.nspname = $1
   AND NOT t.tgisinternal
   AND f.prosecdef
-ORDER BY c.relname, t.tgname`,
+ORDER BY c.relname, t.tgname`
+});
+var RLS_READINESS_CATALOG_KEYS = Object.freeze(["identity", "elevatedRoles", "schemaControl", "tables", "policies", "views", "routines", "triggers"]);
+var COMPOSITE_CATALOG = `SELECT
+${RLS_READINESS_CATALOG_KEYS.map((key) => `  (SELECT json_agg(t)::text FROM (
+${CATALOG_READS[key]}
+  ) t) AS "${key}"`).join(`,
+`)}`;
+var RLS_READINESS_SQL = Object.freeze({
+  identity: CATALOG_READS.identity,
+  elevatedRoles: CATALOG_READS.elevatedRoles,
+  schemaControl: CATALOG_READS.schemaControl,
+  tables: CATALOG_READS.tables,
+  policies: CATALOG_READS.policies,
+  expressions: `SELECT c.relname::text AS "table",
+       p.polname::text AS "name",
+       (n.nspname <> $1) AS "probe",
+       pg_catalog.pg_get_expr(p.polqual, p.polrelid) AS "using",
+       pg_catalog.pg_get_expr(p.polwithcheck, p.polrelid) AS "withCheck"
+FROM pg_catalog.pg_policy p
+JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE (n.nspname = $1 AND p.polname = $2)
+   OR (c.relnamespace = pg_catalog.pg_my_temp_schema() AND p.polname = $3)
+ORDER BY c.relname, p.polname`,
+  views: CATALOG_READS.views,
+  routines: CATALOG_READS.routines,
+  triggers: CATALOG_READS.triggers,
+  catalog: COMPOSITE_CATALOG,
   readSearchPath: `SELECT pg_catalog.current_setting('search_path') AS "searchPath"`,
   setSearchPath: `SELECT pg_catalog.set_config('search_path', $1, true)`
 });
@@ -1995,18 +2056,27 @@ function renderJsonFilter(params) {
   }
   if (dialect.jsonPathMode === "sqliteExtract") {
     const column2 = quoteCol(dialect, expr.column);
-    const compareExtracted = (target, value) => {
-      if (typeof value === "boolean") {
-        return `${target} ${cmp} ${collector.add(value ? 1 : 0)}`;
-      }
-      if (typeof value === "object" && value !== null) {
-        return `${target} ${cmp} json(${collector.add(JSON.stringify(value))})`;
+    const typeMatches = (type, value) => {
+      if (typeof value === "number")
+        return `${type} IN ('integer', 'real')`;
+      const tag = typeof value === "boolean" ? String(value) : value === null ? "null" : Array.isArray(value) ? "array" : typeof value === "object" ? "object" : "text";
+      return `${type} = '${tag}'`;
+    };
+    const compareExtracted = (path, value) => {
+      const type = `json_type(${column2}, ${collector.add(path)})`;
+      const guard = typeMatches(type, value);
+      let base = guard;
+      if (value !== null) {
+        const target = `json_extract(${column2}, ${collector.add(path)})`;
+        const bound = typeof value === "boolean" ? value ? 1 : 0 : value;
+        const operand = typeof value === "object" ? `json(${collector.add(JSON.stringify(value))})` : collector.add(bound);
+        base = `(${guard} AND ${target} = ${operand})`;
       }
-      return `${target} ${cmp} ${collector.add(value)}`;
+      return expr.negate === true ? `NOT (${base})` : base;
     };
     switch (expr.op) {
       case "equals":
-        return compareExtracted(`json_extract(${column2}, ${collector.add(jsonPathString(expr.path))})`, expr.value);
+        return compareExtracted(jsonPathString(expr.path), expr.value);
       case "string_contains":
       case "string_starts_with":
       case "string_ends_with": {
@@ -2016,7 +2086,7 @@ function renderJsonFilter(params) {
       case "array_starts_with":
       case "array_ends_with": {
         const edge = expr.op === "array_starts_with" ? "[0]" : "[#-1]";
-        return compareExtracted(`json_extract(${column2}, ${collector.add(`${jsonPathString(expr.path)}${edge}`)})`, expr.value);
+        return compareExtracted(`${jsonPathString(expr.path)}${edge}`, expr.value);
       }
       case "array_contains": {
         const guard = `json_type(${column2}, ${collector.add(jsonPathString(expr.path))}) = 'array'`;
@@ -2030,7 +2100,9 @@ function renderJsonFilter(params) {
             });
           }
           const bound = typeof element === "boolean" ? element ? 1 : 0 : element;
-          return `EXISTS (SELECT 1 FROM json_each(${column2}, ${collector.add(jsonPathString(expr.path))}) WHERE ${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "value" })} = ${collector.add(bound)})`;
+          const path = collector.add(jsonPathString(expr.path));
+          const type = `${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "type" })}`;
+          return `EXISTS (SELECT 1 FROM json_each(${column2}, ${path}) WHERE ${typeMatches(type, element)} AND ${dialect.quoteIdent({ name: "json_each" })}.${dialect.quoteIdent({ name: "value" })} = ${collector.add(bound)})`;
         });
         return tests.length === 0 ? guard : `(${[guard, ...tests].join(" AND ")})`;
       }
@@ -2400,7 +2472,9 @@ function renderAssignments(params) {
       return `${column} = ${collector.add(value.text)}${dialect.jsonParamCast}`;
     }
     if (isSetOperation(value)) {
-      return `${column} = ${read} ${SET_OPERATION_SQL[value.__op]} ${collector.add(value.value)}`;
+      const operand = collector.add(value.value);
+      const numeric = dialect.name === "sqlite" && value.numericType === "Decimal" ? `CAST(${operand} AS REAL)` : operand;
+      return `${column} = ${read} ${SET_OPERATION_SQL[value.__op]} ${numeric}`;
     }
     if (isDbNowMarker(value)) {
       return `${column} = ${dialect.renderDbNow({ offsetSeconds: value.offsetSeconds, collector })}`;
@@ -2501,29 +2575,57 @@ function sqliteColumnClauses(params) {
   }
   return columns;
 }
-// packages/sql/src/dialects/constraint-owned-index.ts
+// packages/sql/src/dialects/postgres-default-identity.ts
 import { unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
+function renderPostgresDefaultFunctionIdentity(params) {
+  const { dialect, table, column } = params;
+  if (dialect.name !== "postgres")
+    throw unsupportedCapability9({ dialect: dialect.name, feature: "defaultFunctionIdentity" });
+  const collector = new ParamCollector(dialect);
+  const namespace = collector.add(table.namespace);
+  const name = collector.add(table.name);
+  const field = collector.add(column);
+  return {
+    text: `SELECT pg_catalog.pg_get_expr(ad.adbin, ad.adrelid, false) AS "expression",
+       pn.nspname::text AS "functionNamespace", p.proname::text AS "functionName",
+       (p.pronargs = 0 AND p.provariadic = 0 AND p.prokind = 'f' AND NOT p.proretset) AS "zeroArguments",
+       (p.prorettype = a.atttypid AND a.atttypmod = -1) AS "exactResultType"
+FROM pg_catalog.pg_attrdef ad
+JOIN pg_catalog.pg_attribute a ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
+JOIN pg_catalog.pg_class c ON c.oid = ad.adrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_depend d ON d.classid = 'pg_catalog.pg_attrdef'::pg_catalog.regclass AND d.objid = ad.oid AND d.refclassid = 'pg_catalog.pg_proc'::pg_catalog.regclass AND d.deptype = 'n'
+JOIN pg_catalog.pg_proc p ON p.oid = d.refobjid
+JOIN pg_catalog.pg_namespace pn ON pn.oid = p.pronamespace
+WHERE n.nspname = ${namespace} AND c.relname = ${name} AND a.attname = ${field}
+  AND a.attnum > 0 AND NOT a.attisdropped AND a.attgenerated = ''`,
+    values: collector.values,
+    returning: "none"
+  };
+}
+// packages/sql/src/dialects/constraint-owned-index.ts
+import { unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
 function renderConstraintOwnedIndexDrop(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability9({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
+    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "constraintOwnedIndexDrop" });
   const quote = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${quote(params.table)} DROP CONSTRAINT ${quote(params.constraint)};`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/mysql-check-probe.ts
-import { unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 function renderMysqlCheckProbe(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability10({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
+    throw unsupportedCapability11({ dialect: params.dialect.name, feature: "temporaryCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   const probe = q(params.probe);
   switch (params.operation) {
     case "clone":
       if (params.table === undefined)
-        throw unsupportedCapability10({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
+        throw unsupportedCapability11({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "A source table is required" });
       return { text: `CREATE TEMPORARY TABLE ${probe} LIKE ${q(params.table.namespace)}.${q(params.table.name)}`, values: [], returning: "none" };
     case "add": {
       if (params.expression === undefined || params.definition === undefined)
-        throw unsupportedCapability10({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
+        throw unsupportedCapability11({ dialect: "mysql", feature: "temporaryCheckProbe", hint: "An authored expression and temporary clone definition are required" });
       const parts = tableDefinitionParts({ sql: params.definition });
       return { text: `CREATE TEMPORARY TABLE ${probe} (
 ${[...parts.clauses, `CONSTRAINT ${probe} CHECK (${params.expression})`].join(`,
@@ -2569,31 +2671,31 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 function renderMigrationVisibility(params) {
   if (params.dialect.name !== "mysql")
-    throw unsupportedCapability11({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
   const collector = new ParamCollector(params.dialect);
   const grantee = "CONCAT(QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', 1)), '@', QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', -1)))";
   return { text: `SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.USER_PRIVILEGES WHERE GRANTEE = ${grantee} UNION SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.SCHEMA_PRIVILEGES WHERE GRANTEE = ${grantee} AND ${collector.add(params.namespace)} LIKE TABLE_SCHEMA`, values: collector.values, returning: "none" };
 }
 // packages/sql/src/dialects/migration-inventory.ts
-import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT name, hidden, pk, dflt_value AS definition FROM pragma_table_xinfo(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT id, seq, "from", "to", "table", on_update, on_delete, match FROM pragma_foreign_key_list(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY id, seq`, values: collector.values, returning: "none" };
 }
 function renderSqliteRebuildObjects(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability12({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
   return { text: "SELECT name, tbl_name, type, sql FROM main.sqlite_schema WHERE type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name", values: [], returning: "none" };
 }
 function renderMigrationInventory(params) {
@@ -2627,10 +2729,10 @@ UNION ALL SELECT 'function', ROUTINE_NAME, NULL, NULL, '[]', NULL FROM informati
 ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
   }
   const schema = params.dialect.quoteIdent({ name: params.namespace });
-  return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite_%' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
+  return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/migration-objects.ts
-import { unsupportedCapability as unsupportedCapability13 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
   const { dialect, identity: object } = params;
   const collector = new ParamCollector(dialect);
@@ -2668,7 +2770,10 @@ function renderMigrationObjectQuery(params) {
         text = `SELECT pg_catalog.pg_get_indexdef(i.indexrelid, 0, false) AS "definition", i.indisunique AS "unique", i.indisvalid AS "valid", i.indisready AS "ready", con.conname::text AS "constraint", con.contype::text AS "constraintType" ${relation} JOIN pg_catalog.pg_index i ON i.indrelid = c.oid JOIN pg_catalog.pg_class ix ON ix.oid = i.indexrelid LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = i.indexrelid AND con.contype IN ('p', 'u', 'x') WHERE ${where} AND ix.relname = ${collector.add(object.name)}`;
         break;
       case "table":
-        text = `SELECT c.relkind::text AS "type", c.relrowsecurity AS "rls", c.relforcerowsecurity AS "forceRls" ${relation} WHERE ${where} AND c.relkind IN ('r', 'p')`;
+        text = `SELECT c.relkind::text AS "type", c.relrowsecurity AS "rls", c.relforcerowsecurity AS "forceRls", c.relpersistence::text AS "persistence", ARRAY(SELECT option FROM unnest(c.reloptions) AS option ORDER BY option COLLATE "C") AS "options" ${relation} WHERE ${where} AND c.relkind IN ('r', 'p')`;
+        break;
+      case "enum":
+        text = `SELECT ARRAY(SELECT e.enumlabel::text FROM pg_catalog.pg_enum e WHERE e.enumtypid = t.oid ORDER BY e.enumsortorder) AS "values" FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND t.typname = ${name} AND t.typtype = 'e'`;
         break;
       case "postgresExtension":
         text = `SELECT e.extversion::text AS "version", e.extrelocatable AS "relocatable" FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE n.nspname = ${namespace} AND e.extname = ${name}`;
@@ -2692,7 +2797,7 @@ function renderMigrationObjectQuery(params) {
         break;
       case "constraint":
         if (object.constraintType === "exclusion")
-          throw unsupportedCapability13({ dialect: "mysql", feature: "exclusionConstraints" });
+          throw unsupportedCapability14({ dialect: "mysql", feature: "exclusionConstraints" });
         text = `SELECT tc.CONSTRAINT_TYPE AS type, tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS definition, rc.UPDATE_RULE AS onUpdate, rc.DELETE_RULE AS onDelete, rc.MATCH_OPTION AS matchOption FROM information_schema.TABLE_CONSTRAINTS tc LEFT JOIN information_schema.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND rc.TABLE_NAME = tc.TABLE_NAME AND rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME WHERE tc.TABLE_SCHEMA = ${namespace} AND tc.TABLE_NAME = ${name} AND tc.CONSTRAINT_NAME = ${collector.add(object.name)}`;
         break;
       case "index":
@@ -2702,15 +2807,15 @@ function renderMigrationObjectQuery(params) {
         text = `SELECT TABLE_TYPE AS type, ENGINE AS engine, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
         break;
       default:
-        throw unsupportedCapability13({ dialect: "mysql", feature: `inspect:${object.kind}` });
+        throw unsupportedCapability14({ dialect: "mysql", feature: `inspect:${object.kind}` });
     }
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
-      throw unsupportedCapability13({ dialect: "sqlite", feature: "attachedSchemaInspection" });
+      throw unsupportedCapability14({ dialect: "sqlite", feature: "attachedSchemaInspection" });
     const catalog = `${dialect.quoteIdent({ name: physical.namespace })}.sqlite_schema`;
     const kind = object.kind === "table" || object.kind === "view" ? object.kind : object.kind === "trigger" ? "trigger" : object.kind === "index" ? "index" : "table";
-    if (["function", "sequence", "postgresExtension"].includes(object.kind) || object.kind === "constraint" && object.constraintType === "exclusion")
-      throw unsupportedCapability13({ dialect: "sqlite", feature: `inspect:${object.kind}` });
+    if (["function", "sequence", "postgresExtension", "enum"].includes(object.kind) || object.kind === "constraint" && object.constraintType === "exclusion")
+      throw unsupportedCapability14({ dialect: "sqlite", feature: `inspect:${object.kind}` });
     const sqliteParams = new ParamCollector(dialect);
     if (object.kind === "column" || object.kind === "columnDefault" || object.kind === "generatedColumn") {
       text = `SELECT x.type AS type, x."notnull" AS "notNull", x.pk AS primaryKeyPosition, x.hidden AS generated, x.dflt_value AS definition, (SELECT sql FROM ${catalog} WHERE name = ${sqliteParams.add(physical.name)} AND type = 'table') AS tableDefinition FROM pragma_table_xinfo(${sqliteParams.add(physical.name)}, ${sqliteParams.add(physical.namespace)}) x WHERE x.name = ${sqliteParams.add(object.column)}`;
@@ -2737,7 +2842,7 @@ function renderMysqlObjectMembers(params) {
 }
 function renderMigrationDependencies(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "catalogDependencies" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "catalogDependencies" });
   const object = params.identity;
   const physical = "table" in object ? object.table : object.name;
   const collector = new ParamCollector(params.dialect);
@@ -2768,6 +2873,9 @@ function renderMigrationDependencies(params) {
     case "function":
       source = `SELECT 'pg_proc'::regclass AS classid, p.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = ${namespace} AND p.proname = ${name} AND ARRAY(SELECT tn.nspname || '.' || t.typname FROM unnest(p.proargtypes) WITH ORDINALITY a(oid, ord) JOIN pg_catalog.pg_type t ON t.oid = a.oid JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace ORDER BY a.ord) = ${collector.add(object.argumentTypes.map((type) => `${type.namespace}.${type.name}`))}::text[]`;
       break;
+    case "enum":
+      source = `SELECT 'pg_type'::regclass AS classid, t.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = ${namespace} AND t.typname = ${name} AND t.typtype = 'e'`;
+      break;
     case "postgresExtension":
       source = `SELECT 'pg_extension'::regclass AS classid, e.oid AS objid, 0 AS objsubid FROM pg_catalog.pg_extension e JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace WHERE n.nspname = ${namespace} AND e.extname = ${name}`;
       break;
@@ -2785,16 +2893,16 @@ function renderMigrationNamespace(params) {
 }
 function renderCheckProbe(params) {
   if (params.dialect.name !== "postgres")
-    throw unsupportedCapability13({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
+    throw unsupportedCapability14({ dialect: params.dialect.name, feature: "rollbackCheckProbe" });
   const q = (name) => params.dialect.quoteIdent({ name });
   return { text: `ALTER TABLE ${q(params.table.namespace)}.${q(params.table.name)} ADD CONSTRAINT ${q(params.name)} CHECK (${params.expression}) NOT VALID`, values: [], returning: "none" };
 }
 // packages/sql/src/dialects/postgres-migration.ts
-import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability14 } from "@vibeorm/schema";
+import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 var SETTING_VALUE = /^[0-9]+(?:\.[0-9]+)?\s*(?:us|ms|s|min|h|d)?$/;
 function requirePostgres2(params) {
   if (params.dialect.name !== "postgres") {
-    throw unsupportedCapability14({ dialect: params.dialect.name, feature: params.feature });
+    throw unsupportedCapability15({ dialect: params.dialect.name, feature: params.feature });
   }
 }
 function renderMigrationSessionRead(params) {
@@ -2928,8 +3036,10 @@ export {
   renderPredicate,
   renderPostgresWorkload,
   renderPostgresExplain,
+  renderPostgresDefaultFunctionIdentity,
   renderMysqlObjectMembers,
   renderMysqlCheckProbe,
+  renderModuleJournal,
   renderMigrationVisibility,
   renderMigrationSessionSet,
   renderMigrationSessionRestore,
@@ -2983,6 +3093,7 @@ export {
   compileExclusion,
   SQL_DIALECTS,
   SQL_DEFAULT_CELL,
+  SQLITE_SESSION_SQL,
   SQLITE_CODECS,
   SQLITE_CAPABILITIES,
   RLS_READINESS_SQL,
@@ -2995,6 +3106,7 @@ export {
   NATIVE_RLS,
   MYSQL_CODECS,
   MYSQL_CAPABILITIES,
+  MODULE_JOURNAL_COLUMN,
   JSON_TRANSPORT,
   DIALECT_CODECS,
   DIALECT_CAPABILITIES,
@@ -3002,4 +3114,4 @@ export {
   ADVISORY_KEY_BOUNDS
 };
 
-//# debugId=F9D013AFDDCCA77864756E2164756E21
+//# debugId=760F5D93FBC694E964756E2164756E21