@palbase/backend 23.0.0 → 23.1.0

package/dist/bin/palbase-backend.cjs

@@ -218,6 +218,19 @@ var TxPlanBuilder = class {
         }
         return this.push({ op: "insert", table: name, values: encoded }, `${name}.insert()`);
       },
+      upsert: (values, options) => {
+        const encoded = encodeMap(values, false);
+        if (Object.keys(encoded).length === 0) {
+          throw new TxPlanError(`${name}.upsert() needs at least one column`);
+        }
+        if (options.onConflict.length === 0) {
+          throw new TxPlanError(`${name}.upsert() needs at least one onConflict column`);
+        }
+        return this.push(
+          { op: "upsert", table: name, values: encoded, onConflict: options.onConflict },
+          `${name}.upsert()`
+        );
+      },
       insertMany: (rows) => {
         if (rows.length === 0) {
           return new TxRowsImpl(this, SKIPPED_OP, `${name}.insertMany()`);
@@ -425,7 +438,8 @@ function makeTablesAccessor(ops) {
           update: (id, data) => ops().update(name, id, data),
           delete: (id) => ops().delete(name, id),
           findById: (id) => ops().findById(name, id),
-          findMany: (query) => ops().findMany(name, query),
+          findMany: (query, opts) => ops().findMany(name, query, opts),
+          upsert: (data, opts) => ops().upsert(name, data, opts),
           search: (params) => ops().search(name, params),
           similar: (id, params) => ops().similar(name, id, params),
           recommend: (params) => ops().recommend(name, params),
@@ -445,13 +459,17 @@ function makeTypedSurface(raw) {
     update: (table, id, data) => raw.update(table, id, data),
     delete: (table, id) => raw.delete(table, id),
     findById: (table, id) => raw.findById(table, id),
-    findMany: (table, query) => raw.findMany(table, query),
+    findMany: (table, query, opts) => raw.findMany(table, query, opts),
+    upsert: (table, data, opts) => raw.upsert(table, data, opts),
     search: (table, params) => raw.search(table, params),
     similar: (table, id, params) => reco.similar(table, id, params),
     recommend: (table, params) => reco.recommend(table, params),
     supersede: (table, id, row) => raw.supersede(table, id, row)
   };
   return Object.assign(ops, {
+    // Both surfaces get it: a savepoint on the service transaction is as useful
+    // as one on the request's, and each is bound to its own connection.
+    attempt: (fn) => raw.attempt(fn),
     tables: makeTablesAccessor(() => reco),
     transaction(fn) {
       const builder = new TxPlanBuilder();
@@ -920,6 +938,14 @@ function makeMemoryCache(opts = {}) {
 function quoteIdent(name) {
   return `"${name.replace(/"/g, '""')}"`;
 }
+function encodePgArray(value) {
+  const element = (x) => {
+    if (x === null || x === void 0) return "NULL";
+    if (Array.isArray(x)) return encodePgArray(x);
+    return `"${String(x).replace(/(["\\])/g, "\\$1")}"`;
+  };
+  return `{${value.map(element).join(",")}}`;
+}
 var BIND_SQL = "select set_config('role',$1,true), set_config('search_path','public',true), set_config('request.jwt.claims',$2,true)";
 function createLazyTransaction(sql, role, claimsJson, options = {}) {
   const { lockTimeout } = options;
@@ -1140,7 +1166,9 @@ function expandSynonyms(query, map) {
     }).join("");
   }).join("");
 }
-var searchLogger = null;
+var searchLogger = (evt, fields) => {
+  console.log(evt, JSON.stringify(fields));
+};
 function logNoResults(table, query, mode, n) {
   if (n === 0) {
     searchLogger?.("palbase.search.no_results", {
@@ -1181,19 +1209,41 @@ function validitySql(v, add) {
 function excludeSql(pk, ids, add) {
   if (ids.length === 0) return "";
   if (ids.length === 1) return ` AND t.${quoteIdent(pk)} <> ${add(ids[0])}`;
-  return ` AND t.${quoteIdent(pk)} <> ALL(ARRAY[${ids.map((x) => add(x)).join(", ")}])`;
+  return ` AND t.${quoteIdent(pk)}::text <> ALL(ARRAY[${ids.map((x) => add(x)).join(", ")}])`;
+}
+function schemaColumns(table) {
+  const t = Object.values(currentSchema.tables ?? {}).find((x) => x?.name === table);
+  const cols = t?.columns ? Object.keys(t.columns) : [];
+  return cols.length > 0 ? new Set(cols) : null;
+}
+function orderClause(table, known, orderBy) {
+  if (!orderBy) return "";
+  const col = orderBy.column;
+  const shapeOK = /^[A-Za-z_][A-Za-z0-9_]*$/.test(col);
+  if (known !== null ? !known.has(col) : !shapeOK) {
+    throw new Error(`findMany(${table}): orderBy kolonu "${col}" tabloda yok`);
+  }
+  const dir = orderBy.direction === "desc" ? "DESC" : "ASC";
+  return ` ORDER BY ${quoteIdent(col)} ${dir}`;
+}
+function limitClause(limit) {
+  if (limit === void 0) return "";
+  if (!Number.isInteger(limit) || limit < 0) {
+    throw new Error(`findMany: limit bir negatif olmayan tam say\u0131 olmal\u0131 (geldi: ${String(limit)})`);
+  }
+  return ` LIMIT ${limit}`;
 }
-function compileWhere(table, colSet, where, add) {
+function compileWhere(table, colSet, where, add, caller = "search") {
   const parts = [];
   for (const [col, cond] of Object.entries(where)) {
-    if (!colSet.has(col)) {
-      throw new Error(`search(${table}): where kolonu "${col}" tabloda yok (FR-016)`);
+    if (colSet !== null && !colSet.has(col)) {
+      throw new Error(`${caller}(${table}): where kolonu "${col}" tabloda yok (FR-016)`);
     }
     const q = `t.${quoteIdent(col)}`;
     if (cond !== null && typeof cond === "object" && !Array.isArray(cond)) {
       for (const [op, v] of Object.entries(cond)) {
         if (op === "in") {
-          if (!Array.isArray(v)) throw new Error(`search(${table}): where.${col}.in bir dizi olmal\u0131`);
+          if (!Array.isArray(v)) throw new Error(`${caller}(${table}): where.${col}.in bir dizi olmal\u0131`);
           if (v.length === 0) {
             parts.push("false");
             continue;
@@ -1202,7 +1252,7 @@ function compileWhere(table, colSet, where, add) {
         } else if (op in WHERE_OPS) {
           parts.push(`${q} ${WHERE_OPS[op]} ${add(v)}`);
         } else {
-          throw new Error(`search(${table}): where.${col} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in)`);
+          throw new Error(`${caller}(${table}): where.${col} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in)`);
         }
       }
     } else {
@@ -1282,7 +1332,8 @@ function createOps(tx) {
   const at = () => resolveTx(tx);
   const ops = {
     async query(sql, params = []) {
-      return asWireRows(await (await at()).unsafe(sql, params));
+      const bound = params.map((p) => Array.isArray(p) ? encodePgArray(p) : p);
+      return asWireRows(await (await at()).unsafe(sql, bound));
     },
     async insert(table, data) {
       const cols = Object.keys(data);
@@ -1298,6 +1349,41 @@ function createOps(tx) {
       }
       return asTableRow(table, inserted);
     },
+    /**
+     * INSERT the row, or UPDATE it when it collides on `onConflict`.
+     *
+     * WHY IT IS AN OPERATION rather than a recipe. "Try the insert, catch the
+     * unique violation, update instead" does not work here: a request runs in ONE
+     * Postgres transaction, so the failed insert aborts it and every later
+     * statement answers `current transaction is aborted`. A tenant measured that
+     * as 7 of 8 concurrent requests returning 500, gave up on upsert, and had a
+     * trigger create the row instead — a workaround that needs a new trigger for
+     * every table with a unique row.
+     *
+     * The conflict columns are excluded from the SET list: they are what MATCHED,
+     * so writing them back is at best a no-op and at worst a surprise.
+     */
+    async upsert(table, data, opts) {
+      const conflict = opts.onConflict;
+      if (conflict.length === 0) {
+        throw new Error(`upsert into ${table}: onConflict en az bir kolon ad\u0131 ister`);
+      }
+      const cols = Object.keys(data);
+      if (cols.length === 0) throw new Error(`upsert into ${table}: no columns given`);
+      const placeholders = cols.map((_, i) => `$${i + 1}`).join(", ");
+      const conflictSet = new Set(conflict);
+      const assignments = cols.filter((c) => !conflictSet.has(c)).map((c) => `${quoteIdent(c)} = EXCLUDED.${quoteIdent(c)}`);
+      const action = assignments.length ? `DO UPDATE SET ${assignments.join(", ")}` : `DO UPDATE SET ${quoteIdent(conflict[0])} = EXCLUDED.${quoteIdent(conflict[0])}`;
+      const sql = `INSERT INTO ${quoteIdent(table)} (${cols.map(quoteIdent).join(", ")}) VALUES (${placeholders}) ON CONFLICT (${conflict.map(quoteIdent).join(", ")}) ${action} RETURNING *`;
+      const rows = await (await at()).unsafe(sql, asBindParams(table, cols, data));
+      const row = rows[0];
+      if (!row) {
+        throw new Error(
+          `upsert into ${table} returned no row \u2014 the write was rejected (an RLS policy, most likely).`
+        );
+      }
+      return asTableRow(table, row);
+    },
     async update(table, id, data) {
       const cols = Object.keys(data);
       if (cols.length === 0) return ops.findById(table, id);
@@ -1316,13 +1402,18 @@ function createOps(tx) {
       );
       return rows[0] ? asTableRow(table, rows[0]) : null;
     },
-    async findMany(table, query = {}) {
-      const cols = Object.keys(query);
-      const where = cols.length ? ` WHERE ${cols.map((c, i) => `${quoteIdent(c)} = $${i + 1}`).join(" AND ")}` : "";
-      return asTableRows(table, await (await at()).unsafe(
-        `SELECT * FROM ${quoteIdent(table)}${where}`,
-        cols.map((c) => query[c])
-      ));
+    async findMany(table, query = {}, opts = {}) {
+      const params = [];
+      const add = (v) => {
+        params.push(v);
+        return `$${params.length}`;
+      };
+      const known = schemaColumns(table);
+      const whereSql = compileWhere(table, known, query, add, "findMany");
+      const order = orderClause(table, known, opts.orderBy);
+      const limit = limitClause(opts.limit);
+      const sql = `SELECT * FROM ${quoteIdent(table)} t WHERE true${whereSql}${order}${limit}`;
+      return asTableRows(table, await (await at()).unsafe(sql, params));
     },
     /**
      * Tek-SQL hibrit arama (FR-014): iki kol CTE + FULL OUTER JOIN + RRF
@@ -1713,6 +1804,27 @@ function createOps(tx) {
       const live = await at();
       return live.savepoint(async (sp) => cb(withTables(createOps(sp), currentSchema)));
     },
+    /**
+     * Run `fn` against a handle bound to a SAVEPOINT, so a failure inside it
+     * rolls back only what that handle wrote and the request can keep writing.
+     *
+     * WHY THE HANDLE IS AN ARGUMENT. The obvious shape — `attempt(async () => {
+     * ... Database.insert(...) ... })`, with no parameter — would have to point
+     * the ambient `Database` at the savepoint for the duration, and a request is
+     * concurrent with itself: `Promise.all([Database.insert(a),
+     * Database.attempt(...)])` would put `a` inside the savepoint and roll it
+     * back with it. Silent data loss, and the same interleaving this file already
+     * refuses for `asService()`. Passing the handle makes the boundary something
+     * you can see in the code that crosses it.
+     *
+     * Postgres, not us: the savepoint is released on success and rolled back on
+     * failure by the driver, so an aborted statement inside `fn` does not poison
+     * the surrounding transaction.
+     */
+    async attempt(fn) {
+      const live = await at();
+      return live.savepoint(async (sp) => fn(withTables(createOps(sp), currentSchema)));
+    },
     /**
      * Execute a whole transaction plan — what `Database.transaction(fn)` builds.
      *
@@ -1763,22 +1875,47 @@ function withTables(ops, schema = currentSchema) {
       update: (id, data) => ops.update(name, id, data),
       delete: (id) => ops.delete(name, id),
       findById: (id) => ops.findById(name, id),
-      findMany: (query) => ops.findMany(name, query ?? {})
+      findMany: (query, opts) => ops.findMany(name, query ?? {}, opts),
+      upsert: (data, opts) => ops.upsert(name, data, opts)
     };
   }
   const base = /* @__PURE__ */ Object.create(null);
   return Object.assign(base, ops, { tables });
 }
 var SERVICE_LOCK_TIMEOUT = "5s";
+function isAbortedTransaction(e) {
+  const code = e?.code;
+  const message = String(e?.message ?? "");
+  return code === "25P02" || /current transaction is aborted/i.test(message);
+}
+function isForeignKeyViolation(e) {
+  return e?.code === "23503";
+}
 function isLockTimeout(e) {
   const code = e?.code;
   const message = String(e?.message ?? "");
   return code === "55P03" || /lock timeout/i.test(message);
 }
-function diagnosingDriver(sql) {
-  const explain = (e) => isLockTimeout(e) ? new Error(
-    `Database.asService() waited too long for a row lock. It runs in its OWN transaction, so a row this request already wrote through Database.* is locked against it until the request commits \u2014 a wait that cannot end. Do that row's work on one surface or the other. (${String(e?.message ?? e)})`
-  ) : e;
+function diagnosingDriver(sql, surface = "service") {
+  const original = (e) => String(e?.message ?? e);
+  const explain = (e) => {
+    if (isAbortedTransaction(e)) {
+      return new Error(
+        `This request cannot write any more: an earlier write in it failed, and a request runs in ONE Postgres transaction, so every statement after the failure is refused. Nothing here is retryable in place. Wrap a write you expect to fail in \`Database.attempt(async (tx) => \u2026)\` \u2014 it takes a SAVEPOINT, so only that write rolls back \u2014 or use \`Database.tables.<t>.upsert(data, { onConflict: [...] })\` when the failure you were bracing for is a duplicate row. (${original(e)})`
+      );
+    }
+    if (surface === "service" && isForeignKeyViolation(e)) {
+      return new Error(
+        `Database.asService() hit a foreign key with nothing to point at. It runs in its OWN transaction on its OWN connection, so a row this request wrote through \`Database.*\` is not visible to it until the request commits \u2014 and the request cannot commit until the handler returns. If the row it needs is one this request just created, do both writes on ONE surface. (${original(e)})`
+      );
+    }
+    if (isLockTimeout(e)) {
+      return new Error(
+        `Database.asService() waited too long for a row lock. It runs in its OWN transaction, so a row this request already wrote through Database.* is locked against it until the request commits \u2014 a wait that cannot end. Do that row's work on one surface or the other. (${original(e)})`
+      );
+    }
+    return e;
+  };
   const wrapTx = (tx) => ({
     async unsafe(text, params) {
       try {
@@ -1797,13 +1934,13 @@ function diagnosingDriver(sql) {
   };
 }
 function createRequestDatabase(sql, identity) {
-  const tx = createLazyTransaction(sql, identity.role, identity.claimsJson);
+  const tx = createLazyTransaction(diagnosingDriver(sql, "user"), identity.role, identity.claimsJson);
   let serviceTx = null;
   let serviceClient = null;
   const asService = () => {
     if (serviceClient === null) {
       serviceTx = createLazyTransaction(
-        diagnosingDriver(sql),
+        diagnosingDriver(sql, "service"),
         identity.serviceRole,
         identity.claimsJson,
         { lockTimeout: SERVICE_LOCK_TIMEOUT }
@@ -1884,6 +2021,23 @@ async function runPlanOp(sp, op, results) {
       sql = cols.length ? `INSERT INTO ${table} (${cols.map(quoteIdent).join(", ")}) VALUES (${rendered.join(", ")}) RETURNING *` : `INSERT INTO ${table} DEFAULT VALUES RETURNING *`;
       break;
     }
+    case "upsert": {
+      const cols = Object.keys(op.values ?? {});
+      const conflict = op.onConflict ?? [];
+      if (cols.length === 0 || conflict.length === 0) {
+        throw Object.assign(new Error(`upsert on ${op.table} needs columns and onConflict`), {
+          error_code: "tx_bad_upsert"
+        });
+      }
+      const rendered = cols.map(
+        (c) => renderValue(op.values[c], c, args, results, opVectorCols)
+      );
+      const conflictSet = new Set(conflict);
+      const sets = cols.filter((c) => !conflictSet.has(c)).map((c) => `${quoteIdent(c)} = EXCLUDED.${quoteIdent(c)}`);
+      const action = sets.length ? `DO UPDATE SET ${sets.join(", ")}` : `DO UPDATE SET ${quoteIdent(conflict[0])} = EXCLUDED.${quoteIdent(conflict[0])}`;
+      sql = `INSERT INTO ${table} (${cols.map(quoteIdent).join(", ")}) VALUES (${rendered.join(", ")}) ON CONFLICT (${conflict.map(quoteIdent).join(", ")}) ${action} RETURNING *`;
+      break;
+    }
     case "insertMany": {
       const rows = op.rows ?? [];
       if (rows.length === 0 || !rows[0]) return [];
@@ -2080,6 +2234,41 @@ function verifySignature(presented, expected) {
   return diff === 0;
 }
 
+// src/engine/sse.ts
+var SSE_CONTENT_TYPE = "text/event-stream";
+function encodeFrame(value) {
+  return `data: ${JSON.stringify(value)}
+
+`;
+}
+function encodeErrorFrame(requestId) {
+  return `event: error
+data: ${JSON.stringify({ requestId })}
+
+`;
+}
+function makeSseWriter(opts) {
+  let begun = false;
+  let chain = Promise.resolve();
+  return {
+    write(value) {
+      const frame = encodeFrame(value);
+      if (!begun) {
+        begun = true;
+        chain = chain.then(() => opts.onFirstWrite()).then(() => opts.enqueue(frame));
+        return;
+      }
+      chain = chain.then(() => opts.enqueue(frame));
+    },
+    started() {
+      return begun;
+    },
+    drained() {
+      return chain;
+    }
+  };
+}
+
 // src/engine/index.ts
 var JSON_HEADERS = { "content-type": "application/json" };
 function fieldErrors(err) {
@@ -2254,6 +2443,13 @@ async function createApp(opts) {
     const args = [];
     let parsedBody;
     let bodyRead = false;
+    let sseEnqueue = null;
+    let sseSettle = async () => {
+    };
+    const sseWriter = makeSseWriter({
+      enqueue: (chunk) => sseEnqueue?.(chunk),
+      onFirstWrite: () => sseSettle()
+    });
     for (const p of meta.params ?? []) {
       switch (p.kind) {
         case "body": {
@@ -2357,6 +2553,21 @@ async function createApp(opts) {
         case "req":
           args[p.index] = req;
           break;
+        // `@Signal()` — the raw request's AbortSignal, which enters the aborted
+        // state when the client disconnects. Measured on Bun: an infinite
+        // producer guarded by it stops within a few frames of the client dying.
+        // It is deliberately NOT reachable through `@Req()`: PBRequest carries
+        // request-scoped data and no signal.
+        case "signal":
+          args[p.index] = req.signal;
+          break;
+        // `@SseOut()` — the frame writer. Meaningful only on an `@Sse` route;
+        // on any other route it is an inert writer whose frames go nowhere,
+        // which is the same shape `@UploadedObject()` has off an `@Upload`
+        // route.
+        case "sseOut":
+          args[p.index] = sseWriter;
+          break;
         default:
           args[p.index] = void 0;
       }
@@ -2368,6 +2579,84 @@ async function createApp(opts) {
     });
     try {
       const services = buildServices(db);
+      if (meta.options?.sseConfig !== void 0) {
+        let sseController;
+        const sseEncoder = new TextEncoder();
+        const stream = new ReadableStream({
+          start(c) {
+            sseController = c;
+          }
+        });
+        sseEnqueue = (chunk) => {
+          try {
+            sseController.enqueue(sseEncoder.encode(chunk));
+          } catch {
+          }
+        };
+        let sawFirstFrame;
+        const firstFrame = new Promise((r) => sawFirstFrame = r);
+        sseSettle = async () => {
+          await db.commit();
+          sawFirstFrame();
+        };
+        const guarded = {
+          ...services,
+          Database: new Proxy(services.Database, {
+            get(target, prop, recv) {
+              if (sseWriter.started()) {
+                throw new Error(
+                  `sse_db_after_write: ${hit.entry.id} touched the database after its first write(). A streaming response settles its transaction with the first frame \u2014 do the database work before the first write.`
+                );
+              }
+              return Reflect.get(target, prop, recv);
+            }
+          })
+        };
+        let thrown = null;
+        const ran = Promise.resolve(runWithRuntime(guarded, () => {
+          const box = requestALS.getStore();
+          if (box) {
+            box.userId = userId ?? null;
+            box.requestId = requestId;
+            box.idempotencyKey = req.headers.get("idempotency-key");
+          }
+          const method = hit.entry.instance[meta.fnName];
+          if (typeof method !== "function") {
+            throw new Error(
+              `route ${hit.entry.id} names method ${meta.fnName}, which the controller does not define`
+            );
+          }
+          return method.apply(hit.entry.instance, args);
+        })).then(
+          () => void 0,
+          (err) => {
+            thrown = err;
+          }
+        );
+        await Promise.race([firstFrame, ran]);
+        if (!sseWriter.started()) {
+          await ran;
+          await db.commit();
+          if (thrown !== null) throw thrown;
+          return new Response(null, { status: 204 });
+        }
+        void (async () => {
+          await ran;
+          await sseWriter.drained();
+          try {
+            if (thrown !== null) {
+              log.error(`[engine] ${hit.entry.id} threw mid-stream`, thrown);
+              sseController.enqueue(sseEncoder.encode(encodeErrorFrame(requestId)));
+            }
+            sseController.close();
+          } catch {
+          }
+        })();
+        return new Response(stream, {
+          status: 200,
+          headers: { "content-type": SSE_CONTENT_TYPE, "cache-control": "no-cache" }
+        });
+      }
       const result = await runWithRuntime(services, () => {
         const box = requestALS.getStore();
         if (box) {