@palbase/backend 8.2.0 → 8.3.0

package/dist/{index-CArW1VMq.d.ts → index-tudF0wAM.d.ts}

@@ -20,6 +20,7 @@ interface ColumnDef {
     onDeleteAction?: OnDeleteAction;
     enumName?: string;
     enumValues?: string[];
+    unique?: boolean;
 }
 declare const __colKind: unique symbol;
 declare const __colNullable: unique symbol;
@@ -62,6 +63,8 @@ declare class ColumnBuilder<K extends ColumnType = ColumnType, N extends boolean
     references(table: string, column: string): ColumnBuilder<K, N, D, E>;
     /** Set the ON DELETE action for a foreign key reference. */
     onDelete(action: OnDeleteAction): ColumnBuilder<K, N, D, E>;
+    /** Add a single-column UNIQUE constraint. */
+    unique(): ColumnBuilder<K, N, D, E>;
 }
 /**
  * Extracts the TypeScript value type for a column, respecting nullability.
@@ -212,6 +215,22 @@ declare const EXTENSION_DEPENDENCIES: Partial<Record<PalbaseExtension, PalbaseEx
 /** Runtime guard: is `name` a supported Palbase extension? */
 declare function isPalbaseExtension(name: string): name is PalbaseExtension;
 
+/**
+ * A named raw-SQL DDL object declared in db/schema.ts for anything the typed DSL
+ * cannot express (EXCLUDE, CHECK, partial/expression indexes, triggers, views).
+ * The deploy emits `up` verbatim on the privileged DDL connection — same trust
+ * posture as policy().using(). Tracked by NAME (not by diffing the body), so a
+ * changed body needs a new name or an explicit drop+add.
+ */
+interface RawConstraintDef {
+    name: string;
+    up: string;
+    down?: string;
+}
+declare function raw(name: string, up: string, opts?: {
+    down?: string;
+}): RawConstraintDef;
+
 /**
  * A map of column builders keyed by column name — the value you write under
  * the `columns` key of `defineSchema({ tables: { <name>: { columns } } })`.
@@ -239,6 +258,41 @@ interface TableInput<C extends ColumnMap = ColumnMap> {
     columns: C;
     rls?: boolean;
     policies?: (PolicyBuilder | PolicyDef)[];
+    /** Composite/named primary key (ordered column names). Omit for single-column inline .primaryKey(). */
+    primaryKey?: string[];
+    /** Named multi-column UNIQUE constraints. */
+    unique?: {
+        name: string;
+        columns: string[];
+    }[];
+    /** Named raw-SQL DDL objects (EXCLUDE, triggers, views) that the typed DSL cannot express. */
+    raw?: RawConstraintDef[];
+    /**
+     * Named first-class CHECK constraints. Diffed by NAME with a BODY compare:
+     * a changed `expr` (after pg normalization) recreates the constraint
+     * (DROP + ADD). `expr` is trusted SQL emitted verbatim (like policy USING),
+     * `name` is identifier-validated.
+     */
+    checks?: {
+        name: string;
+        expr: string;
+    }[];
+    /**
+     * Plain (non-unique) btree indexes over an ordered column list, emitted as
+     * standalone `CREATE INDEX [IF NOT EXISTS] name ON table (col1, col2)`
+     * statements (NOT a table clause — a separate migration statement category).
+     * Structural compare by NAME (no expression normalization). `name` and each
+     * column are identifier-validated by the Go differ.
+     *
+     * Scope: columns-only plain btree. Partial (`where`) and expression indexes
+     * are a deliberate follow-up — modelling them needs the same raw-SQL
+     * normalization round-trip CHECK uses (Task 10), so they are NOT in this
+     * type yet to avoid a half-working partial-index path.
+     */
+    indexes?: {
+        name: string;
+        columns: string[];
+    }[];
 }
 /**
  * A table definition — the runtime value the Go runtime's `schema_extract.js`
@@ -257,6 +311,23 @@ interface TableDef<C extends ColumnMap = ColumnMap> {
     columns: C;
     rls: boolean;
     policies: PolicyDef[];
+    primaryKey?: string[];
+    unique?: {
+        name: string;
+        columns: string[];
+    }[];
+    /** Named raw-SQL DDL objects emitted verbatim on deploy. Tracked by name. */
+    raw?: RawConstraintDef[];
+    /** Named first-class CHECK constraints. Diffed by name + (normalized) body. */
+    checks?: {
+        name: string;
+        expr: string;
+    }[];
+    /** Plain btree indexes (columns-only), emitted as standalone CREATE INDEX. Diffed by name. */
+    indexes?: {
+        name: string;
+        columns: string[];
+    }[];
 }
 /**
  * A schema definition containing multiple tables, keyed by table name.
@@ -466,4 +537,4 @@ interface EnvTypedDatabase extends Omit<DBClient, "transaction" | "asService"> {
     asService(): EnvServiceDatabase;
 }
 
-export { text as A, timestamp as B, ColumnBuilder as C, uuid as D, type EnvTypedDatabase as E, type InsertShape as I, type OnDeleteAction as O, PALBASE_EXTENSIONS as P, type RowShape as R, type SchemaDef as S, type TableDef as T, type ColumnDef as a, type ColumnMap as b, type ColumnType as c, EXTENSION_DEPENDENCIES as d, type EnvServiceDatabase as e, type EnvTables as f, type EnvTypedTable as g, type EnvTypedTx as h, type PalbaseExtension as i, PolicyBuilder as j, type PolicyCommand as k, type PolicyDef as l, type PolicyMode as m, type SchemaInput as n, type TableInput as o, type TypedDB as p, type TypedTable as q, type TypedTx as r, boolean as s, defineSchema as t, enumType as u, integer as v, isPalbaseExtension as w, jsonb as x, makeTypedDB as y, policy as z };
+export { policy as A, raw as B, ColumnBuilder as C, text as D, type EnvTypedDatabase as E, timestamp as F, uuid as G, type InsertShape as I, type OnDeleteAction as O, PALBASE_EXTENSIONS as P, type RawConstraintDef as R, type SchemaDef as S, type TableDef as T, type ColumnDef as a, type ColumnMap as b, type ColumnType as c, EXTENSION_DEPENDENCIES as d, type EnvServiceDatabase as e, type EnvTables as f, type EnvTypedTable as g, type EnvTypedTx as h, type PalbaseExtension as i, PolicyBuilder as j, type PolicyCommand as k, type PolicyDef as l, type PolicyMode as m, type RowShape as n, type SchemaInput as o, type TableInput as p, type TypedDB as q, type TypedTable as r, type TypedTx as s, boolean as t, defineSchema as u, enumType as v, integer as w, isPalbaseExtension as x, jsonb as y, makeTypedDB as z };

package/dist/index.cjs

@@ -95,6 +95,7 @@ __export(src_exports, {
   makeTypedDB: () => makeTypedDB,
   parseFileSizeLimit: () => parseFileSizeLimit,
   policy: () => policy,
+  raw: () => raw,
   recordThrows: () => recordThrows,
   reservedSecretKey: () => reservedSecretKey,
   storage: () => storage,
@@ -156,19 +157,19 @@ function makeTablesAccessor(ops) {
   return tablesProxy;
 }
 var rawDatabase = makeServiceProxy("Database");
-function makeTypedSurface(raw) {
+function makeTypedSurface(raw2) {
   const ops = {
-    query: (sql, params) => raw.query(sql, params),
-    insert: (table, data) => raw.insert(table, data),
-    update: (table, id, data) => raw.update(table, id, data),
-    delete: (table, id) => raw.delete(table, id),
-    findById: (table, id) => raw.findById(table, id),
-    findMany: (table, query) => raw.findMany(table, query)
+    query: (sql, params) => raw2.query(sql, params),
+    insert: (table, data) => raw2.insert(table, data),
+    update: (table, id, data) => raw2.update(table, id, data),
+    delete: (table, id) => raw2.delete(table, id),
+    findById: (table, id) => raw2.findById(table, id),
+    findMany: (table, query) => raw2.findMany(table, query)
   };
   return Object.assign(ops, {
-    tables: makeTablesAccessor(() => raw),
+    tables: makeTablesAccessor(() => raw2),
     transaction(fn) {
-      return raw.transaction((rawTx) => fn({ tables: makeTablesAccessor(() => rawTx) }));
+      return raw2.transaction((rawTx) => fn({ tables: makeTablesAccessor(() => rawTx) }));
     }
   });
 }
@@ -283,12 +284,18 @@ function defineSchema(input) {
     if (table === void 0) continue;
     const policies = (table.policies ?? []).map(toPolicyDef);
     const rls = table.rls === true || policies.length > 0;
-    tables[name] = {
+    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();
+    tables[name] = tableDef;
   }
   const extensions = [...new Set(input.extensions ?? [])];
   return { tables, extensions };
@@ -384,6 +391,11 @@ var ColumnBuilder = class _ColumnBuilder {
     this._def.onDeleteAction = action;
     return new _ColumnBuilder(this._def.type, this._def);
   }
+  /** Add a single-column UNIQUE constraint. */
+  unique() {
+    this._def.unique = true;
+    return new _ColumnBuilder(this._def.type, this._def);
+  }
 };
 function uuid() {
   return new ColumnBuilder("uuid");
@@ -410,17 +422,22 @@ function enumType(name, values) {
   return builder;
 }
 
+// src/db/raw.ts
+function raw(name, up, opts) {
+  return { name, up, ...opts?.down != null ? { down: opts.down } : {} };
+}
+
 // src/db/typed-db.ts
-function makeTypedTable(name, raw) {
+function makeTypedTable(name, raw2) {
   return {
-    insert: (data) => raw.insert(name, data),
-    update: (id, data) => raw.update(name, id, data),
-    delete: (id) => raw.delete(name, id),
-    findById: (id) => raw.findById(name, id),
-    findMany: (query) => raw.findMany(name, query)
+    insert: (data) => raw2.insert(name, data),
+    update: (id, data) => raw2.update(name, id, data),
+    delete: (id) => raw2.delete(name, id),
+    findById: (id) => raw2.findById(name, id),
+    findMany: (query) => raw2.findMany(name, query)
   };
 }
-function makeTypedDB(schema, raw) {
+function makeTypedDB(schema, raw2) {
   function buildTables(client) {
     const tables = {};
     for (const key of Object.keys(schema.tables)) {
@@ -432,8 +449,8 @@ function makeTypedDB(schema, raw) {
     return tables;
   }
   const result = {
-    tables: buildTables(raw),
-    transaction: (fn) => raw.transaction((rawTx) => fn({ tables: buildTables(rawTx) }))
+    tables: buildTables(raw2),
+    transaction: (fn) => raw2.transaction((rawTx) => fn({ tables: buildTables(rawTx) }))
   };
   return result;
 }
@@ -1536,6 +1553,7 @@ var import_zod2 = require("zod");
   makeTypedDB,
   parseFileSizeLimit,
   policy,
+  raw,
   recordThrows,
   reservedSecretKey,
   storage,