@palbase/backend 30.0.1 → 32.0.0

package/dist/{chunk-VVMJEVQP.js → chunk-BRLJOXWS.js}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-VXPNPVAG.js";
+} from "./chunk-KATPXCJ5.js";
 
 // src/decorators/registry.ts
 var ROUTES = /* @__PURE__ */ Symbol.for("palbase.backend.routes");
@@ -290,4 +290,4 @@ export {
   resolveController,
   assertZeroArgConstructor
 };
-//# sourceMappingURL=chunk-VVMJEVQP.js.map
+//# sourceMappingURL=chunk-BRLJOXWS.js.map

package/dist/{chunk-3TUJWHC2.js → chunk-IXAX5CON.js}

@@ -1,6 +1,7 @@
 import {
-  __name
-} from "./chunk-VXPNPVAG.js";
+  __name,
+  isRetryable
+} from "./chunk-KATPXCJ5.js";
 
 // src/db/input-guards.ts
 var REF_BRAND = /* @__PURE__ */ Symbol.for("palbase.db.ref");
@@ -113,23 +114,23 @@ function assertUsableFilter(caller, table, where) {
   ]);
   if (!where) return;
   if (isSqlFragment(where)) return;
-  for (const [col, cond] of Object.entries(where)) {
-    if (COMPOSITES.has(col)) {
-      const branches = col === "NOT" ? [
+  for (const [col2, cond] of Object.entries(where)) {
+    if (COMPOSITES.has(col2)) {
+      const branches = col2 === "NOT" ? [
         cond
       ] : cond;
-      if (!Array.isArray(branches) && col !== "NOT") {
-        throw new Error(`${caller}(${table}): where.${col} bir dizi olmal\u0131`);
+      if (!Array.isArray(branches) && col2 !== "NOT") {
+        throw new Error(`${caller}(${table}): where.${col2} bir dizi olmal\u0131`);
       }
       for (const b of branches) {
         if (b === null || typeof b !== "object") {
-          throw new Error(`${caller}(${table}): where.${col} dallar\u0131 filtre nesnesi olmal\u0131`);
+          throw new Error(`${caller}(${table}): where.${col2} dallar\u0131 filtre nesnesi olmal\u0131`);
         }
         assertUsableFilter(caller, table, b);
       }
       continue;
     }
-    if (col === "has") {
+    if (col2 === "has") {
       if (cond === null || typeof cond !== "object" || Array.isArray(cond)) {
         throw new Error(`${caller}(${table}): where.has bir ili\u015Fki haritas\u0131 olmal\u0131 ({ <ili\u015Fki>: { \u2026 } })`);
       }
@@ -142,31 +143,31 @@ function assertUsableFilter(caller, table, where) {
       continue;
     }
     if (cond === void 0) {
-      throw new Error(`${caller}(${table}): where.${col} de\u011Feri undefined \u2014 bu bir filtre de\u011Feri de\u011Fil. Ba\u011Flan\u0131nca NULL olur ve '= NULL' hi\xE7bir sat\u0131ra uymaz, yani sorgu sessizce bo\u015F sonu\xE7 d\xF6nerdi. De\u011Fer yoksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n.`);
+      throw new Error(`${caller}(${table}): where.${col2} de\u011Feri undefined \u2014 bu bir filtre de\u011Feri de\u011Fil. Ba\u011Flan\u0131nca NULL olur ve '= NULL' hi\xE7bir sat\u0131ra uymaz, yani sorgu sessizce bo\u015F sonu\xE7 d\xF6nerdi. De\u011Fer yoksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n.`);
     }
     if (cond === null || typeof cond !== "object" || Array.isArray(cond)) continue;
     if (isColRef(cond)) continue;
     if (isNowExpr(cond)) continue;
     const entries = Object.entries(cond);
     if (entries.length === 0) {
-      throw new Error(`${caller}(${table}): where.${col} bo\u015F bir operat\xF6r nesnesi ({}) \u2014 hi\xE7bir ko\u015Ful \xFCretmez, yani bu alan filtreden sessizce D\xDC\u015EERD\u0130. Ko\u015Ful kurulmayacaksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n (D-21).`);
+      throw new Error(`${caller}(${table}): where.${col2} bo\u015F bir operat\xF6r nesnesi ({}) \u2014 hi\xE7bir ko\u015Ful \xFCretmez, yani bu alan filtreden sessizce D\xDC\u015EERD\u0130. Ko\u015Ful kurulmayacaksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n (D-21).`);
     }
     for (const [op, v] of entries) {
       if (op === "in") {
-        if (!Array.isArray(v)) throw new Error(`${caller}(${table}): where.${col}.in bir dizi olmal\u0131`);
+        if (!Array.isArray(v)) throw new Error(`${caller}(${table}): where.${col2}.in bir dizi olmal\u0131`);
         if (v.some((x) => x === void 0)) {
-          throw new Error(`${caller}(${table}): where.${col}.in listesinde undefined var \u2014 sessizce NULL'a ba\u011Flan\u0131r ve o eleman hi\xE7bir sat\u0131rla e\u015Fle\u015Fmez. Listeyi kurarken eleyin.`);
+          throw new Error(`${caller}(${table}): where.${col2}.in listesinde undefined var \u2014 sessizce NULL'a ba\u011Flan\u0131r ve o eleman hi\xE7bir sat\u0131rla e\u015Fle\u015Fmez. Listeyi kurarken eleyin.`);
         }
         continue;
       }
       if (REFUSED_OPS[op] !== void 0) {
-        throw new Error(`${caller}(${table}): where.${col}.${op} bu filtre dilinde yok \u2014 ${REFUSED_OPS[op]}`);
+        throw new Error(`${caller}(${table}): where.${col2}.${op} bu filtre dilinde yok \u2014 ${REFUSED_OPS[op]}`);
       }
       if (!KNOWN_OPS.has(op)) {
-        throw new Error(`${caller}(${table}): where.${col} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in/contains/icontains/startsWith/endsWith/isNull)`);
+        throw new Error(`${caller}(${table}): where.${col2} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in/contains/icontains/startsWith/endsWith/isNull)`);
       }
       if (v === void 0) {
-        throw new Error(`${caller}(${table}): where.${col}.${op} de\u011Feri undefined \u2014 kar\u015F\u0131la\u015Ft\u0131rman\u0131n sa\u011F taraf\u0131 NULL olur ve sonu\xE7 hi\xE7bir sat\u0131ra uymaz. Ko\u015Fulu kurmay\u0131n.`);
+        throw new Error(`${caller}(${table}): where.${col2}.${op} de\u011Feri undefined \u2014 kar\u015F\u0131la\u015Ft\u0131rman\u0131n sa\u011F taraf\u0131 NULL olur ve sonu\xE7 hi\xE7bir sat\u0131ra uymaz. Ko\u015Fulu kurmay\u0131n.`);
       }
     }
   }
@@ -707,8 +708,360 @@ function translateRejection(err, builder) {
 }
 __name(translateRejection, "translateRejection");
 
+// src/db/typed-db.ts
+function makeTypedTable(name, raw) {
+  return {
+    insert: /* @__PURE__ */ __name((data) => raw.insert(name, data), "insert"),
+    aggregate: /* @__PURE__ */ __name((q) => raw.aggregate(name, q), "aggregate"),
+    insertMany: /* @__PURE__ */ __name((rows, opts) => raw.insertMany(name, rows, opts), "insertMany"),
+    put: /* @__PURE__ */ __name((q) => raw.put(name, q.data, {
+      onConflict: q.onConflict
+    }), "put"),
+    update: /* @__PURE__ */ __name((q) => raw.update(name, q.where.id, q.set), "update"),
+    delete: /* @__PURE__ */ __name((id) => raw.delete(name, id), "delete"),
+    findById: /* @__PURE__ */ __name((id) => raw.findById(name, id), "findById"),
+    findMany: /* @__PURE__ */ __name((q) => {
+      const { where, ...opts } = q ?? {};
+      return raw.findMany(name, where, opts);
+    }, "findMany"),
+    updateMany: /* @__PURE__ */ __name((q) => raw.updateMany(name, q.where, q.set, q.returning === void 0 ? void 0 : {
+      returning: q.returning
+    }), "updateMany"),
+    deleteMany: /* @__PURE__ */ __name((q) => raw.deleteMany(name, q.where), "deleteMany"),
+    count: /* @__PURE__ */ __name((q) => raw.count(name, q?.where), "count")
+  };
+}
+__name(makeTypedTable, "makeTypedTable");
+function makeTypedDB(schema, raw) {
+  const tables = {};
+  for (const key of Object.keys(schema.tables)) {
+    const tableDef = schema.tables[key];
+    if (tableDef !== void 0) {
+      tables[key] = makeTypedTable(tableDef.name, raw);
+    }
+  }
+  const result = {
+    tables,
+    transaction(fn) {
+      const builder = new TxPlanBuilder();
+      const planTables = {};
+      for (const key of Object.keys(schema.tables)) {
+        const tableDef = schema.tables[key];
+        if (tableDef !== void 0) planTables[key] = builder.table(tableDef.name);
+      }
+      return runTxPlan(raw, {
+        tables: planTables
+      }, builder, fn);
+    }
+  };
+  return result;
+}
+__name(makeTypedDB, "makeTypedDB");
+function col(name) {
+  return brandRef({
+    $col: name
+  }, "col");
+}
+__name(col, "col");
+async function withRetry(fn, opts = {}) {
+  const budget = opts.retry ?? 0;
+  let attempt = 0;
+  for (; ; ) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (attempt >= budget || !isRetryable(e)) throw e;
+      attempt += 1;
+    }
+  }
+}
+__name(withRetry, "withRetry");
+function sqlFragment(strings, ...values) {
+  return brandRef({
+    $sql: {
+      text: [
+        ...strings
+      ],
+      values
+    }
+  }, "sql");
+}
+__name(sqlFragment, "sqlFragment");
+
+// src/db/schema-json.ts
+function defOf(column) {
+  return "_def" in column ? column._def : column;
+}
+__name(defOf, "defOf");
+function columnToJSON(column) {
+  const def = defOf(column);
+  const out = {
+    type: def.type,
+    nullable: def.nullable,
+    primaryKey: def.primaryKey
+  };
+  if (def.defaultValue !== void 0) out.defaultValue = def.defaultValue;
+  if (def.defaultRandom === true) out.defaultRandom = true;
+  if (def.defaultNow === true) out.defaultNow = true;
+  if (def.renamedFrom !== void 0) out.renamedFrom = def.renamedFrom;
+  if (def.ignored === true) out.ignored = true;
+  if (def.owns === true) out.owns = true;
+  if (def.references !== void 0) {
+    out.references = {
+      table: def.references.table,
+      column: def.references.column
+    };
+  }
+  if (def.onDeleteAction !== void 0) out.onDeleteAction = def.onDeleteAction;
+  if (def.index === false) out.index = false;
+  if (def.counter === true) out.counter = true;
+  if (def.enumName !== void 0) out.enumName = def.enumName;
+  if (def.enumValues !== void 0) out.enumValues = [
+    ...def.enumValues
+  ];
+  if (def.unique === true) out.unique = true;
+  if (def.dimensions !== void 0) out.dimensions = def.dimensions;
+  return out;
+}
+__name(columnToJSON, "columnToJSON");
+function policyToJSON(policy) {
+  return {
+    name: policy.name,
+    command: policy.command ?? "all",
+    roles: policy.roles ? [
+      ...policy.roles
+    ] : [],
+    // null rather than omitted: a policy with no USING clause is a different
+    // thing from one whose clause the emitter forgot, and Go reads the
+    // difference.
+    using: policy.using ?? null,
+    withCheck: policy.withCheck ?? null,
+    permissive: policy.permissive !== false
+  };
+}
+__name(policyToJSON, "policyToJSON");
+function commonSearchFields(search, out) {
+  if (search.synonyms !== void 0 && Object.keys(search.synonyms).length > 0) {
+    out.synonyms = Object.fromEntries(Object.entries(search.synonyms).map(([word, alts]) => [
+      word,
+      [
+        ...alts
+      ]
+    ]));
+  }
+  if (search.validity === true) out.validity = true;
+}
+__name(commonSearchFields, "commonSearchFields");
+function searchToJSON(search, vectorColumn) {
+  if (search.from !== void 0 && search.model !== void 0) {
+    const out2 = {};
+    const textCols = search.text === false ? void 0 : Array.isArray(search.text) && search.text.length > 0 ? search.text : search.from;
+    if (textCols !== void 0) out2.text = {
+      columns: [
+        ...textCols
+      ]
+    };
+    const v = {
+      metric: search.metric ?? "cosine"
+    };
+    if (vectorColumn !== void 0) v.column = vectorColumn;
+    v.embed = {
+      provider: search.model.provider,
+      model: search.model.model,
+      from: [
+        ...search.from
+      ],
+      ...search.model.apiKeyName !== void 0 ? {
+        apiKeyName: search.model.apiKeyName
+      } : {},
+      ...search.model.dimensions !== void 0 ? {
+        dimensions: search.model.dimensions
+      } : {},
+      ...search.model.baseURL !== void 0 ? {
+        baseURL: search.model.baseURL
+      } : {}
+    };
+    if (search.staleness !== void 0) v.staleness = search.staleness;
+    if (vectorColumn === void 0) {
+      v.mode = "chunks";
+      if (search.chunks !== void 0) {
+        const c = {};
+        if (search.chunks.size !== void 0 && search.chunks.size > 0) c.sizeChars = search.chunks.size;
+        if (search.chunks.overlap !== void 0 && search.chunks.overlap > 0) c.overlapChars = search.chunks.overlap;
+        if (Object.keys(c).length > 0) v.chunks = c;
+      }
+    }
+    out2.vector = [
+      v
+    ];
+    commonSearchFields(search, out2);
+    return out2;
+  }
+  const out = {};
+  if (Array.isArray(search.text) && search.text.length > 0) out.text = {
+    columns: [
+      ...search.text
+    ]
+  };
+  const legs = search.vector === void 0 ? [] : Array.isArray(search.vector) ? search.vector : [
+    search.vector
+  ];
+  if (legs.length > 0) {
+    out.vector = legs.map((leg) => {
+      const v = {
+        metric: leg.metric ?? "cosine"
+      };
+      if (leg.column !== void 0) v.column = leg.column;
+      if (leg.staleness !== void 0) v.staleness = leg.staleness;
+      if (leg.model !== void 0) {
+        v.embed = {
+          provider: leg.model.provider,
+          model: leg.model.model,
+          from: [
+            ...leg.from ?? []
+          ],
+          ...leg.model.apiKeyName !== void 0 ? {
+            apiKeyName: leg.model.apiKeyName
+          } : {},
+          ...leg.model.dimensions !== void 0 ? {
+            dimensions: leg.model.dimensions
+          } : {},
+          ...leg.model.baseURL !== void 0 ? {
+            baseURL: leg.model.baseURL
+          } : {}
+        };
+      }
+      return v;
+    });
+  }
+  commonSearchFields(search, out);
+  return out;
+}
+__name(searchToJSON, "searchToJSON");
+function memoryToJSON(m) {
+  return {
+    from: [
+      ...m.from
+    ],
+    into: m.into,
+    ...m.subject !== void 0 ? {
+      subject: m.subject
+    } : {},
+    extract: {
+      provider: m.extract.provider,
+      model: m.extract.model
+    }
+  };
+}
+__name(memoryToJSON, "memoryToJSON");
+function tableToJSON(table, schemaName) {
+  const columns = {};
+  for (const [name, column] of Object.entries(table.columns)) {
+    columns[name] = columnToJSON(column);
+  }
+  const out = {
+    name: table.name,
+    schema: schemaName,
+    columns,
+    // Read, not re-derived. `defineSchema` already resolves the fail-closed
+    // default (RLS on unless the author wrote `rls: false`, and forced on by any
+    // policy), and a second copy of a SECURITY default is exactly the thing that
+    // drifts — the direction it drifted last time was "expose everything", and
+    // the live proof was one user reading another's rows.
+    rls: table.rls,
+    policies: (table.policies ?? []).map(policyToJSON)
+  };
+  if (table.primaryKey !== void 0 && table.primaryKey.length > 0) {
+    out.primaryKey = [
+      ...table.primaryKey
+    ];
+  }
+  if (table.unique !== void 0 && table.unique.length > 0) {
+    out.uniqueConstraints = table.unique.map((u) => ({
+      name: u.name,
+      columns: [
+        ...u.columns
+      ]
+    }));
+  }
+  if (table.raw !== void 0 && table.raw.length > 0) {
+    out.rawConstraints = table.raw.map((r) => ({
+      name: r.name,
+      up: r.up,
+      down: r.down ?? null
+    }));
+  }
+  if (table.checks !== void 0 && table.checks.length > 0) {
+    out.checks = table.checks.map((c) => ({
+      name: c.name,
+      expr: c.expr
+    }));
+  }
+  if (table.indexes !== void 0 && table.indexes.length > 0) {
+    out.indexes = table.indexes.map((i) => {
+      const ix = {
+        name: i.name,
+        columns: i.columns ? [
+          ...i.columns
+        ] : []
+      };
+      if (i.where !== void 0) ix.where = i.where;
+      if (i.expression !== void 0) ix.expression = i.expression;
+      if (i.sort !== void 0) ix.sort = i.sort;
+      if (i.nulls !== void 0) ix.nulls = i.nulls;
+      if (i.include !== void 0) ix.include = [
+        ...i.include
+      ];
+      return ix;
+    });
+  }
+  if (table.appendOnly === true) out.appendOnly = true;
+  if (table.search !== void 0) {
+    const vectorColumn = Object.entries(columns).find(([, c]) => c.dimensions !== void 0)?.[0];
+    const sj = searchToJSON(table.search, vectorColumn);
+    if (sj.text !== void 0 || sj.vector !== void 0) out.search = sj;
+  }
+  if (table.memory !== void 0) {
+    out.memory = memoryToJSON(table.memory);
+  }
+  return out;
+}
+__name(tableToJSON, "tableToJSON");
+function qualifiedTableKey(schemaName, tableName) {
+  return schemaName === "" || schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
+}
+__name(qualifiedTableKey, "qualifiedTableKey");
+function toSchemaJSON(schemas) {
+  const tables = {};
+  const extensions = [];
+  const meta = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const schema of schemas) {
+    if (seen.has(schema.name)) {
+      throw new Error(`two schemas declare the name "${schema.name}" \u2014 schema names must be unique`);
+    }
+    seen.add(schema.name);
+    for (const table of Object.values(schema.tables)) {
+      const json = tableToJSON(table, schema.name);
+      tables[qualifiedTableKey(schema.name, json.name)] = json;
+    }
+    extensions.push(...schema.extensions ?? []);
+    meta.push({
+      name: schema.name,
+      exposed: schema.exposed
+    });
+  }
+  return {
+    tables,
+    extensions: [
+      ...new Set(extensions)
+    ],
+    schemas: meta
+  };
+}
+__name(toSchemaJSON, "toSchemaJSON");
+
 export {
-  brandRef,
   looksLikeUnbrandedRef,
   isColRef,
   isPlanRef,
@@ -728,6 +1081,12 @@ export {
   dec,
   columnExprOf,
   TxPlanBuilder,
-  runTxPlan
+  runTxPlan,
+  makeTypedDB,
+  col,
+  withRetry,
+  sqlFragment,
+  qualifiedTableKey,
+  toSchemaJSON
 };
-//# sourceMappingURL=chunk-3TUJWHC2.js.map
+//# sourceMappingURL=chunk-IXAX5CON.js.map