orez 0.3.9 → 0.4.1

package/dist/pg-proxy-do-backend.js

@@ -2,6 +2,7 @@
 import { deparseSync, loadModule, parseSync } from 'pgsql-parser';
 import { RETURNING_INTERNAL_PREFIX } from './do-sql-tracking.js';
 import { signalReplicationChange } from './replication/handler.js';
+import { markSQLiteKeywordIdentifiers, restoreSQLiteKeywordIdentifierMarkers, } from './sqlite-keyword-identifiers.js';
 /**
  * DoBackend: a PGlite-compatible adapter that forwards SQL to Cloudflare Durable Objects.
  *
@@ -142,9 +143,44 @@ function buildCommandComplete(tag) {
 function buildReadyForQuery(status = STATUS_IDLE) {
     return msg(0x5a, new Uint8Array([status]));
 }
-function buildErrorResponse(message) {
+/**
+ * map a SQLite error message to the closest PostgreSQL SQLSTATE. zero-cache and
+ * pg clients (e.g. @take-out/database's migrate) branch on the SQLSTATE code,
+ * not the message — notably to treat "already exists" / "does not exist" DDL as
+ * idempotent during migration replay. without this the DO backend reported
+ * everything as XX000 (internal_error), so a re-applied `ADD COLUMN` aborted the
+ * whole migration instead of being recorded as applied. codes mirror the ones
+ * postgres returns for the equivalent failures.
+ */
+function sqlstateForSqliteError(message) {
+    const m = message.toLowerCase();
+    // duplicate-object DDL (idempotent on replay)
+    if (m.includes('duplicate column name'))
+        return '42701'; // duplicate_column
+    if (/\btable\b[^]*already exists/.test(m))
+        return '42P07'; // duplicate_table
+    if (/already exists/.test(m))
+        return '42710'; // duplicate_object (index/trigger/view/etc)
+    // missing-object DDL (idempotent for DROP ... without IF EXISTS)
+    if (m.includes('no such column'))
+        return '42703'; // undefined_column
+    if (m.includes('no such table'))
+        return '42P01'; // undefined_table
+    if (m.includes('no such index') || m.includes('no such trigger'))
+        return '42704'; // undefined_object
+    if (m.includes('syntax error'))
+        return '42601'; // syntax_error
+    if (m.includes('unique constraint failed'))
+        return '23505'; // unique_violation
+    if (m.includes('not null constraint failed'))
+        return '23502'; // not_null_violation
+    if (m.includes('foreign key constraint failed'))
+        return '23503'; // foreign_key_violation
+    return 'XX000'; // internal_error
+}
+function buildErrorResponse(message, sqlstate) {
     const field = (code, value) => concat(textEncoder.encode(code), cstr(value));
-    return msg(0x45, concat(field('S', 'ERROR'), field('V', 'ERROR'), field('C', 'XX000'), field('M', message), new Uint8Array([0])));
+    return msg(0x45, concat(field('S', 'ERROR'), field('V', 'ERROR'), field('C', sqlstate ?? sqlstateForSqliteError(message)), field('M', message), new Uint8Array([0])));
 }
 function buildParseComplete() {
     return msg(0x31, zero4);
@@ -2121,17 +2157,69 @@ function normalizeColumnType(columnDef) {
     if (sqliteType)
         setTypeName(columnDef.typeName, sqliteType);
 }
+// pg SERIAL types auto-assign from a sequence. SQLite only auto-increments an
+// INTEGER PRIMARY KEY, so a non-PK serial column (e.g. zero 1.6's replicas.rank
+// BIGSERIAL) becomes a plain nullable integer and stays NULL on inserts that
+// don't supply it — zero then reads it and throws "Expected bigint at rank.
+// Got null". emulate the sequence with an AFTER INSERT trigger that fills the
+// column with max()+1 when it's left NULL.
+const SERIAL_TYPES = new Set([
+    'serial',
+    'serial2',
+    'serial4',
+    'serial8',
+    'smallserial',
+    'bigserial',
+]);
+function serialColumnNames(createStmt) {
+    const names = [];
+    for (const elt of createStmt?.tableElts ?? []) {
+        const col = elt?.ColumnDef;
+        if (!col?.colname)
+            continue;
+        const base = typeNameBase(col.typeName);
+        if (!base || !SERIAL_TYPES.has(base))
+            continue;
+        // an inline PRIMARY KEY serial becomes INTEGER PRIMARY KEY (rowid alias),
+        // which SQLite already auto-increments — no trigger needed.
+        const isPrimaryKey = (col.constraints ?? []).some((c) => c?.Constraint?.contype === 'CONSTR_PRIMARY');
+        if (isPrimaryKey)
+            continue;
+        names.push(col.colname);
+    }
+    return names;
+}
+function serialTriggerStatements(table, columns) {
+    return columns.map((col) => ({
+        sql: `CREATE TRIGGER IF NOT EXISTS ${quoteIdentifier(`${table}_${col}_serial`)}
+AFTER INSERT ON ${quoteIdentifier(table)}
+FOR EACH ROW WHEN NEW.${quoteIdentifier(col)} IS NULL
+BEGIN
+  UPDATE ${quoteIdentifier(table)}
+  SET ${quoteIdentifier(col)} = (SELECT coalesce(max(${quoteIdentifier(col)}), 0) + 1 FROM ${quoteIdentifier(table)})
+  WHERE rowid = NEW.rowid;
+END`,
+        isDDL: true,
+    }));
+}
 function isDefaultConstraint(constraint) {
     return constraint?.Constraint?.contype === 'CONSTR_DEFAULT';
 }
-function shouldDropAddColumnDefault(constraint) {
+// functions that produce a fresh non-constant value and have no usable SQLite
+// column-default form. on the DO replica these defaults are never exercised:
+// zero-cache replicates full row values (every column is supplied), and zero's
+// own replicas.id default is explicitly "for backwards compatibility" with each
+// insert providing id. so we drop the default rather than translate it. checked
+// recursively because zero wraps it, e.g. replace(gen_random_uuid()::text,…).
+const NON_CONSTANT_DEFAULT_FUNCTIONS = new Set([
+    'gen_random_uuid',
+    'uuid_generate_v4',
+    'md5',
+]);
+function shouldDropFunctionDefault(constraint) {
     if (!isDefaultConstraint(constraint))
         return false;
-    const raw = constraint.Constraint.raw_expr;
-    if (!raw?.FuncCall)
-        return false;
-    const name = functionName(raw.FuncCall);
-    return name === 'md5' || name === 'gen_random_uuid';
+    return containsAnyFuncCall(constraint.Constraint.raw_expr, NON_CONSTANT_DEFAULT_FUNCTIONS);
 }
 function containsAnyFuncCall(value, names) {
     if (!value || typeof value !== 'object')
@@ -2155,7 +2243,7 @@ function normalizeColumnDef(columnDef, options) {
             if (options?.addedColumn &&
                 (type === 'CONSTR_NOTNULL' || type === 'CONSTR_PRIMARY'))
                 return false;
-            if (options?.addedColumn && shouldDropAddColumnDefault(constraint))
+            if (shouldDropFunctionDefault(constraint))
                 return false;
             if (type === 'CONSTR_GENERATED' &&
                 containsAnyFuncCall(constraint.Constraint.raw_expr, UNSUPPORTED_GENERATED_COLUMN_FUNCTIONS))
@@ -2589,7 +2677,8 @@ function replaceSchemaSpecsFunctionCalls(sql) {
     return { sql: replaced, count };
 }
 function deparseStatement(version, stmt) {
-    return stripTrailingSemicolon(deparseSync({ version, stmts: [{ stmt }] }).trim());
+    const quotedByMarker = markSQLiteKeywordIdentifiers(stmt);
+    return stripTrailingSemicolon(restoreSQLiteKeywordIdentifierMarkers(deparseSync({ version, stmts: [{ stmt }] }), quotedByMarker).trim());
 }
 function starTarget() {
     return {
@@ -2824,7 +2913,7 @@ function selectWhereSQL(version, whereClause) {
             op: 'SETOP_NONE',
         },
     };
-    const sql = stripTrailingSemicolon(deparseSync({ version, stmts: [{ stmt }] }).trim());
+    const sql = deparseStatement(version, stmt);
     const whereIndex = findKeywordOutsideQuotes(sql, 'WHERE');
     if (whereIndex < 0)
         return null;
@@ -2849,27 +2938,17 @@ function compileSelectIntoNew(version, select, triggerTable, rowCondition) {
     const targetColumn = rel.relname;
     const cloned = cloneAst(select);
     delete cloned.intoClause;
-    const selectSQL = stripTrailingSemicolon(deparseSync({
-        version,
-        stmts: [{ stmt: { SelectStmt: rewriteNode(cloned) } }],
-    }).trim());
+    const selectSQL = deparseStatement(version, { SelectStmt: rewriteNode(cloned) });
     return rowUpdateSQL(triggerTable, targetColumn, `(${selectSQL})`, rowCondition);
 }
 function deparseExpressionSQL(version, expr) {
-    const sql = stripTrailingSemicolon(deparseSync({
-        version,
-        stmts: [
-            {
-                stmt: {
-                    SelectStmt: {
-                        targetList: [{ ResTarget: { val: expr, location: -1 } }],
-                        limitOption: 'LIMIT_OPTION_DEFAULT',
-                        op: 'SETOP_NONE',
-                    },
-                },
-            },
-        ],
-    }).trim());
+    const sql = deparseStatement(version, {
+        SelectStmt: {
+            targetList: [{ ResTarget: { val: expr, location: -1 } }],
+            limitOption: 'LIMIT_OPTION_DEFAULT',
+            op: 'SETOP_NONE',
+        },
+    });
     const selectIndex = findKeywordOutsideQuotes(sql, 'SELECT');
     if (selectIndex < 0)
         return null;
@@ -3228,6 +3307,7 @@ function rewriteParsedStatement(version, rawStmt, context) {
     let skipIfTableEmpty = null;
     let changeTracking;
     let writeTable = null;
+    let serialTriggers = [];
     if (nodeType === 'AlterTableStmt') {
         alterMetadata = normalizeAlterTable(node);
         if (!node.cmds?.length) {
@@ -3245,7 +3325,12 @@ function rewriteParsedStatement(version, rawStmt, context) {
     }
     else if (nodeType === 'CreateStmt') {
         schemaColumns = schemaColumnsForCreateTable(node);
+        // capture serial columns before normalizeCreateTable rewrites the type to integer
+        const serialCols = serialColumnNames(node);
         normalizeCreateTable(node);
+        if (serialCols.length && node.relation?.relname) {
+            serialTriggers = serialTriggerStatements(node.relation.relname, serialCols);
+        }
     }
     else if (nodeType === 'CreateTableAsStmt') {
         normalizeCreateTableAs(node);
@@ -3356,7 +3441,7 @@ function rewriteParsedStatement(version, rawStmt, context) {
     const isWrite = nodeType === 'DeleteStmt' || nodeType === 'InsertStmt' || nodeType === 'UpdateStmt';
     const usesPublishedSchemaFunction = context?.skippedFunctionNames?.has('schema_specs') &&
         containsFuncCall(stmt, 'schema_specs');
-    return {
+    const mainStatement = {
         sql: rewritten,
         ...(isDDL ? { isDDL } : null),
         ...(isWrite ? { isWrite } : null),
@@ -3378,6 +3463,7 @@ function rewriteParsedStatement(version, rawStmt, context) {
         ...(skipIfColumnMissing ? { skipIfColumnMissing } : null),
         ...(skipIfTableEmpty ? { skipIfTableEmpty } : null),
     };
+    return serialTriggers.length ? [mainStatement, ...serialTriggers] : mainStatement;
 }
 function rewriteSQLStatements(sql, context) {
     const trimmed = sql.trim();
@@ -3539,10 +3625,7 @@ function copySelectSQL(sql) {
                 stringValue(def.arg)?.toLowerCase() === 'binary');
         });
         return {
-            sql: stripTrailingSemicolon(deparseSync({
-                version: parsed.version,
-                stmts: [{ stmt: { SelectStmt: copy.query.SelectStmt } }],
-            }).trim()),
+            sql: deparseStatement(parsed.version, { SelectStmt: copy.query.SelectStmt }),
             binary,
         };
     }