@palbase/backend 25.1.0 → 27.1.0

package/dist/chunk-XABHGMUT.js

@@ -0,0 +1,885 @@
+import {
+  qualifiedTableKey
+} from "./chunk-OZKSM3JW.js";
+import {
+  __name
+} from "./chunk-VXPNPVAG.js";
+
+// src/db/schema.ts
+var IndexBuilder = class {
+  static {
+    __name(this, "IndexBuilder");
+  }
+  _def;
+  constructor(name) {
+    if (name.trim() === "") {
+      throw new Error("index(ad): index'in ad\u0131 bo\u015F olamaz \u2014 Palbase index'leri ADA g\xF6re uzla\u015Ft\u0131r\u0131r.");
+    }
+    this._def = {
+      name
+    };
+  }
+  /** Index'in kolonları. SIRA KORUNUR — çok kolonlu bir index'in anlamı sırasıdır. */
+  on(...cols) {
+    this._def.columns = cols.map((c) => {
+      const e = c.expr;
+      if (e.kind !== "col") {
+        throw new Error(`index(${this._def.name}).on(): yaln\u0131z kolon referans\u0131 al\u0131r \u2014 ifade i\xE7in onExpression("\u2026") kullan\u0131n.`);
+      }
+      return e.name;
+    });
+    return this;
+  }
+  /**
+  * İfade index'i (`lower(email)`), kolon yerine.
+  *
+  * Metin VERBATIM emit ediliyor — `policy().using("…")` ile aynı güven duruşu.
+  * Tipli yapı bunu ifade edemiyor ve kaçış kapağını kapatmak, yazarı elle
+  * migration yazmaya iterdi.
+  */
+  onExpression(expr) {
+    this._def.expression = expr;
+    return this;
+  }
+  /** Partial index koşulu — politika ifade dilinin ta kendisi. */
+  where(expr) {
+    this._def.where = expr.expr;
+    return this;
+  }
+  /** Sıra. Tek yönlü index'te sıra genelde önemsizdir; ORDER BY ile eşleşen
+  * bir index arandığında değildir. */
+  desc() {
+    this._def.sort = "desc";
+    return this;
+  }
+  asc() {
+    this._def.sort = "asc";
+    return this;
+  }
+  /** NULL'ların yeri — `ORDER BY … NULLS LAST` ile eşleşmesi için. */
+  nulls(where) {
+    this._def.nulls = where;
+    return this;
+  }
+  /** Covering index (`INCLUDE`): index-only scan için taşınan ama
+  * ARANMAYAN kolonlar. */
+  include(cols) {
+    this._def.include = cols;
+    return this;
+  }
+};
+function index(name) {
+  return new IndexBuilder(name);
+}
+__name(index, "index");
+function toPolicyDef(p) {
+  return p instanceof PolicyBuilder ? p._def : p;
+}
+__name(toPolicyDef, "toPolicyDef");
+var TABLE_META = /* @__PURE__ */ Symbol.for("palbase.table.meta");
+function defineTable(name, input) {
+  if (name.trim() === "") {
+    throw new Error("defineTable(name, \u2026): name must not be empty");
+  }
+  const policies = (input.policies?.(exprCtx(Object.keys(input.columns), 0, name)) ?? []).map(toPolicyDef);
+  const rls = policies.length > 0 || input.rls !== false;
+  const owned = {};
+  for (const [colName, b] of Object.entries(input.columns)) {
+    const builder = b;
+    const clone = Object.create(Object.getPrototypeOf(builder));
+    Object.defineProperty(clone, "_def", {
+      value: {
+        ...builder._def
+      },
+      enumerable: true,
+      writable: true
+    });
+    owned[colName] = clone;
+  }
+  const def = {
+    name,
+    columns: owned,
+    rls,
+    policies
+  };
+  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 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.search !== void 0) {
+    const s = input.search;
+    if (s.from !== void 0) {
+      if (s.vector !== void 0) {
+        throw new Error(`table ${name}: search beyan\u0131nda tek bi\xE7im kullan\u0131n \u2014 'from' (yeni) ile 'vector' (eski) birlikte olamaz`);
+      }
+      if (s.from.length === 0) {
+        throw new Error(`table ${name}: search.from bo\u015F olamaz`);
+      }
+      if (s.model === void 0) {
+        throw new Error(`table ${name}: search.from model'siz anlams\u0131z \u2014 auto-embed i\xE7in model verin (BYO i\xE7in eski 'vector' bi\xE7imini kullan\u0131n)`);
+      }
+      if (Array.isArray(s.text) && s.text.length === 0) {
+        throw new Error(`table ${name}: search.text bo\u015F dizi olamaz \u2014 FTS istemiyorsan text: false yaz\u0131n`);
+      }
+    } else {
+      if (typeof s.text === "boolean") {
+        throw new Error(`table ${name}: text:${String(s.text)} yaln\u0131z yeni bi\xE7imde ('from' ile) ge\xE7erli`);
+      }
+      if (s.text === void 0 && s.vector === void 0) {
+        throw new Error(`table ${name}: search beyan\u0131 bo\u015F \u2014 en az bir kol (text ya da vector) verin, yoksa alan\u0131 hi\xE7 yazmay\u0131n`);
+      }
+      if (s.text !== void 0 && s.text.length === 0) {
+        throw new Error(`table ${name}: search.text bo\u015F olamaz \u2014 FTS kolu istemiyorsan alan\u0131 hi\xE7 yazma`);
+      }
+      const legs = s.vector === void 0 ? [] : Array.isArray(s.vector) ? s.vector : [
+        s.vector
+      ];
+      for (const leg of legs) {
+        if (leg.model !== void 0 && (leg.from === void 0 || leg.from.length === 0)) {
+          throw new Error(`table ${name}: search.vector.model beyan edildi ama 'from' yok \u2014 embed kayna\u011F\u0131 kolonlar zorunlu (C-2)`);
+        }
+        if (leg.model === void 0 && leg.from !== void 0) {
+          throw new Error(`table ${name}: search.vector.from model'siz anlams\u0131z \u2014 auto-embed i\xE7in model verin`);
+        }
+      }
+    }
+    def.search = s;
+  }
+  if (input.memory !== void 0) {
+    if (input.memory.from.length === 0) {
+      throw new Error(`table ${name}: memory.from bo\u015F olamaz`);
+    }
+    def.memory = input.memory;
+  }
+  for (const b of Object.values(owned)) {
+    b._def.ownerTable = def;
+  }
+  const handle = {
+    ...owned
+  };
+  Object.defineProperty(handle, TABLE_META, {
+    value: def,
+    enumerable: false
+  });
+  return handle;
+}
+__name(defineTable, "defineTable");
+var declaringSchemaOf = /* @__PURE__ */ new WeakMap();
+function resolveReferences(tables, schemaName) {
+  for (const table of Object.values(tables)) {
+    for (const [colName, builder] of Object.entries(table.columns)) {
+      const def = builder._def;
+      if (def.selfRefColumn !== void 0) {
+        if (!(def.selfRefColumn in table.columns)) {
+          throw new Error(`table "${table.name}" column "${colName}": selfReferences("${def.selfRefColumn}") \u2014 no such column on this table`);
+        }
+        def.references = {
+          table: qualifiedTableKey(schemaName, table.name),
+          column: def.selfRefColumn
+        };
+        continue;
+      }
+      if (def.referencesThunk === void 0) continue;
+      const target = def.referencesThunk();
+      const owner = target?._def?.ownerTable;
+      if (owner === void 0) {
+        throw new Error(`table "${table.name}" column "${colName}": references(() => \u2026) must point at a column of a table declared with defineTable(...)`);
+      }
+      const targetColumn = Object.entries(owner.columns).find(([, b]) => b._def === target._def)?.[0];
+      if (targetColumn === void 0) {
+        throw new Error(`table "${table.name}" column "${colName}": the referenced column was not found on table "${owner.name}"`);
+      }
+      const targetSchema = declaringSchemaOf.get(owner);
+      if (targetSchema === void 0) {
+        throw new Error(`table "${table.name}" column "${colName}": references(() => \u2026) points at table "${owner.name}", which no defineSchema(...) has claimed yet \u2014 a foreign key 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).`);
+      }
+      def.references = {
+        table: qualifiedTableKey(targetSchema, owner.name),
+        column: targetColumn
+      };
+    }
+  }
+}
+__name(resolveReferences, "resolveReferences");
+function defineSchema(name, input) {
+  if (typeof name !== "string") {
+    throw new Error(`defineSchema(...) takes the schema NAME first: defineSchema("public", { tables: [todos, lists] }). The one-argument form defineSchema({ tables: { \u2026 } }) is gone \u2014 a schema that does not say its own name cannot be told apart from another schema's table of the same name, which is what a cross-schema foreign key has to do. Migrate db/public.ts (one file per schema: db/public.ts, db/billing.ts \u2026): name the schema, and lift each table key onto the table itself with defineTable("todos", { columns: { \u2026 } }), then list the tables in the array.`);
+  }
+  if (name.trim() === "") {
+    throw new Error("defineSchema(name, \u2026): name must not be empty");
+  }
+  const tables = {};
+  for (const handle of input.tables) {
+    const table = handle[TABLE_META];
+    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`);
+    }
+    tables[table.name] = table;
+    declaringSchemaOf.set(table, name);
+  }
+  resolveReferences(tables, name);
+  for (const [name2, def] of Object.entries(tables)) {
+    const m = def.memory;
+    if (m === void 0) continue;
+    const target = Object.values(tables).find((t) => t.name === m.into);
+    if (target === void 0) {
+      throw new Error(`table ${name2}: memory.into "${m.into}" \u015Femada declared de\u011Fil`);
+    }
+    const subject = m.subject ?? "owner";
+    if (!(subject in def.columns)) {
+      throw new Error(`table ${name2}: memory.subject "${subject}" kolonu kaynak tabloda yok`);
+    }
+    if (!(subject in target.columns)) {
+      throw new Error(`table ${name2}: memory.subject "${subject}" kolonu hedef "${m.into}" tablosunda yok`);
+    }
+    const factCol = target.columns["fact"];
+    const factDef = factCol !== void 0 && "_def" in factCol ? factCol._def : factCol;
+    if (factDef === void 0 || factDef.type !== "text") {
+      throw new Error(`table ${name2}: memory.into "${m.into}" tablosunda "fact" (text) kolonu zorunlu`);
+    }
+    for (const c of m.from) {
+      if (!(c in def.columns)) {
+        throw new Error(`table ${name2}: memory.from kolonu "${c}" kaynak tabloda yok`);
+      }
+    }
+  }
+  const extensions = [
+    ...new Set(input.extensions ?? [])
+  ];
+  return {
+    name,
+    tables,
+    extensions,
+    exposed: input.exposed ?? name === "public"
+  };
+}
+__name(defineSchema, "defineSchema");
+
+// src/db/policy.ts
+var PolicyExprRef = class _PolicyExprRef {
+  static {
+    __name(this, "PolicyExprRef");
+  }
+  expr;
+  constructor(expr) {
+    this.expr = expr;
+  }
+  bin(op, other) {
+    return new _PolicyExprRef({
+      kind: "binop",
+      op,
+      left: this.expr,
+      right: toExpr(other)
+    });
+  }
+  eq(other) {
+    return this.bin("eq", other);
+  }
+  neq(other) {
+    return this.bin("neq", other);
+  }
+  gt(other) {
+    return this.bin("gt", other);
+  }
+  gte(other) {
+    return this.bin("gte", other);
+  }
+  lt(other) {
+    return this.bin("lt", other);
+  }
+  lte(other) {
+    return this.bin("lte", other);
+  }
+  /**
+  * `IS NULL` / `IS NOT NULL` — `= NULL` SQL'de her zaman UNKNOWN'dır, o yüzden
+  * niyet ayrı bir düğümle yazılır. Partial index'in en sık koşulu
+  * (`WHERE deleted_at IS NULL`) tam olarak bu.
+  */
+  isNull(negated = false) {
+    return new _PolicyExprRef({
+      kind: "isNull",
+      expr: this.expr,
+      negated
+    });
+  }
+  and(...others) {
+    return new _PolicyExprRef({
+      kind: "and",
+      parts: [
+        this.expr,
+        ...others.map((o) => o.expr)
+      ]
+    });
+  }
+  or(...others) {
+    return new _PolicyExprRef({
+      kind: "or",
+      parts: [
+        this.expr,
+        ...others.map((o) => o.expr)
+      ]
+    });
+  }
+  not() {
+    return new _PolicyExprRef({
+      kind: "not",
+      expr: this.expr
+    });
+  }
+};
+function toExpr(v) {
+  return v instanceof PolicyExprRef ? v.expr : {
+    kind: "lit",
+    value: v
+  };
+}
+__name(toExpr, "toExpr");
+function exprCtx(_columns, depth = 0, ownTable = "") {
+  const alias = `pb_e${depth}`;
+  return {
+    col: /* @__PURE__ */ __name((name) => new PolicyExprRef(depth === 0 ? {
+      kind: "col",
+      name
+    } : {
+      kind: "col",
+      name,
+      alias
+    }), "col"),
+    auth: {
+      uid: /* @__PURE__ */ __name(() => new PolicyExprRef({
+        kind: "authUid"
+      }), "uid")
+    },
+    lit: /* @__PURE__ */ __name((v) => new PolicyExprRef({
+      kind: "lit",
+      value: v
+    }), "lit"),
+    and: /* @__PURE__ */ __name((...parts) => new PolicyExprRef({
+      kind: "and",
+      parts: parts.map((p) => p.expr)
+    }), "and"),
+    or: /* @__PURE__ */ __name((...parts) => new PolicyExprRef({
+      kind: "or",
+      parts: parts.map((p) => p.expr)
+    }), "or"),
+    not: /* @__PURE__ */ __name((part) => new PolicyExprRef({
+      kind: "not",
+      expr: part.expr
+    }), "not"),
+    existsIn: /* @__PURE__ */ __name((table, predicate) => {
+      const meta = table[TABLE_META];
+      const inner = exprCtx(Object.keys(meta.columns), depth + 1, ownTable);
+      return new PolicyExprRef({
+        kind: "exists",
+        table: meta.name,
+        alias: `pb_e${depth + 1}`,
+        outer: ownTable,
+        predicate: predicate(inner).expr
+      });
+    }, "existsIn")
+  };
+}
+__name(exprCtx, "exprCtx");
+function quote(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+__name(quote, "quote");
+var PolicyBuilder = class {
+  static {
+    __name(this, "PolicyBuilder");
+  }
+  _def;
+  constructor(name) {
+    this._def = {
+      name,
+      command: "all",
+      roles: [
+        "authenticated"
+      ],
+      using: null,
+      withCheck: null,
+      permissive: true
+    };
+  }
+  /** Restrict the policy to a single SQL command (default `"all"`). */
+  for(command) {
+    this._def.command = command;
+    return this;
+  }
+  /**
+  * Set the DB roles the policy applies to (the `TO` clause), replacing any
+  * previously-set roles. Call with no arguments to target PUBLIC (all roles).
+  *
+  * @example
+  * policy("p").to("authenticated")
+  * policy("p").to("authenticated", "service_role")
+  * policy("p").to() // PUBLIC
+  */
+  to(...roles) {
+    this._def.roles = roles;
+    return this;
+  }
+  /**
+  * `USING (...)` satır görünürlüğü ifadesi.
+  *
+  * Tercih edilen biçim YAPI'dır (FR-022) — `policies` callback'inin verdiği
+  * bağlamla kurulur ve kolon adları derlemede doğrulanır:
+  *
+  * ```ts
+  * policies: (p) => [
+  *   policy("owner_read").for("select").using(p.col("owner").eq(p.auth.uid())),
+  * ]
+  * ```
+  *
+  * Ham string KAÇIŞ KAPAĞI olarak kalır (FR-028): yapının ifade edemediği bir
+  * şey gerektiğinde yol kapanmaz. Ama o yolda kolon adı doğrulaması yoktur ve
+  * hata deploy anında Postgres'ten gelir.
+  */
+  using(expr) {
+    this._def.using = expr instanceof PolicyExprRef ? expr.expr : expr;
+    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;
+  }
+  /** `WITH CHECK (...)` yazma doğrulaması — `using` ile aynı iki biçim. */
+  withCheck(expr) {
+    this._def.withCheck = expr instanceof PolicyExprRef ? expr.expr : expr;
+    return this;
+  }
+  /** Set the policy mode: `"permissive"` (default, OR-combined) or
+  * `"restrictive"` (AND-combined). */
+  as(mode) {
+    this._def.permissive = mode === "permissive";
+    return this;
+  }
+};
+function policy(name) {
+  return new PolicyBuilder(name);
+}
+__name(policy, "policy");
+
+// src/db/extensions.ts
+var PALBASE_EXTENSIONS = [
+  // Search & text
+  "vector",
+  // NB: the Postgres extension is named "vector", not "pgvector" — declare "vector".
+  "pg_trgm",
+  "unaccent",
+  "citext",
+  // Geospatial / location
+  "cube",
+  "earthdistance",
+  // Data types & structures
+  "hstore",
+  "ltree",
+  // Indexing & constraints
+  "btree_gist",
+  // constraints that mix "=" with a range/&& overlap (e.g. no-double-booking).
+  // Scheduling
+  // Crypto / ids (also installed by default; listable for explicitness)
+  "pgcrypto",
+  "uuid-ossp"
+];
+var EXTENSION_DEPENDENCIES = {
+  earthdistance: [
+    "cube"
+  ]
+};
+function isPalbaseExtension(name) {
+  return PALBASE_EXTENSIONS.includes(name);
+}
+__name(isPalbaseExtension, "isPalbaseExtension");
+
+// src/db/columns.ts
+function refuseOnVector(def, modifier) {
+  if (def.type === "vector") {
+    throw new Error(`vector column: .${modifier}() is not supported (FR-002 \u2014 allowed: nullable()/notNull())`);
+  }
+}
+__name(refuseOnVector, "refuseOnVector");
+var ColumnBuilder = class _ColumnBuilder {
+  static {
+    __name(this, "ColumnBuilder");
+  }
+  _def;
+  constructor(type, existingDef) {
+    this._def = existingDef ?? {
+      type,
+      nullable: false,
+      primaryKey: false
+    };
+  }
+  /** Mark this column as the primary key. */
+  primaryKey() {
+    refuseOnVector(this._def, "primaryKey");
+    this._def.primaryKey = true;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** Mark this column as NOT NULL (default). */
+  notNull() {
+    this._def.nullable = false;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** Allow NULL values. */
+  nullable() {
+    this._def.nullable = true;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** Set a default value. */
+  default(value) {
+    refuseOnVector(this._def, "default");
+    this._def.defaultValue = value;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** UUID: generate a random default (gen_random_uuid()). */
+  defaultRandom() {
+    refuseOnVector(this._def, "defaultRandom");
+    this._def.defaultRandom = true;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** Timestamp: default to now(). */
+  defaultNow() {
+    refuseOnVector(this._def, "defaultNow");
+    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`.
+  *
+  * A schema diff sees one name gone and another present; it cannot know whether
+  * you renamed a column or dropped one and added another, and the two are very
+  * different — the second loses every value. Saying so here turns the plan into
+  * `ALTER TABLE … RENAME COLUMN` instead.
+  *
+  * Once the rename has been applied the annotation is inert (the old name is no
+  * longer there to rename), so it can be deleted at your leisure.
+  */
+  renamedFrom(previous) {
+    this._def.renamedFrom = previous;
+    return this;
+  }
+  /**
+  * See {@link ColumnDef.ignored}.
+  *
+  * COPIES the def rather than mutating it. The constructor takes an existing
+  * def BY REFERENCE, so every builder derived from another shares one object —
+  * `const a = slug.unique()` leaves `a._def === slug._def`. An in-place
+  * `ignored = true` therefore marks every column sharing that def, including
+  * one another table actively reads, and the gate would let THAT column be
+  * dropped. Measured before this copy existed.
+  *
+  * The aliasing is older than this method and other fields leak through it too.
+  * The reason this one cannot wait: every other leak produces a VISIBLE schema
+  * difference — the plan shows it, the DDL shows it. This one is invisible by
+  * design (no DDL, no diff, no plan line), so its only effect is to disarm a
+  * safety gate in silence.
+  */
+  ignored() {
+    return new _ColumnBuilder(this._def.type, {
+      ...this._def,
+      ignored: true
+    });
+  }
+  /**
+  * Foreign key onto another table's column.
+  *
+  * The target is a THUNK, not a direct reference. In a cycle (`x → y`, `y → x`)
+  * the second table does not exist yet when the first is built; a direct
+  * reference makes TypeScript chase its own tail (TS7022 — measured, and making
+  * the return type independent of the target does NOT help). The thunk is
+  * invoked in `defineSchema`, where every binding exists and every table
+  * already knows its name.
+  *
+  * In a cycle, ONE side needs an explicit return type:
+  * `references((): AnyColumn => y.id)`. One side is enough — measured.
+  * For a self-reference use `selfReferences(column)`: no thunk, no annotation.
+  *
+  * `as` names the FORWARD relation (`author_id` → `author` by default);
+  * `reverseAs` names the REVERSE one on the parent, whose default is this
+  * table's own name (`users.posts`). Two foreign keys from one table onto one
+  * parent therefore need a `reverseAs` on at least one of them — the reverse
+  * names would otherwise both be this table's name.
+  */
+  references(target, opts) {
+    refuseOnVector(this._def, "references");
+    if (typeof target !== "function") {
+      throw new Error(`references(...) takes a callback: write references(() => otherTable.column). The two-string form references("table", "column") is gone \u2014 a string cannot be type-checked and cannot point at a table that does not exist yet.`);
+    }
+    this._def.referencesThunk = target;
+    if (opts?.as !== void 0) this._def.refAs = opts.as;
+    if (opts?.reverseAs !== void 0) this._def.reverseAs = opts.reverseAs;
+    if (opts?.onDelete !== void 0) this._def.onDeleteAction = opts.onDelete;
+    if (opts?.index === false) this._def.index = false;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /**
+  * Bu kolon `increment()` / `decrement()` ile güncelleniyor (FR-049).
+  *
+  * Deploy kontrolcü kodunu OKUMAZ, o yüzden bildirimin söylemesi gerekiyor —
+  * ve söylediği anda plan bir şeyi görebiliyor: aynı kolon hem sayaç hem
+  * indeksliyse her güncelleme HOT'u kaybeder.
+  *
+  * ZİNCİR (D-028+D-030): HOT kaybı → ölü tuple → autovacuum yükü → ve
+  * autovacuum worker'ları KÜME GENELİNDE bir kaynak, yani bedeli başka
+  * kiracıların tabloları da öder.
+  *
+  * Sektörde çare "dokümana uyarı yaz"dır, çünkü index'i ekleyen kişi
+  * `increment()`'i yazan kişi değildir. Bu bildirimde ikisi de YAN YANA
+  * duruyor.
+  *
+  * Uyarı, HATA DEĞİL: sayaç kolonunu indekslemek bazen doğru karardır.
+  */
+  counter() {
+    this._def.counter = true;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /**
+  * Foreign key onto THIS table (`parent_id → id`) — category trees, comment
+  * replies, org charts.
+  *
+  * No thunk and no type annotation: the target table is the one being declared,
+  * so there is nothing to defer and nothing for TypeScript to chase in a circle.
+  * Drizzle forces an explicit `(): AnyPgColumn =>` here because its reference
+  * always goes through a callback; measured, we do not need one.
+  */
+  selfReferences(column, opts) {
+    refuseOnVector(this._def, "selfReferences");
+    this._def.selfRefColumn = column;
+    if (opts?.as !== void 0) this._def.refAs = opts.as;
+    if (opts?.onDelete !== void 0) this._def.onDeleteAction = opts.onDelete;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** Set the ON DELETE action for a foreign key reference. */
+  onDelete(action) {
+    this._def.onDeleteAction = action;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
+  /** Add a single-column UNIQUE constraint. */
+  unique() {
+    refuseOnVector(this._def, "unique");
+    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");
+}
+__name(uuid, "uuid");
+function text() {
+  return new ColumnBuilder("text");
+}
+__name(text, "text");
+function integer() {
+  return new ColumnBuilder("integer");
+}
+__name(integer, "integer");
+function bigint() {
+  return new ColumnBuilder("bigint");
+}
+__name(bigint, "bigint");
+function numeric() {
+  return new ColumnBuilder("numeric");
+}
+__name(numeric, "numeric");
+function boolean() {
+  return new ColumnBuilder("boolean");
+}
+__name(boolean, "boolean");
+function timestamp() {
+  return new ColumnBuilder("timestamp");
+}
+__name(timestamp, "timestamp");
+function jsonb() {
+  return new ColumnBuilder("jsonb");
+}
+__name(jsonb, "jsonb");
+function enumType(name, values) {
+  const builder = new ColumnBuilder("enum");
+  builder._def.enumName = name;
+  builder._def.enumValues = [
+    ...values
+  ];
+  return builder;
+}
+__name(enumType, "enumType");
+function vector(dimensions) {
+  if (!Number.isInteger(dimensions) || dimensions < 1 || dimensions > 2e3) {
+    throw new Error(`vector(): dimensions must be an integer in [1, 2000], got ${String(dimensions)}`);
+  }
+  const b = new ColumnBuilder("vector");
+  b._def.dimensions = dimensions;
+  return b;
+}
+__name(vector, "vector");
+function ownedByUser() {
+  const b = new ColumnBuilder("text");
+  b._def.nullable = false;
+  b._def.references = {
+    table: "auth.users",
+    column: "id"
+  };
+  b._def.onDeleteAction = "cascade";
+  b._def.owns = true;
+  return b;
+}
+__name(ownedByUser, "ownedByUser");
+function userRef(opts) {
+  const b = new ColumnBuilder("text");
+  b._def.references = {
+    table: "auth.users",
+    column: "id"
+  };
+  b._def.onDeleteAction = opts.onDelete;
+  if (opts.as !== void 0) b._def.refAs = opts.as;
+  return b;
+}
+__name(userRef, "userRef");
+function installationRef(opts) {
+  const b = new ColumnBuilder("text");
+  b._def.references = {
+    table: "auth.installations",
+    column: "id"
+  };
+  b._def.onDeleteAction = opts.onDelete;
+  if (opts.as !== void 0) b._def.refAs = opts.as;
+  return b;
+}
+__name(installationRef, "installationRef");
+
+// src/db/raw.ts
+function raw(name, up, opts) {
+  return {
+    name,
+    up,
+    ...opts?.down != null ? {
+      down: opts.down
+    } : {}
+  };
+}
+__name(raw, "raw");
+
+// src/db/embedding.ts
+var openai = {
+  embedding(model, opts) {
+    return {
+      provider: "openai",
+      model,
+      apiKeyName: opts?.apiKeyName ?? "OPENAI_API_KEY",
+      ...opts?.dimensions !== void 0 ? {
+        dimensions: opts.dimensions
+      } : {},
+      ...opts?.baseURL !== void 0 ? {
+        baseURL: opts.baseURL
+      } : {}
+    };
+  },
+  chat(model) {
+    return {
+      provider: "openai",
+      model
+    };
+  }
+};
+
+export {
+  PolicyExprRef,
+  exprCtx,
+  PolicyBuilder,
+  policy,
+  IndexBuilder,
+  index,
+  TABLE_META,
+  defineTable,
+  defineSchema,
+  PALBASE_EXTENSIONS,
+  EXTENSION_DEPENDENCIES,
+  isPalbaseExtension,
+  uuid,
+  text,
+  integer,
+  bigint,
+  numeric,
+  boolean,
+  timestamp,
+  jsonb,
+  enumType,
+  vector,
+  ownedByUser,
+  userRef,
+  installationRef,
+  raw,
+  openai
+};
+//# sourceMappingURL=chunk-XABHGMUT.js.map