@gaganref/confect-test 10.3.1-fork.91 → 10.3.1-fork.93

package/src/internal/KernelQuery.ts

@@ -99,17 +99,19 @@ export const validateDocument = (
 };
 
 /**
- * An interval a query reads, before it says where it starts and how far it got.
+ * An interval a query reads, before it says where it starts and how far it got,
+ * and the index it reads it from.
  */
 export type Interval = Omit<
   ReadSet.IntervalRead,
   "componentPath" | "after" | "through"
->;
+> & { readonly index: string };
 
 /**
  * What a query reads: one table of one component, as the running attempt sees
  * it. `read` records an interval in the attempt's read set and returns how to
- * advance it.
+ * advance it. `examine` charges one document the query examined, before the
+ * query's filters see it.
  */
 export interface TableView {
   readonly schema: KernelSchema | null;
@@ -118,6 +120,7 @@ export interface TableView {
     interval: Interval,
     after: ReadSet.Key | null,
   ) => (through: ReadSet.Key | "end") => void;
+  readonly examine: (table: string, doc: GenericDocument) => void;
 }
 
 interface ResolvedSource {
@@ -138,9 +141,12 @@ const resolveSource = (
   let order: "asc" | "desc";
   let table: string;
   let range: ReadonlyArray<SerializedRangeExpression> = [];
+  let index: string;
   switch (source.type) {
     case "FullTableScan": {
       table = source.tableName;
+      // The binary scans a whole table through its creation-time index.
+      index = "by_creation_time";
       docs = [...view.scan(source.tableName)];
       order = source.order ?? "asc";
       fieldPathsToSortBy = ["_creationTime"];
@@ -152,6 +158,7 @@ const resolveSource = (
         string,
       ];
       table = tableName;
+      index = indexName;
       range = source.range;
       order = source.order ?? "asc";
       let fields: Array<string>;
@@ -160,18 +167,18 @@ const resolveSource = (
       } else if (indexName === "by_id") {
         fields = ["_id"];
       } else {
-        const index = view.schema?.tables
+        const declared = view.schema?.tables
           .get(tableName)
           ?.indexes.find(
             ({ indexDescriptor }) => indexDescriptor === indexName,
           );
-        if (index === undefined) {
+        if (declared === undefined) {
           throw new Error(
             `Cannot use index "${indexName}" for table "${tableName}" because ` +
               `it is not declared in the schema.`,
           );
         }
-        fields = index.fields.concat(["_creationTime", "_id"]);
+        fields = declared.fields.concat(["_creationTime", "_id"]);
       }
       fieldPathsToSortBy = fields;
       validateIndexRangeExpression(source, fields);
@@ -216,6 +223,7 @@ const resolveSource = (
     order,
     interval: {
       kind: "interval",
+      index,
       table,
       fields: fieldPathsToSortBy.includes("_id")
         ? fieldPathsToSortBy
@@ -241,6 +249,7 @@ export const stream = (
     let returned = 0;
     for (const doc of sortedDocs) {
       if (limit !== null && returned >= limit) return;
+      view.examine(interval.table, doc);
       examined(ReadSet.keyOf(interval.fields, doc as StoredDocument));
       if (filterFn(doc)) {
         returned++;
@@ -352,6 +361,7 @@ export const paginate = (
         reachedEnd = false;
         examined(endCursorKeys);
         if (cmp === 0) {
+          view.examine(interval.table, doc);
           rowsRead += 1;
           bytesRead += getDocumentSize(doc);
           readDocCursors.push(encodeCursor(doc, cursorFields));
@@ -361,6 +371,7 @@ export const paginate = (
         break;
       }
     }
+    view.examine(interval.table, doc);
     rowsRead += 1;
     bytesRead += getDocumentSize(doc);
     readDocCursors.push(encodeCursor(doc, cursorFields));

package/src/internal/KernelRefusal.ts

@@ -110,3 +110,163 @@ export const rowPending = (operation: string, row: number) =>
     row,
     message: `The test kernel supplies ${operation} in build-order row ${row}.`,
   });
+
+/**
+ * Snapshot bytes are not a kernel snapshot this kernel reads: an unknown
+ * header, a body that is not the snapshot's JSON, or a value that does not
+ * decode.
+ */
+export class SnapshotMalformed extends Schema.TaggedError<SnapshotMalformed>()(
+  "SnapshotMalformed",
+  { reason: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's body does not hash to the digest its header names, so its bytes
+ * changed after export.
+ */
+export class SnapshotDigestMismatch extends Schema.TaggedError<SnapshotDigestMismatch>()(
+  "SnapshotDigestMismatch",
+  { expected: Schema.String, actual: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's components are not the components registered on the world
+ * restoring it.
+ */
+export class SnapshotComponentMismatch extends Schema.TaggedError<SnapshotComponentMismatch>()(
+  "SnapshotComponentMismatch",
+  {
+    snapshot: Schema.Array(Schema.String),
+    registered: Schema.Array(Schema.String),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A job's test world is named by no world, or by more than one, so the job
+ * could not run under the world that scheduled it.
+ */
+export class SnapshotWorldUnresolved extends Schema.TaggedError<SnapshotWorldUnresolved>()(
+  "SnapshotWorldUnresolved",
+  {
+    name: Schema.String,
+    reason: Schema.Literals(["missing", "ambiguous"]),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A world holds work a snapshot does not carry: attempts held for `apply`, or,
+ * when it restores, commits of its own.
+ */
+export class SnapshotWorldBusy extends Schema.TaggedError<SnapshotWorldBusy>()(
+  "SnapshotWorldBusy",
+  {
+    version: Schema.Int,
+    held: Schema.Array(Schema.String),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A snapshot marks a secret the restore was not given, so the raw value its
+ * replay needs is not in memory.
+ */
+export class SnapshotSecretMissing extends Schema.TaggedError<SnapshotSecretMissing>()(
+  "SnapshotSecretMissing",
+  { ref: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A world is running work a snapshot taken or restored now would split: calls
+ * from the test, scheduler walks, or function executions, nested and detached
+ * ones included.
+ */
+export class SnapshotWorldRunning extends Schema.TaggedError<SnapshotWorldRunning>()(
+  "SnapshotWorldRunning",
+  {
+    registry: Schema.Literals(["running", "walks", "functions"]),
+    count: Schema.Int,
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A world has subscribers, whose identity versions a restore would rewind.
+ * Subscriptions are live client state, so a restore needs a world with none.
+ */
+export class SnapshotSubscribed extends Schema.TaggedError<SnapshotSubscribed>()(
+  "SnapshotSubscribed",
+  { subscribers: Schema.Int, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's identity counters stand at or behind an identity its state
+ * already holds, so the next allocation would reuse one.
+ */
+export class SnapshotAllocatorBehind extends Schema.TaggedError<SnapshotAllocatorBehind>()(
+  "SnapshotAllocatorBehind",
+  {
+    allocator: Schema.Literals([
+      "nextDocumentId",
+      "lastCreationTime",
+      "nextAttemptId",
+      "identityEpoch",
+    ]),
+    value: Schema.Finite,
+    required: Schema.Finite,
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A snapshot's rows are not what its write log publishes: a row filed under
+ * another table or an unregistered component, a version the log does not give
+ * it, or a log change whose before value is not the row it replaced.
+ */
+export class SnapshotRowInconsistent extends Schema.TaggedError<SnapshotRowInconsistent>()(
+  "SnapshotRowInconsistent",
+  {
+    componentPath: Schema.String,
+    id: Schema.String,
+    reason: Schema.Literals([
+      "id",
+      "component",
+      "log",
+      "row",
+      "systemFields",
+      "duplicate",
+    ]),
+    message: Schema.String,
+  },
+) {}
+
+/**
+ * A snapshot's commit timestamps do not strictly increase through its write
+ * log, or its latest commit timestamp is not the log's last.
+ */
+export class SnapshotTimestampInconsistent extends Schema.TaggedError<SnapshotTimestampInconsistent>()(
+  "SnapshotTimestampInconsistent",
+  { version: Schema.Int, commitTs: Schema.String, message: Schema.String },
+) {}
+
+/**
+ * A snapshot's jobs and job rows disagree: a job with no row, a row with no
+ * job, a job left running, or a target no registered component exports.
+ */
+export class SnapshotJobInconsistent extends Schema.TaggedError<SnapshotJobInconsistent>()(
+  "SnapshotJobInconsistent",
+  {
+    id: Schema.String,
+    reason: Schema.Literals([
+      "row",
+      "untargeted",
+      "inProgress",
+      "component",
+      "function",
+      "duplicate",
+    ]),
+    message: Schema.String,
+  },
+) {}