@rocicorp/zero 0.25.0-canary.1 → 0.25.0-canary.10

package/out/zero-client/src/client/metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.js","sources":["../../../../../zero-client/src/client/metrics.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {ClientErrorKind} from './client-error-kind.ts';\nimport {\n  isClientError,\n  isServerError,\n  type ZeroError,\n  type ZeroErrorKind,\n} from './error.ts';\nimport {MetricName} from './metric-name.ts';\n\n// This value is used to indicate that the client's last connection attempt\n// failed. We don't make this -1 because we want to stack this never connected\n// state in a graph on top of actual connection times, so it should be greater\n// than any other value.\nexport const DID_NOT_CONNECT_VALUE = 100 * 1000;\n\nexport const REPORT_INTERVAL_MS = 5_000;\n\ntype NotConnectedReason =\n  | 'init'\n  | 'error'\n  | 'hidden'\n  | 'hidden_was_init'\n  | 'hidden_was_error';\n\nexport function getLastConnectErrorValue(reason: ZeroError) {\n  return `${isServerError(reason) ? 'server_' : 'client_'}${camelToSnake(reason.kind)}` as const;\n}\n\n// camelToSnake is used to convert a ZeroErrorKind into a suitable\n// metric name, eg AuthInvalidated => auth_invalidated. It converts\n// both PascalCase and camelCase to snake_case.\nfunction camelToSnake(kind: ZeroErrorKind): string {\n  return kind\n    .split(/\\.?(?=[A-Z])/)\n    .join('_')\n    .toLowerCase();\n}\n\n/**\n * Returns whether an error should be reported in metrics and\n * increment the connect error count.\n *\n * Returns `true` for all server errors and client errors that represent actual\n * connection problems. Returns `false` for expected client-side disconnections\n * (user disconnect, client closed, hidden tab, clean/abrupt close).\n */\nexport function shouldReportConnectError(reason: ZeroError): boolean {\n  if (!isClientError(reason)) {\n    return true;\n  }\n  switch (reason.kind) {\n    case ClientErrorKind.Hidden:\n    case ClientErrorKind.ClientClosed:\n    case ClientErrorKind.UserDisconnect:\n    case ClientErrorKind.CleanClose:\n    case ClientErrorKind.AbruptClose:\n      return false;\n    default:\n      return true;\n  }\n}\n\ntype MetricsReporter = (metrics: Series[]) => MaybePromise<void>;\n\nexport type MetricManagerOptions = {\n  reportIntervalMs: number;\n  host: string;\n  source: string;\n  reporter: MetricsReporter;\n  lc: LogContext;\n};\n\n/**\n * MetricManager keeps track of the set of metrics in use and flushes them\n * to a format suitable for reporting.\n */\nexport class MetricManager {\n  #reportIntervalMs: number;\n  #host: string;\n  #reporter: MetricsReporter;\n  #lc: LogContext;\n  #timerID: ReturnType<typeof setInterval> | null;\n\n  constructor(opts: MetricManagerOptions) {\n    this.#reportIntervalMs = opts.reportIntervalMs;\n    this.#host = opts.host;\n    this.#reporter = opts.reporter;\n    this.#lc = opts.lc;\n\n    this.tags.push(`source:${opts.source}`);\n\n    this.timeToConnectMs.set(DID_NOT_CONNECT_VALUE);\n    this.#setNotConnectedReason('init');\n\n    this.#timerID = setInterval(() => {\n      void this.flush();\n    }, this.#reportIntervalMs);\n  }\n\n  #metrics: Flushable[] = [];\n\n  // timeToConnectMs measures the time from the call to connect() to receiving\n  // the 'connected' ws message. We record the DID_NOT_CONNECT_VALUE if the previous\n  // connection attempt failed for any reason.\n  //\n  // We set the gauge using #connectStart as follows:\n  // - #connectStart is undefined if we are disconnected or connected; it is\n  //   defined only in the Connecting state, as a number representing the timestamp\n  //   at which we started connecting.\n  // - #connectStart is set to the current time when connect() is called.\n  // - When we receive the 'connected' message we record the time to connect and\n  //   set #connectStart to undefined.\n  // - If disconnect() is called with a defined #connectStart then we record\n  //   DID_NOT_CONNECT_VALUE and set #connectStart to undefined.\n  //\n  // TODO: this should be folded into the ConnectionManager.\n  readonly timeToConnectMs = this.#register(\n    new Gauge(MetricName.TimeToConnectMs),\n  );\n\n  // lastConnectError records the last error that occurred when connecting,\n  // if any. It is cleared when connecting successfully or when reported, so this\n  // state only gets reported if there was a failure during the reporting period and\n  // we are still not connected.\n  readonly lastConnectError = this.#register(\n    new State(\n      MetricName.LastConnectError,\n      true, // clearOnFlush\n    ),\n  );\n\n  // notConnected records the reason why the client is not currently connected.\n  // It is cleared when the client successfully connects.\n  readonly #notConnected = this.#register(new State(MetricName.NotConnected));\n\n  // The time from the call to connect() to receiving the 'connected' ws message\n  // for the current connection.  Cleared when the client is not connected.\n  // TODO: Not actually currently cleared on disconnect untill there is a\n  // connect error, or client reports disconnected and waiting for visible.\n  // Should have a value iff _notConnected has no value.\n  readonly #timeToConnectMsV2 = this.#register(\n    new Gauge(MetricName.TimeToConnectMsV2),\n  );\n\n  // lastConnectErrorV2 records the last error that occurred when connecting,\n  // if any. It is cleared when the client successfully connects or\n  // stops trying to connect due to being hidden.\n  // Should have a value iff notConnected state is NotConnectedReason.Error.\n  readonly #lastConnectErrorV2 = this.#register(\n    new State(MetricName.LastConnectErrorV2),\n  );\n\n  // The total time it took to connect across retries for the current\n  // connection.  Cleared when the client is not connected.\n  // TODO: Not actually currently cleared on disconnect until there is a\n  // connect error, or client reports disconnected and waiting for visible.\n  // See Zero.#totalToConnectStart for details of how this total is computed.\n  // Should have a value iff _notConnected has no value.\n  readonly #totalTimeToConnectMs = this.#register(\n    new Gauge(MetricName.TotalTimeToConnectMs),\n  );\n\n  #setNotConnectedReason(reason: NotConnectedReason) {\n    this.#notConnected.set(reason);\n  }\n\n  setConnected(timeToConnectMs: number, totalTimeToConnectMs: number) {\n    this.#notConnected.clear();\n    this.#lastConnectErrorV2.clear();\n    this.#timeToConnectMsV2.set(timeToConnectMs);\n    this.#totalTimeToConnectMs.set(totalTimeToConnectMs);\n  }\n\n  setDisconnectedWaitingForVisible() {\n    this.#timeToConnectMsV2.clear();\n    this.#totalTimeToConnectMs.clear();\n    this.#lastConnectErrorV2.clear();\n    let notConnectedReason: NotConnectedReason;\n    switch (this.#notConnected.get()) {\n      case 'init':\n        notConnectedReason = 'hidden_was_init';\n        break;\n      case 'error':\n        notConnectedReason = 'hidden_was_error';\n        break;\n      default:\n        notConnectedReason = 'hidden';\n        break;\n    }\n    this.#setNotConnectedReason(notConnectedReason);\n  }\n\n  setConnectError(reason: ZeroError) {\n    this.#timeToConnectMsV2.clear();\n    this.#totalTimeToConnectMs.clear();\n    this.#setNotConnectedReason('error');\n    this.#lastConnectErrorV2.set(getLastConnectErrorValue(reason));\n  }\n\n  /**\n   * Tags to include in all metrics.\n   */\n  readonly tags: string[] = [];\n\n  // Flushes all metrics to an array of time series (plural), one Series\n  // per metric.\n  async flush() {\n    const lc = this.#lc;\n    if (this.#timerID === null) {\n      lc.error?.('MetricManager.flush() called but already stopped');\n      return;\n    }\n    const allSeries: Series[] = [];\n    for (const metric of this.#metrics) {\n      const series = metric.flush();\n      if (series !== undefined) {\n        allSeries.push({\n          ...series,\n          host: this.#host,\n          tags: this.tags,\n        });\n      }\n    }\n    if (allSeries.length === 0) {\n      lc?.debug?.('No metrics to report');\n      return;\n    }\n    try {\n      await this.#reporter(allSeries);\n    } catch (e) {\n      lc?.error?.('Error reporting metrics', e);\n    }\n  }\n\n  stop() {\n    if (this.#timerID === null) {\n      this.#lc.error?.('MetricManager.stop() called but already stopped');\n      return;\n    }\n    clearInterval(this.#timerID);\n    this.#timerID = null;\n  }\n\n  #register<M extends Flushable>(metric: M) {\n    this.#metrics.push(metric);\n    return metric;\n  }\n}\n\n// These two types are influenced by Datadog's API's needs. We could change what\n// we use internally if necessary, but we'd just have to convert to/from before\n// sending to DD. So for convenience we go with their format.\n\n/** Series is a time series of points for a single metric. */\nexport type Series = {\n  host: string;\n  metric: string; // We call this 'name' bc 'metric' is overloaded in code.\n  points: Point[];\n  tags?: string[];\n};\n/**\n * A point is a second-resolution timestamp and a set of values for that\n * timestamp. A point represents exactly one second in time and the values\n * are those recorded for that second. The first element of this array\n * is the timestamp and the second element is an array of values.\n */\nexport type Point = [number, number[]];\n\nfunction makePoint(ts: number, value: number): Point {\n  return [ts, [value]];\n}\n\ntype Flushable = {\n  flush(): Pick<Series, 'metric' | 'points'> | undefined;\n};\n\n/**\n * Gauge is a metric type that represents a single value that can go up and\n * down. It's typically used to track discrete values or counts eg the number\n * of active users, number of connections, cpu load, etc. A gauge retains\n * its value when flushed.\n *\n * We use a Gauge to sample at the client. If we are interested in tracking\n * a metric value *per client*, the client can note the latest value in\n * a Gauge metric. The metric is periodically reported via Reporter. On the\n * server, we graph the value of the metric rolled up over the periodic\n * reporting period, that is, counted over a span of time equal to the\n * reporting period. The result is ~one point per client per reporting\n * period.\n */\nexport class Gauge implements Flushable {\n  readonly #name: string;\n  #value: number | undefined = undefined;\n\n  constructor(name: string) {\n    this.#name = name;\n  }\n\n  set(value: number) {\n    this.#value = value;\n  }\n\n  get() {\n    return this.#value;\n  }\n\n  clear() {\n    this.#value = undefined;\n  }\n\n  flush() {\n    if (this.#value === undefined) {\n      return undefined;\n    }\n    // Gauge reports the timestamp at flush time, not at the point the value was\n    // recorded.\n    const points = [makePoint(t(), this.#value)];\n    return {metric: this.#name, points};\n  }\n}\n\nfunction t() {\n  return Math.round(Date.now() / 1000);\n}\n\n/**\n * State is a metric type that represents a specific state that the system is\n * in, for example the state of a connection which may be 'open' or 'closed'.\n * The state is given a name/prefix at construction time (eg 'connection') and\n * then can be set to a specific state (eg 'open'). The prefix is prepended to\n * the set state (eg, 'connection_open') and a value of 1 is reported.\n * Unset/cleared states are not reported.\n *\n * Example:\n *   const s = new State('connection');\n *   s.set('open');\n *   s.flush(); // returns {metric: 'connection_open', points: [[now(), [1]]]}\n */\nexport class State implements Flushable {\n  readonly #prefix: string;\n  readonly #clearOnFlush: boolean;\n  #current: string | undefined = undefined;\n\n  constructor(prefix: string, clearOnFlush = false) {\n    this.#prefix = prefix;\n    this.#clearOnFlush = clearOnFlush;\n  }\n\n  set(state: string) {\n    this.#current = state;\n  }\n\n  get() {\n    return this.#current;\n  }\n\n  clear() {\n    this.#current = undefined;\n  }\n\n  flush() {\n    if (this.#current === undefined) {\n      return undefined;\n    }\n    const gauge = new Gauge([this.#prefix, this.#current].join('_'));\n    gauge.set(1);\n    const series = gauge.flush();\n    if (this.#clearOnFlush) {\n      this.clear();\n    }\n    return series;\n  }\n}\n"],"names":["ClientErrorKind.Hidden","ClientErrorKind.ClientClosed","ClientErrorKind.UserDisconnect","ClientErrorKind.CleanClose","ClientErrorKind.AbruptClose","MetricName.TimeToConnectMs","MetricName.LastConnectError","MetricName.NotConnected","MetricName.TimeToConnectMsV2","MetricName.LastConnectErrorV2","MetricName.TotalTimeToConnectMs"],"mappings":";;;AAeO,MAAM,wBAAwB,MAAM;AAEpC,MAAM,qBAAqB;AAS3B,SAAS,yBAAyB,QAAmB;AAC1D,SAAO,GAAG,cAAc,MAAM,IAAI,YAAY,SAAS,GAAG,aAAa,OAAO,IAAI,CAAC;AACrF;AAKA,SAAS,aAAa,MAA6B;AACjD,SAAO,KACJ,MAAM,cAAc,EACpB,KAAK,GAAG,EACR,YAAA;AACL;AAUO,SAAS,yBAAyB,QAA4B;AACnE,MAAI,CAAC,cAAc,MAAM,GAAG;AAC1B,WAAO;AAAA,EACT;AACA,UAAQ,OAAO,MAAA;AAAA,IACb,KAAKA;AAAAA,IACL,KAAKC;AAAAA,IACL,KAAKC;AAAAA,IACL,KAAKC;AAAAA,IACL,KAAKC;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EAAA;AAEb;AAgBO,MAAM,cAAc;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,MAA4B;AACtC,SAAK,oBAAoB,KAAK;AAC9B,SAAK,QAAQ,KAAK;AAClB,SAAK,YAAY,KAAK;AACtB,SAAK,MAAM,KAAK;AAEhB,SAAK,KAAK,KAAK,UAAU,KAAK,MAAM,EAAE;AAEtC,SAAK,gBAAgB,IAAI,qBAAqB;AAC9C,SAAK,uBAAuB,MAAM;AAElC,SAAK,WAAW,YAAY,MAAM;AAChC,WAAK,KAAK,MAAA;AAAA,IACZ,GAAG,KAAK,iBAAiB;AAAA,EAC3B;AAAA,EAEA,WAAwB,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBf,kBAAkB,KAAK;AAAA,IAC9B,IAAI,MAAMC,eAA0B;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO7B,mBAAmB,KAAK;AAAA,IAC/B,IAAI;AAAA,MACFC;AAAAA,MACA;AAAA;AAAA,IAAA;AAAA,EACF;AAAA;AAAA;AAAA,EAKO,gBAAgB,KAAK,UAAU,IAAI,MAAMC,YAAuB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOjE,qBAAqB,KAAK;AAAA,IACjC,IAAI,MAAMC,iBAA4B;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO/B,sBAAsB,KAAK;AAAA,IAClC,IAAI,MAAMC,kBAA6B;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAShC,wBAAwB,KAAK;AAAA,IACpC,IAAI,MAAMC,oBAA+B;AAAA,EAAA;AAAA,EAG3C,uBAAuB,QAA4B;AACjD,SAAK,cAAc,IAAI,MAAM;AAAA,EAC/B;AAAA,EAEA,aAAa,iBAAyB,sBAA8B;AAClE,SAAK,cAAc,MAAA;AACnB,SAAK,oBAAoB,MAAA;AACzB,SAAK,mBAAmB,IAAI,eAAe;AAC3C,SAAK,sBAAsB,IAAI,oBAAoB;AAAA,EACrD;AAAA,EAEA,mCAAmC;AACjC,SAAK,mBAAmB,MAAA;AACxB,SAAK,sBAAsB,MAAA;AAC3B,SAAK,oBAAoB,MAAA;AACzB,QAAI;AACJ,YAAQ,KAAK,cAAc,IAAA,GAAI;AAAA,MAC7B,KAAK;AACH,6BAAqB;AACrB;AAAA,MACF,KAAK;AACH,6BAAqB;AACrB;AAAA,MACF;AACE,6BAAqB;AACrB;AAAA,IAAA;AAEJ,SAAK,uBAAuB,kBAAkB;AAAA,EAChD;AAAA,EAEA,gBAAgB,QAAmB;AACjC,SAAK,mBAAmB,MAAA;AACxB,SAAK,sBAAsB,MAAA;AAC3B,SAAK,uBAAuB,OAAO;AACnC,SAAK,oBAAoB,IAAI,yBAAyB,MAAM,CAAC;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA,EAKS,OAAiB,CAAA;AAAA;AAAA;AAAA,EAI1B,MAAM,QAAQ;AACZ,UAAM,KAAK,KAAK;AAChB,QAAI,KAAK,aAAa,MAAM;AAC1B,SAAG,QAAQ,kDAAkD;AAC7D;AAAA,IACF;AACA,UAAM,YAAsB,CAAA;AAC5B,eAAW,UAAU,KAAK,UAAU;AAClC,YAAM,SAAS,OAAO,MAAA;AACtB,UAAI,WAAW,QAAW;AACxB,kBAAU,KAAK;AAAA,UACb,GAAG;AAAA,UACH,MAAM,KAAK;AAAA,UACX,MAAM,KAAK;AAAA,QAAA,CACZ;AAAA,MACH;AAAA,IACF;AACA,QAAI,UAAU,WAAW,GAAG;AAC1B,UAAI,QAAQ,sBAAsB;AAClC;AAAA,IACF;AACA,QAAI;AACF,YAAM,KAAK,UAAU,SAAS;AAAA,IAChC,SAAS,GAAG;AACV,UAAI,QAAQ,2BAA2B,CAAC;AAAA,IAC1C;AAAA,EACF;AAAA,EAEA,OAAO;AACL,QAAI,KAAK,aAAa,MAAM;AAC1B,WAAK,IAAI,QAAQ,iDAAiD;AAClE;AAAA,IACF;AACA,kBAAc,KAAK,QAAQ;AAC3B,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,UAA+B,QAAW;AACxC,SAAK,SAAS,KAAK,MAAM;AACzB,WAAO;AAAA,EACT;AACF;AAqBA,SAAS,UAAU,IAAY,OAAsB;AACnD,SAAO,CAAC,IAAI,CAAC,KAAK,CAAC;AACrB;AAoBO,MAAM,MAA2B;AAAA,EAC7B;AAAA,EACT,SAA6B;AAAA,EAE7B,YAAY,MAAc;AACxB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,IAAI,OAAe;AACjB,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,MAAM;AACJ,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,QAAQ;AACN,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,QAAQ;AACN,QAAI,KAAK,WAAW,QAAW;AAC7B,aAAO;AAAA,IACT;AAGA,UAAM,SAAS,CAAC,UAAU,KAAK,KAAK,MAAM,CAAC;AAC3C,WAAO,EAAC,QAAQ,KAAK,OAAO,OAAA;AAAA,EAC9B;AACF;AAEA,SAAS,IAAI;AACX,SAAO,KAAK,MAAM,KAAK,IAAA,IAAQ,GAAI;AACrC;AAeO,MAAM,MAA2B;AAAA,EAC7B;AAAA,EACA;AAAA,EACT,WAA+B;AAAA,EAE/B,YAAY,QAAgB,eAAe,OAAO;AAChD,SAAK,UAAU;AACf,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,IAAI,OAAe;AACjB,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,MAAM;AACJ,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,QAAQ;AACN,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,QAAQ;AACN,QAAI,KAAK,aAAa,QAAW;AAC/B,aAAO;AAAA,IACT;AACA,UAAM,QAAQ,IAAI,MAAM,CAAC,KAAK,SAAS,KAAK,QAAQ,EAAE,KAAK,GAAG,CAAC;AAC/D,UAAM,IAAI,CAAC;AACX,UAAM,SAAS,MAAM,MAAA;AACrB,QAAI,KAAK,eAAe;AACtB,WAAK,MAAA;AAAA,IACP;AACA,WAAO;AAAA,EACT;AACF;"}

package/out/zero-client/src/client/mutation-tracker.d.ts

@@ -1,22 +1,29 @@
-import type { EphemeralID, MutationTrackingData } from '../../../replicache/src/replicache-options.ts';
+import type { LogContext } from '@rocicorp/logger';
 import type { ReplicacheImpl } from '../../../replicache/src/impl.ts';
+import type { EphemeralID, MutationTrackingData } from '../../../replicache/src/replicache-options.ts';
 import { type MutationID, type PushResponseBody } from '../../../zero-protocol/src/push.ts';
+import type { MutatorResultSuccessDetails } from './custom.ts';
 import { type ZeroError } from './error.ts';
-import type { ZeroLogContext } from './zero-log-context.ts';
+type MutationSuccessType = MutatorResultSuccessDetails;
 /**
  * Tracks what pushes are in-flight and resolves promises when they're acked.
  */
 export declare class MutationTracker {
     #private;
-    constructor(lc: ZeroLogContext, ackMutations: (upTo: MutationID) => void, onFatalError: (error: ZeroError) => void);
+    constructor(lc: LogContext, ackMutations: (upTo: MutationID) => void, onFatalError: (error: ZeroError) => void);
     setClientIDAndWatch(clientID: string, experimentalWatch: ReplicacheImpl['experimentalWatch']): void;
-    trackMutation(): MutationTrackingData;
+    trackMutation(): MutationTrackingData<MutationSuccessType>;
     mutationIDAssigned(id: EphemeralID, mutationID: number): void;
     /**
      * Reject the mutation due to an unhandled exception on the client.
      * The mutation must not have been persisted to the client store.
      */
     rejectMutation(id: EphemeralID, e: unknown): void;
+    /**
+     * Reject all outstanding mutations. Called when the client is in a state
+     * that prevents mutations from being applied, such as offline or closed.
+     */
+    rejectAllOutstandingMutations(error: ZeroError): void;
     processPushResponse(response: PushResponseBody): void;
     /**
      * DEPRECATED: to be removed when we switch to fully driving
@@ -61,4 +68,5 @@ export declare class MutationTracker {
      */
     onAllMutationsApplied(listener: () => void): void;
 }
+export {};
 //# sourceMappingURL=mutation-tracker.d.ts.map

package/out/zero-client/src/client/mutation-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-tracker.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/mutation-tracker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACrB,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,iCAAiC,CAAC;AAOpE,OAAO,EAGL,KAAK,UAAU,EAIf,KAAK,gBAAgB,EACtB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAC,KAAK,SAAS,EAAC,MAAM,YAAY,CAAC;AAE1C,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAgB1D;;GAEG;AACH,qBAAa,eAAe;;gBAmBxB,EAAE,EAAE,cAAc,EAClB,YAAY,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,EACxC,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI;IAY1C,mBAAmB,CACjB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,cAAc,CAAC,mBAAmB,CAAC;IAexD,aAAa,IAAI,oBAAoB;IAUrC,kBAAkB,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAY7D;;;OAGG;IACH,cAAc,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI;IA+CjD,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAuDrD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,cAAc,EAAE,MAAM;IAIlC;;;;;;OAMG;IACH,YAAY,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAoB1C,IAAI,IAAI,WAEP;IAuHD;;;;;;;;;OASG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;CASlD"}
+{"version":3,"file":"mutation-tracker.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/mutation-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACrB,MAAM,+CAA+C,CAAC;AAevD,OAAO,EAGL,KAAK,UAAU,EAIf,KAAK,gBAAgB,EACtB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAc,KAAK,SAAS,EAAC,MAAM,YAAY,CAAC;AAGvD,KAAK,mBAAmB,GAAG,2BAA2B,CAAC;AAUvD;;GAEG;AACH,qBAAa,eAAe;;gBAoBxB,EAAE,EAAE,UAAU,EACd,YAAY,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,EACxC,YAAY,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI;IAY1C,mBAAmB,CACjB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,cAAc,CAAC,mBAAmB,CAAC;IAexD,aAAa,IAAI,oBAAoB,CAAC,mBAAmB,CAAC;IAU1D,kBAAkB,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAY7D;;;OAGG;IACH,cAAc,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI;IAOjD;;;OAGG;IACH,6BAA6B,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAmDrD,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAuDrD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,cAAc,EAAE,MAAM;IAIlC;;;;;;OAMG;IACH,YAAY,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAoB1C,IAAI,IAAI,WAEP;IAwJD;;;;;;;;;OASG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;CASlD"}

package/out/zero-client/src/client/mutation-tracker.js

@@ -0,0 +1,363 @@
+import { resolver } from "@rocicorp/resolver";
+import { assert, unreachable } from "../../../shared/src/asserts.js";
+import { getErrorDetails } from "../../../shared/src/error.js";
+import { must } from "../../../shared/src/must.js";
+import { emptyObject } from "../../../shared/src/sentinels.js";
+import { parse } from "../../../shared/src/valita.js";
+import { wrapWithApplicationError, ApplicationError, isApplicationError } from "../../../zero-protocol/src/application-error.js";
+import { PushFailed, InvalidPush } from "../../../zero-protocol/src/error-kind-enum.js";
+import { ZeroCache, Server } from "../../../zero-protocol/src/error-origin-enum.js";
+import { Internal, HTTP } from "../../../zero-protocol/src/error-reason-enum.js";
+import { ProtocolError } from "../../../zero-protocol/src/error.js";
+import { mutationResultSchema } from "../../../zero-protocol/src/push.js";
+import { isZeroError } from "./error.js";
+import { MUTATIONS_KEY_PREFIX } from "./keys.js";
+let currentEphemeralID = 0;
+function nextEphemeralID() {
+  return ++currentEphemeralID;
+}
+const successResultDetails = { type: "success" };
+class MutationTracker {
+  #outstandingMutations;
+  #ephemeralIDsByMutationID;
+  #allMutationsAppliedListeners;
+  #lc;
+  #ackMutations;
+  #onFatalError;
+  #clientID;
+  #largestOutstandingMutationID;
+  #currentMutationID;
+  constructor(lc, ackMutations, onFatalError) {
+    this.#lc = lc.withContext("MutationTracker");
+    this.#outstandingMutations = /* @__PURE__ */ new Map();
+    this.#ephemeralIDsByMutationID = /* @__PURE__ */ new Map();
+    this.#allMutationsAppliedListeners = /* @__PURE__ */ new Set();
+    this.#largestOutstandingMutationID = 0;
+    this.#currentMutationID = 0;
+    this.#ackMutations = ackMutations;
+    this.#onFatalError = onFatalError;
+  }
+  setClientIDAndWatch(clientID, experimentalWatch) {
+    assert(this.#clientID === void 0, "clientID already set");
+    this.#clientID = clientID;
+    experimentalWatch(
+      (diffs) => {
+        this.#processMutationResponses(diffs);
+      },
+      {
+        prefix: MUTATIONS_KEY_PREFIX + clientID + "/",
+        initialValuesInFirstDiff: true
+      }
+    );
+  }
+  trackMutation() {
+    const id = nextEphemeralID();
+    const mutationResolver = resolver();
+    this.#outstandingMutations.set(id, {
+      resolver: mutationResolver
+    });
+    return { ephemeralID: id, serverPromise: mutationResolver.promise };
+  }
+  mutationIDAssigned(id, mutationID) {
+    const entry = this.#outstandingMutations.get(id);
+    if (entry) {
+      entry.mutationID = mutationID;
+      this.#ephemeralIDsByMutationID.set(mutationID, id);
+      this.#largestOutstandingMutationID = Math.max(
+        this.#largestOutstandingMutationID,
+        mutationID
+      );
+    }
+  }
+  /**
+   * Reject the mutation due to an unhandled exception on the client.
+   * The mutation must not have been persisted to the client store.
+   */
+  rejectMutation(id, e) {
+    const entry = this.#outstandingMutations.get(id);
+    if (entry) {
+      this.#settleMutation(id, entry, wrapWithApplicationError(e));
+    }
+  }
+  /**
+   * Reject all outstanding mutations. Called when the client is in a state
+   * that prevents mutations from being applied, such as offline or closed.
+   */
+  rejectAllOutstandingMutations(error) {
+    if (this.#outstandingMutations.size === 0) {
+      return;
+    }
+    for (const [id, entry] of this.#outstandingMutations) {
+      this.#settleMutation(id, entry, error);
+    }
+    this.#largestOutstandingMutationID = this.#currentMutationID;
+    this.#notifyAllMutationsAppliedListeners();
+  }
+  /**
+   * Used when zero-cache pokes down mutation results.
+   */
+  #processMutationResponses(diffs) {
+    const clientID = must(this.#clientID);
+    let largestLmid = 0;
+    for (const diff of diffs) {
+      const mutationID = Number(
+        diff.key.slice(MUTATIONS_KEY_PREFIX.length + clientID.length + 1)
+      );
+      assert(
+        !isNaN(mutationID),
+        `MutationTracker received a diff with an invalid mutation ID: ${diff.key}`
+      );
+      largestLmid = Math.max(largestLmid, mutationID);
+      switch (diff.op) {
+        case "add": {
+          const result = parse(diff.newValue, mutationResultSchema);
+          if ("error" in result) {
+            this.#processMutationError(clientID, mutationID, result);
+          } else {
+            this.#processMutationOk(clientID, mutationID, result);
+          }
+          break;
+        }
+        case "del":
+          break;
+        case "change":
+          throw new Error("MutationTracker does not expect change operations");
+      }
+    }
+    if (largestLmid > 0) {
+      this.#ackMutations({
+        clientID: must(this.#clientID),
+        id: largestLmid
+      });
+    }
+  }
+  processPushResponse(response) {
+    if ("error" in response) {
+      this.#lc.error?.(
+        "Received an error response when pushing mutations",
+        response
+      );
+      const fatalError = this.#fatalErrorFromPushError(response);
+      if (fatalError) {
+        this.#onFatalError(fatalError);
+      }
+    } else {
+      this.#processPushOk(response);
+    }
+  }
+  #fatalErrorFromPushError(error) {
+    switch (error.error) {
+      case "unsupportedPushVersion":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: Internal,
+          message: `Unsupported push version`,
+          mutationIDs: []
+        });
+      case "unsupportedSchemaVersion":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: Internal,
+          message: `Unsupported schema version`,
+          mutationIDs: []
+        });
+      case "http":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: HTTP,
+          status: error.status,
+          message: `Fetch from API server returned non-OK status ${error.status}: ${error.details ?? "unknown"}`,
+          mutationIDs: []
+        });
+      case "zeroPusher":
+        return new ProtocolError({
+          kind: PushFailed,
+          origin: ZeroCache,
+          reason: Internal,
+          message: `ZeroPusher error: ${error.details ?? "unknown"}`,
+          mutationIDs: []
+        });
+      default:
+        unreachable();
+    }
+  }
+  /**
+   * DEPRECATED: to be removed when we switch to fully driving
+   * mutation resolution via poke.
+   *
+   * When we reconnect to zero-cache, we resolve all outstanding mutations
+   * whose ID is less than or equal to the lastMutationID.
+   *
+   * The reason is that any responses the API server sent
+   * to those mutations have been lost.
+   *
+   * An example case: the API server responds while the connection
+   * is down. Those responses are lost.
+   *
+   * Mutations whose LMID is > the lastMutationID are not resolved
+   * since they will be retried by the client, giving us another chance
+   * at getting a response.
+   *
+   * The only way to ensure that all API server responses are
+   * received would be to have the API server write them
+   * to the DB while writing the LMID.
+   */
+  onConnected(lastMutationID) {
+    this.lmidAdvanced(lastMutationID);
+  }
+  /**
+   * lmid advance will:
+   * 1. notify "allMutationsApplied" listeners if the lastMutationID
+   *    is greater than or equal to the largest outstanding mutation ID.
+   * 2. resolve all mutations whose mutation ID is less than or equal to
+   *    the lastMutationID.
+   */
+  lmidAdvanced(lastMutationID) {
+    assert(
+      lastMutationID >= this.#currentMutationID,
+      "lmid must be greater than or equal to current lmid"
+    );
+    if (lastMutationID === this.#currentMutationID) {
+      return;
+    }
+    try {
+      this.#currentMutationID = lastMutationID;
+      this.#resolveMutations(lastMutationID);
+    } finally {
+      if (lastMutationID >= this.#largestOutstandingMutationID) {
+        this.#notifyAllMutationsAppliedListeners();
+      }
+    }
+  }
+  get size() {
+    return this.#outstandingMutations.size;
+  }
+  #resolveMutations(upTo) {
+    for (const [id, entry] of this.#outstandingMutations) {
+      if (entry.mutationID && entry.mutationID <= upTo) {
+        this.#settleMutation(id, entry, emptyObject);
+      } else {
+        break;
+      }
+    }
+  }
+  #processPushOk(ok) {
+    for (const mutation of ok.mutations) {
+      if ("error" in mutation.result) {
+        this.#processMutationError(
+          mutation.id.clientID,
+          mutation.id.id,
+          mutation.result
+        );
+      } else {
+        this.#processMutationOk(
+          mutation.id.clientID,
+          mutation.id.id,
+          mutation.result
+        );
+      }
+    }
+  }
+  #processMutationError(clientID, mid, error) {
+    assert(
+      clientID === this.#clientID,
+      "received mutation for the wrong client"
+    );
+    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);
+    if (!ephemeralID) {
+      this.#lc.debug?.(
+        "Mutation already resolved or rejected (e.g. due to disconnect); ignore late reject."
+      );
+      return;
+    }
+    const entry = this.#outstandingMutations.get(ephemeralID);
+    assert(
+      entry && entry.mutationID === mid,
+      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`
+    );
+    if (error.error === "alreadyProcessed") {
+      this.#settleMutation(ephemeralID, entry, emptyObject);
+      return;
+    }
+    this.#settleMutation(
+      ephemeralID,
+      entry,
+      error.error === "app" ? new ApplicationError(
+        error.message ?? `Unknown application error: ${error.error}`,
+        error.details ? { details: error.details } : void 0
+      ) : new ProtocolError({
+        kind: InvalidPush,
+        origin: Server,
+        reason: Internal,
+        message: error.error === "oooMutation" ? "Server reported an out-of-order mutation" : `Unknown fallback error with mutation ID ${mid}: ${error.error}`,
+        details: getErrorDetails(error)
+      })
+    );
+    if (error.error === "oooMutation") {
+      this.#onFatalError(
+        new ProtocolError({
+          kind: InvalidPush,
+          origin: Server,
+          reason: Internal,
+          message: "Server reported an out-of-order mutation",
+          details: error.details
+        })
+      );
+    }
+  }
+  #processMutationOk(clientID, mid, result) {
+    assert(
+      clientID === this.#clientID,
+      "received mutation for the wrong client"
+    );
+    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);
+    if (!ephemeralID) {
+      this.#lc.debug?.(
+        "Mutation already resolved or rejected (e.g. due to disconnect); ignore late resolve."
+      );
+      return;
+    }
+    const entry = this.#outstandingMutations.get(ephemeralID);
+    assert(
+      entry && entry.mutationID === mid,
+      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`
+    );
+    this.#settleMutation(ephemeralID, entry, result);
+  }
+  #settleMutation(ephemeralID, entry, result) {
+    if (isApplicationError(result) || isZeroError(result)) {
+      entry.resolver.reject(result);
+    } else {
+      entry.resolver.resolve(successResultDetails);
+    }
+    this.#outstandingMutations.delete(ephemeralID);
+    if (entry.mutationID) {
+      this.#ephemeralIDsByMutationID.delete(entry.mutationID);
+    }
+  }
+  /**
+   * Be notified when all mutations have been included in the server snapshot.
+   *
+   * The query manager will not de-register queries from the server until there
+   * are no pending mutations.
+   *
+   * The reason is that a mutation may need to be rebased. We do not want
+   * data that was available the first time it was run to not be available
+   * on a rebase.
+   */
+  onAllMutationsApplied(listener) {
+    this.#allMutationsAppliedListeners.add(listener);
+  }
+  #notifyAllMutationsAppliedListeners() {
+    for (const listener of this.#allMutationsAppliedListeners) {
+      listener();
+    }
+  }
+}
+export {
+  MutationTracker
+};
+//# sourceMappingURL=mutation-tracker.js.map

package/out/zero-client/src/client/mutation-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-tracker.js","sources":["../../../../../zero-client/src/client/mutation-tracker.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\nimport type {NoIndexDiff} from '../../../replicache/src/btree/node.ts';\nimport type {ReplicacheImpl} from '../../../replicache/src/impl.ts';\nimport type {\n  EphemeralID,\n  MutationTrackingData,\n} from '../../../replicache/src/replicache-options.ts';\nimport {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {getErrorDetails} from '../../../shared/src/error.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {emptyObject} from '../../../shared/src/sentinels.ts';\nimport * as v from '../../../shared/src/valita.ts';\nimport {\n  ApplicationError,\n  isApplicationError,\n  wrapWithApplicationError,\n} from '../../../zero-protocol/src/application-error.ts';\nimport {ErrorKind} from '../../../zero-protocol/src/error-kind.ts';\nimport {ErrorOrigin} from '../../../zero-protocol/src/error-origin.ts';\nimport {ErrorReason} from '../../../zero-protocol/src/error-reason.ts';\nimport {ProtocolError} from '../../../zero-protocol/src/error.ts';\nimport {\n  mutationResultSchema,\n  type MutationError,\n  type MutationID,\n  type MutationOk,\n  type PushError,\n  type PushOk,\n  type PushResponseBody,\n} from '../../../zero-protocol/src/push.ts';\nimport type {MutatorResultSuccessDetails} from './custom.ts';\nimport {isZeroError, type ZeroError} from './error.ts';\nimport {MUTATIONS_KEY_PREFIX} from './keys.ts';\n\ntype MutationSuccessType = MutatorResultSuccessDetails;\ntype MutationErrorType = ApplicationError | ZeroError;\n\nlet currentEphemeralID = 0;\nfunction nextEphemeralID(): EphemeralID {\n  return ++currentEphemeralID as EphemeralID;\n}\n\nconst successResultDetails: MutationSuccessType = {type: 'success'};\n\n/**\n * Tracks what pushes are in-flight and resolves promises when they're acked.\n */\nexport class MutationTracker {\n  readonly #outstandingMutations: Map<\n    EphemeralID,\n    {\n      mutationID?: number | undefined;\n      resolver: Resolver<MutationSuccessType, MutationErrorType>;\n    }\n  >;\n  readonly #ephemeralIDsByMutationID: Map<number, EphemeralID>;\n  readonly #allMutationsAppliedListeners: Set<() => void>;\n  readonly #lc: LogContext;\n\n  readonly #ackMutations: (upTo: MutationID) => void;\n  readonly #onFatalError: (error: ZeroError) => void;\n\n  #clientID: string | undefined;\n  #largestOutstandingMutationID: number;\n  #currentMutationID: number;\n\n  constructor(\n    lc: LogContext,\n    ackMutations: (upTo: MutationID) => void,\n    onFatalError: (error: ZeroError) => void,\n  ) {\n    this.#lc = lc.withContext('MutationTracker');\n    this.#outstandingMutations = new Map();\n    this.#ephemeralIDsByMutationID = new Map();\n    this.#allMutationsAppliedListeners = new Set();\n    this.#largestOutstandingMutationID = 0;\n    this.#currentMutationID = 0;\n    this.#ackMutations = ackMutations;\n    this.#onFatalError = onFatalError;\n  }\n\n  setClientIDAndWatch(\n    clientID: string,\n    experimentalWatch: ReplicacheImpl['experimentalWatch'],\n  ) {\n    assert(this.#clientID === undefined, 'clientID already set');\n    this.#clientID = clientID;\n    experimentalWatch(\n      diffs => {\n        this.#processMutationResponses(diffs);\n      },\n      {\n        prefix: MUTATIONS_KEY_PREFIX + clientID + '/',\n        initialValuesInFirstDiff: true,\n      },\n    );\n  }\n\n  trackMutation(): MutationTrackingData<MutationSuccessType> {\n    const id = nextEphemeralID();\n    const mutationResolver = resolver<MutationSuccessType, MutationErrorType>();\n\n    this.#outstandingMutations.set(id, {\n      resolver: mutationResolver,\n    });\n    return {ephemeralID: id, serverPromise: mutationResolver.promise};\n  }\n\n  mutationIDAssigned(id: EphemeralID, mutationID: number): void {\n    const entry = this.#outstandingMutations.get(id);\n    if (entry) {\n      entry.mutationID = mutationID;\n      this.#ephemeralIDsByMutationID.set(mutationID, id);\n      this.#largestOutstandingMutationID = Math.max(\n        this.#largestOutstandingMutationID,\n        mutationID,\n      );\n    }\n  }\n\n  /**\n   * Reject the mutation due to an unhandled exception on the client.\n   * The mutation must not have been persisted to the client store.\n   */\n  rejectMutation(id: EphemeralID, e: unknown): void {\n    const entry = this.#outstandingMutations.get(id);\n    if (entry) {\n      this.#settleMutation(id, entry, wrapWithApplicationError(e));\n    }\n  }\n\n  /**\n   * Reject all outstanding mutations. Called when the client is in a state\n   * that prevents mutations from being applied, such as offline or closed.\n   */\n  rejectAllOutstandingMutations(error: ZeroError): void {\n    if (this.#outstandingMutations.size === 0) {\n      return;\n    }\n    for (const [id, entry] of this.#outstandingMutations) {\n      this.#settleMutation(id, entry, error);\n    }\n    this.#largestOutstandingMutationID = this.#currentMutationID;\n    this.#notifyAllMutationsAppliedListeners();\n  }\n\n  /**\n   * Used when zero-cache pokes down mutation results.\n   */\n  #processMutationResponses(diffs: NoIndexDiff): void {\n    const clientID = must(this.#clientID);\n    let largestLmid = 0;\n    for (const diff of diffs) {\n      const mutationID = Number(\n        diff.key.slice(MUTATIONS_KEY_PREFIX.length + clientID.length + 1),\n      );\n      assert(\n        !isNaN(mutationID),\n        `MutationTracker received a diff with an invalid mutation ID: ${diff.key}`,\n      );\n      largestLmid = Math.max(largestLmid, mutationID);\n      switch (diff.op) {\n        case 'add': {\n          const result = v.parse(diff.newValue, mutationResultSchema);\n          if ('error' in result) {\n            this.#processMutationError(clientID, mutationID, result);\n          } else {\n            this.#processMutationOk(clientID, mutationID, result);\n          }\n          break;\n        }\n        case 'del':\n          break;\n        case 'change':\n          throw new Error('MutationTracker does not expect change operations');\n      }\n    }\n\n    if (largestLmid > 0) {\n      this.#ackMutations({\n        clientID: must(this.#clientID),\n        id: largestLmid,\n      });\n    }\n  }\n\n  processPushResponse(response: PushResponseBody): void {\n    if ('error' in response) {\n      this.#lc.error?.(\n        'Received an error response when pushing mutations',\n        response,\n      );\n      const fatalError = this.#fatalErrorFromPushError(response);\n      if (fatalError) {\n        this.#onFatalError(fatalError);\n      }\n    } else {\n      this.#processPushOk(response);\n    }\n  }\n\n  #fatalErrorFromPushError(error: PushError): ZeroError | undefined {\n    switch (error.error) {\n      case 'unsupportedPushVersion':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.Internal,\n          message: `Unsupported push version`,\n          mutationIDs: [],\n        });\n      case 'unsupportedSchemaVersion':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.Internal,\n          message: `Unsupported schema version`,\n          mutationIDs: [],\n        });\n      case 'http':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.HTTP,\n          status: error.status,\n          message: `Fetch from API server returned non-OK status ${error.status}: ${error.details ?? 'unknown'}`,\n          mutationIDs: [],\n        });\n      case 'zeroPusher':\n        return new ProtocolError({\n          kind: ErrorKind.PushFailed,\n          origin: ErrorOrigin.ZeroCache,\n          reason: ErrorReason.Internal,\n          message: `ZeroPusher error: ${error.details ?? 'unknown'}`,\n          mutationIDs: [],\n        });\n      default:\n        unreachable(error);\n    }\n  }\n\n  /**\n   * DEPRECATED: to be removed when we switch to fully driving\n   * mutation resolution via poke.\n   *\n   * When we reconnect to zero-cache, we resolve all outstanding mutations\n   * whose ID is less than or equal to the lastMutationID.\n   *\n   * The reason is that any responses the API server sent\n   * to those mutations have been lost.\n   *\n   * An example case: the API server responds while the connection\n   * is down. Those responses are lost.\n   *\n   * Mutations whose LMID is > the lastMutationID are not resolved\n   * since they will be retried by the client, giving us another chance\n   * at getting a response.\n   *\n   * The only way to ensure that all API server responses are\n   * received would be to have the API server write them\n   * to the DB while writing the LMID.\n   */\n  onConnected(lastMutationID: number) {\n    this.lmidAdvanced(lastMutationID);\n  }\n\n  /**\n   * lmid advance will:\n   * 1. notify \"allMutationsApplied\" listeners if the lastMutationID\n   *    is greater than or equal to the largest outstanding mutation ID.\n   * 2. resolve all mutations whose mutation ID is less than or equal to\n   *    the lastMutationID.\n   */\n  lmidAdvanced(lastMutationID: number): void {\n    assert(\n      lastMutationID >= this.#currentMutationID,\n      'lmid must be greater than or equal to current lmid',\n    );\n    if (lastMutationID === this.#currentMutationID) {\n      return;\n    }\n\n    try {\n      this.#currentMutationID = lastMutationID;\n      this.#resolveMutations(lastMutationID);\n    } finally {\n      if (lastMutationID >= this.#largestOutstandingMutationID) {\n        // this is very important otherwise we hang query de-registration\n        this.#notifyAllMutationsAppliedListeners();\n      }\n    }\n  }\n\n  get size() {\n    return this.#outstandingMutations.size;\n  }\n\n  #resolveMutations(upTo: number): void {\n    // We resolve all mutations whose mutation ID is less than or equal to\n    // the upTo mutation ID.\n    for (const [id, entry] of this.#outstandingMutations) {\n      if (entry.mutationID && entry.mutationID <= upTo) {\n        this.#settleMutation(id, entry, emptyObject);\n      } else {\n        break; // the map is in insertion order which is in mutation ID order\n      }\n    }\n  }\n\n  #processPushOk(ok: PushOk): void {\n    for (const mutation of ok.mutations) {\n      if ('error' in mutation.result) {\n        this.#processMutationError(\n          mutation.id.clientID,\n          mutation.id.id,\n          mutation.result,\n        );\n      } else {\n        this.#processMutationOk(\n          mutation.id.clientID,\n          mutation.id.id,\n          mutation.result,\n        );\n      }\n    }\n  }\n\n  #processMutationError(\n    clientID: string,\n    mid: number,\n    error: MutationError | Omit<PushError, 'mutationIDs'>,\n  ): void {\n    assert(\n      clientID === this.#clientID,\n      'received mutation for the wrong client',\n    );\n\n    // Each tab sends all mutations for the client group\n    // and the server responds back to the individual client that actually\n    // ran the mutation. This means that N clients can send the same\n    // mutation concurrently. If that happens, the promise for the mutation tracked\n    // by this class will try to be resolved N times.\n    // Every time after the first, the ephemeral ID will not be found.\n    //\n    // We also reject all outstanding mutations when the client is in a state\n    // that prevents mutations from being applied, such as offline or closed.\n    // In this case, the ephemeral ID will also not be found.\n    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);\n    if (!ephemeralID) {\n      this.#lc.debug?.(\n        'Mutation already resolved or rejected (e.g. due to disconnect); ignore late reject.',\n      );\n      return;\n    }\n\n    const entry = this.#outstandingMutations.get(ephemeralID);\n    assert(\n      entry && entry.mutationID === mid,\n      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`,\n    );\n\n    if (error.error === 'alreadyProcessed') {\n      this.#settleMutation(ephemeralID, entry, emptyObject);\n      return;\n    }\n\n    this.#settleMutation(\n      ephemeralID,\n      entry,\n      error.error === 'app'\n        ? new ApplicationError(\n            error.message ?? `Unknown application error: ${error.error}`,\n            error.details ? {details: error.details} : undefined,\n          )\n        : new ProtocolError({\n            kind: ErrorKind.InvalidPush,\n            origin: ErrorOrigin.Server,\n            reason: ErrorReason.Internal,\n            message:\n              error.error === 'oooMutation'\n                ? 'Server reported an out-of-order mutation'\n                : `Unknown fallback error with mutation ID ${mid}: ${error.error}`,\n            details: getErrorDetails(error),\n          }),\n    );\n\n    // this is included for backwards compatibility with the per-mutation fatal error responses\n    if (error.error === 'oooMutation') {\n      this.#onFatalError(\n        new ProtocolError({\n          kind: ErrorKind.InvalidPush,\n          origin: ErrorOrigin.Server,\n          reason: ErrorReason.Internal,\n          message: 'Server reported an out-of-order mutation',\n          details: error.details,\n        }),\n      );\n    }\n  }\n\n  #processMutationOk(clientID: string, mid: number, result: MutationOk): void {\n    assert(\n      clientID === this.#clientID,\n      'received mutation for the wrong client',\n    );\n\n    // We reject all outstanding mutations when the client is in a state\n    // that prevents mutations from being applied, such as offline or closed.\n    // In this case, the ephemeral ID will not be found.\n    const ephemeralID = this.#ephemeralIDsByMutationID.get(mid);\n    if (!ephemeralID) {\n      this.#lc.debug?.(\n        'Mutation already resolved or rejected (e.g. due to disconnect); ignore late resolve.',\n      );\n      return;\n    }\n\n    const entry = this.#outstandingMutations.get(ephemeralID);\n    assert(\n      entry && entry.mutationID === mid,\n      `outstanding mutation not found for mutation ID ${mid} and ephemeral ID ${ephemeralID}`,\n    );\n    this.#settleMutation(ephemeralID, entry, result);\n  }\n\n  #settleMutation<Result extends MutationOk | ApplicationError | ZeroError>(\n    ephemeralID: EphemeralID,\n    entry: {\n      mutationID?: number | undefined;\n      resolver: Resolver<MutationSuccessType, MutationErrorType>;\n    },\n    result: Result,\n  ): void {\n    if (isApplicationError(result) || isZeroError(result)) {\n      // we reject here and catch in the mutator proxy\n      // the mutator proxy catches both client and server errors\n      entry.resolver.reject(result);\n    } else {\n      entry.resolver.resolve(successResultDetails);\n    }\n\n    this.#outstandingMutations.delete(ephemeralID);\n    if (entry.mutationID) {\n      this.#ephemeralIDsByMutationID.delete(entry.mutationID);\n    }\n  }\n\n  /**\n   * Be notified when all mutations have been included in the server snapshot.\n   *\n   * The query manager will not de-register queries from the server until there\n   * are no pending mutations.\n   *\n   * The reason is that a mutation may need to be rebased. We do not want\n   * data that was available the first time it was run to not be available\n   * on a rebase.\n   */\n  onAllMutationsApplied(listener: () => void): void {\n    this.#allMutationsAppliedListeners.add(listener);\n  }\n\n  #notifyAllMutationsAppliedListeners() {\n    for (const listener of this.#allMutationsAppliedListeners) {\n      listener();\n    }\n  }\n}\n"],"names":["v.parse","ErrorKind.PushFailed","ErrorOrigin.ZeroCache","ErrorReason.Internal","ErrorReason.HTTP","ErrorKind.InvalidPush","ErrorOrigin.Server"],"mappings":"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"}

package/out/zero-client/src/client/mutator-proxy.d.ts

@@ -0,0 +1,15 @@
+import type { ReadonlyJSONValue } from '../../../shared/src/json.ts';
+import type { ConnectionManager } from './connection-manager.ts';
+import type { MutatorResult } from './custom.ts';
+import { type ZeroError } from './error.ts';
+import type { MutationTracker } from './mutation-tracker.ts';
+export declare class MutatorProxy {
+    #private;
+    constructor(connectionManager: ConnectionManager, mutationTracker: MutationTracker);
+    get mutationRejectionError(): ZeroError | undefined;
+    wrapCustomMutator<F extends (...args: [] | [ReadonlyJSONValue]) => {
+        client: Promise<unknown>;
+        server: Promise<unknown>;
+    }>(f: F): (...args: Parameters<F>) => MutatorResult;
+}
+//# sourceMappingURL=mutator-proxy.d.ts.map

package/out/zero-client/src/client/mutator-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutator-proxy.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/mutator-proxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AAGnE,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EACV,aAAa,EAGd,MAAM,aAAa,CAAC;AACrB,OAAO,EAAc,KAAK,SAAS,EAAC,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAY3D,qBAAa,YAAY;;gBAMrB,iBAAiB,EAAE,iBAAiB,EACpC,eAAe,EAAE,eAAe;IAWlC,IAAI,sBAAsB,IAAI,SAAS,GAAG,SAAS,CAElD;IAgCD,iBAAiB,CACf,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,CAAC,iBAAiB,CAAC,KAAK;QAC/C,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QACzB,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;KAC1B,EACD,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,aAAa;CAkGnD"}

package/out/zero-client/src/client/mutator-proxy.js

@@ -0,0 +1,132 @@
+import { unreachable } from "../../../shared/src/asserts.js";
+import { wrapWithApplicationError } from "../../../zero-protocol/src/application-error.js";
+import { NeedsAuth, Connecting, Connected, Closed, Error, Disconnected } from "./connection-status-enum.js";
+import { isZeroError } from "./error.js";
+const successResultDetails = {
+  type: "success"
+};
+const successResult = () => successResultDetails;
+class MutatorProxy {
+  #connectionManager;
+  #mutationTracker;
+  #mutationRejection;
+  constructor(connectionManager, mutationTracker) {
+    this.#connectionManager = connectionManager;
+    this.#mutationTracker = mutationTracker;
+    this.#connectionManager.subscribe(
+      (state) => this.#onConnectionStateChange(state)
+    );
+    this.#onConnectionStateChange(connectionManager.state);
+  }
+  get mutationRejectionError() {
+    return this.#mutationRejection?.error;
+  }
+  /**
+   * Called when the connection state changes.
+   *
+   * If the connection state is disconnected, error, or closed, the
+   * mutation rejection error is set and all outstanding `.server` promises in
+   * the mutation tracker are rejected with the error.
+   */
+  #onConnectionStateChange(state) {
+    switch (state.name) {
+      case Disconnected:
+      case Error:
+      case Closed:
+        this.#mutationRejection = {
+          error: state.reason,
+          promise: Promise.resolve(
+            this.#makeZeroErrorResultDetails(state.reason)
+          )
+        };
+        this.#mutationTracker.rejectAllOutstandingMutations(state.reason);
+        break;
+      case Connected:
+      case Connecting:
+      case NeedsAuth:
+        this.#mutationRejection = void 0;
+        return;
+      default:
+        unreachable();
+    }
+  }
+  wrapCustomMutator(f) {
+    return (...args) => {
+      if (this.#mutationRejection) {
+        return {
+          client: this.#mutationRejection.promise,
+          server: this.#mutationRejection.promise
+        };
+      }
+      let result;
+      const cachedMutationPromises = {};
+      const wrapErrorFor = (origin) => (error) => {
+        const cachedPromise = cachedMutationPromises[origin];
+        if (cachedPromise) {
+          return cachedPromise;
+        }
+        if (isZeroError(error)) {
+          const zeroErrorPromise = this.#makeZeroErrorResultDetails(error);
+          cachedMutationPromises[origin] = zeroErrorPromise;
+          return zeroErrorPromise;
+        }
+        const applicationErrorPromise = this.#makeApplicationErrorResultDetails(
+          wrapWithApplicationError(error)
+        );
+        cachedMutationPromises[origin] = applicationErrorPromise;
+        return applicationErrorPromise;
+      };
+      try {
+        result = f(...args);
+      } catch (error) {
+        const clientPromise = wrapErrorFor("client")(error);
+        const serverPromise = wrapErrorFor("server")(error);
+        return {
+          client: clientPromise,
+          server: serverPromise
+        };
+      }
+      const client = this.#normalizeResultPromise(
+        result.client,
+        wrapErrorFor("client")
+      );
+      const server = this.#normalizeResultPromise(
+        result.server,
+        wrapErrorFor("server")
+      );
+      return {
+        client,
+        server
+      };
+    };
+  }
+  #normalizeResultPromise(promise, wrapError) {
+    return promise.then(
+      successResult,
+      wrapError
+    );
+  }
+  #makeZeroErrorResultDetails(zeroError) {
+    return Promise.resolve({
+      type: "error",
+      error: {
+        type: "zero",
+        message: zeroError.message
+      }
+    });
+  }
+  #makeApplicationErrorResultDetails(applicationError) {
+    return Promise.resolve({
+      type: "error",
+      error: {
+        type: "app",
+        message: applicationError.message,
+        details: applicationError.details
+      }
+    });
+  }
+}
+export {
+  MutatorProxy
+};
+//# sourceMappingURL=mutator-proxy.js.map