okmodel 0.5.1 → 0.7.0

package/dist/runtime/result-name.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Result keys a caller chooses.
+ *
+ * Loaded with the bucket chunk and the window chunk (D258). The startup
+ * graph does not import it.
+ */
+/**
+ * Refuses a result key that would shadow or replace a prototype property.
+ *
+ * Assigning `__proto__` replaces that object's prototype when the value is an
+ * object. The other names shadow methods on the row. `then` makes the row a
+ * thenable. The check runs before any SQL.
+ *
+ * @param name - The result key
+ * @param where - The call, such as `rowNumber as` or `bucket as`
+ */
+export declare function refusePrototypeKey(name: string, where: string): void;

package/dist/runtime/safety/index.js

@@ -1,6 +1,6 @@
 import {
   callerLocation
-} from "../../shared/k7dwkhvq.js";
+} from "../../shared/y6jdds7g.js";
 import {
   installSafetyHook
 } from "../../shared/a5sxz52y.js";

package/dist/runtime/server-check.d.ts

@@ -17,11 +17,11 @@ export declare const versionQuery = "select current_setting('server_version_num'
 /**
  * Accepts the `server_version_num` row, or throws OKM1801, OKM1520, OKM1802, or OKM1803.
  *
- * A declared `requires` is the minimum, including a major below 15 when the
- * schema names it on purpose. With no `requires`, the floor is 15.
+ * A declared floor is the minimum. With no floor, the minimum is 15.
+ * A major below 15 is refused when the schema is built.
  *
  * @param pool - Connection that ran the version query
- * @param schema - Schema whose `requires` is the declared minimum
+ * @param schema - Schema whose floor is the declared minimum
  * @param rows - `server_version_num`, `version()`, and the `okm_meta` hash
  * @param http - Status overrides from `connect`
  * @param requireMeta - When true, a missing hash is OKM1520

package/dist/runtime/sort-bind.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unique index `sortable()` adds.
+ *
+ * Tenancy has already widened uniques (D168), so this index names the tenant
+ * keys itself. The move and insert SQL load later, on the first call.
+ */
+import type { AnyTable } from "../dialects/pg/table.js";
+/**
+ * Adds the position unique index on tables this trait applies to.
+ *
+ * A path table is refused: the tenant key is not a column, so the index could
+ * not keep two tenants from sharing a position.
+ *
+ * @param self - The trait object `schema()` stored
+ * @param tables - Tables after the tenancy rewrite
+ * @param casing - Schema casing
+ * @param schemaTraits - Traits from `schema()`, when any were passed
+ * @param group - Field that splits the order, when `sortable` was given one
+ * @returns Tables with the index on the ones this trait applies to
+ */
+export declare function rewriteSortable(self: object, tables: readonly AnyTable[], casing: "snake" | undefined, schemaTraits: readonly object[] | undefined, group: string | undefined): readonly AnyTable[];

package/dist/runtime/sort.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Position assignment and `move`.
+ *
+ * Loaded on the first insert or move of a `sortable()` table. Positions are
+ * dense positive integers, unique inside the group (and the tenant). The
+ * advisory lock is its own statement. The next statement reads positions.
+ * Under READ COMMITTED a statement's snapshot is taken when it starts, which
+ * is before a lock in that same statement is granted, so a commit that landed
+ * while this transaction waited would be invisible.
+ */
+import type { Statement } from "../contracts/driver.js";
+import type { ColumnModel, QuerySchema } from "../dialects/pg/model.js";
+import { type ArchiveView, type CallScope, type Indexed } from "./plan.js";
+import { type RunHost } from "./tx.js";
+type Host = RunHost & {
+    readonly schema: QuerySchema;
+    readonly scope?: CallScope;
+    readonly connected?: Promise<void>;
+};
+/**
+ * Inserts rows at the end of their group.
+ *
+ * The lock statement runs first. The insert then takes `max(position) + n`
+ * from a snapshot taken after that lock is held. A writer that bypasses these
+ * statements can still race; the unique index rejects a duplicate.
+ *
+ * @param table - Target table
+ * @param columns - Columns the insert already decided to write
+ * @param rows - Stamped rows, in call order
+ * @param group - Group field, when the trait has one
+ * @param tenantFields - Tenant fields stored on this table
+ * @returns The lock, then the insert without `returning`
+ */
+export declare function insertAtEnd(table: Indexed, columns: readonly ColumnModel[], rows: readonly Record<string, unknown>[], group: string | undefined, tenantFields: readonly string[] | undefined): {
+    readonly lock: Statement;
+    readonly text: string;
+    readonly params: (string | null)[];
+};
+/**
+ * Moves one row before or after another in the same group.
+ *
+ * The result is `{ position }` after the move. A missing id is `not_found`.
+ * An anchor in another group is OKM1120 and writes nothing. The same id on
+ * both sides leaves the row where it is.
+ *
+ * @param host - Pool and schema
+ * @param tableName - Table the trait is on
+ * @param id - Primary key of the row to move, without the tenant key
+ * @param place - `{ before }` or `{ after }`, the anchor's primary key
+ * @param view - Archive visibility, when the handle narrowed it
+ * @returns The row's position after the move
+ */
+export declare function move(host: Host, tableName: string, id: unknown, place: unknown, view: ArchiveView | undefined): Promise<{
+    readonly position: number;
+}>;
+export {};

package/dist/runtime/sync.d.ts

@@ -0,0 +1,70 @@
+/**
+ * `sync` (spec §11, §13 tool 10).
+ *
+ * One transaction sets a to-many relation to an exact set of ids. The first
+ * statement locks the parent row. The write is a second statement, so a sync
+ * that waited for that lock sees the links the previous sync committed. A join table
+ * gains and loses link rows. A one-to-many sets or clears a nullable foreign
+ * key and leaves the related row in place. A link that would have to delete
+ * that row is refused. Duplicate ids count once. An id that is not in the
+ * related table, or a parent id that is not in this table, writes nothing and
+ * throws `not_found`. The parent row is locked, so two syncs of the same id
+ * run one after the other.
+ *
+ * Loaded on the first call.
+ */
+import type { Statement } from "../contracts/driver.js";
+import type { PresetUse } from "../dialects/pg/model.js";
+import { type Mods as ReadMods, type Session } from "./client.js";
+import { type ArchiveView } from "./plan.js";
+type Mods = {
+    readonly expect?: number;
+    readonly archive?: ArchiveView | undefined;
+    readonly uses?: PresetUse | undefined;
+};
+/**
+ * Runs one `sync`.
+ *
+ * @param session - Client session
+ * @param table - Table that owns the relation
+ * @param id - Primary key of that row
+ * @param relation - To-many relation name
+ * @param ids - Related primary keys the relation should hold
+ * @param options - `expect`, `signal`, and `timeout`
+ * @param mods - Chained `expect`, archive visibility, and presets
+ * @returns The ids whose links were added or removed
+ */
+export declare function execute(session: Session, table: string, id: unknown, relation: unknown, ids: unknown, options: object | undefined, mods: Mods): Promise<{
+    readonly added: readonly unknown[];
+    readonly removed: readonly unknown[];
+}>;
+/**
+ * The statement `sync` would run.
+ *
+ * @param session - Client session
+ * @param table - Table that owns the relation
+ * @param id - Primary key of that row
+ * @param relation - To-many relation name
+ * @param ids - Related primary keys the relation should hold
+ * @param options - `expect`, `signal`, and `timeout`
+ * @param mods - Chained `expect`, archive visibility, and presets
+ * @returns One statement
+ */
+export declare function explain(session: Session, table: string, id: unknown, relation: unknown, ids: unknown, options: object | undefined, mods: Mods): Promise<{
+    readonly statements: readonly Statement[];
+}>;
+/**
+ * The handle for one `sync`.
+ *
+ * Await runs the change. `sql` shows the lock and the write. `expect` lives on
+ * the outer handle, which calls this again with `mods.expect` set.
+ *
+ * @param session - Client session
+ * @param table - Table that owns the relation
+ * @param input - `id`, `relation`, `ids`, and `options`
+ * @param mods - Presets, plus `expect` when the outer handle chained it
+ * @param view - Archive view. The same value a read on this handle uses
+ * @returns A handle. The value is `{ added, removed }`
+ */
+export declare function build(session: Session, table: string, input: object, mods: ReadMods, view: ArchiveView | undefined): Promise<unknown> & Record<string, unknown>;
+export {};

package/dist/runtime/tenancy/composite.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Composite tenancy (`compositeTenancy()`).
+ *
+ * Every tenant table carries the key list, in that order. A column-only app
+ * does not import this file. `via()` is a separate import: this file calls a
+ * table's own `rewrite` and does not load the path compiler.
+ */
+import type { ColumnTenancy } from "../../dialects/pg/tenancy.js";
+/**
+ * Composite tenancy for `schema({ tenancy })`.
+ *
+ * Every table gains each key unless it passes `global("reason")` or `via()`.
+ * The keys are guarded uuids, in this order. Insert fills them from `for()`.
+ * Reads and writes filter on every key.
+ *
+ * @typeParam Keys - Field names, at least one
+ * @param input - The key list and `uuid`
+ * @returns The object `schema()` applies
+ */
+export declare function compositeTenancy<const Keys extends readonly [string, ...string[]]>(input: {
+    readonly key: Keys;
+    readonly type: "uuid";
+}): ColumnTenancy & {
+    readonly key: Keys[number];
+    readonly keys: Keys;
+};

package/dist/runtime/tenancy/context.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What a table tenancy `rewrite` receives.
+ *
+ * `columnTenancy()` and `compositeTenancy()` pass it. `via()` reads it.
+ * This file is types only, so it is not in a bundle.
+ */
+import type { AnyTable } from "../../dialects/pg/table.js";
+import type { ColumnTenancy } from "../../dialects/pg/tenancy.js";
+/** Context for one table whose tenancy mark carries `rewrite`. */
+export type TableRewriteContext = {
+    readonly tables: readonly AnyTable[];
+    readonly keys: readonly string[];
+    readonly encodes: readonly ((value: string) => string)[];
+    readonly api: ColumnTenancy;
+    readonly extras: Map<string, readonly string[]>;
+};

package/dist/runtime/tenancy/index.d.ts

@@ -22,16 +22,20 @@ export declare function global(reason: string): {
 /**
  * Column tenancy for `schema({ tenancy })`.
  *
- * Every table gains `key` unless it passes `global("reason")`. The key is a
- * guarded uuid. Insert fills it from `for()`. Reads and writes filter on it.
+ * Every table gains `key` unless it passes `global("reason")` or `via()`.
+ * The key is a guarded uuid. Insert fills it from `for()`. Reads and writes
+ * filter on it. A list of keys is `compositeTenancy()`.
  *
  * @typeParam Key - Field name of the tenant key
  * @param input - Field name and `uuid`
  * @returns The object `schema()` applies
  */
-export declare function columnTenancy<const Key extends string>(input: {
-    readonly key: Key;
+export declare function columnTenancy<const Key>(input: {
+    readonly key: Key extends readonly unknown[] ? "columnTenancy() takes one key. Use compositeTenancy()." : Key extends string ? Key : "columnTenancy() key must be a field name.";
     readonly type: "uuid";
 }): ColumnTenancy & {
-    readonly key: Key;
+    readonly key: Key extends string ? Key : string;
 };
+export { compositeTenancy } from "./composite.js";
+export { via } from "./via.js";
+export { RlsRoleError, rlsTenancy, type RlsRoleReason } from "./rls.js";