@palbase/backend 30.0.1 → 32.0.0

package/dist/bin/palbase-backend.cjs

@@ -827,7 +827,11 @@ function qualifiedTableKey(schemaName, tableName) {
 __name(qualifiedTableKey, "qualifiedTableKey");
 
 // src/runtime.ts
-var __requestALS = new import_node_async_hooks.AsyncLocalStorage();
+var REQUEST_ALS = /* @__PURE__ */ Symbol.for("palbase.backend.requestALS");
+var __requestALS = (() => {
+  const g = globalThis;
+  return g[REQUEST_ALS] ??= new import_node_async_hooks.AsyncLocalStorage();
+})();
 var runtime = null;
 function __runWithRuntime(services, fn) {
   return __requestALS.run({
@@ -1093,8 +1097,21 @@ var Flags = Object.assign({
    * the runtime proxy, so caching would leak one request's sibling into
    * another concurrent request. Mirrors `Database.asService()`.
    */
-  asService() {
+  $asService() {
     return rawFlags.asService();
+  },
+  /**
+   * The name this member carried before 31.0.0.
+   *
+   * It does NOT work silently. A retired member that quietly keeps returning
+   * is how a rename becomes a mystery: the old call site goes on compiling,
+   * the new name never spreads, and the two live side by side until somebody
+   * greps for one and misses half the codebase. `Database` made this split
+   * first (`$asService`), and this JSDoc promised "exactly like
+   * Database.$asService()" while the promise went unkept.
+   */
+  asService() {
+    throw new Error("Flags.asService() was renamed to Flags.$asService() in 31.0.0 \u2014 system members carry the `$` prefix, like Database.$asService().");
   }
 });
 var Realtime = makeServiceProxy("Realtime");
@@ -1463,6 +1480,25 @@ function makeMemoryCache(opts = {}) {
 }
 __name(makeMemoryCache, "makeMemoryCache");
 
+// src/db/columns.ts
+var CODECS = {
+  // Exact-precision column → JS number. Safe below 2^53; a value above it is
+  // not representable and the author wants `asDecimal()` instead.
+  number: {
+    fromDb: /* @__PURE__ */ __name((v) => Number(v), "fromDb"),
+    toDb: /* @__PURE__ */ __name((v) => String(v), "toDb"),
+    tsType: "number"
+  },
+  // Exact-precision column → the string Postgres sent. It exists so the
+  // DECLARATION is explicit: "this column is a decimal I handle as text",
+  // rather than the ABSENCE of a declaration meaning the same thing by default.
+  decimal: {
+    fromDb: /* @__PURE__ */ __name((v) => String(v), "fromDb"),
+    toDb: /* @__PURE__ */ __name((v) => String(v), "toDb"),
+    tsType: "string"
+  }
+};
+
 // src/db/env-gen.ts
 function forwardName(column) {
   return column.endsWith("_id") ? column.slice(0, -3) : column;
@@ -1676,6 +1712,15 @@ function transformsOf(schema, table) {
   if (def) {
     for (const [col, c] of Object.entries(def.columns ?? {})) {
       const d = c !== null && typeof c === "object" && "_def" in c ? c._def : c;
+      const codec = d?.codec;
+      if (typeof codec === "string" && codec in CODECS) {
+        const c2 = CODECS[codec];
+        out.set(col, {
+          fromDb: c2.fromDb,
+          toDb: c2.toDb
+        });
+        continue;
+      }
       const t = d?.transform;
       if (t !== null && typeof t === "object") {
         out.set(col, t);
@@ -2011,6 +2056,29 @@ function selectClause(table, known, select) {
   }).join(", ");
 }
 __name(selectClause, "selectClause");
+function quoteLiteral(v) {
+  return `'${v.replace(/'/g, "''")}'`;
+}
+__name(quoteLiteral, "quoteLiteral");
+function orderClauseFor(table, known, orderBy, alias) {
+  if (orderBy === void 0 || orderBy === null) return "";
+  const items = Array.isArray(orderBy) ? orderBy : [
+    orderBy
+  ];
+  if (items.length === 0) return "";
+  const rendered = items.map((o) => {
+    const col = o.column;
+    const shapeOK = /^[A-Za-z_][A-Za-z0-9_]*$/.test(col);
+    if (known !== null ? !known.has(col) : !shapeOK) {
+      throw new Error(`with(${table}): orderBy kolonu "${col}" tabloda yok`);
+    }
+    const dir = o.direction === "desc" ? "DESC" : "ASC";
+    const nulls = o.nulls === "first" ? " NULLS FIRST" : o.nulls === "last" ? " NULLS LAST" : "";
+    return `${alias}.${quoteIdent(col)} ${dir}${nulls}`;
+  });
+  return ` ORDER BY ${rendered.join(", ")}`;
+}
+__name(orderClauseFor, "orderClauseFor");
 function orderClause(table, known, orderBy) {
   if (!orderBy) return "";
   const items = Array.isArray(orderBy) ? orderBy : [
@@ -2314,6 +2382,65 @@ function aggregateExpr(table, fn, col, alias) {
   return t !== null && NUMERIC_PG_TYPES.has(t) && t !== "integer" ? `${fn}(${q})::text AS ${quoteIdent(alias)}` : `${fn}(${q}) AS ${quoteIdent(alias)}`;
 }
 __name(aggregateExpr, "aggregateExpr");
+function jsonObjectFor(table, cols, alias) {
+  const pairs = cols.map((c) => {
+    const t = columnTypeOf(table, c);
+    const expr = t !== null && (t === "numeric" || t === "bigint") ? `${alias}.${quoteIdent(c)}::text` : `${alias}.${quoteIdent(c)}`;
+    return `${quoteLiteral(c)}, ${expr}`;
+  });
+  return `json_build_object(${pairs.join(", ")})`;
+}
+__name(jsonObjectFor, "jsonObjectFor");
+function withClauses(table, spec, add, caller) {
+  const rels = currentRelations.get(table) ?? [];
+  const select = [];
+  const joins = [];
+  let i = 0;
+  for (const [name, opt] of Object.entries(spec)) {
+    if (opt === false || opt === void 0) continue;
+    const rel = rels.find((r) => r.name === name);
+    if (rel === void 0) {
+      const known = rels.map((r) => r.name).sort();
+      throw new Error(`${caller}(${table}): with.${name} diye bir ili\u015Fki yok` + (known.length > 0 ? ` (bilinenler: ${known.join(", ")})` : `. Bu tablo hi\xE7 yabanc\u0131 anahtar bildirmiyor ve ili\u015Fkiler onlardan T\xDCRET\u0130L\u0130R`) + `. \u0130li\u015Fkiler references(() => <tablo>.<kolon>) ile bildirilir.`);
+    }
+    const ourCol = rel.kind === "many" ? primaryKeyOf(table) : rel.via;
+    const theirCol = rel.kind === "many" ? rel.via : primaryKeyOf(rel.to);
+    if (ourCol === null || theirCol === null) {
+      throw new Error(`${caller}(${table}): with.${name} birincil anahtar bilmeden kurulamaz \u2014 ili\u015Fkinin bir ucu tablonun PK's\u0131 ve bu tablo tek kolonlu bir PK bildirmiyor.`);
+    }
+    const o = typeof opt === "object" && opt !== null ? opt : {};
+    const childAlias = `w${++i}`;
+    const childKnown = schemaColumns(rel.to);
+    const childCols = Array.isArray(o["select"]) && o["select"].length > 0 ? o["select"] : childKnown !== null ? [
+      ...childKnown
+    ] : [];
+    if (childCols.length === 0) {
+      throw new Error(`${caller}(${table}): with.${name} i\xE7in "${rel.to}" tablosunun kolonlar\u0131 bilinmiyor \u2014 select ile hangi kolonlar\u0131 istedi\u011Finizi yaz\u0131n.`);
+    }
+    for (const c of childCols) {
+      if (childKnown !== null && !childKnown.has(c)) {
+        throw new Error(`${caller}(${table}): with.${name}.select kolonu "${c}" "${rel.to}" tablosunda yok`);
+      }
+    }
+    const obj = jsonObjectFor(rel.to, childCols, childAlias);
+    const innerWhere = o["where"] !== void 0 && o["where"] !== null ? compileWhereBare(rel.to, childKnown, o["where"], add, caller, childAlias, i) : "";
+    const link = `${childAlias}.${quoteIdent(theirCol)} = t.${quoteIdent(ourCol)}`;
+    const cond = innerWhere === "" ? link : `${link} AND ${innerWhere}`;
+    const inner = orderClauseFor(rel.to, childKnown, o["orderBy"], childAlias) + limitClause(o["limit"]);
+    const outAlias = `wj${i}`;
+    if (rel.kind === "many") {
+      joins.push(`LEFT JOIN LATERAL (SELECT coalesce(json_agg(x.o), '[]'::json) AS d FROM (SELECT ${obj} AS o FROM ${quoteTable(rel.to)} ${childAlias} WHERE ${cond}${inner}) x) ${quoteIdent(outAlias)} ON true`);
+    } else {
+      joins.push(`LEFT JOIN LATERAL (SELECT ${obj} AS d FROM ${quoteTable(rel.to)} ${childAlias} WHERE ${cond}${inner} LIMIT 1) ${quoteIdent(outAlias)} ON true`);
+    }
+    select.push(`${quoteIdent(outAlias)}."d" AS ${quoteIdent(name)}`);
+  }
+  return {
+    select,
+    joins
+  };
+}
+__name(withClauses, "withClauses");
 function createOps(tx) {
   const at = /* @__PURE__ */ __name(() => resolveTx(tx), "at");
   const ops = {
@@ -2757,7 +2884,13 @@ function createOps(tx) {
       const limit = limitClause(opts.limit);
       const offset = offsetClause(opts.offset, opts.limit);
       const cols = selectClause(table, known, opts.select);
-      const sql = `SELECT ${cols} FROM ${quoteTable(table)} t WHERE true${whereSql}${order}${limit}${offset}`;
+      const w = opts.with !== void 0 && Object.keys(opts.with).length > 0 ? withClauses(table, opts.with, add, "findMany") : {
+        select: [],
+        joins: []
+      };
+      const selectList = w.select.length > 0 ? `${cols === "*" ? "t.*" : cols}, ${w.select.join(", ")}` : cols;
+      const joinSql = w.joins.length > 0 ? ` ${w.joins.join(" ")}` : "";
+      const sql = `SELECT ${selectList} FROM ${quoteTable(table)} t${joinSql} WHERE true${whereSql}${order}${limit}${offset}`;
       return asTableRows(table, await (await at()).unsafe(sql, params));
     },
     /**