@palbase/backend 24.3.0 → 25.0.1

package/dist/chunk-D5CQES25.js

@@ -1,556 +0,0 @@
-import {
-  TxPlanBuilder,
-  runTxPlan
-} from "./chunk-P2Q27SGP.js";
-
-// src/db/policy.ts
-function quote(name) {
-  return `"${name.replace(/"/g, '""')}"`;
-}
-var PolicyBuilder = class {
-  _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;
-  }
-  /** Set the `USING (...)` row-visibility expression (raw SQL). */
-  using(sqlExpr) {
-    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;
-    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);
-}
-
-// src/db/schema.ts
-function toPolicyDef(p) {
-  return p instanceof PolicyBuilder ? p._def : p;
-}
-function defineSchema(input) {
-  const tables = {};
-  for (const name of Object.keys(input.tables)) {
-    const table = input.tables[name];
-    if (table === void 0) continue;
-    const policies = (table.policies ?? []).map(toPolicyDef);
-    const rls = policies.length > 0 || table.rls !== false;
-    const tableDef = {
-      name,
-      columns: table.columns,
-      rls,
-      policies
-    };
-    if (table.primaryKey !== void 0) tableDef.primaryKey = table.primaryKey;
-    if (table.unique !== void 0) tableDef.unique = table.unique;
-    if (table.raw !== void 0 && table.raw.length > 0) tableDef.raw = table.raw.slice();
-    if (table.checks !== void 0 && table.checks.length > 0) tableDef.checks = table.checks.slice();
-    if (table.indexes !== void 0 && table.indexes.length > 0) tableDef.indexes = table.indexes.slice();
-    if (table.search !== void 0) {
-      const s = table.search;
-      if (s.from !== void 0) {
-        if (s.vector !== void 0) {
-          throw new Error(
-            `table ${String(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 ${String(name)}: search.from bo\u015F olamaz`);
-        }
-        if (s.model === void 0) {
-          throw new Error(
-            `table ${String(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 ${String(name)}: search.text bo\u015F dizi olamaz \u2014 FTS istemiyorsan text: false yaz\u0131n`);
-        }
-      } else {
-        if (typeof s.text === "boolean") {
-          throw new Error(`table ${String(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 ${String(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 ${String(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 ${String(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 ${String(name)}: search.vector.from model'siz anlams\u0131z \u2014 auto-embed i\xE7in model verin`);
-          }
-        }
-      }
-      tableDef.search = s;
-    }
-    if (table.memory !== void 0) {
-      if (table.memory.from.length === 0) {
-        throw new Error(`table ${String(name)}: memory.from bo\u015F olamaz`);
-      }
-      tableDef.memory = table.memory;
-    }
-    tables[name] = tableDef;
-  }
-  for (const [name, 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 ${name}: memory.into "${m.into}" \u015Femada declared de\u011Fil`);
-    }
-    const subject = m.subject ?? "owner";
-    if (!(subject in def.columns)) {
-      throw new Error(`table ${name}: memory.subject "${subject}" kolonu kaynak tabloda yok`);
-    }
-    if (!(subject in target.columns)) {
-      throw new Error(`table ${name}: 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 ${name}: memory.into "${m.into}" tablosunda "fact" (text) kolonu zorunlu`);
-    }
-    for (const c of m.from) {
-      if (!(c in def.columns)) {
-        throw new Error(`table ${name}: memory.from kolonu "${c}" kaynak tabloda yok`);
-      }
-    }
-  }
-  const extensions = [...new Set(input.extensions ?? [])];
-  return { tables, extensions };
-}
-
-// src/db/extensions.ts
-var PALBASE_EXTENSIONS = [
-  // Search & text
-  "vector",
-  // pgvector: AI embeddings + vector similarity search (semantic search / RAG).
-  // NB: the Postgres extension is named "vector", not "pgvector" — declare "vector".
-  "pg_trgm",
-  // trigram fuzzy / typo-tolerant text search
-  "unaccent",
-  // accent-insensitive text search
-  "citext",
-  // case-insensitive text type
-  // Geospatial / location
-  "cube",
-  // multi-dimensional cubes (dependency of earthdistance)
-  "earthdistance",
-  // great-circle distance (needs cube)
-  // Data types & structures
-  "hstore",
-  // key/value pairs in a single column
-  "ltree",
-  // hierarchical tree-structured labels
-  // Indexing & constraints
-  "btree_gist",
-  // GiST operator classes for scalar types — needed for EXCLUDE
-  // constraints that mix "=" with a range/&& overlap (e.g. no-double-booking).
-  // Scheduling
-  // Crypto / ids (also installed by default; listable for explicitness)
-  "pgcrypto",
-  // cryptographic functions (hashing, encryption)
-  "uuid-ossp"
-  // UUID generation functions
-];
-var EXTENSION_DEPENDENCIES = {
-  earthdistance: ["cube"]
-};
-function isPalbaseExtension(name) {
-  return PALBASE_EXTENSIONS.includes(name);
-}
-
-// 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())`);
-  }
-}
-var ColumnBuilder = class _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
-    });
-  }
-  references(table, column) {
-    refuseOnVector(this._def, "references");
-    this._def.references = { table, column };
-    return new _ColumnBuilder(this._def.type, this._def);
-  }
-  /**
-   * Add a real DB-level foreign key to the built-in auth users
-   * (`REFERENCES auth.users(id)`), so a column like `user_id` gets true
-   * database cascade/integrity instead of app-layer-only. Sugar for
-   * `.references("auth.users", "id")`.
-   *
-   * `auth.users` lives in the SAME tenant database (palauth-owned), so this is
-   * a genuine cross-schema integrity constraint scoped to THIS tenant's users.
-   * The referenced `auth.users.id` is `text` (palauth ids are `usr_<uuid>`), so
-   * the referencing column must be `text()` too.
-   *
-   * ON DELETE is REQUIRED here and may only be `cascade` or `set null`: an
-   * account-erasure request must never be blocked by a lingering FK, so
-   * `restrict` / `no action` are not accepted (they don't type-check). Example:
-   * `text().notNull().referencesAuthUser("cascade")`, or
-   * `text().nullable().referencesAuthUser("set null")`. The server
-   * (validateAuthUserFK) enforces this — and the remaining rules the type can't
-   * express (referencing column is text, `set null` needs a nullable column) —
-   * as the real boundary; this signature is the compile-time DX mirror.
-   */
-  referencesAuthUser(onDelete) {
-    refuseOnVector(this._def, "referencesAuthUser");
-    this._def.references = { table: "auth.users", column: "id" };
-    this._def.onDeleteAction = onDelete;
-    return new _ColumnBuilder(this._def.type, this._def);
-  }
-  /**
-   * Add a real DB-level foreign key to the canonical, server-minted installation
-   * anchor (`REFERENCES auth.installations(id)`) — the app-scoped verified-device
-   * root (`ins_...`). Sugar for `.references("auth.installations", "id")`.
-   *
-   * An installation is an APP INSTALL, not a user: this FK is NOT user ownership.
-   * A user-owned row STILL needs its own `.referencesAuthUser(...)` FK so account
-   * erasure removes it — an installation reference alone does not tie a row to a
-   * user's deletion. Use this only for install-scoped state (device prefs, push
-   * routing, …), alongside a separate auth-user FK where the row is user-owned.
-   *
-   * `auth.installations` lives in the SAME tenant DB (palauth-owned); its `id` is
-   * `text` (`ins_<uuid>`), so the referencing column must be `text()` too. ON
-   * DELETE is REQUIRED and may only be `cascade` or `set null` (same allowed set
-   * as an auth-user FK): an installation revoke / orphan cleanup must never be
-   * blocked by a lingering FK. The server (validateAuthAnchorFK) is the real
-   * boundary; this signature is the compile-time DX mirror.
-   */
-  referencesInstallation(onDelete) {
-    refuseOnVector(this._def, "referencesInstallation");
-    this._def.references = { table: "auth.installations", column: "id" };
-    this._def.onDeleteAction = 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");
-}
-function text() {
-  return new ColumnBuilder("text");
-}
-function integer() {
-  return new ColumnBuilder("integer");
-}
-function bigint() {
-  return new ColumnBuilder("bigint");
-}
-function numeric() {
-  return new ColumnBuilder("numeric");
-}
-function boolean() {
-  return new ColumnBuilder("boolean");
-}
-function timestamp() {
-  return new ColumnBuilder("timestamp");
-}
-function jsonb() {
-  return new ColumnBuilder("jsonb");
-}
-function enumType(name, values) {
-  const builder = new ColumnBuilder("enum");
-  builder._def.enumName = name;
-  builder._def.enumValues = [...values];
-  return builder;
-}
-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;
-}
-
-// src/db/raw.ts
-function raw(name, up, opts) {
-  return { name, up, ...opts?.down != null ? { down: opts.down } : {} };
-}
-
-// 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 };
-  }
-};
-
-// src/db/typed-db.ts
-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, 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) {
-  const tables = {};
-  for (const key of Object.keys(schema.tables)) {
-    const tableDef = schema.tables[key];
-    if (tableDef !== void 0) {
-      tables[key] = makeTypedTable(tableDef.name, raw2);
-    }
-  }
-  const result = {
-    tables,
-    transaction(fn) {
-      const builder = new TxPlanBuilder();
-      const planTables = {};
-      for (const key of Object.keys(schema.tables)) {
-        const tableDef = schema.tables[key];
-        if (tableDef !== void 0) planTables[key] = builder.table(tableDef.name);
-      }
-      return runTxPlan(
-        raw2,
-        planTables,
-        builder,
-        fn
-      );
-    }
-  };
-  return result;
-}
-
-export {
-  PolicyBuilder,
-  policy,
-  defineSchema,
-  PALBASE_EXTENSIONS,
-  EXTENSION_DEPENDENCIES,
-  isPalbaseExtension,
-  uuid,
-  text,
-  integer,
-  bigint,
-  numeric,
-  boolean,
-  timestamp,
-  jsonb,
-  enumType,
-  vector,
-  raw,
-  openai,
-  makeTypedDB
-};
-//# sourceMappingURL=chunk-D5CQES25.js.map