@palbase/backend 38.0.16 → 39.1.0

package/dist/index.cjs

@@ -80,7 +80,7 @@ __export(src_exports, {
   Sse: () => Sse,
   SseOut: () => SseOut,
   Storage: () => Storage,
-  TABLE_META: () => TABLE_META,
+  TABLE_META: () => TABLE_META2,
   TooManyRequests: () => TooManyRequests,
   TraceId: () => TraceId,
   TxPlanError: () => TxPlanError,
@@ -103,11 +103,13 @@ __export(src_exports, {
   __setRuntime: () => __setRuntime,
   assertNoOrphanEntryPoints: () => assertNoOrphanEntryPoints,
   assertZeroArgConstructor: () => assertZeroArgConstructor,
+  backfill: () => backfill,
   bigint: () => bigint,
   boolean: () => boolean,
   buildContainer: () => buildContainer,
   buildModuleClients: () => buildModuleClients,
   can: () => can,
+  check: () => check,
   col: () => col,
   controllersOf: () => controllersOf,
   dec: () => dec,
@@ -116,10 +118,13 @@ __export(src_exports, {
   defineDefaultAuth: () => defineDefaultAuth,
   defineError: () => defineError,
   defineMiddleware: () => defineMiddleware,
+  defineRepository: () => defineRepository,
   defineSchema: () => defineSchema,
   defineTable: () => defineTable,
   enumType: () => enumType,
   exprCtx: () => exprCtx,
+  foreignKey: () => foreignKey,
+  freeze: () => freeze,
   getErrorRegistry: () => getErrorRegistry,
   getHookConfig: () => getHookConfig,
   getHookManifest: () => getHookManifest,
@@ -129,6 +134,7 @@ __export(src_exports, {
   getRoutes: () => getRoutes,
   getWebhookConfig: () => getWebhookConfig,
   getWebhookManifest: () => getWebhookManifest,
+  guard: () => guard,
   hooksOf: () => hooksOf,
   inc: () => inc,
   increment: () => increment,
@@ -962,8 +968,7 @@ function tableToJSON(table, schemaName) {
   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
+      up: r.up
     }));
   }
   if (table.checks !== void 0 && table.checks.length > 0) {
@@ -980,6 +985,7 @@ function tableToJSON(table, schemaName) {
           ...i.columns
         ] : []
       };
+      if (i.unique === true) ix.unique = true;
       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;
@@ -990,6 +996,70 @@ function tableToJSON(table, schemaName) {
       return ix;
     });
   }
+  if (table.dropConstraints !== void 0 && table.dropConstraints.length > 0) {
+    out.dropConstraints = [
+      ...table.dropConstraints
+    ];
+  }
+  if (table.foreignKeys !== void 0 && table.foreignKeys.length > 0) {
+    out.foreignKeys = table.foreignKeys.map((fk) => {
+      const j = {
+        name: fk.name,
+        columns: [
+          ...fk.columns
+        ],
+        refTable: fk.refTable,
+        refColumns: [
+          ...fk.refColumns
+        ]
+      };
+      if (fk.onUpdate !== void 0) j.onUpdate = fk.onUpdate;
+      if (fk.onDelete !== void 0) j.onDelete = fk.onDelete;
+      if (fk.match !== void 0) j.match = fk.match;
+      return j;
+    });
+  }
+  if (table.freeze !== void 0 && table.freeze.length > 0) {
+    out.freeze = table.freeze.map((f) => ({
+      name: f.name,
+      when: f.when,
+      columns: [
+        ...f.columns
+      ],
+      refTable: f.refTable,
+      refColumns: [
+        ...f.refColumns
+      ]
+    }));
+  }
+  if (table.guards !== void 0 && table.guards.length > 0) {
+    out.guards = table.guards.map((g) => ({
+      name: g.name,
+      event: g.event,
+      ...g.when !== void 0 ? {
+        when: g.when
+      } : {},
+      ...g.exists !== void 0 ? {
+        exists: g.exists
+      } : {},
+      message: g.message,
+      ...g.detail !== void 0 ? {
+        detail: g.detail
+      } : {},
+      ...g.hint !== void 0 ? {
+        hint: g.hint
+      } : {},
+      ...g.column !== void 0 ? {
+        column: g.column
+      } : {}
+    }));
+  }
+  if (table.backfills !== void 0 && table.backfills.length > 0) {
+    out.backfills = table.backfills.map((b) => ({
+      name: b.name,
+      sql: b.sql
+    }));
+  }
   if (table.appendOnly === true) out.appendOnly = true;
   if (table.search !== void 0) {
     const vectorColumn = Object.entries(columns).find(([, c]) => c.dimensions !== void 0)?.[0];
@@ -1244,6 +1314,7 @@ function makeTypedSurface(raw2) {
     $facets: /* @__PURE__ */ __name((table, params) => reco.facets(table, params), "$facets"),
     $claim: /* @__PURE__ */ __name((table, unique, extra) => reco.claim(table, unique, extra), "$claim"),
     $lockRows: /* @__PURE__ */ __name((table, ids) => reco.lockRows(table, ids), "$lockRows"),
+    $lockRowsWhere: /* @__PURE__ */ __name((table, where, opts) => reco.lockRowsWhere(table, where, opts), "$lockRowsWhere"),
     $advisoryXactLock: /* @__PURE__ */ __name((key) => reco.advisoryXactLock(key), "$advisoryXactLock"),
     $aggregate: /* @__PURE__ */ __name((table, q) => raw2.aggregate(table, q), "$aggregate"),
     $insertMany: /* @__PURE__ */ __name((table, rows, opts) => raw2.insertMany(table, rows, opts), "$insertMany"),
@@ -2576,6 +2647,192 @@ __name(buildModuleClients, "buildModuleClients");
 
 // src/db/policy.ts
 var import_zod = require("zod");
+
+// src/db/foreign-key.ts
+var TABLE_META = /* @__PURE__ */ Symbol.for("palbase.table.meta");
+var REF_TARGET = /* @__PURE__ */ Symbol.for("palbase.ref.target");
+var ForeignKeyBuilder = class {
+  static {
+    __name(this, "ForeignKeyBuilder");
+  }
+  _def;
+  constructor(name) {
+    if (name.trim() === "") {
+      throw new Error("foreignKey(ad): foreign key'in ad\u0131 bo\u015F olamaz \u2014 Palbase k\u0131s\u0131tlar\u0131 ADA g\xF6re uzla\u015Ft\u0131r\u0131r.");
+    }
+    this._def = {
+      name,
+      columns: [],
+      refTable: "",
+      refColumns: []
+    };
+  }
+  /** Yerel sütunlar. SIRA KORUNUR — hedef sütunlarla birebir eşleşir. */
+  on(...cols) {
+    this._def.columns = cols.map((c) => {
+      const e = c.expr;
+      if (e.kind !== "col") {
+        throw new Error(`foreignKey(${this._def.name}).on(): yaln\u0131z kolon referans\u0131 al\u0131r \u2014 ifade bir FK'n\u0131n par\xE7as\u0131 olamaz.`);
+      }
+      return e.name;
+    });
+    return this;
+  }
+  /**
+  * Hedef tablo ve sütunları. Sütun sayısı `.on()`'unkiyle eşit OLMALI ve bu
+  * burada, bildirim yazılırken kontrol edilir — bozuk bir FK wire'a hiç çıkmaz.
+  */
+  references(table, ...cols) {
+    if (cols.length === 0) {
+      throw new Error(`foreignKey(${this._def.name}).references(): en az bir hedef s\xFCtun gerekir.`);
+    }
+    this._def.refTable = table[TABLE_META].name;
+    this._def.refColumns = [
+      ...cols
+    ];
+    Object.defineProperty(this._def, REF_TARGET, {
+      value: table[TABLE_META],
+      enumerable: false,
+      configurable: true
+    });
+    return this;
+  }
+  onUpdate(action) {
+    this._def.onUpdate = action;
+    return this;
+  }
+  onDelete(action) {
+    this._def.onDelete = action;
+    return this;
+  }
+  /**
+  * `MATCH FULL`: referans veren sütunların HEPSİ NULL olmadıkça kısıt
+  * değerlendirilir. Varsayılan `MATCH SIMPLE`'da tek bir NULL kısıtı atlatır —
+  * `freeze` bunu bilerek kullanır, sıradan bir FK'da genelde istenmez.
+  */
+  match(m) {
+    this._def.match = m;
+    return this;
+  }
+};
+function foreignKey(name) {
+  return new ForeignKeyBuilder(name);
+}
+__name(foreignKey, "foreignKey");
+function toForeignKeyDef(b) {
+  const def = b instanceof ForeignKeyBuilder ? b._def : b;
+  if (def.columns.length === 0) {
+    throw new Error(`foreignKey(${def.name}): en az bir yerel s\xFCtun gerekir \u2014 .on(...) \xE7a\u011F\u0131r\u0131n.`);
+  }
+  if (def.refColumns.length === 0 || def.refTable === "") {
+    throw new Error(`foreignKey(${def.name}): hedef tablo ve s\xFCtunlar gerekir \u2014 .references(...) \xE7a\u011F\u0131r\u0131n.`);
+  }
+  if (def.columns.length !== def.refColumns.length) {
+    throw new Error(`foreignKey(${def.name}): ${def.columns.length} yerel s\xFCtun (${def.columns.join(", ")}) ama ${def.refColumns.length} hedef s\xFCtun (${def.refColumns.join(", ")}) \u2014 iki liste e\u015Fit uzunlukta olmal\u0131.`);
+  }
+  return def;
+}
+__name(toForeignKeyDef, "toForeignKeyDef");
+var FreezeBuilder = class {
+  static {
+    __name(this, "FreezeBuilder");
+  }
+  _def;
+  constructor(name) {
+    if (name.trim() === "") {
+      throw new Error("freeze(ad): freeze k\u0131s\u0131t\u0131n\u0131n ad\u0131 bo\u015F olamaz \u2014 Palbase k\u0131s\u0131tlar\u0131 ADA g\xF6re uzla\u015Ft\u0131r\u0131r.");
+    }
+    this._def = {
+      name,
+      columns: [],
+      refTable: "",
+      refColumns: []
+    };
+  }
+  /**
+  * DONMA KOŞULU — çocuk satırının kendi kolonları üzerinde bir yüklem.
+  *
+  * Generated sütunlara `CASE WHEN <koşul> THEN <sütun> END` olarak iner; yani
+  * koşul yanlışken sütunlar NULL olur ve FK o satır için hiç değerlendirilmez.
+  */
+  when(pred) {
+    this._def.when = pred.expr;
+    return this;
+  }
+  /** Çocuğun DONAN sütunları. SIRA KORUNUR — hedef sütunlarla birebir eşleşir. */
+  columns(...cols) {
+    if (cols.length === 0) {
+      throw new Error(`freeze(${this._def.name}).columns(): en az bir donan s\xFCtun gerekir \u2014 hi\xE7birini vermeyen bir freeze hi\xE7bir \u015Feyi dondurmaz.`);
+    }
+    this._def.columns = [
+      ...cols
+    ];
+    return this;
+  }
+  /**
+  * Ebeveyn tablo ve donan demetin ORADAKİ karşılığı. Zincirin SON halkası:
+  * bildirim burada tamamlanır ve tutarlılığı burada doğrulanır, yani
+  * `.references()`'ı unutmuş bir freeze `FreezeDef` üretmediği için tabloya
+  * hiç giremez.
+  */
+  references(table, ...cols) {
+    if (cols.length === 0) {
+      throw new Error(`freeze(${this._def.name}).references(): en az bir hedef s\xFCtun gerekir.`);
+    }
+    this._def.refTable = table[TABLE_META].name;
+    this._def.refColumns = [
+      ...cols
+    ];
+    Object.defineProperty(this._def, REF_TARGET, {
+      value: table[TABLE_META],
+      enumerable: false,
+      configurable: true
+    });
+    return toFreezeDef(this);
+  }
+};
+function freeze(name) {
+  return new FreezeBuilder(name);
+}
+__name(freeze, "freeze");
+function toFreezeDef(b) {
+  const def = b instanceof FreezeBuilder ? b._def : b;
+  if (def.columns.length === 0) {
+    throw new Error(`freeze(${def.name}): en az bir donan s\xFCtun gerekir \u2014 .columns(...) \xE7a\u011F\u0131r\u0131n.`);
+  }
+  if (def.refColumns.length === 0 || def.refTable === "") {
+    throw new Error(`freeze(${def.name}): hedef tablo ve s\xFCtunlar gerekir \u2014 .references(...) \xE7a\u011F\u0131r\u0131n.`);
+  }
+  if (def.columns.length !== def.refColumns.length) {
+    throw new Error(`freeze(${def.name}): ${def.columns.length} donan s\xFCtun (${def.columns.join(", ")}) ama ${def.refColumns.length} hedef s\xFCtun (${def.refColumns.join(", ")}) \u2014 iki liste e\u015Fit uzunlukta olmal\u0131.`);
+  }
+  if (def.when === void 0) {
+    throw new Error(`freeze(${def.name}): donma ko\u015Fulu gerekir \u2014 .when(...) \xE7a\u011F\u0131r\u0131n. Ko\u015Fulsuz bir freeze s\u0131radan bir FK'd\u0131r; onun i\xE7in foreignKey(...) var.`);
+  }
+  const out = {
+    name: def.name,
+    when: def.when,
+    columns: [
+      ...def.columns
+    ],
+    refTable: def.refTable,
+    refColumns: [
+      ...def.refColumns
+    ]
+  };
+  const target = def[REF_TARGET];
+  if (target !== void 0) {
+    Object.defineProperty(out, REF_TARGET, {
+      value: target,
+      enumerable: false,
+      configurable: true
+    });
+  }
+  return out;
+}
+__name(toFreezeDef, "toFreezeDef");
+
+// src/db/policy.ts
 var PolicyExprRef = class _PolicyExprRef {
   static {
     __name(this, "PolicyExprRef");
@@ -2687,15 +2944,21 @@ function exprCtx(_columns, depth = 0, ownTable = "") {
       expr: part.expr
     }), "not"),
     existsIn: /* @__PURE__ */ __name((table, predicate) => {
-      const meta = table[TABLE_META];
+      const meta = table[TABLE_META2];
       const inner = exprCtx(Object.keys(meta.columns), depth + 1, ownTable);
-      return new PolicyExprRef({
+      const node = {
         kind: "exists",
         table: meta.name,
         alias: `pb_e${depth + 1}`,
         outer: ownTable,
         predicate: predicate(inner).expr
+      };
+      Object.defineProperty(node, REF_TARGET, {
+        value: meta,
+        enumerable: false,
+        configurable: true
       });
+      return new PolicyExprRef(node);
     }, "existsIn")
   };
 }
@@ -2783,13 +3046,13 @@ var PolicyBuilder = class {
   * // → id IN (SELECT "channel_id" FROM "channel_members"
   * //          WHERE "user_id" = (select auth.uid()))
   */
-  memberOf(membershipTable, foreignKey, options = {}) {
+  memberOf(membershipTable, foreignKey2, 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()))`;
+    this._def.using = `${quote(column)} IN (SELECT ${quote(foreignKey2)} FROM ${quote(membershipTable)} WHERE ${quote(userColumn)} = (select auth.uid()))`;
     return this;
   }
   /** `WITH CHECK (...)` yazma doğrulaması — `using` ile aynı iki biçim. */
@@ -2808,6 +3071,92 @@ function policy(name) {
   return new PolicyBuilder(name);
 }
 __name(policy, "policy");
+function assertCheckNode(node, name) {
+  switch (node.kind) {
+    case "exists":
+      throw new Error(`check(${name}): \`existsIn(...)\` is a subquery and PostgreSQL forbids subqueries in a CHECK constraint \u2014 express a cross-table rule as a composite FOREIGN KEY (foreignKeys), or as a guard.`);
+    case "authUid":
+      throw new Error(`check(${name}): \`auth.uid()\` renders as a subquery \`(SELECT auth.uid())\` and PostgreSQL forbids subqueries in a CHECK constraint \u2014 a caller-dependent rule belongs in an RLS policy, not a CHECK.`);
+    case "binop":
+      assertCheckNode(node.left, name);
+      assertCheckNode(node.right, name);
+      return;
+    case "and":
+    case "or":
+      for (const part of node.parts) assertCheckNode(part, name);
+      return;
+    case "not":
+    case "isNull":
+      assertCheckNode(node.expr, name);
+      return;
+    default:
+      return;
+  }
+}
+__name(assertCheckNode, "assertCheckNode");
+var CHECK_BIN_OPS = {
+  eq: "=",
+  neq: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+function literalSQL(v) {
+  if (v === null) return "NULL";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) {
+      throw new Error(`check(): ${v} bir SQL say\u0131 literali de\u011Fil.`);
+    }
+    return String(v);
+  }
+  return `'${v.replace(/'/g, "''")}'`;
+}
+__name(literalSQL, "literalSQL");
+function checkNodeSQL(node, name) {
+  switch (node.kind) {
+    case "col":
+      return quote(node.name);
+    case "lit":
+      return literalSQL(node.value);
+    case "binop": {
+      const op = CHECK_BIN_OPS[node.op];
+      if (op === void 0) {
+        throw new Error(`check(${name}): \`${node.op}\` bir CHECK ifadesinde desteklenmiyor.`);
+      }
+      return `(${checkNodeSQL(node.left, name)} ${op} ${checkNodeSQL(node.right, name)})`;
+    }
+    case "and":
+    case "or": {
+      if (node.parts.length === 0) {
+        return node.kind === "and" ? "(true)" : "(false)";
+      }
+      const joiner = node.kind === "and" ? " AND " : " OR ";
+      return `(${node.parts.map((p) => checkNodeSQL(p, name)).join(joiner)})`;
+    }
+    case "not":
+      return `(NOT ${checkNodeSQL(node.expr, name)})`;
+    case "isNull":
+      return `(${checkNodeSQL(node.expr, name)} IS ${node.negated ? "NOT NULL" : "NULL"})`;
+    default: {
+      const kind = node.kind;
+      throw new Error(`check(${name}): \`${kind}\` d\xFC\u011F\xFCm\xFC bir CHECK ifadesinde tan\u0131nm\u0131yor.`);
+    }
+  }
+}
+__name(checkNodeSQL, "checkNodeSQL");
+function check(name, expr) {
+  if (name.trim() === "") {
+    throw new Error("check(): k\u0131s\u0131t\u0131n ad\u0131 bo\u015F olamaz \u2014 CHECK'ler ADA g\xF6re uzla\u015Ft\u0131r\u0131l\u0131yor.");
+  }
+  assertCheckNode(expr.expr, name);
+  return {
+    name,
+    expr: checkNodeSQL(expr.expr, name)
+  };
+}
+__name(check, "check");
 function can(table) {
   if (table === void 0 || table === null) {
     throw new Error("can(<table>): received " + String(table) + " \u2014 the schema declares no such table (check the name against db/*.ts; can(publicSchema.tables.<name>))");
@@ -2851,6 +3200,117 @@ function reservedCanRelation(tableName, columns) {
 }
 __name(reservedCanRelation, "reservedCanRelation");
 
+// src/db/guard.ts
+var GuardBuilder = class {
+  static {
+    __name(this, "GuardBuilder");
+  }
+  _def;
+  constructor(name) {
+    if (name.trim() === "") {
+      throw new Error("guard(ad): guard'\u0131n ad\u0131 bo\u015F olamaz \u2014 Postgres ayn\u0131 olaydaki trigger'lar\u0131 ADA G\xD6RE alfabetik ko\u015Fuyor ve ba\u015Fka s\u0131ra tutamac\u0131 yok.");
+    }
+    this._def = {
+      name
+    };
+  }
+  /** Hangi yazma fiilinde bakılacak. */
+  on(event) {
+    this._def.event = event;
+    return this;
+  }
+  /**
+  * Satırın KENDİ kolonları üzerinde koşul — trigger'ın `WHEN` yan tümcesi.
+  *
+  * Emitter karşılaştırmaları `IS DISTINCT FROM` ile yazar (`<>` NULL'da yanlış
+  * cevap verir) ve geçen sütunlardan bir `UPDATE OF (…)` listesi türetir
+  * (FR-018).
+  */
+  when(pred) {
+    this._def.when = pred.expr;
+    return this;
+  }
+  /**
+  * ÇAPRAZ SATIR koşulu — gövdedeki `EXISTS` bloğuna iner, `WHEN`'e DEĞİL:
+  * Postgres trigger `WHEN`'inde alt sorgu kabul etmiyor (FR-019).
+  *
+  * Yüklem içinde takma adsız kalan kolon guard'ın KENDİ satırıdır (`NEW`/`OLD`);
+  * `r.col(...)` hedef tablonun kolonlarını verir ve ayrı nitelenir. Bu yüzden
+  * düğümün `outer` alanı BOŞ kalır: bir guard'ın "dış satır"ı bir tablo takma
+  * adı değildir.
+  */
+  exists(table, predicate) {
+    this._def.exists = exprCtx().existsIn(table, predicate).expr;
+    return this;
+  }
+  /**
+  * REDDİN KENDİSİ ve zincirin son halkası: mesaj olmadan bir guard tamamlanmaz.
+  *
+  * `detail`/`hint` Postgres'in aynı adlı alanlarına, `column` ise `COLUMN`
+  * alanına gider — istemci hangi alanın reddedildiğini mesajı parse etmeden
+  * okur.
+  */
+  refuse(message, opts) {
+    this._def.message = message;
+    if (opts?.detail !== void 0) this._def.detail = opts.detail;
+    if (opts?.hint !== void 0) this._def.hint = opts.hint;
+    if (opts?.column !== void 0) this._def.column = opts.column;
+    return toGuardDef(this);
+  }
+};
+function guard(name) {
+  return new GuardBuilder(name);
+}
+__name(guard, "guard");
+function toGuardDef(b) {
+  const def = b instanceof GuardBuilder ? b._def : b;
+  if (def.event === void 0) {
+    throw new Error(`guard(${def.name}): hangi olayda bakaca\u011F\u0131 gerekir \u2014 .on("insert"|"update"|"delete") \xE7a\u011F\u0131r\u0131n.`);
+  }
+  if (def.when === void 0 && def.exists === void 0) {
+    throw new Error(`guard(${def.name}): bir ko\u015Ful gerekir \u2014 .when(...) ya da .exists(...) \xE7a\u011F\u0131r\u0131n. Ko\u015Fulsuz bir guard o olaydaki HER yazmay\u0131 reddeder.`);
+  }
+  if (def.message === void 0 || def.message.trim() === "") {
+    throw new Error(`guard(${def.name}): bo\u015F mesaj kabul edilmez \u2014 reddin mesaj\u0131 guard'\u0131n kullan\u0131c\u0131ya ula\u015Fan TEK \xE7\u0131kt\u0131s\u0131.`);
+  }
+  return {
+    name: def.name,
+    event: def.event,
+    ...def.when !== void 0 ? {
+      when: def.when
+    } : {},
+    ...def.exists !== void 0 ? {
+      exists: def.exists
+    } : {},
+    message: def.message,
+    ...def.detail !== void 0 ? {
+      detail: def.detail
+    } : {},
+    ...def.hint !== void 0 ? {
+      hint: def.hint
+    } : {},
+    ...def.column !== void 0 ? {
+      column: def.column
+    } : {}
+  };
+}
+__name(toGuardDef, "toGuardDef");
+
+// src/db/backfill.ts
+function backfill(name, sql) {
+  if (name.trim() === "") {
+    throw new Error("backfill(ad, sql): backfill'in ad\u0131 bo\u015F olamaz \u2014 'bir kez ko\u015Ftu' kayd\u0131 ADA g\xF6re tutuluyor.");
+  }
+  if (sql.trim() === "") {
+    throw new Error(`backfill(${name}): SQL bo\u015F olamaz \u2014 bo\u015F bir g\xF6vde ad\u0131 kayda ge\xE7irip KALICI olarak yakar; sonradan yaz\u0131lan ger\xE7ek SQL "zaten ko\u015Ftu" diye hi\xE7 \xE7al\u0131\u015Fmaz.`);
+  }
+  return {
+    name,
+    sql
+  };
+}
+__name(backfill, "backfill");
+
 // src/db/schema.ts
 var IndexBuilder = class {
   static {
@@ -2865,6 +3325,15 @@ var IndexBuilder = class {
       name
     };
   }
+  /**
+  * `CREATE UNIQUE INDEX` (FR-007). `.where()` ile birlikte PARTIAL UNIQUE
+  * index verir (FR-007b) — "NULL'lar serbest, non-NULL'lar tekil" kalıbının
+  * tek bildirimsel yolu.
+  */
+  unique() {
+    this._def.unique = true;
+    return this;
+  }
   /** Index'in kolonları. SIRA KORUNUR — çok kolonlu bir index'in anlamı sırasıdır. */
   on(...cols) {
     this._def.columns = cols.map((c) => {
@@ -2922,7 +3391,7 @@ function toPolicyDef(p) {
   return p instanceof PolicyBuilder ? p._def : p;
 }
 __name(toPolicyDef, "toPolicyDef");
-var TABLE_META = /* @__PURE__ */ Symbol.for("palbase.table.meta");
+var TABLE_META2 = /* @__PURE__ */ Symbol.for("palbase.table.meta");
 function defineTable(name, input) {
   if (name.trim() === "") {
     throw new Error("defineTable(name, \u2026): name must not be empty");
@@ -2955,9 +3424,46 @@ function defineTable(name, input) {
   if (input.primaryKey !== void 0) def.primaryKey = input.primaryKey;
   if (input.unique !== void 0) def.unique = input.unique;
   if (input.raw !== void 0 && input.raw.length > 0) def.raw = input.raw.slice();
-  if (input.checks !== void 0 && input.checks.length > 0) def.checks = input.checks.slice();
+  const declaredChecks = typeof input.checks === "function" ? input.checks(exprCtx(Object.keys(input.columns), 0, name)) : input.checks?.slice() ?? [];
+  if (declaredChecks.length > 0) def.checks = declaredChecks;
   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;
+  const declaredFKs = (input.foreignKeys?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(toForeignKeyDef);
+  if (declaredFKs.length > 0) def.foreignKeys = declaredFKs;
+  const declaredFreezes = (input.freeze?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(toFreezeDef);
+  if (declaredFreezes.length > 0) def.freeze = declaredFreezes;
+  for (const fz of declaredFreezes) {
+    for (const c of fz.columns) {
+      if (!(c in input.columns)) {
+        throw new Error(`table "${name}": freeze("${fz.name}").columns("${c}") \u2014 no such column on this table. Declared columns: ${Object.keys(input.columns).join(", ")}`);
+      }
+    }
+  }
+  const declaredGuards = (input.guards?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(toGuardDef);
+  if (declaredGuards.length > 0) def.guards = declaredGuards;
+  for (const g of declaredGuards) {
+    if (g.column !== void 0 && !(g.column in input.columns)) {
+      throw new Error(`table "${name}": guard("${g.name}").refuse(\u2026, { column: "${g.column}" }) \u2014 no such column on this table. Declared columns: ${Object.keys(input.columns).join(", ")}`);
+    }
+  }
+  if (input.backfills !== void 0 && input.backfills.length > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const b of input.backfills) {
+      if (seen.has(b.name)) {
+        throw new Error(`table ${name}: backfill ad\u0131 iki kez bildirildi: ${b.name} \u2014 kay\u0131t ADA g\xF6re tutuluyor, ikincisi hi\xE7 ko\u015Fmazd\u0131.`);
+      }
+      seen.add(b.name);
+    }
+    def.backfills = input.backfills.map((b) => ({
+      name: b.name,
+      sql: b.sql
+    }));
+  }
+  if (input.dropConstraints !== void 0 && input.dropConstraints.length > 0) {
+    def.dropConstraints = [
+      ...input.dropConstraints
+    ];
+  }
   if (input.appendOnly === true) def.appendOnly = true;
   if (input.ignored === true) def.ignored = true;
   if (input.search !== void 0) {
@@ -3011,7 +3517,7 @@ function defineTable(name, input) {
   const handle = {
     ...owned2
   };
-  Object.defineProperty(handle, TABLE_META, {
+  Object.defineProperty(handle, TABLE_META2, {
     value: def,
     enumerable: false
   });
@@ -3020,6 +3526,9 @@ function defineTable(name, input) {
 __name(defineTable, "defineTable");
 var declaringSchemaOf = /* @__PURE__ */ new WeakMap();
 function resolveReferences(tables, schemaName) {
+  for (const table of Object.values(tables)) {
+    qualifyRefTargets(table, `table "${table.name}"`);
+  }
   for (const table of Object.values(tables)) {
     for (const [colName, builder] of Object.entries(table.columns)) {
       const def = builder._def;
@@ -3064,7 +3573,7 @@ function defineSchema(name, input) {
   }
   const tables = {};
   for (const handle of input.tables) {
-    const table = handle[TABLE_META];
+    const table = handle[TABLE_META2];
     if (tables[table.name] !== void 0) {
       throw new Error(`defineSchema("${name}"): two tables declare the name "${table.name}" \u2014 table names must be unique within a schema`);
     }
@@ -3108,6 +3617,48 @@ function defineSchema(name, input) {
   };
 }
 __name(defineSchema, "defineSchema");
+function qualifyRefTargets(table, where) {
+  const qualify = /* @__PURE__ */ __name((holder, what) => {
+    const target = holder[REF_TARGET];
+    if (target === void 0) return;
+    const targetSchema = declaringSchemaOf.get(target);
+    if (targetSchema === void 0) {
+      throw new Error(`${where}: ${what} points at table "${target.name}", which no defineSchema(...) has claimed yet \u2014 a cross-table reference cannot be written without its target's schema. Declare that table's schema first (one file per schema: db/public.ts, db/billing.ts \u2026, imported by this one).`);
+    }
+    const qualified = qualifiedTableKey(targetSchema, target.name);
+    if (holder.refTable !== void 0) holder.refTable = qualified;
+    if (holder.table !== void 0) holder.table = qualified;
+  }, "qualify");
+  for (const fk of table.foreignKeys ?? []) qualify(fk, `foreignKey("${fk.name}")`);
+  for (const fz of table.freeze ?? []) qualify(fz, `freeze("${fz.name}")`);
+  for (const g of table.guards ?? []) {
+    if (g.exists !== void 0) {
+      qualifyExistsNodes(g.exists, `guard("${g.name}").exists(...)`, where);
+    }
+  }
+}
+__name(qualifyRefTargets, "qualifyRefTargets");
+function qualifyExistsNodes(node, what, where) {
+  if (node === null || typeof node !== "object") return;
+  if (node.kind === "exists") {
+    const target = node[REF_TARGET];
+    if (target !== void 0) {
+      const targetSchema = declaringSchemaOf.get(target);
+      if (targetSchema === void 0) {
+        throw new Error(`${where}: ${what} points at table "${target.name}", which no defineSchema(...) has claimed yet \u2014 a guard body is parsed at RUN TIME under a pinned search_path, so an unqualified name never resolves.`);
+      }
+      node.table = qualifiedTableKey(targetSchema, target.name);
+    }
+  }
+  for (const v of Object.values(node)) {
+    if (Array.isArray(v)) {
+      for (const e of v) qualifyExistsNodes(e, what, where);
+    } else if (v !== null && typeof v === "object") {
+      qualifyExistsNodes(v, what, where);
+    }
+  }
+}
+__name(qualifyExistsNodes, "qualifyExistsNodes");
 
 // src/channels.ts
 var CHANNELS = /* @__PURE__ */ Symbol.for("palbase.backend.channels");
@@ -3584,13 +4135,10 @@ function installationRef(opts) {
 __name(installationRef, "installationRef");
 
 // src/db/raw.ts
-function raw(name, up, opts) {
+function raw(name, up) {
   return {
     name,
-    up,
-    ...opts?.down != null ? {
-      down: opts.down
-    } : {}
+    up
   };
 }
 __name(raw, "raw");
@@ -3791,7 +4339,7 @@ var DeadlockDetected = class extends Conflict {
     return typeof e === "object" && e !== null && e.name === "DeadlockDetected";
   }
   constructor(sqlstate = SQLSTATE.deadlockDetected, message, data) {
-    super(message ?? "deadlock: iki i\u015Flem birbirinin kilidini bekledi ve bu i\u015Flem iptal edildi \u2014 kilit s\u0131ras\u0131n\u0131 sabitlemek i\xE7in Database.$lockRows(tablo, id'ler) kullan\u0131n", "deadlock_detected", data);
+    super(message ?? "deadlock: iki i\u015Flem birbirinin kilidini bekledi ve bu i\u015Flem iptal edildi \u2014 kilit s\u0131ras\u0131n\u0131 sabitleyin: id'ler elinizdeyse Database.$lockRows(tablo, id'ler), elinizde bir filtre varsa Database.$lockRowsWhere(tablo, filtre) kullan\u0131n", "deadlock_detected", data);
     this.name = "DeadlockDetected";
     this.sqlstate = sqlstate;
   }
@@ -3905,6 +4453,64 @@ function sqlFragment(strings, ...values) {
 }
 __name(sqlFragment, "sqlFragment");
 
+// src/db/repository.ts
+function defineRepository(table, opts) {
+  const tenantColumn = opts.tenant;
+  const rowKey = opts.key ?? "id";
+  const scope = /* @__PURE__ */ __name((tenant) => ({
+    [tenantColumn]: tenant
+  }), "scope");
+  const scopeRow = /* @__PURE__ */ __name((tenant, id) => ({
+    [tenantColumn]: tenant,
+    [rowKey]: id
+  }), "scopeRow");
+  const scopedPayload = /* @__PURE__ */ __name((values, tenant) => ({
+    ...values,
+    [tenantColumn]: tenant
+  }), "scopedPayload");
+  let Repository = class Repository {
+    static {
+      __name(this, "Repository");
+    }
+    list(tenant) {
+      return table.findMany({
+        where: scope(tenant)
+      });
+    }
+    async find(tenant, id) {
+      const rows = await table.findMany({
+        where: scopeRow(tenant, id),
+        limit: 1
+      });
+      return rows[0] ?? null;
+    }
+    insert(tenant, values) {
+      return table.insert(scopedPayload(values, tenant));
+    }
+    async update(tenant, id, patch) {
+      const row = await this.updateScoped(tenant, id, patch);
+      if (row === null) {
+        throw new NotFound(`${String(tenantColumn)}=${String(tenant)} kapsam\u0131nda ${rowKey}=${String(id)} bulunamad\u0131`);
+      }
+      return row;
+    }
+    async updateScoped(tenant, id, patch) {
+      const rows = await table.updateMany({
+        where: scopeRow(tenant, id),
+        set: patch
+      });
+      return rows[0] ?? null;
+    }
+    async delete(tenant, id) {
+      await table.deleteMany({
+        where: scopeRow(tenant, id)
+      });
+    }
+  };
+  return Repository;
+}
+__name(defineRepository, "defineRepository");
+
 // src/refusals.ts
 var DECLARATION_REFUSAL = /* @__PURE__ */ Symbol.for("palbase.backend.declarationRefusal");
 var DeclarationRefused = class extends Error {
@@ -5761,11 +6367,13 @@ var import_zod3 = require("zod");
   __setRuntime,
   assertNoOrphanEntryPoints,
   assertZeroArgConstructor,
+  backfill,
   bigint,
   boolean,
   buildContainer,
   buildModuleClients,
   can,
+  check,
   col,
   controllersOf,
   dec,
@@ -5774,10 +6382,13 @@ var import_zod3 = require("zod");
   defineDefaultAuth,
   defineError,
   defineMiddleware,
+  defineRepository,
   defineSchema,
   defineTable,
   enumType,
   exprCtx,
+  foreignKey,
+  freeze,
   getErrorRegistry,
   getHookConfig,
   getHookManifest,
@@ -5787,6 +6398,7 @@ var import_zod3 = require("zod");
   getRoutes,
   getWebhookConfig,
   getWebhookManifest,
+  guard,
   hooksOf,
   inc,
   increment,