@palbase/backend 23.0.0 → 24.0.0

package/dist/db/index.cjs

@@ -47,6 +47,9 @@ __export(db_exports, {
 module.exports = __toCommonJS(db_exports);
 
 // src/db/policy.ts
+function quote(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
 var PolicyBuilder = class {
   _def;
   constructor(name) {
@@ -82,6 +85,41 @@ var PolicyBuilder = class {
     this._def.using = sqlExpr;
     return this;
   }
+  /**
+   * "Rows of THIS table whose owner the caller is a member of" — the membership
+   * pattern, written so it cannot recurse.
+   *
+   * THE TRAP IT EXISTS FOR. Written by hand, membership policies point at each
+   * other: `channels` is visible to members, so its policy reads
+   * `channel_members`; `channel_members` is visible to members, so its policy
+   * reads `channels`. Postgres refuses the pair at query time with `infinite
+   * recursion detected in policy for relation ...`, and the error names the
+   * relation but not the cycle. The way out is asymmetry — the MEMBERSHIP table
+   * is protected by `user_id = auth.uid()` and nothing else, and every other
+   * table subqueries INTO it. That shape was in the platform's own schema and
+   * written down nowhere; a customer recovered it by reading that schema.
+   *
+   * `(select auth.uid())` rather than a bare call: the scalar subquery is
+   * evaluated ONCE per statement instead of per row.
+   *
+   * @example
+   * // channels: visible to members. The membership table gets the simple one.
+   * policy("member_read").for("select").to("authenticated")
+   *   .memberOf("channel_members", "channel_id")
+   * // → id IN (SELECT "channel_id" FROM "channel_members"
+   * //          WHERE "user_id" = (select auth.uid()))
+   */
+  memberOf(membershipTable, foreignKey, options = {}) {
+    if (this._def.using !== null) {
+      throw new Error(
+        `policy(${this._def.name}).memberOf(): this policy already has a using() expression. Write one or the other \u2014 memberOf IS the using expression.`
+      );
+    }
+    const column = options.column ?? "id";
+    const userColumn = options.userColumn ?? "user_id";
+    this._def.using = `${quote(column)} IN (SELECT ${quote(foreignKey)} FROM ${quote(membershipTable)} WHERE ${quote(userColumn)} = (select auth.uid()))`;
+    return this;
+  }
   /** Set the `WITH CHECK (...)` write-validation expression (raw SQL). */
   withCheck(sqlExpr) {
     this._def.withCheck = sqlExpr;
@@ -289,6 +327,21 @@ var ColumnBuilder = class _ColumnBuilder {
     this._def.defaultNow = true;
     return new _ColumnBuilder(this._def.type, this._def);
   }
+  /**
+   * The DATABASE assigns this column's value — a trigger, a rule, an identity.
+   *
+   * The column becomes optional on INSERT (the author has nothing to send) while
+   * the DDL stays free of a DEFAULT this schema would not honour. It is NOT
+   * `default()`: that declares a value the schema promises to write.
+   *
+   * Naming: deliberately not `generated()`. Postgres has GENERATED columns and
+   * they are a different thing; borrowing the word would send a reader — or a
+   * model writing a schema — to the wrong feature.
+   */
+  dbAssigned() {
+    this._def.dbAssigned = true;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
   /** Add a foreign key reference. */
   /**
    * Declares that this column used to be called `previous`.
@@ -371,6 +424,28 @@ var ColumnBuilder = class _ColumnBuilder {
     this._def.unique = true;
     return new _ColumnBuilder(this._def.type, this._def);
   }
+  /**
+   * Declare how this column's value is projected in and out of the process.
+   *
+   * The DDL does not move: `numeric` stays `numeric`, and the driver still hands
+   * back what Postgres sent. What changes is the type the row surface exposes —
+   * it becomes `Target`:
+   *
+   *   amount: numeric().transform<number>({ fromDb: Number, toDb: String })
+   *
+   * `numeric` surfacing as `string` is CORRECT (a JS number cannot hold
+   * arbitrary precision), and that is exactly why this exists: application code
+   * that does arithmetic on the column otherwise rewrites the same
+   * `Number(row.amount)` / `String(x)` pair in every controller that touches it,
+   * and each rewrite is a place the two directions can drift apart.
+   *
+   * A transform is a PROJECTION, never a constraint: it lives only in this
+   * process, so it can neither validate nor migrate what is stored.
+   */
+  transform(fns) {
+    this._def.transform = fns;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
 };
 function uuid() {
   return new ColumnBuilder("uuid");
@@ -668,7 +743,20 @@ var TxPlanBuilder = class {
         }
         return this.push({ op: "insert", table: name, values: encoded }, `${name}.insert()`);
       },
-      insertMany: (rows) => {
+      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, opts) => {
         if (rows.length === 0) {
           return new TxRowsImpl(this, SKIPPED_OP, `${name}.insertMany()`);
         }
@@ -679,7 +767,23 @@ var TxPlanBuilder = class {
         }
         const encoded = rows.map((row) => encodeMap(row, false));
         assertUniformRows(encoded, name);
-        return this.push({ op: "insertMany", table: name, rows: encoded }, `${name}.insertMany()`);
+        if (opts !== void 0 && opts.onConflict.length === 0) {
+          throw new TxPlanError(
+            `${name}.insertMany() was given a conflict action with no onConflict columns. Postgres matches a collision on columns, so name them.`
+          );
+        }
+        return this.push(
+          {
+            op: "insertMany",
+            table: name,
+            rows: encoded,
+            // Omitted entirely when no options were given, so the op a plain
+            // insertMany produces is byte-identical to the one it produced
+            // before this option existed.
+            ...opts !== void 0 ? { onConflict: opts.onConflict, action: opts.action ?? "ignore" } : {}
+          },
+          `${name}.insertMany()`
+        );
       },
       updateWhere: (where, set) => {
         const encodedWhere = encodeMap(where, false);
@@ -841,10 +945,18 @@ function translateRejection(err, builder) {
 function makeTypedTable(name, raw2) {
   return {
     insert: (data) => raw2.insert(name, data),
+    upsert: (data, opts) => raw2.upsert(name, data, opts),
     update: (id, data) => raw2.update(name, id, data),
     delete: (id) => raw2.delete(name, id),
     findById: (id) => raw2.findById(name, id),
-    findMany: (query) => raw2.findMany(name, query)
+    findMany: (query, opts) => raw2.findMany(name, query, opts),
+    updateMany: (where, set) => raw2.updateMany(
+      name,
+      where,
+      set
+    ),
+    deleteMany: (where) => raw2.deleteMany(name, where),
+    count: (where) => raw2.count(name, where)
   };
 }
 function makeTypedDB(schema, raw2) {