@gaganref/confect-test 10.3.1-fork.9 → 10.3.1-fork.90

package/src/internal/MountedHttp.ts

@@ -102,11 +102,16 @@ export const make = (
   const registered = new Set<string>();
   let tail = Promise.resolve();
 
-  const register: RegisterComponent = (componentPath, schema, modules) => {
+  const register: RegisterComponent = (
+    componentPath,
+    schema,
+    modules,
+    options,
+  ) => {
     if (
       !normalized.success.some((mount) => mount.componentPath === componentPath)
     ) {
-      registerComponent(componentPath, schema, modules);
+      registerComponent(componentPath, schema, modules, options);
       return;
     }
     const generated = Object.keys(modules).find((key) =>
@@ -188,10 +193,12 @@ export const make = (
         }
       },
     });
-    registerComponent(componentPath, schema, {
-      ...modules,
-      [bridgePath]: () => Promise.resolve({ invoke }),
-    });
+    registerComponent(
+      componentPath,
+      schema,
+      { ...modules, [bridgePath]: () => Promise.resolve({ invoke }) },
+      options,
+    );
     registered.add(componentPath);
   };
 

package/src/internal/ReadSet.ts

@@ -0,0 +1,108 @@
+import { compareValues, type Value } from "convex/values";
+import type {
+  DocumentId,
+  SerializedRangeExpression,
+  StoredDocument,
+} from "./KernelValues.js";
+import {
+  evaluateFieldPath,
+  evaluateRangeFilter,
+  tableNameFromId,
+} from "./KernelValues.js";
+
+/**
+ * A row's position in an interval's order: its value at each of the interval's
+ * fields.
+ */
+export type Key = ReadonlyArray<Value | undefined>;
+
+/**
+ * A read of one document by ID. It records the document's absence as well as
+ * its presence, so a commit that creates the document invalidates it.
+ */
+export interface DocumentRead {
+  readonly kind: "document";
+  readonly componentPath: string;
+  readonly id: DocumentId;
+}
+
+/**
+ * A read of an ordered interval of one table.
+ *
+ * `fields` is the sort key: an index's fields, then the tie-breakers
+ * `_creationTime` and `_id`. `range` is the index range expression, whose `Gt`
+ * and `Lt` bounds are exclusive and `Gte` and `Lte` inclusive. `after` is an
+ * exclusive start in `order`, a page's cursor. `through` is how far the query
+ * examined, inclusive: nothing yet, up to a key, or to the end of the range. An
+ * empty result reads to the end, so it still covers an insert into the range.
+ *
+ * Only the attempt that owns the read advances `through`.
+ */
+export interface IntervalRead {
+  readonly kind: "interval";
+  readonly componentPath: string;
+  readonly table: string;
+  readonly fields: ReadonlyArray<string>;
+  readonly order: "asc" | "desc";
+  readonly range: ReadonlyArray<SerializedRangeExpression>;
+  readonly after: Key | null;
+  through: Key | "end" | null;
+}
+
+export type Read = DocumentRead | IntervalRead;
+
+/**
+ * Where `doc` sorts against `key` in the interval's order.
+ */
+export const compareToKey = (
+  fields: ReadonlyArray<string>,
+  order: "asc" | "desc",
+  doc: StoredDocument,
+  key: Key,
+): number => {
+  const direction = order === "asc" ? 1 : -1;
+  for (let i = 0; i < fields.length; i++) {
+    const cmp = compareValues(
+      evaluateFieldPath(fields[i]!, doc),
+      key[i] as Value,
+    );
+    if (cmp !== 0) return cmp * direction;
+  }
+  return 0;
+};
+
+export const keyOf = (
+  fields: ReadonlyArray<string>,
+  doc: StoredDocument,
+): Key => fields.map((field) => evaluateFieldPath(field, doc));
+
+const inInterval = (read: IntervalRead, doc: StoredDocument): boolean =>
+  read.through !== null &&
+  read.range.every((filter) => evaluateRangeFilter(doc, filter)) &&
+  (read.after === null ||
+    compareToKey(read.fields, read.order, doc, read.after) > 0) &&
+  (read.through === "end" ||
+    compareToKey(read.fields, read.order, doc, read.through) <= 0);
+
+/**
+ * Whether a commit's change to one document invalidates `read`: it wrote the
+ * document read by ID, or the document entered or left the interval.
+ */
+export const covers = (
+  read: Read,
+  change: {
+    readonly componentPath: string;
+    readonly id: DocumentId;
+    readonly before: StoredDocument | null;
+    readonly after: StoredDocument | null;
+  },
+): boolean => {
+  if (read.componentPath !== change.componentPath) return false;
+  if (read.kind === "document") return read.id === change.id;
+  return (
+    tableNameFromId(change.id) === read.table &&
+    [change.before, change.after].some(
+      (doc) => doc !== null && inInterval(read, doc),
+    )
+  );
+};

package/src/internal/Scheduling.ts

@@ -0,0 +1,126 @@
+import type { Value } from "convex/values";
+import type * as Invocation from "./Invocation.js";
+import type * as Kernel from "./Kernel.js";
+import type {
+  DocumentId,
+  FunctionPath,
+  StoredDocument,
+} from "./KernelValues.js";
+
+/**
+ * Convex's system table of scheduled functions. Each component has its own.
+ */
+export const table = "_scheduled_functions";
+
+export type JobState =
+  | { readonly kind: "pending" }
+  | { readonly kind: "inProgress" }
+  | { readonly kind: "success" }
+  | { readonly kind: "failed"; readonly error: string }
+  | { readonly kind: "canceled" };
+
+/**
+ * What the kernel keeps beside a job's row: the function it calls, which a
+ * handle may place in another component, whether a standing source owns the
+ * job, and the test world whose invocation scheduled it. The row holds only
+ * what Convex's system table holds.
+ */
+export interface Target {
+  readonly functionPath: FunctionPath;
+  readonly standing: boolean;
+  /**
+   * The job runs as a fresh invocation of this world, with its services, or
+   * unbound when no invocation was bound as it was scheduled.
+   */
+  readonly world: Invocation.World | undefined;
+}
+
+/**
+ * A pending job as a driver sees it.
+ */
+export interface Job {
+  readonly id: DocumentId;
+  readonly componentPath: string;
+  readonly name: string;
+  readonly scheduledTime: number;
+  /**
+   * A standing job is never drain work. Time reaches it through `advance`.
+   */
+  readonly standing: boolean;
+}
+
+/**
+ * A pending job with what running it needs.
+ */
+export interface Due extends Job {
+  readonly target: FunctionPath;
+  readonly args: Value;
+  readonly world: Invocation.World | undefined;
+}
+
+export const row = (
+  id: DocumentId,
+  creationTime: number,
+  name: string,
+  args: Value,
+  scheduledTime: number,
+): StoredDocument => ({
+  _id: id,
+  _creationTime: creationTime,
+  name,
+  args: [args],
+  scheduledTime,
+  state: { kind: "pending" },
+});
+
+export const stateOf = (doc: StoredDocument): JobState =>
+  doc["state"] as JobState;
+
+const byDeadline = (a: Due, b: Due) =>
+  a.scheduledTime - b.scheduledTime || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+
+/**
+ * Every committed pending job of every component, earliest deadline first. Jobs
+ * that share a deadline run in the order they were scheduled.
+ */
+export const pending = (
+  state: Kernel.State,
+  targets: ReadonlyMap<DocumentId, Target>,
+): Array<Due> => {
+  const due: Array<Due> = [];
+  for (const [componentPath, tables] of state.tables) {
+    for (const { doc } of tables.get(table)?.values() ?? []) {
+      if (stateOf(doc).kind !== "pending") continue;
+      const name = doc["name"] as string;
+      const target = targets.get(doc._id) ?? {
+        functionPath: { componentPath, udfPath: name },
+        standing: false,
+        world: undefined,
+      };
+      due.push({
+        id: doc._id,
+        componentPath,
+        name,
+        scheduledTime: doc["scheduledTime"] as number,
+        standing: target.standing,
+        target: target.functionPath,
+        args: (doc["args"] as ReadonlyArray<Value>)[0]!,
+        world: target.world,
+      });
+    }
+  }
+  return due.sort(byDeadline);
+};
+
+/**
+ * The distinct functions of `jobs`, for a refusal that names what is left.
+ */
+export const functions = (
+  jobs: ReadonlyArray<Job>,
+): Array<{ readonly componentPath: string; readonly name: string }> => {
+  const seen = new Map<string, { componentPath: string; name: string }>();
+  for (const { componentPath, name } of jobs) {
+    seen.set(`${componentPath}\u0000${name}`, { componentPath, name });
+  }
+  return [...seen.values()];
+};