@palbase/backend 34.0.0 → 34.1.1

package/dist/{chunk-LOGL2ZHD.js → chunk-YO5GYM73.js}

@@ -3,7 +3,7 @@ import {
   assertPlanRetry,
   qualifiedTableKey,
   runTxPlan
-} from "./chunk-FOWA7PF4.js";
+} from "./chunk-P7MGSAFT.js";
 import {
   __name
 } from "./chunk-VXPNPVAG.js";
@@ -417,4 +417,4 @@ export {
   Flags,
   Realtime
 };
-//# sourceMappingURL=chunk-LOGL2ZHD.js.map
+//# sourceMappingURL=chunk-YO5GYM73.js.map

package/dist/db/index.cjs

@@ -63,6 +63,7 @@ function qualifiedTableKey(schemaName, tableName) {
 __name(qualifiedTableKey, "qualifiedTableKey");
 
 // src/db/policy.ts
+var import_zod = require("zod");
 var PolicyExprRef = class _PolicyExprRef {
   static {
     __name(this, "PolicyExprRef");
@@ -295,6 +296,24 @@ function policy(name) {
   return new PolicyBuilder(name);
 }
 __name(policy, "policy");
+function reservedCanRelation(tableName, columns) {
+  if (tableName === "can") {
+    return `a table named "can" would put a relation named "can" on every parent it references \u2014 rename the table`;
+  }
+  for (const [col, b] of Object.entries(columns)) {
+    const def = b._def;
+    if (def.referencesThunk === void 0 && def.selfRefColumn === void 0) continue;
+    if (def.reverseAs === "can") {
+      return `column "${col}" names its reverse relation "can" \u2014 the parent's rows would carry a relation where can is reserved; pick another reverseAs`;
+    }
+    const forward = def.owns === true ? "owner" : def.refAs ?? (col.endsWith("_id") ? col.slice(0, -3) : col);
+    if (forward === "can") {
+      return `column "${col}" would be read as a relation named "can" (${def.refAs === void 0 ? "derived from the column name" : "its as: option"}) \u2014 can is reserved for the policy echo; rename it`;
+    }
+  }
+  return null;
+}
+__name(reservedCanRelation, "reservedCanRelation");
 
 // src/db/schema.ts
 var IndexBuilder = class {
@@ -368,6 +387,10 @@ function defineTable(name, input) {
   if (name.trim() === "") {
     throw new Error("defineTable(name, \u2026): name must not be empty");
   }
+  {
+    const reserved = reservedCanRelation(name, input.columns);
+    if (reserved !== null) throw new Error(`defineTable(${JSON.stringify(name)}): ${reserved}`);
+  }
   const policies = (input.policies?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(toPolicyDef);
   const rls = policies.length > 0 || input.rls !== false;
   const owned = {};
@@ -396,6 +419,7 @@ function defineTable(name, input) {
   const declaredIndexes = (input.indexes?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map((i) => i instanceof IndexBuilder ? i._def : i);
   if (declaredIndexes.length > 0) def.indexes = declaredIndexes;
   if (input.appendOnly === true) def.appendOnly = true;
+  if (input.ignored === true) def.ignored = true;
   if (input.search !== void 0) {
     const s = input.search;
     if (s.from !== void 0) {
@@ -553,7 +577,7 @@ function defineSchema(name, input) {
 __name(defineSchema, "defineSchema");
 
 // src/db/query.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var import_zod_to_openapi = require("@asteasolutions/zod-to-openapi");
 
 // src/db/query-contract.ts
@@ -586,27 +610,27 @@ function stableContract(value) {
 __name(stableContract, "stableContract");
 
 // src/db/query.ts
-(0, import_zod_to_openapi.extendZodWithOpenApi)(import_zod.z);
+(0, import_zod_to_openapi.extendZodWithOpenApi)(import_zod2.z);
 function responseColumn(column, validator) {
   const contract = queryColumnContract(column);
   let schema;
   if (validator) return validator;
-  if (contract.codec === "number") schema = import_zod.z.number().finite();
-  else if (contract.codec === "decimal") schema = import_zod.z.string();
+  if (contract.codec === "number") schema = import_zod2.z.number().finite();
+  else if (contract.codec === "decimal") schema = import_zod2.z.string();
   else switch (contract.type) {
     case "integer":
-      schema = import_zod.z.number().int().min(-2147483648).max(2147483647);
+      schema = import_zod2.z.number().int().min(-2147483648).max(2147483647);
       break;
     case "boolean":
-      schema = import_zod.z.boolean();
+      schema = import_zod2.z.boolean();
       break;
     case "vector":
-      schema = import_zod.z.array(import_zod.z.number().finite());
+      schema = import_zod2.z.array(import_zod2.z.number().finite());
       break;
     case "enum": {
       const values = contract.enumValues;
       if (!values?.length) throw new Error("Query response requires declared enum values");
-      schema = import_zod.z.enum(values);
+      schema = import_zod2.z.enum(values);
       break;
     }
     case "uuid":
@@ -614,7 +638,7 @@ function responseColumn(column, validator) {
     case "timestamp":
     case "numeric":
     case "bigint":
-      schema = import_zod.z.string();
+      schema = import_zod2.z.string();
       break;
     case "jsonb":
       throw new Error("Query response requires a fields validator for a selected jsonb column: its TypeScript payload is erased at runtime");
@@ -637,7 +661,7 @@ function defineQuery(name, options) {
     columns[key] = queryColumnContract(options.table[key]);
     shape[key] = responseColumn(options.table[key], options.fields?.[key]);
   }
-  const response = import_zod.z.array(import_zod.z.object(shape).strict());
+  const response = import_zod2.z.array(import_zod2.z.object(shape).strict());
   const queryInput = options.input, where = options.where, limit = options.limit;
   const orderBy = options.orderBy === void 0 ? void 0 : JSON.parse(JSON.stringify(options.orderBy));
   const prepare = /* @__PURE__ */ __name((input) => {