@crvouga/mockingbird-service-postgres 1.5.1 → 1.6.0

package/dist/runtime/database-context.d.ts

@@ -0,0 +1,4 @@
+export type DatabaseCatalogContext = {
+    name: string;
+    names: () => readonly string[];
+};

package/dist/sql/deparse.d.ts

@@ -1,3 +1,4 @@
 import type { SelectStmt } from "../ast/nodes.js";
 /** Minimal SELECT deparsing for pg_get_viewdef / information_schema. */
 export declare function deparseSelect(stmt: SelectStmt): string;
+export declare function quoteIdent(name: string): string;

package/dist/unstable.js

@@ -6524,6 +6524,19 @@ function exactDegTan(x) {
   return Math.tan(x * Math.PI / 180);
 }
 
+// src/sql/deparse.ts
+function quoteIdent(name) {
+  if (/^[a-z_][a-z0-9_$]*$/.test(name)) return name;
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
+// src/runtime/database-context.ts
+var contexts = /* @__PURE__ */ new WeakMap();
+var fallback = { name: "postgres", names: () => ["postgres"] };
+function databaseCatalogContext(state) {
+  return contexts.get(state) ?? fallback;
+}
+
 // src/functions/misc-fns.ts
 var PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
 function findSequenceForCall(ctx, name) {
@@ -6607,8 +6620,8 @@ function sequenceNextval(ctx, seq) {
 function getMiscFunctions() {
   const m = /* @__PURE__ */ new Map();
   m.set("version", () => tv("text", PG_VERSION_TEXT));
-  m.set("current_database", () => tv("name", "postgres"));
-  m.set("current_catalog", () => tv("name", "postgres"));
+  m.set("current_database", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
+  m.set("current_catalog", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
   m.set("current_schema", (ctx) => {
     const path = ctx.state.effectiveSearchPath();
     const first = path.find((s) => ctx.state.schemas.has(s));
@@ -6730,7 +6743,7 @@ function getMiscFunctions() {
       if (!col.identity) return tv("text", null);
       return tv(
         "text",
-        col.identity.sequence.split(".").map((p) => p).join(".")
+        col.identity.sequence.split(".").map(quoteIdent).join(".")
       );
     })
   );
@@ -8989,7 +9002,8 @@ function pgSettings(ctx) {
     "pg_settings"
   );
 }
-function pgDatabase() {
+function pgDatabase(ctx) {
+  const names = databaseCatalogContext(ctx.state).names();
   return rel(
     [
       ["oid", "oid"],
@@ -8998,7 +9012,7 @@ function pgDatabase() {
       ["datistemplate", "bool"],
       ["datallowconn", "bool"]
     ],
-    [[5, "postgres", 6, false, true]],
+    names.map((name, index) => [5 + index, name, 6, false, true]),
     "pg_database"
   );
 }
@@ -9033,13 +9047,14 @@ function pgTrigger(ctx) {
     "pg_trigger"
   );
 }
-var CATALOG_NAME = "postgres";
+var catalogName = (state) => databaseCatalogContext(state).name;
 function infoSchemata(state) {
+  const catalog = catalogName(state);
   const rows = [
-    [CATALOG_NAME, "pg_catalog", OWNER],
-    [CATALOG_NAME, "information_schema", OWNER]
+    [catalog, "pg_catalog", OWNER],
+    [catalog, "information_schema", OWNER]
   ];
-  for (const s of state.schemas.values()) rows.push([CATALOG_NAME, s.name, OWNER]);
+  for (const s of state.schemas.values()) rows.push([catalog, s.name, OWNER]);
   return rel(
     [
       ["catalog_name", "name"],
@@ -9051,13 +9066,14 @@ function infoSchemata(state) {
   );
 }
 function infoTables(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const t of schema.tables.values()) {
-      rows.push([CATALOG_NAME, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
+      rows.push([catalog, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
     }
     for (const v of schema.views.values()) {
-      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, "VIEW", "NO"]);
+      if (!v.materialized) rows.push([catalog, v.schema, v.name, "VIEW", "NO"]);
     }
   }
   return rel(
@@ -9073,6 +9089,7 @@ function infoTables(ctx) {
   );
 }
 function infoColumns(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     t.columns.forEach((c, i) => {
@@ -9083,7 +9100,7 @@ function infoColumns(ctx) {
       const dataType = isArrayType(id) ? "ARRAY" : isEnumType(id) ? "USER-DEFINED" : typeDisplayName(id);
       const udt = isArrayType(id) ? `_${arrayUdt(id)}` : isEnumType(id) ? id.slice(5).split(".").pop() : id;
       rows.push([
-        CATALOG_NAME,
+        catalog,
         t.schema,
         t.name,
         c.name,
@@ -9128,10 +9145,11 @@ function arrayUdt(t) {
   return isEnumType(elem) ? elem.slice(5).split(".").pop() : elem;
 }
 function infoViews(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const v of schema.views.values()) {
-      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, null]);
+      if (!v.materialized) rows.push([catalog, v.schema, v.name, null]);
     }
   }
   return rel(
@@ -9146,10 +9164,11 @@ function infoViews(ctx) {
   );
 }
 function infoSequences(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const s of allSequences(ctx.state)) {
     rows.push([
-      CATALOG_NAME,
+      catalog,
       s.schema,
       s.name,
       typeDisplayName(s.dataType),
@@ -9177,11 +9196,12 @@ function infoSequences(ctx) {
   );
 }
 function infoTableConstraints(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     for (const c of t.constraints) {
       const type = c.kind === "primary_key" ? "PRIMARY KEY" : c.kind === "unique" ? "UNIQUE" : c.kind === "check" ? "CHECK" : "FOREIGN KEY";
-      rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, type]);
+      rows.push([catalog, t.schema, c.name, catalog, t.schema, t.name, type]);
     }
   }
   return rel(
@@ -9199,12 +9219,13 @@ function infoTableConstraints(ctx) {
   );
 }
 function infoKeyColumnUsage(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     for (const c of t.constraints) {
       if (c.kind !== "primary_key" && c.kind !== "unique" && c.kind !== "foreign_key") continue;
       c.columns.forEach((col, i) => {
-        rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, col, i + 1]);
+        rows.push([catalog, t.schema, c.name, catalog, t.schema, t.name, col, i + 1]);
       });
     }
   }
@@ -9224,12 +9245,13 @@ function infoKeyColumnUsage(ctx) {
   );
 }
 function infoRoutines(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const fns of schema.functions.values()) {
       for (const f of fns) {
         rows.push([
-          CATALOG_NAME,
+          catalog,
           f.schema,
           f.name,
           "FUNCTION",
@@ -9286,7 +9308,7 @@ function buildCatalogRelation(ctx, schema, name) {
       case "pg_settings":
         return pgSettings(ctx);
       case "pg_database":
-        return pgDatabase();
+        return pgDatabase(ctx);
       case "pg_roles":
       case "pg_user":
         return pgRoles();
@@ -11438,14 +11460,19 @@ var Parser = class {
   parseIdentityOptions() {
     const options = {};
     if (this.eatPunct("(")) {
-      Object.assign(options, this.parseSequenceOptions());
+      Object.assign(options, this.parseSequenceOptions(true));
       this.expectPunct(")");
     }
     return options;
   }
-  parseSequenceOptions() {
+  parseSequenceOptions(identity = false) {
     const options = {};
     for (; ; ) {
+      if (identity && this.eatKw("sequence")) {
+        this.expectKw("name");
+        options.sequenceName = this.qualifiedName();
+        continue;
+      }
       if (this.eatKw("increment")) {
         this.eatKw("by");
         options.increment = this.parseSignedBigInt();
@@ -20020,7 +20047,13 @@ var DatabaseState = class _DatabaseState {
     this.settings.set("lc_numeric", "C");
     this.settings.set("lc_time", "C");
     this.settings.set("default_transaction_isolation", "read committed");
+    this.settings.set("lock_timeout", "0");
+    this.settings.set("idle_in_transaction_session_timeout", "0");
+    this.settings.set("transaction_timeout", "0");
     this.settings.set("statement_timeout", "0");
+    this.settings.set("check_function_bodies", "on");
+    this.settings.set("xmloption", "content");
+    this.settings.set("row_security", "on");
     this.settings.set("array_nulls", "on");
     this.settings.set("backslash_quote", "safe_encoding");
   }
@@ -20310,6 +20343,11 @@ var MAX_IDENT = 63;
 function truncIdent(s) {
   return s.length > MAX_IDENT ? s.slice(0, MAX_IDENT) : s;
 }
+function identitySequenceTarget(env, tableSchema, defaultName, options) {
+  const parts = options.sequenceName;
+  if (!parts || parts.length === 0) return { schema: tableSchema, name: defaultName };
+  return targetSchema(env, parts);
+}
 var SEQ_LIMITS = {
   int2: { min: -32768n, max: 32767n },
   int4: { min: -2147483648n, max: 2147483647n },
@@ -20486,8 +20524,8 @@ function buildColumn(env, schema, tableName, def, out, taken) {
         break;
       }
       case "generated_identity": {
-        const seqName = truncIdent(`${tableName}_${def.name}_seq`);
-        const seq = buildSequence(env, schema, seqName, c.options, false);
+        const target = identitySequenceTarget(env, schema, truncIdent(`${tableName}_${def.name}_seq`), c.options);
+        const seq = buildSequence(env, target.schema, target.name, c.options, false);
         if (!c.options.as) {
           seq.dataType = col.type.id === "int2" || col.type.id === "int4" || col.type.id === "int8" ? col.type.id : "int8";
           const limits = SEQ_LIMITS[seq.dataType];
@@ -20496,7 +20534,7 @@ function buildColumn(env, schema, tableName, def, out, taken) {
         }
         seq.ownedBy = { table: tableName, column: def.name };
         out.sequences.push(seq);
-        col.identity = { always: c.always, sequence: `${schema.name}.${seqName}` };
+        col.identity = { always: c.always, sequence: `${target.schema.name}.${target.name}` };
         col.notNull = true;
         break;
       }
@@ -20632,10 +20670,11 @@ function executeCreateTable(env, stmt) {
     throw pgError("invalid_table_definition", `multiple primary keys for table "${name}" are not allowed`, "42P16");
   }
   for (const seq of built.sequences) {
-    if (schema.hasRelation(seq.name)) {
+    const seqSchema = state.getSchema(seq.schema);
+    if (seqSchema.hasRelation(seq.name)) {
       throw pgError("duplicate_table", `relation "${seq.name}" already exists`, "42P07");
     }
-    schema.sequences.set(seq.name, seq);
+    seqSchema.sequences.set(seq.name, seq);
   }
   const table = new TableData(schema.name, name, built.columns, state.nextOid(), stmt.temp);
   table.constraints = built.constraints;
@@ -20987,7 +21026,13 @@ function executeAlterTable(env, stmt) {
         const built = { columns: [], constraints: [], sequences: [] };
         const taken = constraintNames(table);
         const col = buildColumn(env, schema, table.name, action.column, built, taken);
-        for (const seq of built.sequences) schema.sequences.set(seq.name, seq);
+        for (const seq of built.sequences) {
+          const seqSchema = state.getSchema(seq.schema);
+          if (seqSchema.hasRelation(seq.name)) {
+            throw pgError("duplicate_table", `relation "${seq.name}" already exists`, "42P07");
+          }
+          seqSchema.sequences.set(seq.name, seq);
+        }
         table.columns.push(col);
         table.constraints.push(...built.constraints);
         for (let i = 0; i < rows.length; i++) {
@@ -21307,12 +21352,32 @@ function executeAlterTable(env, stmt) {
             "42P16"
           );
         }
-        const seqName = truncIdent(`${table.name}_${action.column}_seq`);
-        const seq = buildSequence(env, schema, seqName, action.options, false);
+        if (!col.notNull) {
+          throw pgError(
+            "object_not_in_prerequisite_state",
+            `column "${action.column}" of relation "${table.name}" must be declared NOT NULL before identity can be added`,
+            "55000"
+          );
+        }
+        const target = identitySequenceTarget(
+          env,
+          schema,
+          truncIdent(`${table.name}_${action.column}_seq`),
+          action.options
+        );
+        if (target.schema.hasRelation(target.name)) {
+          throw pgError("duplicate_table", `relation "${target.name}" already exists`, "42P07");
+        }
+        const seq = buildSequence(env, target.schema, target.name, action.options, false);
+        if (!action.options.as) {
+          seq.dataType = col.type.id === "int2" || col.type.id === "int4" || col.type.id === "int8" ? col.type.id : "int8";
+          const limits = SEQ_LIMITS[seq.dataType];
+          if (action.options.maxValue === void 0) seq.maxValue = seq.increment > 0n ? limits.max : -1n;
+          if (action.options.minValue === void 0) seq.minValue = seq.increment > 0n ? 1n : limits.min;
+        }
         seq.ownedBy = { table: table.name, column: action.column };
-        schema.sequences.set(seqName, seq);
-        col.identity = { always: true, sequence: `${schema.name}.${seqName}` };
-        col.notNull = true;
+        target.schema.sequences.set(target.name, seq);
+        col.identity = { always: action.always, sequence: `${target.schema.name}.${target.name}` };
         break;
       }
       case "drop_identity": {