@palbase/backend 38.0.15 → 39.0.0

package/dist/{chunk-7WAGQ3VR.js → chunk-AR2I4M7I.js}

@@ -4,17 +4,312 @@ import {
   qualifiedTableKey,
   retryBudget,
   runTxPlan
-} from "./chunk-LFUNRWUE.js";
+} from "./chunk-4J6I4KVQ.js";
 import {
   isRetryable
-} from "./chunk-CS6NQ6PO.js";
+} from "./chunk-JPTFYHP3.js";
 import {
   __name
 } from "./chunk-VXPNPVAG.js";
 
+// 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
 import { z } from "zod";
 
+// 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 {
@@ -29,6 +324,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) => {
@@ -86,7 +390,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");
@@ -119,9 +423,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) {
@@ -175,7 +516,7 @@ function defineTable(name, input) {
   const handle = {
     ...owned
   };
-  Object.defineProperty(handle, TABLE_META, {
+  Object.defineProperty(handle, TABLE_META2, {
     value: def,
     enumerable: false
   });
@@ -184,6 +525,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;
@@ -228,7 +572,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`);
     }
@@ -272,6 +616,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/db/policy.ts
 var PolicyExprRef = class _PolicyExprRef {
@@ -385,15 +771,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")
   };
 }
@@ -481,13 +873,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. */
@@ -506,6 +898,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>))");
@@ -582,13 +1060,10 @@ function isPalbaseExtension(name) {
 __name(isPalbaseExtension, "isPalbaseExtension");
 
 // 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");
@@ -717,14 +1192,19 @@ function sqlFragment(strings, ...values) {
 __name(sqlFragment, "sqlFragment");
 
 export {
+  foreignKey,
+  freeze,
   PolicyExprRef,
   exprCtx,
   PolicyBuilder,
   policy,
+  check,
   can,
+  guard,
+  backfill,
   IndexBuilder,
   index,
-  TABLE_META,
+  TABLE_META2 as TABLE_META,
   defineTable,
   defineSchema,
   PALBASE_EXTENSIONS,
@@ -737,4 +1217,4 @@ export {
   withRetry,
   sqlFragment
 };
-//# sourceMappingURL=chunk-7WAGQ3VR.js.map
+//# sourceMappingURL=chunk-AR2I4M7I.js.map