@graphrefly/ts 0.0.0

package/dist/core/index.js

@@ -0,0 +1,74 @@
+import {
+  Dispatcher,
+  Node,
+  batch,
+  defaultDispatcher,
+  defaultNodeVersionHash,
+  dynamicNode,
+  node
+} from "../chunk-I3IHOHCJ.js";
+import "../chunk-4VLAQHZI.js";
+import {
+  depBatch,
+  depCount,
+  depLatest,
+  depTerminal,
+  depWaves,
+  isTerminalComplete,
+  isTerminalError,
+  isTerminalNone,
+  terminalErrorValue
+} from "../chunk-SWTLEQL6.js";
+import {
+  SENTINEL,
+  TIER_CONTROL,
+  TIER_NOTIFICATION,
+  TIER_SETTLE,
+  TIER_START,
+  TIER_TEARDOWN,
+  TIER_TERMINAL,
+  TIER_VALUE,
+  errorPayload,
+  isDeferredTier,
+  isInvalidErrorPayload,
+  isPauseBufferedTier,
+  isTerminal,
+  isUpAllowed,
+  isValueTier,
+  messageTier
+} from "../chunk-DK554R7P.js";
+export {
+  Dispatcher,
+  Node,
+  SENTINEL,
+  TIER_CONTROL,
+  TIER_NOTIFICATION,
+  TIER_SETTLE,
+  TIER_START,
+  TIER_TEARDOWN,
+  TIER_TERMINAL,
+  TIER_VALUE,
+  batch,
+  defaultDispatcher,
+  defaultNodeVersionHash,
+  depBatch,
+  depCount,
+  depLatest,
+  depTerminal,
+  depWaves,
+  dynamicNode,
+  errorPayload,
+  isDeferredTier,
+  isInvalidErrorPayload,
+  isPauseBufferedTier,
+  isTerminal,
+  isTerminalComplete,
+  isTerminalError,
+  isTerminalNone,
+  isUpAllowed,
+  isValueTier,
+  messageTier,
+  node,
+  terminalErrorValue
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/cqrs/index.cjs

@@ -0,0 +1,595 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cqrs/index.ts
+var cqrs_exports = {};
+__export(cqrs_exports, {
+  cqrs: () => cqrs,
+  cqrsCommandHandler: () => cqrsCommandHandler,
+  cqrsProjection: () => cqrsProjection
+});
+module.exports = __toCommonJS(cqrs_exports);
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+
+// src/ctx/types.ts
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+
+// src/cqrs/index.ts
+function cqrsCommandHandler(type, handle) {
+  if (type.length === 0) throw new Error("cqrsCommandHandler: type must be non-empty");
+  return { type, handle };
+}
+function cqrs(graph, opts = {}) {
+  const name = opts.name ?? "cqrs";
+  const handlers = normalizeHandlers(opts.handlers ?? []);
+  const knownEvents = opts.events === void 0 ? void 0 : new Set(uniqueNames(opts.events, "cqrs.events"));
+  const now = opts.now ?? Date.now;
+  const dedupe = normalizeDedupePolicy(opts.dedupe);
+  const command = graph.node([], null, {
+    name: `${name}/command`,
+    factory: "cqrsCommand",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+  const runtime = graph.node(
+    [command],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        eventSeq: 0,
+        commandCount: 0,
+        errorCount: 0,
+        auditSeq: 0,
+        seenCommandIds: [],
+        seenEventIds: []
+      };
+      ctx.state.persist(true);
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        reduceCommandFact(
+          raw,
+          state,
+          handlers,
+          knownEvents,
+          now,
+          dedupe,
+          (fact) => ctx.down([["DATA", fact]])
+        );
+      }
+      ctx.state.set(state);
+    },
+    {
+      name: `${name}/runtime`,
+      factory: "cqrsRuntime",
+      meta: {
+        commandTypes: [...handlers.keys()],
+        eventTypes: knownEvents ? [...knownEvents] : "open",
+        dedupe: dedupeMeta(dedupe)
+      },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const events = runtimeProjection(
+    graph,
+    runtime,
+    "event",
+    `${name}/events`,
+    "cqrsEvents",
+    (fact) => fact.kind === "event" ? fact.event : void 0
+  );
+  const status = runtimeProjection(
+    graph,
+    runtime,
+    "status",
+    `${name}/status`,
+    "cqrsStatus",
+    (fact) => fact.kind === "status" ? fact.status : void 0
+  );
+  const errors = runtimeProjection(
+    graph,
+    runtime,
+    "error",
+    `${name}/errors`,
+    "cqrsErrors",
+    (fact) => fact.kind === "error" ? fact.error : void 0
+  );
+  const audit = runtimeProjection(
+    graph,
+    runtime,
+    "audit",
+    `${name}/audit`,
+    "cqrsAudit",
+    (fact) => fact.kind === "audit" ? fact.audit : void 0
+  );
+  const cursor = runtimeProjection(
+    graph,
+    runtime,
+    "cursor",
+    `${name}/cursor`,
+    "cqrsCursor",
+    (fact) => fact.kind === "cursor" ? fact.cursor : void 0
+  );
+  graph.retain(runtime, { reason: `${name}.cqrs.runtime` });
+  graph.retain(events, { reason: `${name}.cqrs.events` });
+  graph.retain(status, { reason: `${name}.cqrs.status` });
+  graph.retain(errors, { reason: `${name}.cqrs.errors` });
+  graph.retain(audit, { reason: `${name}.cqrs.audit` });
+  graph.retain(cursor, { reason: `${name}.cqrs.cursor` });
+  return {
+    command,
+    runtime,
+    events,
+    status,
+    errors,
+    audit,
+    cursor,
+    dispatch(commandFact) {
+      command.down([["DATA", commandFact]]);
+      return commandFact;
+    }
+  };
+}
+function cqrsProjection(graph, source, opts) {
+  const name = opts.name ?? "cqrsProjection";
+  const eventFilter = opts.events === void 0 ? void 0 : new Set(uniqueNames(opts.events, "cqrsProjection.events"));
+  const frames = graph.node(
+    [source.events],
+    (ctx) => {
+      const state = ctx.state.get() ?? { value: opts.initial };
+      ctx.state.persist(true);
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const event = raw;
+        if (eventFilter !== void 0 && !eventFilter.has(event.type)) continue;
+        try {
+          state.value = opts.reducer(state.value, event);
+          ctx.state.set(state);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "value",
+                state: state.value,
+                eventId: event.id,
+                cursor: event.runtimeCursor
+              }
+            ]
+          ]);
+        } catch (error) {
+          rethrowGraphRuntimeInvariant(error);
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "error",
+                error: {
+                  code: "projection-threw",
+                  message: errorMessage(error),
+                  eventId: event.id,
+                  eventType: event.type,
+                  cursor: event.runtimeCursor
+                }
+              }
+            ]
+          ]);
+          return;
+        }
+      }
+    },
+    {
+      name,
+      factory: "cqrsProjection",
+      meta: { eventTypes: eventFilter ? [...eventFilter] : "open" },
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const value = graph.node(
+    [frames],
+    (ctx) => {
+      for (const frame of depBatch(ctx, 0) ?? []) {
+        const typed = frame;
+        if (typed.kind === "value") ctx.down([["DATA", typed.state]]);
+      }
+    },
+    {
+      name: `${name}/value`,
+      factory: "cqrsProjectionValue",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const errors = graph.node(
+    [frames],
+    (ctx) => {
+      for (const frame of depBatch(ctx, 0) ?? []) {
+        const typed = frame;
+        if (typed.kind === "error") ctx.down([["DATA", typed.error]]);
+      }
+    },
+    {
+      name: `${name}/errors`,
+      factory: "cqrsProjectionErrors",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  const status = graph.node(
+    [frames],
+    (ctx) => {
+      for (const frame of depBatch(ctx, 0) ?? []) {
+        const typed = frame;
+        if (typed.kind === "value") {
+          ctx.down([
+            [
+              "DATA",
+              {
+                state: "updated",
+                eventId: typed.eventId,
+                cursor: typed.cursor
+              }
+            ]
+          ]);
+        } else {
+          ctx.down([
+            [
+              "DATA",
+              {
+                state: "errored",
+                eventId: typed.error.eventId,
+                eventType: typed.error.eventType,
+                cursor: typed.error.cursor
+              }
+            ]
+          ]);
+        }
+      }
+    },
+    {
+      name: `${name}/status`,
+      factory: "cqrsProjectionStatus",
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+  graph.retain(frames, { reason: `${name}.cqrsProjection.frames` });
+  graph.retain(value, { reason: `${name}.cqrsProjection.value` });
+  graph.retain(status, { reason: `${name}.cqrsProjection.status` });
+  graph.retain(errors, { reason: `${name}.cqrsProjection.errors` });
+  return { frames, value, status, errors };
+}
+function normalizeHandlers(definitions) {
+  const handlers = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    if (definition.type.length === 0) throw new Error("cqrs: handler type must be non-empty");
+    if (handlers.has(definition.type))
+      throw new Error(`cqrs: duplicate handler '${definition.type}'`);
+    handlers.set(definition.type, {
+      type: definition.type,
+      handle: definition.handle
+    });
+  }
+  return handlers;
+}
+function reduceCommandFact(raw, state, handlers, knownEvents, now, dedupe, emit) {
+  state.commandCount += 1;
+  const parsed = parseCommand(raw);
+  if (typeof parsed === "string") {
+    emitFailure(state, emit, raw, void 0, "malformed-command", parsed, dedupe);
+    return;
+  }
+  const command = parsed;
+  if (state.seenCommandIds.includes(command.id)) {
+    emitFailure(
+      state,
+      emit,
+      command,
+      command,
+      "duplicate-command",
+      `cqrs: duplicate command '${command.id}'`,
+      dedupe
+    );
+    return;
+  }
+  state.seenCommandIds.push(command.id);
+  trimDedupeWindow(state.seenCommandIds, dedupe.commandMaxEntries, (evicted) => {
+    state.commandDedupeEvicted = (state.commandDedupeEvicted ?? 0) + evicted;
+  });
+  const handler = handlers.get(command.type);
+  if (handler === void 0) {
+    emitFailure(
+      state,
+      emit,
+      command,
+      command,
+      "unknown-command",
+      `cqrs: unknown command '${command.type}'`,
+      dedupe
+    );
+    return;
+  }
+  let drafts;
+  try {
+    drafts = handler.handle(command);
+  } catch (error) {
+    rethrowGraphRuntimeInvariant(error);
+    emitFailure(state, emit, command, command, "handler-threw", errorMessage(error), dedupe);
+    return;
+  }
+  if (!Array.isArray(drafts)) {
+    emitFailure(
+      state,
+      emit,
+      command,
+      command,
+      "malformed-event",
+      "cqrs: command handler must return an event draft array",
+      dedupe
+    );
+    return;
+  }
+  const prepared = prepareEvents(command, drafts, state, knownEvents);
+  if (typeof prepared === "string") {
+    emitFailure(state, emit, command, command, preparedCode(prepared), prepared, dedupe);
+    return;
+  }
+  const timestampMs = readTimestampMs(now);
+  if (typeof timestampMs === "string") {
+    emitFailure(state, emit, command, command, "clock-threw", timestampMs, dedupe);
+    return;
+  }
+  const events = [];
+  for (const draft of prepared) {
+    state.eventSeq += 1;
+    state.seenEventIds.push(draft.id);
+    trimDedupeWindow(state.seenEventIds, dedupe.eventMaxEntries, (evicted) => {
+      state.eventDedupeEvicted = (state.eventDedupeEvicted ?? 0) + evicted;
+    });
+    const runtimeCursor = cursorOf(state, dedupe);
+    events.push({
+      id: draft.id,
+      type: draft.type,
+      seq: state.eventSeq,
+      cursor: state.eventSeq,
+      runtimeCursor,
+      commandId: command.id,
+      commandType: command.type,
+      payload: draft.payload,
+      timestampMs,
+      ...draft.aggregateId === void 0 ? {} : { aggregateId: draft.aggregateId },
+      ...draft.correlationId === void 0 ? {} : { correlationId: draft.correlationId },
+      ...draft.causationId === void 0 ? {} : { causationId: draft.causationId },
+      ...draft.metadata === void 0 ? {} : { metadata: draft.metadata }
+    });
+  }
+  for (const event of events) emit({ kind: "event", event });
+  emitStatus(state, emit, command, "accepted", events.length, dedupe);
+  emitAudit(state, emit, command, "success", events, void 0, void 0, dedupe);
+  emit({ kind: "cursor", cursor: cursorOf(state, dedupe) });
+}
+function parseCommand(value) {
+  if (!isObjectRecord(value)) return "cqrs: command fact must be an object";
+  if (typeof value.id !== "string" || value.id.length === 0) {
+    return "cqrs: command id must be a non-empty string";
+  }
+  if (typeof value.type !== "string" || value.type.length === 0) {
+    return "cqrs: command type must be a non-empty string";
+  }
+  return {
+    id: value.id,
+    type: value.type,
+    payload: value.payload,
+    ...typeof value.aggregateId === "string" ? { aggregateId: value.aggregateId } : {},
+    ...typeof value.correlationId === "string" ? { correlationId: value.correlationId } : {},
+    ...typeof value.causationId === "string" ? { causationId: value.causationId } : {},
+    ...isObjectRecord(value.metadata) ? { metadata: value.metadata } : {}
+  };
+}
+function prepareEvents(command, drafts, state, knownEvents) {
+  const seenInCommand = /* @__PURE__ */ new Set();
+  const prepared = [];
+  for (let i = 0; i < drafts.length; i += 1) {
+    const draft = drafts[i];
+    if (!isObjectRecord(draft) || typeof draft.type !== "string" || draft.type.length === 0) {
+      return "cqrs: event draft must have a non-empty type";
+    }
+    if (knownEvents !== void 0 && !knownEvents.has(draft.type)) {
+      return `cqrs: unknown event '${draft.type}'`;
+    }
+    const id = typeof draft.id === "string" && draft.id.length > 0 ? draft.id : `${command.id}:${i + 1}`;
+    if (state.seenEventIds.includes(id) || seenInCommand.has(id)) {
+      return `cqrs: duplicate event '${id}'`;
+    }
+    seenInCommand.add(id);
+    prepared.push({
+      id,
+      type: draft.type,
+      payload: draft.payload,
+      ...typeof draft.aggregateId === "string" ? { aggregateId: draft.aggregateId } : {},
+      ...typeof draft.correlationId === "string" ? { correlationId: draft.correlationId } : {},
+      ...typeof draft.causationId === "string" ? { causationId: draft.causationId } : {},
+      ...isObjectRecord(draft.metadata) ? { metadata: draft.metadata } : {}
+    });
+  }
+  return prepared;
+}
+function preparedCode(message) {
+  if (message.includes("unknown event")) return "unknown-event";
+  if (message.includes("duplicate event")) return "duplicate-event";
+  return "malformed-event";
+}
+function rethrowGraphRuntimeInvariant(error) {
+  const message = errorMessage(error);
+  if (message.includes("R-reentrancy") || message.includes("R-rewire") || message.includes("R-graph-domain") || message.includes("D37") || message.includes("D22") || message.includes("different graph") || message.includes("cross-graph") || message.includes("wire bridge") || message.includes("mid-fn topology mutation") || message.includes("reentrant dep mutation") || message.includes("feedback cycle")) {
+    throw error;
+  }
+}
+function emitFailure(state, emit, raw, command, code, message, dedupe) {
+  state.errorCount += 1;
+  const cursor = cursorOf(state, dedupe);
+  const error = {
+    code,
+    message,
+    command: raw,
+    ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+    cursor
+  };
+  emit({ kind: "error", error });
+  emit({
+    kind: "status",
+    status: {
+      state: "rejected",
+      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+      eventCount: 0,
+      errorCode: code,
+      cursor
+    }
+  });
+  emitAudit(state, emit, command, "failure", [], code, message, dedupe);
+  emit({ kind: "cursor", cursor: cursorOf(state, dedupe) });
+}
+function emitStatus(state, emit, command, statusState, eventCount, dedupe) {
+  emit({
+    kind: "status",
+    status: {
+      state: statusState,
+      commandId: command.id,
+      commandType: command.type,
+      eventCount,
+      cursor: cursorOf(state, dedupe)
+    }
+  });
+}
+function emitAudit(state, emit, command, outcome, events, errorCode, errorMessageValue, dedupe) {
+  state.auditSeq += 1;
+  emit({
+    kind: "audit",
+    audit: {
+      seq: state.auditSeq,
+      ...command === void 0 ? {} : { commandId: command.id, commandType: command.type },
+      outcome,
+      eventIds: Object.freeze(events.map((event) => event.id)),
+      eventTypes: Object.freeze(events.map((event) => event.type)),
+      ...errorCode === void 0 ? {} : { errorCode },
+      ...errorMessageValue === void 0 ? {} : { errorMessage: errorMessageValue },
+      cursor: cursorOf(state, dedupe)
+    }
+  });
+}
+function runtimeProjection(graph, runtime, kind, name, factory, select) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        if (typed.kind !== kind) continue;
+        const selected = select(typed);
+        if (selected !== void 0) ctx.down([["DATA", selected]]);
+      }
+    },
+    {
+      name,
+      factory,
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false
+    }
+  );
+}
+function cursorOf(state, dedupe) {
+  return {
+    eventSeq: state.eventSeq,
+    commandCount: state.commandCount,
+    errorCount: state.errorCount,
+    auditSeq: state.auditSeq,
+    ...dedupe.bounded ? {
+      dedupe: {
+        commandIdsRetained: state.seenCommandIds.length,
+        eventIdsRetained: state.seenEventIds.length,
+        commandIdsEvicted: state.commandDedupeEvicted ?? 0,
+        eventIdsEvicted: state.eventDedupeEvicted ?? 0
+      }
+    } : {}
+  };
+}
+function normalizeDedupePolicy(policy) {
+  const commandMaxEntries = normalizeDedupeWindow(policy?.commands, "cqrs.dedupe.commands");
+  const eventMaxEntries = normalizeDedupeWindow(policy?.events, "cqrs.dedupe.events");
+  return {
+    ...commandMaxEntries === void 0 ? {} : { commandMaxEntries },
+    ...eventMaxEntries === void 0 ? {} : { eventMaxEntries },
+    bounded: commandMaxEntries !== void 0 || eventMaxEntries !== void 0
+  };
+}
+function normalizeDedupeWindow(window, owner) {
+  if (window === void 0 || window === "unbounded") return void 0;
+  if (!Number.isInteger(window.maxEntries) || window.maxEntries < 0) {
+    throw new RangeError(`${owner}: maxEntries must be a non-negative integer`);
+  }
+  return window.maxEntries;
+}
+function dedupeMeta(dedupe) {
+  if (!dedupe.bounded) return "unbounded";
+  return {
+    commands: dedupe.commandMaxEntries === void 0 ? "unbounded" : { maxEntries: dedupe.commandMaxEntries },
+    events: dedupe.eventMaxEntries === void 0 ? "unbounded" : { maxEntries: dedupe.eventMaxEntries }
+  };
+}
+function trimDedupeWindow(ids, maxEntries, onEvicted) {
+  if (maxEntries === void 0 || ids.length <= maxEntries) return;
+  const evicted = ids.length - maxEntries;
+  ids.splice(0, evicted);
+  onEvicted(evicted);
+}
+function readTimestampMs(now) {
+  try {
+    const timestampMs = now();
+    return Number.isFinite(timestampMs) ? timestampMs : "cqrs: now() must return a finite number";
+  } catch (error) {
+    return `cqrs: now() threw: ${errorMessage(error)}`;
+  }
+}
+function uniqueNames(values, owner) {
+  const unique = [...new Set(values)];
+  if (unique.length !== values.length) throw new Error(`${owner}: duplicate value`);
+  for (const value of unique) {
+    if (value.length === 0) throw new Error(`${owner}: values must be non-empty`);
+  }
+  return Object.freeze(unique);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cqrs,
+  cqrsCommandHandler,
+  cqrsProjection
+});
+//# sourceMappingURL=index.cjs.map