statewire 0.14.0 → 0.15.0

package/src/wire/documents.ts

@@ -0,0 +1,109 @@
+import { applyOps } from "./ops";
+import { reviveValue } from "./meta";
+import type { StatewirePath } from "./ops";
+
+export namespace StatewireDocuments {
+  export type Document = { key: readonly string[] | null; value: unknown };
+  export type State = {
+    mode: "mounted" | "keyless" | null;
+    documents: ReadonlyMap<number, Document>;
+  };
+}
+
+const invalid: (message: string) => never = (message) => {
+  throw new Error(`statewire: protocol error: ${message}`);
+};
+
+export const applyDocumentOps = (
+  previous: StatewireDocuments.State,
+  ops: readonly unknown[],
+) => {
+  let mode = previous.mode;
+  const documents = new Map(previous.documents);
+  const changedPaths: StatewirePath[] = [];
+  for (const raw of ops) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      invalid("operation must be an object");
+    }
+    const op = raw as Record<string, unknown>;
+    const doc = op.doc === undefined ? 0 : op.doc;
+    if (typeof doc !== "number" || !Number.isSafeInteger(doc) || doc < 0) {
+      invalid("doc must be a nonnegative safe integer");
+    }
+    if (
+      !["mount", "unmount", "add", "replace", "remove"].includes(
+        op.op as string,
+      )
+    ) {
+      const { doc: _doc, ...unknown } = op;
+      applyOps(undefined, [unknown]);
+      continue;
+    }
+    if (mode === null) {
+      if (op.op === "mount") mode = "mounted";
+      else if (
+        op.op === "replace" &&
+        doc === 0 &&
+        Array.isArray(op.path) &&
+        op.path.length === 0 &&
+        "value" in op
+      ) {
+        mode = "keyless";
+        documents.set(0, { key: null, value: undefined });
+      } else
+        invalid(
+          "first operation must mount a document or replace document 0 at the root",
+        );
+    }
+    if (
+      mode === "keyless" &&
+      (doc !== 0 || op.op === "mount" || op.op === "unmount")
+    ) {
+      invalid("keyless mode only supports mutations of document 0");
+    }
+    if (op.op === "mount") {
+      if (documents.has(doc)) invalid("document is already mounted");
+      if (
+        !Array.isArray(op.key) ||
+        !op.key.every((key) => typeof key === "string") ||
+        !("value" in op)
+      ) {
+        invalid("mount requires a key array and value");
+      }
+      documents.set(doc, {
+        key: op.key,
+        value:
+          op.meta === undefined ? op.value : reviveValue(op.value, op.meta),
+      });
+      if (doc === 0) changedPaths.push([]);
+    } else if (op.op === "unmount") {
+      if (!documents.delete(doc)) invalid("document is not mounted");
+      if (doc === 0) changedPaths.push([]);
+    } else if (op.op === "add" || op.op === "replace" || op.op === "remove") {
+      const document = documents.get(doc);
+      if (!document) invalid("document is not mounted");
+      if (
+        !Array.isArray(op.path) ||
+        !op.path.every(
+          (part) =>
+            typeof part === "string" ||
+            (typeof part === "number" &&
+              Number.isSafeInteger(part) &&
+              part >= 0),
+        )
+      ) {
+        invalid("operation requires a valid path");
+      }
+      if (op.op !== "remove" && !("value" in op))
+        invalid("operation requires a value");
+      const { doc: _doc, meta, ...mutation } = op;
+      if (meta !== undefined)
+        mutation.value = reviveValue(mutation.value, meta);
+      const applied = applyOps(document.value, [mutation]);
+      documents.set(doc, { ...document, value: applied.state });
+      if (doc === 0) changedPaths.push(...applied.changedPaths);
+    }
+  }
+  if (mode === null) invalid("hello missing snapshot");
+  return { mode, documents, changedPaths };
+};

package/src/wire/limits.ts

@@ -0,0 +1,6 @@
+export const MAX_COMMANDS_PER_FRAME = 256;
+export const MAX_INFLIGHT_COMMANDS_PER_CLIENT = 256;
+export const MAX_FRAME_BODY_BYTES = 8 * 1024 * 1024;
+export const MAX_CONTEXT_VALUE_BYTES = 64 * 1024;
+export const MAX_INFLIGHT_COMMANDS_PER_HOST = 1024;
+export const COMMAND_CAPACITY_RETRY_MS = 1_000;

package/src/wire/meta.ts

@@ -42,7 +42,12 @@ export const reviveValue = (
       return fault(`meta path ${path.join(".")} must name a string`);
     }
     const date = new Date(walked.leaf);
-    if (Number.isNaN(date.getTime())) {
+    if (
+      !/(?:T| )\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})$/i.test(
+        walked.leaf,
+      ) ||
+      Number.isNaN(date.getTime())
+    ) {
       return fault(`invalid date at meta path ${path.join(".")}`);
     }
     if (walked.parent === undefined) return date;

package/src/wire/ops.ts

@@ -161,8 +161,7 @@ const applyOpToDraft = (box: { state: unknown }, op: Statewire.Op): void => {
     return;
   }
   if (op.path.length === 0) {
-    if (op.op !== "replace") throw invalid(op);
-    box.state = sanitizeValue(op.value);
+    box.state = op.op === "remove" ? undefined : sanitizeValue(op.value);
     return;
   }
   const walked = walkStatePath(box.state, op.path, "parent");

package/src/wire/version.ts

@@ -0,0 +1,3 @@
+export const PROTOCOL_VERSION = "1";
+export const VERSION_HEADER = "Statewire-Version";
+export const WS_SUBPROTOCOL = "statewire.v1";