okmodel 0.6.0 → 0.8.0

package/dist/runtime/traits/index.js

@@ -1,34 +1,34 @@
-import"../../shared/qq3899ht.js";
+import {
+  functionObject,
+  triggerObject
+} from "../../shared/12z7aznj.js";
 import {
   checkPresetNames,
   duplicatePreset
-} from "../../shared/nsva2a6b.js";
+} from "../../shared/znm0bpp5.js";
 import {
   checkTrait
 } from "../../shared/n0dgs0pb.js";
-import {
-  quoteIdent
-} from "../../shared/9s0ypp87.js";
 import {
   pathEndpoint
 } from "../../shared/rhs3xe4k.js";
 import {
-  functionObject,
-  triggerObject
-} from "../../shared/y34a8714.js";
-import {
+  integer2,
   timestamptz2
-} from "../../shared/5yv4k6a6.js";
+} from "../../shared/nmnsgj7x.js";
 import {
   uuid2
-} from "../../shared/2jd1sn0e.js";
+} from "../../shared/ecn8mfdq.js";
 import {
   snakeCase
-} from "../../shared/rpycarcr.js";
+} from "../../shared/gcefca6p.js";
 import {
   ColumnBuilder2,
   retarget
-} from "../../shared/ywr8hmey.js";
+} from "../../shared/606g0nbf.js";
+import {
+  quoteIdent
+} from "../../shared/sjk86yrx.js";
 import {
   definition,
   unavailable
@@ -41,10 +41,12 @@ import {
   queryHandle,
   attachHttp,
   settleCall
-} from "../../shared/j60w0dvr.js";
+} from "../../shared/bah9nbg3.js";
 import {
-  installArchiveInspect
-} from "../../shared/2z7wv5tj.js";
+  installArchiveInspect,
+  indexes,
+  isRecord
+} from "../../shared/kgwp4jdd.js";
 import {
   fitIdentifier2
 } from "../../shared/nfzc5z0w.js";
@@ -465,13 +467,13 @@ function refuse(host, table) {
 }
 var archiveMod;
 function loadArchive() {
-  archiveMod ??= import("../../shared/mb2ycs1p.js");
+  archiveMod ??= import("../../shared/qfw14tna.js");
   return archiveMod;
 }
 async function settle(host, table, mods) {
   if (mods.uses === undefined)
     return mods;
-  const { resolve } = await import("../../shared/r6nwkxnt.js");
+  const { resolve } = await import("../../shared/m7n9h2a5.js");
   return { ...mods, presets: resolve(host.schema, table, mods.uses).wheres };
 }
 async function run(host, op, table, input, options, mods) {
@@ -484,6 +486,93 @@ async function run(host, op, table, input, options, mods) {
   }
 }
 
+// src/runtime/sort-bind.ts
+function rewriteSortable(self, tables, casing, schemaTraits, group) {
+  return tables.map((item) => {
+    if (!applies2(self, item, schemaTraits))
+      return item;
+    refusePath(item);
+    return withIndex(item, casing, schemaTraits, group);
+  });
+}
+function applies2(self, item, schemaTraits) {
+  const options = item.options;
+  const own = Array.isArray(options?.traits) ? options.traits : [];
+  if (own.includes(self))
+    return true;
+  if (options?.omitDefaults !== undefined)
+    return false;
+  return schemaTraits?.includes(self) ?? false;
+}
+function refusePath(item) {
+  const tenancy = item.options?.tenancy;
+  if (typeof tenancy === "object" && tenancy !== null && "via" in tenancy) {
+    definition(`sortable() on ${item.name} does not combine with via(). Position needs the tenant columns on the row.`);
+  }
+}
+function withIndex(item, casing, schemaTraits, group) {
+  const options = item.options;
+  const prior = options?.indexes;
+  const tenantKeys = options?.tenantKeys ?? [];
+  const fields = [];
+  for (const field of tenantKeys)
+    if (!fields.includes(field))
+      fields.push(field);
+  if (group !== undefined && !fields.includes(group))
+    fields.push(group);
+  fields.push("position");
+  const predicate = archivedPredicate(item, casing, schemaTraits);
+  const indexes = (handles) => {
+    const calls = prior === undefined ? [] : prior(handles);
+    const columns = fields.map((field) => {
+      const handle = handles[field];
+      if (handle === undefined) {
+        definition(`sortable() on ${item.name} needs a column named ${field}.`);
+      }
+      return handle.name;
+    });
+    return [...Array.isArray(calls) ? calls : [], uniqueIndex(columns, predicate)];
+  };
+  return {
+    ...item,
+    options: { ...options, indexes }
+  };
+}
+function archivedPredicate(item, casing, schemaTraits) {
+  if (!archivable(item, schemaTraits))
+    return;
+  return casing === "snake" ? "(archived_at IS NULL)" : '("archivedAt" IS NULL)';
+}
+function archivable(item, schemaTraits) {
+  const options = item.options;
+  const own = Array.isArray(options?.traits) ? options.traits : [];
+  for (const trait of own)
+    if (marked2(trait))
+      return true;
+  if (options?.omitDefaults !== undefined)
+    return false;
+  if (schemaTraits === undefined)
+    return false;
+  for (const trait of schemaTraits)
+    if (marked2(trait))
+      return true;
+  return false;
+}
+function marked2(value) {
+  return value["~archive"] === true;
+}
+function uniqueIndex(columns, predicate) {
+  const call = {
+    columns,
+    isUnique: true,
+    ...predicate !== undefined ? { predicate } : {},
+    unique() {
+      return call;
+    }
+  };
+  return call;
+}
+
 // src/runtime/traits/index.ts
 function trait(name, input) {
   if (input.presets !== undefined)
@@ -561,7 +650,7 @@ function timestamps(options) {
 function stamped() {
   return timestamptz2().defaultSql("now()").guarded();
 }
-function archivable(options) {
+function archivable2(options) {
   installArchiveContributions();
   const cascade = readCascade(options);
   const base = trait("archivable", {
@@ -585,6 +674,78 @@ function archivable(options) {
   };
   return self;
 }
+function versioned() {
+  return trait("versioned", {
+    fields: {
+      version: integer2().defaultSql("1").guarded()
+    },
+    sealed: ["version"]
+  });
+}
+function sortable(groupBy) {
+  if (groupBy !== undefined && groupBy.length === 0) {
+    definition("sortable() groupBy must be a column name.");
+  }
+  if (groupBy === "position")
+    definition("sortable() cannot group by position.");
+  const base = trait("sortable", {
+    fields: {
+      position: integer2().guarded()
+    },
+    sealed: ["position"]
+  });
+  const self = {
+    ...base,
+    ...groupBy !== undefined ? { group: groupBy } : {},
+    "~sort": true,
+    apply(model, ctx) {
+      if (groupBy !== undefined && !Object.hasOwn(model.columns, groupBy)) {
+        definition(`sortable() on ${ctx.table} needs a column named ${groupBy}.`);
+      }
+      base.apply(model, ctx);
+    },
+    rewrite(tables, casing, schemaTraits) {
+      return rewriteSortable(self, tables, casing, schemaTraits, groupBy);
+    },
+    hook: attachSort
+  };
+  return self;
+}
+function attachSort(target, ctx) {
+  const tableName = ctx.table;
+  const session = ctx.session;
+  if (tableName === undefined || session === undefined)
+    return;
+  const host = session;
+  const table = indexes(host.schema).get(tableName);
+  if (table === undefined)
+    return;
+  let sortableTable = false;
+  for (const item of table.model.traits ?? []) {
+    if (item.name === "sortable")
+      sortableTable = true;
+  }
+  if (!sortableTable)
+    return;
+  const order = { position: "asc" };
+  for (const field of table.model.primary) {
+    if (field !== "position")
+      order[field] = "asc";
+  }
+  wrapOrder(target, "find", order);
+  wrapOrder(target, "page", order);
+  const view = ctx.view;
+  target.move = (id, place) => import("../../shared/xfhe73sb.js").then((mod) => mod.move(host, tableName, id, place, view));
+}
+function wrapOrder(target, key, order) {
+  const previous = target[key];
+  if (typeof previous !== "function")
+    return;
+  target[key] = (options = {}) => {
+    const next = isRecord(options) && options.orderBy !== undefined ? options : { ...options, orderBy: order };
+    return previous.call(target, next);
+  };
+}
 function readCascade(options) {
   if (options === undefined)
     return [];
@@ -647,7 +808,9 @@ function addFields(name, fields, model, ctx) {
   }
 }
 export {
-  archivable,
+  archivable2 as archivable,
+  sortable,
   timestamps,
-  trait
+  trait,
+  versioned
 };

package/dist/runtime/tree.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `descendants` and `ancestors` (spec §13 tool 11).
+ *
+ * One recursive statement walks a self-relation's parent column. A row already
+ * on the path is not entered again, so a cycle in the data returns. `depth`
+ * stops the walk earlier. `ltree` is not read: the extension is a later index,
+ * and this statement does not require it.
+ *
+ * Tenancy and the active set apply on the start row, on every step, and on
+ * the rows that come back. `where` and presets filter those rows and do not
+ * cut the walk short. A missing id returns no rows, including with `self`.
+ * The root has no ancestors. Loaded on the first call.
+ */
+import type { ColumnModel } from "../dialects/pg/model.js";
+import { type Mods, type Session } from "./client.js";
+import { type ArchiveView, type Indexed } from "./plan.js";
+/**
+ * Builds the handle for one `descendants` or `ancestors` call.
+ *
+ * @param session - Client session
+ * @param table - Table name
+ * @param options - The packed call: the id, the direction, and the caller's options
+ * @param mods - Presets, signal, and timeout
+ * @param view - Archive visibility
+ * @returns A handle that resolves to the walked rows
+ */
+export declare function build(session: Session, table: string, options: object, mods: Mods, view: ArchiveView | undefined): Promise<unknown> & Record<string, unknown>;
+/**
+ * The primary key the caller passes, without the tenant key.
+ *
+ * A tree walk and `sync` both address one column. A composite key beside the
+ * tenant key is refused.
+ *
+ * @param session - Client session, for the tenant key
+ * @param table - The table
+ * @returns That column
+ */
+export declare function identityColumn(session: Session, table: Indexed): ColumnModel;