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

package/out/zero-client/src/client/query-manager.js

@@ -0,0 +1,377 @@
+import { assert } from "../../../shared/src/asserts.js";
+import { must } from "../../../shared/src/must.js";
+import { TDigest } from "../../../shared/src/tdigest.js";
+import { mapAST, normalizeAST } from "../../../zero-protocol/src/ast.js";
+import { TransformFailed } from "../../../zero-protocol/src/error-kind-enum.js";
+import { ZeroCache } from "../../../zero-protocol/src/error-origin-enum.js";
+import { Internal } from "../../../zero-protocol/src/error-reason-enum.js";
+import { ProtocolError } from "../../../zero-protocol/src/error.js";
+import { hashOfNameAndArgs, hashOfAST } from "../../../zero-protocol/src/query-hash.js";
+import { clientToServer, serverToClient } from "../../../zero-schema/src/name-mapper.js";
+import { clampTTL, compareTTL } from "../../../zql/src/query/ttl.js";
+import "../../../shared/src/json-schema.js";
+import { GOT_QUERIES_KEY_PREFIX, desiredQueriesPrefixForClient } from "./keys.js";
+class QueryManager {
+  #clientID;
+  #clientToServer;
+  #serverToClient;
+  #send;
+  #onFatalError;
+  #queries = /* @__PURE__ */ new Map();
+  #recentQueriesMaxSize;
+  #recentQueries = /* @__PURE__ */ new Set();
+  #gotQueries = /* @__PURE__ */ new Set();
+  #mutationTracker;
+  #pendingQueryChanges = [];
+  #queryChangeThrottleMs;
+  #pendingRemovals = [];
+  #batchTimer;
+  #lc;
+  #metrics = newMetrics();
+  #queryMetrics = /* @__PURE__ */ new Map();
+  #slowMaterializeThreshold;
+  #closedError;
+  constructor(lc, mutationTracker, clientID, tables, send, experimentalWatch, recentQueriesMaxSize, queryChangeThrottleMs, slowMaterializeThreshold, onFatalError) {
+    this.#lc = lc.withContext("QueryManager");
+    this.#clientID = clientID;
+    this.#clientToServer = clientToServer(tables);
+    this.#serverToClient = serverToClient(tables);
+    this.#recentQueriesMaxSize = recentQueriesMaxSize;
+    this.#send = send;
+    this.#mutationTracker = mutationTracker;
+    this.#queryChangeThrottleMs = queryChangeThrottleMs;
+    this.#slowMaterializeThreshold = slowMaterializeThreshold;
+    this.#onFatalError = onFatalError;
+    this.#mutationTracker.onAllMutationsApplied(() => {
+      if (this.#pendingRemovals.length === 0) {
+        return;
+      }
+      const pendingRemovals = this.#pendingRemovals;
+      this.#pendingRemovals = [];
+      for (const removal of pendingRemovals) {
+        removal();
+      }
+    });
+    experimentalWatch(
+      (diff) => {
+        for (const diffOp of diff) {
+          const queryHash = diffOp.key.substring(GOT_QUERIES_KEY_PREFIX.length);
+          switch (diffOp.op) {
+            case "add":
+              this.#gotQueries.add(queryHash);
+              this.#fireGotCallbacks(queryHash, true);
+              break;
+            case "del":
+              this.#gotQueries.delete(queryHash);
+              this.#fireGotCallbacks(queryHash, false);
+              break;
+          }
+        }
+      },
+      {
+        prefix: GOT_QUERIES_KEY_PREFIX,
+        initialValuesInFirstDiff: true
+      }
+    );
+  }
+  getAST(queryID) {
+    const ast = this.#queries.get(queryID)?.normalized;
+    return ast && mapAST(ast, this.#serverToClient);
+  }
+  mapClientASTToServer(ast) {
+    return mapAST(ast, this.#clientToServer);
+  }
+  #fireGotCallbacks(queryHash, got) {
+    const gotCallbacks = this.#queries.get(queryHash)?.gotCallbacks ?? [];
+    for (const gotCallback of gotCallbacks) {
+      gotCallback(got);
+    }
+  }
+  /**
+   * Get the queries that need to be registered with the server.
+   *
+   * An optional `lastPatch` can be provided. This is the last patch that was
+   * sent to the server and may not yet have been acked. If `lastPatch` is provided,
+   * this method will return a patch that does not include any events sent in `lastPatch`.
+   *
+   * This diffing of last patch and current patch is needed since we send
+   * a set of queries to the server when we first connect inside of the `sec-protocol` as
+   * the `initConnectionMessage`.
+   *
+   * While we're waiting for the `connected` response to come back from the server,
+   * the client may have registered more queries. We need to diff the `initConnectionMessage`
+   * queries with the current set of queries to understand what those were.
+   */
+  async getQueriesPatch(tx, lastPatch) {
+    const existingQueryHashes = /* @__PURE__ */ new Set();
+    const prefix = desiredQueriesPrefixForClient(this.#clientID);
+    for await (const key of tx.scan({ prefix }).keys()) {
+      existingQueryHashes.add(key.substring(prefix.length, key.length));
+    }
+    const patch = /* @__PURE__ */ new Map();
+    for (const hash of existingQueryHashes) {
+      if (!this.#queries.has(hash)) {
+        patch.set(hash, { op: "del", hash });
+      }
+    }
+    for (const [hash, { normalized, ttl, name, args }] of this.#queries) {
+      if (!existingQueryHashes.has(hash)) {
+        patch.set(hash, {
+          op: "put",
+          hash,
+          ast: name === void 0 ? normalized : void 0,
+          name,
+          args,
+          // We get TTL out of the DagStore so it is possible that the TTL was written
+          // with a too high TTL.
+          ttl: clampTTL(ttl)
+          // no lc here since no need to log here
+        });
+      }
+    }
+    if (lastPatch) {
+      for (const [hash, { op }] of lastPatch) {
+        if (op === "put" && !patch.has(hash)) {
+          patch.set(hash, { op: "del", hash });
+        }
+      }
+      for (const [hash, { op }] of patch) {
+        const lastPatchOp = lastPatch.get(hash);
+        if (lastPatchOp && lastPatchOp.op === op) {
+          patch.delete(hash);
+        }
+      }
+    }
+    return patch;
+  }
+  handleTransformErrors(errors) {
+    for (const error of errors) {
+      const queryId = error.id;
+      const entry = this.#queries.get(queryId);
+      if (!entry) {
+        continue;
+      }
+      if (error.error === "app" || error.error === "parse") {
+        entry.gotCallbacks.forEach((callback) => callback(false, error));
+      } else {
+        this.#onFatalError(
+          new ProtocolError({
+            kind: TransformFailed,
+            origin: ZeroCache,
+            reason: Internal,
+            message: `Unknown error transforming queries: ${JSON.stringify(error)}`,
+            queryIDs: []
+          })
+        );
+      }
+    }
+  }
+  handleClosed(reason) {
+    if (this.#closedError) {
+      return;
+    }
+    this.#closedError = reason;
+    for (const [queryId, entry] of this.#queries) {
+      const erroredQuery = {
+        error: "app",
+        id: queryId,
+        name: entry.name ?? "legacy",
+        message: reason.message,
+        details: { kind: reason.kind }
+      };
+      for (const gotCallback of entry.gotCallbacks) {
+        gotCallback(false, erroredQuery);
+      }
+    }
+  }
+  addCustom(ast, { name, args }, ttl, gotCallback) {
+    const normalized = normalizeAST(ast);
+    const queryId = hashOfNameAndArgs(name, args);
+    return this.#add(queryId, normalized, name, args, ttl, gotCallback);
+  }
+  addLegacy(ast, ttl, gotCallback) {
+    const normalized = normalizeAST(ast);
+    const astHash = hashOfAST(normalized);
+    return this.#add(
+      astHash,
+      normalized,
+      void 0,
+      // name is undefined for legacy queries
+      void 0,
+      // args are undefined for legacy queries
+      ttl,
+      gotCallback
+    );
+  }
+  #add(queryId, normalized, name, args, ttl, gotCallback) {
+    assert(
+      name === void 0 === (args === void 0),
+      "If name is defined, args must be defined"
+    );
+    ttl = clampTTL(ttl, this.#lc);
+    let entry = this.#queries.get(queryId);
+    this.#recentQueries.delete(queryId);
+    if (!entry) {
+      normalized = mapAST(normalized, this.#clientToServer);
+      entry = {
+        normalized,
+        name,
+        args,
+        count: 1,
+        gotCallbacks: gotCallback ? [gotCallback] : [],
+        ttl
+      };
+      this.#queries.set(queryId, entry);
+      this.#queueQueryChange({
+        op: "put",
+        hash: queryId,
+        ast: name === void 0 ? normalized : void 0,
+        name,
+        args,
+        ttl
+      });
+    } else {
+      ++entry.count;
+      this.#updateEntry(entry, queryId, ttl);
+      if (gotCallback) {
+        entry.gotCallbacks.push(gotCallback);
+      }
+    }
+    if (gotCallback) {
+      gotCallback(this.#gotQueries.has(queryId));
+    }
+    let removed = false;
+    const cleanupCb = () => {
+      if (removed) {
+        return;
+      }
+      removed = true;
+      if (this.#mutationTracker.size > 0) {
+        this.#pendingRemovals.push(
+          () => this.#remove(entry, queryId, gotCallback)
+        );
+        return;
+      }
+      this.#remove(entry, queryId, gotCallback);
+    };
+    return cleanupCb;
+  }
+  updateCustom({ name, args }, ttl) {
+    const queryID = hashOfNameAndArgs(name, args);
+    const entry = must(this.#queries.get(queryID));
+    this.#updateEntry(entry, queryID, ttl);
+  }
+  updateLegacy(ast, ttl) {
+    const normalized = normalizeAST(ast);
+    const queryID = hashOfAST(normalized);
+    const entry = must(this.#queries.get(queryID));
+    this.#updateEntry(entry, queryID, ttl);
+  }
+  #updateEntry(entry, queryID, ttl) {
+    ttl = clampTTL(ttl, this.#lc);
+    if (compareTTL(ttl, entry.ttl) > 0) {
+      entry.ttl = ttl;
+      this.#queueQueryChange({
+        op: "put",
+        hash: queryID,
+        ast: entry.name === void 0 ? entry.normalized : void 0,
+        name: entry.name,
+        args: entry.args,
+        ttl
+      });
+    }
+  }
+  #queueQueryChange(op) {
+    this.#pendingQueryChanges.push(op);
+    this.#scheduleBatch();
+  }
+  #scheduleBatch() {
+    if (this.#batchTimer === void 0) {
+      this.#batchTimer = setTimeout(
+        () => this.flushBatch(),
+        this.#queryChangeThrottleMs
+      );
+    }
+  }
+  flushBatch() {
+    if (this.#batchTimer !== void 0) {
+      clearTimeout(this.#batchTimer);
+      this.#batchTimer = void 0;
+    }
+    if (this.#pendingQueryChanges.length > 0) {
+      this.#send([
+        "changeDesiredQueries",
+        {
+          desiredQueriesPatch: [...this.#pendingQueryChanges]
+        }
+      ]);
+      this.#pendingQueryChanges.length = 0;
+    }
+  }
+  #remove(entry, astHash, gotCallback) {
+    if (gotCallback) {
+      const index = entry.gotCallbacks.indexOf(gotCallback);
+      entry.gotCallbacks.splice(index, 1);
+    }
+    --entry.count;
+    if (entry.count === 0) {
+      this.#recentQueries.add(astHash);
+      if (this.#recentQueries.size > this.#recentQueriesMaxSize) {
+        const lruQueryID = this.#recentQueries.values().next().value;
+        assert(lruQueryID);
+        this.#queries.delete(lruQueryID);
+        this.#recentQueries.delete(lruQueryID);
+        this.#queryMetrics.delete(lruQueryID);
+        this.#queueQueryChange({ op: "del", hash: lruQueryID });
+      }
+    }
+  }
+  /**
+   * Gets the aggregated metrics for all queries managed by this QueryManager.
+   */
+  get metrics() {
+    return this.#metrics;
+  }
+  addMetric(metric, value, ...args) {
+    this.#metrics[metric].add(value);
+    const queryID = args[0];
+    if (metric === "query-materialization-end-to-end") {
+      const ast = args[1];
+      if (this.#slowMaterializeThreshold !== void 0 && value > this.#slowMaterializeThreshold) {
+        this.#lc.warn?.(
+          "Slow query materialization (including server/network)",
+          queryID,
+          ast,
+          value
+        );
+      } else {
+        this.#lc.debug?.(
+          "Materialized query (including server/network)",
+          queryID,
+          ast,
+          value
+        );
+      }
+    }
+    let existing = this.#queryMetrics.get(queryID);
+    if (!existing) {
+      existing = newMetrics();
+      this.#queryMetrics.set(queryID, existing);
+    }
+    existing[metric].add(value);
+  }
+  getQueryMetrics(queryID) {
+    return this.#queryMetrics.get(queryID);
+  }
+}
+function newMetrics() {
+  return {
+    "query-materialization-client": new TDigest(),
+    "query-materialization-end-to-end": new TDigest(),
+    "query-update-client": new TDigest()
+  };
+}
+export {
+  QueryManager
+};
+//# sourceMappingURL=query-manager.js.map

package/out/zero-client/src/client/query-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-manager.js","sources":["../../../../../zero-client/src/client/query-manager.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {ReplicacheImpl} from '../../../replicache/src/replicache-impl.ts';\nimport type {ClientID} from '../../../replicache/src/sync/ids.ts';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {TDigest} from '../../../shared/src/tdigest.ts';\nimport {\n  mapAST,\n  normalizeAST,\n  type AST,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {ChangeDesiredQueriesMessage} from '../../../zero-protocol/src/change-desired-queries.ts';\nimport type {ErroredQuery} from '../../../zero-protocol/src/custom-queries.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 type {UpQueriesPatchOp} from '../../../zero-protocol/src/queries-patch.ts';\nimport {\n  hashOfAST,\n  hashOfNameAndArgs,\n} from '../../../zero-protocol/src/query-hash.ts';\nimport {\n  clientToServer,\n  serverToClient,\n  type NameMapper,\n} from '../../../zero-schema/src/name-mapper.ts';\nimport type {TableSchema} from '../../../zero-schema/src/table-schema.ts';\nimport type {ClientMetricMap} from '../../../zql/src/query/metrics-delegate.ts';\nimport type {CustomQueryID} from '../../../zql/src/query/named.ts';\nimport type {GotCallback} from '../../../zql/src/query/query-delegate.ts';\nimport {clampTTL, compareTTL, type TTL} from '../../../zql/src/query/ttl.ts';\nimport type {ClientErrorKind} from './client-error-kind.ts';\nimport type {ClientError} from './error.ts';\nimport {type ZeroError} from './error.ts';\nimport type {InspectorDelegate} from './inspector/inspector.ts';\nimport {desiredQueriesPrefixForClient, GOT_QUERIES_KEY_PREFIX} from './keys.ts';\nimport type {MutationTracker} from './mutation-tracker.ts';\nimport type {ReadTransaction} from './replicache-types.ts';\n\ntype QueryHash = string;\n\ntype Entry = {\n  // We keep track of the AST so we can use it in the inspector.\n  normalized: AST;\n  name: string | undefined;\n  args: readonly ReadonlyJSONValue[] | undefined;\n  count: number;\n  gotCallbacks: GotCallback[];\n  ttl: TTL;\n};\n\ntype ClientMetric = {\n  [K in keyof ClientMetricMap]: TDigest;\n};\n\n/**\n * Tracks what queries the client is currently subscribed to on the server.\n * Sends `changeDesiredQueries` message to server when this changes.\n * Deduplicates requests so that we only listen to a given unique query once.\n */\nexport class QueryManager implements InspectorDelegate {\n  readonly #clientID: ClientID;\n  readonly #clientToServer: NameMapper;\n  readonly #serverToClient: NameMapper;\n  readonly #send: (change: ChangeDesiredQueriesMessage) => void;\n  readonly #onFatalError: (error: ZeroError) => void;\n  readonly #queries: Map<QueryHash, Entry> = new Map();\n  readonly #recentQueriesMaxSize: number;\n  readonly #recentQueries: Set<string> = new Set();\n  readonly #gotQueries: Set<string> = new Set();\n  readonly #mutationTracker: MutationTracker;\n  readonly #pendingQueryChanges: UpQueriesPatchOp[] = [];\n  readonly #queryChangeThrottleMs: number;\n  #pendingRemovals: Array<() => void> = [];\n  #batchTimer: ReturnType<typeof setTimeout> | undefined;\n  readonly #lc: LogContext;\n  readonly #metrics: ClientMetric = newMetrics();\n  readonly #queryMetrics: Map<string, ClientMetric> = new Map();\n  readonly #slowMaterializeThreshold: number;\n  #closedError: ZeroError | undefined;\n\n  constructor(\n    lc: LogContext,\n    mutationTracker: MutationTracker,\n    clientID: ClientID,\n    tables: Record<string, TableSchema>,\n    send: (change: ChangeDesiredQueriesMessage) => void,\n    experimentalWatch: ReplicacheImpl['experimentalWatch'],\n    recentQueriesMaxSize: number,\n    queryChangeThrottleMs: number,\n    slowMaterializeThreshold: number,\n    onFatalError: (error: ZeroError) => void,\n  ) {\n    this.#lc = lc.withContext('QueryManager');\n    this.#clientID = clientID;\n    this.#clientToServer = clientToServer(tables);\n    this.#serverToClient = serverToClient(tables);\n    this.#recentQueriesMaxSize = recentQueriesMaxSize;\n    this.#send = send;\n    this.#mutationTracker = mutationTracker;\n    this.#queryChangeThrottleMs = queryChangeThrottleMs;\n    this.#slowMaterializeThreshold = slowMaterializeThreshold;\n    this.#onFatalError = onFatalError;\n    this.#mutationTracker.onAllMutationsApplied(() => {\n      if (this.#pendingRemovals.length === 0) {\n        return;\n      }\n      const pendingRemovals = this.#pendingRemovals;\n      this.#pendingRemovals = [];\n      for (const removal of pendingRemovals) {\n        removal();\n      }\n    });\n\n    experimentalWatch(\n      diff => {\n        for (const diffOp of diff) {\n          const queryHash = diffOp.key.substring(GOT_QUERIES_KEY_PREFIX.length);\n          switch (diffOp.op) {\n            case 'add':\n              this.#gotQueries.add(queryHash);\n              this.#fireGotCallbacks(queryHash, true);\n              break;\n            case 'del':\n              this.#gotQueries.delete(queryHash);\n              this.#fireGotCallbacks(queryHash, false);\n              break;\n          }\n        }\n      },\n      {\n        prefix: GOT_QUERIES_KEY_PREFIX,\n        initialValuesInFirstDiff: true,\n      },\n    );\n  }\n\n  getAST(queryID: string): AST | undefined {\n    const ast = this.#queries.get(queryID)?.normalized;\n    return ast && mapAST(ast, this.#serverToClient);\n  }\n\n  mapClientASTToServer(ast: AST): AST {\n    return mapAST(ast, this.#clientToServer);\n  }\n\n  #fireGotCallbacks(queryHash: string, got: boolean) {\n    const gotCallbacks = this.#queries.get(queryHash)?.gotCallbacks ?? [];\n    for (const gotCallback of gotCallbacks) {\n      gotCallback(got);\n    }\n  }\n\n  /**\n   * Get the queries that need to be registered with the server.\n   *\n   * An optional `lastPatch` can be provided. This is the last patch that was\n   * sent to the server and may not yet have been acked. If `lastPatch` is provided,\n   * this method will return a patch that does not include any events sent in `lastPatch`.\n   *\n   * This diffing of last patch and current patch is needed since we send\n   * a set of queries to the server when we first connect inside of the `sec-protocol` as\n   * the `initConnectionMessage`.\n   *\n   * While we're waiting for the `connected` response to come back from the server,\n   * the client may have registered more queries. We need to diff the `initConnectionMessage`\n   * queries with the current set of queries to understand what those were.\n   */\n  async getQueriesPatch(\n    tx: ReadTransaction,\n    lastPatch?: Map<string, UpQueriesPatchOp>,\n  ): Promise<Map<string, UpQueriesPatchOp>> {\n    const existingQueryHashes = new Set<string>();\n    const prefix = desiredQueriesPrefixForClient(this.#clientID);\n    for await (const key of tx.scan({prefix}).keys()) {\n      existingQueryHashes.add(key.substring(prefix.length, key.length));\n    }\n    const patch: Map<string, UpQueriesPatchOp> = new Map();\n    for (const hash of existingQueryHashes) {\n      if (!this.#queries.has(hash)) {\n        patch.set(hash, {op: 'del', hash});\n      }\n    }\n\n    for (const [hash, {normalized, ttl, name, args}] of this.#queries) {\n      if (!existingQueryHashes.has(hash)) {\n        patch.set(hash, {\n          op: 'put',\n          hash,\n          ast: name === undefined ? normalized : undefined,\n          name,\n          args,\n          // We get TTL out of the DagStore so it is possible that the TTL was written\n          // with a too high TTL.\n          ttl: clampTTL(ttl), // no lc here since no need to log here\n        });\n      }\n    }\n\n    if (lastPatch) {\n      // if there are any `puts` in `lastPatch` that are not in `patch` then we need to\n      // send a `del` event in `patch`.\n      for (const [hash, {op}] of lastPatch) {\n        if (op === 'put' && !patch.has(hash)) {\n          patch.set(hash, {op: 'del', hash});\n        }\n      }\n      // Remove everything from `patch` that was already sent in `lastPatch`.\n      for (const [hash, {op}] of patch) {\n        const lastPatchOp = lastPatch.get(hash);\n        if (lastPatchOp && lastPatchOp.op === op) {\n          patch.delete(hash);\n        }\n      }\n    }\n\n    return patch;\n  }\n\n  handleTransformErrors(errors: ErroredQuery[]) {\n    for (const error of errors) {\n      const queryId = error.id;\n      const entry = this.#queries.get(queryId);\n\n      // if we don't have the query registered, continue\n      if (!entry) {\n        continue;\n      }\n\n      if (error.error === 'app' || error.error === 'parse') {\n        entry.gotCallbacks.forEach(callback => callback(false, error));\n      }\n      // this code path is not possible technically since errors were never implemented in the legacy query transform error\n      // but is included for backwards compatibility and we have a test case for it\n      else {\n        this.#onFatalError(\n          new ProtocolError({\n            kind: ErrorKind.TransformFailed,\n            origin: ErrorOrigin.ZeroCache,\n            reason: ErrorReason.Internal,\n            message: `Unknown error transforming queries: ${JSON.stringify(error)}`,\n            queryIDs: [],\n          }),\n        );\n        // unreachable(error); TODO(0xcadams): this should eventually be unreachable\n      }\n    }\n  }\n\n  handleClosed(\n    reason: ClientError<{kind: ClientErrorKind.ClientClosed; message: string}>,\n  ) {\n    if (this.#closedError) {\n      return;\n    }\n    this.#closedError = reason;\n    for (const [queryId, entry] of this.#queries) {\n      const erroredQuery: ErroredQuery = {\n        error: 'app',\n        id: queryId,\n        name: entry.name ?? 'legacy',\n        message: reason.message,\n        details: {kind: reason.kind},\n      };\n      for (const gotCallback of entry.gotCallbacks) {\n        gotCallback(false, erroredQuery);\n      }\n    }\n  }\n\n  addCustom(\n    ast: AST,\n    {name, args}: CustomQueryID,\n    ttl: TTL,\n    gotCallback?: GotCallback,\n  ): () => void {\n    const normalized = normalizeAST(ast);\n    const queryId = hashOfNameAndArgs(name, args);\n    return this.#add(queryId, normalized, name, args, ttl, gotCallback);\n  }\n\n  addLegacy(ast: AST, ttl: TTL, gotCallback?: GotCallback): () => void {\n    const normalized = normalizeAST(ast);\n    const astHash = hashOfAST(normalized);\n    return this.#add(\n      astHash,\n      normalized,\n      undefined, // name is undefined for legacy queries\n      undefined, // args are undefined for legacy queries\n      ttl,\n      gotCallback,\n    );\n  }\n\n  #add(\n    queryId: string,\n    normalized: AST,\n    name: string | undefined,\n    args: readonly ReadonlyJSONValue[] | undefined,\n    ttl: TTL,\n    gotCallback?: GotCallback,\n  ) {\n    assert(\n      (name === undefined) === (args === undefined),\n      'If name is defined, args must be defined',\n    );\n    ttl = clampTTL(ttl, this.#lc);\n    let entry = this.#queries.get(queryId);\n    this.#recentQueries.delete(queryId);\n    if (!entry) {\n      normalized = mapAST(normalized, this.#clientToServer);\n\n      entry = {\n        normalized,\n        name,\n        args,\n        count: 1,\n        gotCallbacks: gotCallback ? [gotCallback] : [],\n        ttl,\n      };\n      this.#queries.set(queryId, entry);\n      this.#queueQueryChange({\n        op: 'put',\n        hash: queryId,\n        ast: name === undefined ? normalized : undefined,\n        name,\n        args,\n        ttl,\n      });\n    } else {\n      ++entry.count;\n      this.#updateEntry(entry, queryId, ttl);\n\n      if (gotCallback) {\n        entry.gotCallbacks.push(gotCallback);\n      }\n    }\n\n    if (gotCallback) {\n      gotCallback(this.#gotQueries.has(queryId));\n    }\n\n    let removed = false;\n    const cleanupCb = () => {\n      if (removed) {\n        return;\n      }\n      removed = true;\n\n      // We cannot remove queries while mutations are pending\n      // as that could take data out of scope that is needed in a rebase\n      if (this.#mutationTracker.size > 0) {\n        this.#pendingRemovals.push(() =>\n          this.#remove(entry, queryId, gotCallback),\n        );\n        return;\n      }\n\n      this.#remove(entry, queryId, gotCallback);\n    };\n    return cleanupCb;\n  }\n\n  updateCustom({name, args}: CustomQueryID, ttl: TTL) {\n    const queryID = hashOfNameAndArgs(name, args);\n    const entry = must(this.#queries.get(queryID));\n    this.#updateEntry(entry, queryID, ttl);\n  }\n\n  updateLegacy(ast: AST, ttl: TTL) {\n    const normalized = normalizeAST(ast);\n    const queryID = hashOfAST(normalized);\n    const entry = must(this.#queries.get(queryID));\n    this.#updateEntry(entry, queryID, ttl);\n  }\n\n  #updateEntry(entry: Entry, queryID: string, ttl: TTL): void {\n    // If the query already exists and the new ttl is larger than the old one\n    // we send a changeDesiredQueries message to the server to update the ttl.\n    ttl = clampTTL(ttl, this.#lc);\n    if (compareTTL(ttl, entry.ttl) > 0) {\n      entry.ttl = ttl;\n      this.#queueQueryChange({\n        op: 'put',\n        hash: queryID,\n        ast: entry.name === undefined ? entry.normalized : undefined,\n        name: entry.name,\n        args: entry.args,\n        ttl,\n      });\n    }\n  }\n\n  #queueQueryChange(op: UpQueriesPatchOp) {\n    this.#pendingQueryChanges.push(op);\n    this.#scheduleBatch();\n  }\n\n  #scheduleBatch() {\n    if (this.#batchTimer === undefined) {\n      this.#batchTimer = setTimeout(\n        () => this.flushBatch(),\n        this.#queryChangeThrottleMs,\n      );\n    }\n  }\n\n  flushBatch() {\n    if (this.#batchTimer !== undefined) {\n      clearTimeout(this.#batchTimer);\n      this.#batchTimer = undefined;\n    }\n    if (this.#pendingQueryChanges.length > 0) {\n      this.#send([\n        'changeDesiredQueries',\n        {\n          desiredQueriesPatch: [...this.#pendingQueryChanges],\n        },\n      ]);\n      this.#pendingQueryChanges.length = 0;\n    }\n  }\n\n  #remove(entry: Entry, astHash: string, gotCallback: GotCallback | undefined) {\n    if (gotCallback) {\n      const index = entry.gotCallbacks.indexOf(gotCallback);\n      entry.gotCallbacks.splice(index, 1);\n    }\n    --entry.count;\n    if (entry.count === 0) {\n      this.#recentQueries.add(astHash);\n      if (this.#recentQueries.size > this.#recentQueriesMaxSize) {\n        const lruQueryID = this.#recentQueries.values().next().value;\n        assert(lruQueryID);\n        this.#queries.delete(lruQueryID);\n        this.#recentQueries.delete(lruQueryID);\n        this.#queryMetrics.delete(lruQueryID);\n        this.#queueQueryChange({op: 'del', hash: lruQueryID});\n      }\n    }\n  }\n\n  /**\n   * Gets the aggregated metrics for all queries managed by this QueryManager.\n   */\n  get metrics(): ClientMetric {\n    return this.#metrics;\n  }\n\n  addMetric<K extends keyof ClientMetricMap>(\n    metric: K,\n    value: number,\n    ...args: ClientMetricMap[K]\n  ): void {\n    // Only query metrics are tracked at this point.\n    // If this check fails then we need to add a runtime check.\n    metric satisfies `query-${string}`;\n\n    // We track all materializations of queries as well as per\n    // query materializations.\n    this.#metrics[metric].add(value);\n\n    const queryID = args[0];\n\n    // Handle slow query logging for end-to-end materialization\n    if (metric === 'query-materialization-end-to-end') {\n      const ast = args[1];\n\n      if (\n        this.#slowMaterializeThreshold !== undefined &&\n        value > this.#slowMaterializeThreshold\n      ) {\n        this.#lc.warn?.(\n          'Slow query materialization (including server/network)',\n          queryID,\n          ast,\n          value,\n        );\n      } else {\n        this.#lc.debug?.(\n          'Materialized query (including server/network)',\n          queryID,\n          ast,\n          value,\n        );\n      }\n    }\n\n    // The query manager manages metrics that are per query.\n    let existing = this.#queryMetrics.get(queryID);\n    if (!existing) {\n      existing = newMetrics();\n      this.#queryMetrics.set(queryID, existing);\n    }\n    existing[metric].add(value);\n  }\n\n  getQueryMetrics(queryID: string): ClientMetric | undefined {\n    return this.#queryMetrics.get(queryID);\n  }\n}\n\nfunction newMetrics(): ClientMetric {\n  return {\n    'query-materialization-client': new TDigest(),\n    'query-materialization-end-to-end': new TDigest(),\n    'query-update-client': new TDigest(),\n  };\n}\n"],"names":["ErrorKind.TransformFailed","ErrorOrigin.ZeroCache","ErrorReason.Internal"],"mappings":"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"}

package/out/zero-client/src/client/reload-error-handler.d.ts

@@ -1,7 +1,7 @@
+import type { LogContext } from '@rocicorp/logger';
 import * as v from '../../../shared/src/valita.ts';
-import { ErrorKind } from '../../../zero-protocol/src/error-kind.ts';
+import type { ErrorKind } from '../../../zero-protocol/src/error-kind.ts';
 import type { UpdateNeededReasonType } from './update-needed-reason-type.ts';
-import type { ZeroLogContext } from './zero-log-context.ts';
 export declare const RELOAD_REASON_STORAGE_KEY = "_zeroReloadReason";
 export declare const RELOAD_BACKOFF_STATE_KEY = "_zeroReloadBackoffState";
 declare const backoffStateSchema: v.ObjectType<{
@@ -12,8 +12,8 @@ export type BackoffState = v.Infer<typeof backoffStateSchema>;
 export declare const MIN_RELOAD_INTERVAL_MS = 500;
 export declare const MAX_RELOAD_INTERVAL_MS = 60000;
 export declare const FALLBACK_RELOAD_INTERVAL_MS = 10000;
-export declare function reloadWithReason(lc: ZeroLogContext, reload: () => void, reason: UpdateNeededReasonType | ErrorKind, message: string): void;
-export declare function reportReloadReason(lc: ZeroLogContext): void;
+export declare function reloadWithReason(lc: LogContext, reload: () => void, reason: UpdateNeededReasonType | ErrorKind, message: string): void;
+export declare function reportReloadReason(lc: LogContext): void;
 /** If a reload is scheduled, do not attempt to reconnect. */
 export declare function reloadScheduled(): boolean;
 /** Call upon a successful connection, indicating that backoff should be reset. */

package/out/zero-client/src/client/reload-error-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reload-error-handler.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/reload-error-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AACnD,OAAO,EAAC,SAAS,EAAC,MAAM,0CAA0C,CAAC;AAGnE,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,gCAAgC,CAAC;AAC3E,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAE1D,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAC7D,eAAO,MAAM,wBAAwB,4BAA4B,CAAC;AAOlE,QAAA,MAAM,kBAAkB;;;aAGtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAG7C,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAMlD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,cAAc,EAClB,MAAM,EAAE,MAAM,IAAI,EAClB,MAAM,EAAE,sBAAsB,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,QA6BhB;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,cAAc,QAgBpD;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,YAE9B;AAED,kFAAkF;AAClF,wBAAgB,YAAY,SAI3B"}
+{"version":3,"file":"reload-error-handler.d.ts","sourceRoot":"","sources":["../../../../../zero-client/src/client/reload-error-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AACnD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,0CAA0C,CAAC;AAGxE,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,gCAAgC,CAAC;AAE3E,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAC7D,eAAO,MAAM,wBAAwB,4BAA4B,CAAC;AAOlE,QAAA,MAAM,kBAAkB;;;aAGtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAG7C,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAMlD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,MAAM,IAAI,EAClB,MAAM,EAAE,sBAAsB,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,QA6BhB;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,UAAU,QAgBhD;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,YAE9B;AAED,kFAAkF;AAClF,wBAAgB,YAAY,SAI3B"}

package/out/zero-client/src/client/reload-error-handler.js

@@ -0,0 +1,114 @@
+import { parse } from "../../../shared/src/valita.js";
+import { errorKindSchema } from "../../../zero-protocol/src/error.js";
+import { updateNeededReasonTypeSchema } from "./options.js";
+import { tuple, union, string, object, number } from "@badrap/valita";
+const RELOAD_REASON_STORAGE_KEY = "_zeroReloadReason";
+const RELOAD_BACKOFF_STATE_KEY = "_zeroReloadBackoffState";
+const reloadReasonSchema = tuple([
+  union(updateNeededReasonTypeSchema, errorKindSchema),
+  string()
+]);
+const backoffStateSchema = object({
+  lastReloadTime: number().default(0),
+  nextIntervalMs: number().default(0)
+});
+const MIN_RELOAD_INTERVAL_MS = 500;
+const MAX_RELOAD_INTERVAL_MS = 6e4;
+const FALLBACK_RELOAD_INTERVAL_MS = 1e4;
+let reloadTimer = null;
+function reloadWithReason(lc, reload, reason, message) {
+  if (reloadTimer) {
+    lc.info?.("reload timer already scheduled");
+    return;
+  }
+  const now = Date.now();
+  const backoff = nextBackoff(lc, now);
+  if (typeof sessionStorage !== "undefined") {
+    sessionStorage.setItem(RELOAD_BACKOFF_STATE_KEY, JSON.stringify(backoff));
+    sessionStorage.setItem(
+      RELOAD_REASON_STORAGE_KEY,
+      JSON.stringify([reason, message])
+    );
+  }
+  const delay = backoff.lastReloadTime - now;
+  lc.error?.(
+    reason,
+    "\n",
+    "reloading",
+    delay > 0 ? `in ${delay / 1e3} seconds` : ""
+  );
+  reloadTimer = setTimeout(() => {
+    reloadTimer = null;
+    reload();
+  }, delay);
+}
+function reportReloadReason(lc) {
+  if (typeof sessionStorage !== "undefined") {
+    const value = sessionStorage.getItem(RELOAD_REASON_STORAGE_KEY);
+    if (value) {
+      sessionStorage.removeItem(RELOAD_REASON_STORAGE_KEY);
+      try {
+        const parsed = JSON.parse(value);
+        const [reasonType, message] = parse(parsed, reloadReasonSchema);
+        lc.error?.(reasonType, "Zero reloaded the page.", message);
+      } catch (e) {
+        lc.error?.("Zero reloaded the page.", e);
+        return;
+      }
+    }
+  }
+}
+function reloadScheduled() {
+  return reloadTimer !== null;
+}
+function resetBackoff() {
+  if (typeof sessionStorage !== "undefined") {
+    sessionStorage.removeItem(RELOAD_BACKOFF_STATE_KEY);
+  }
+}
+function nextBackoff(lc, now) {
+  if (typeof sessionStorage === "undefined") {
+    lc.warn?.(
+      `sessionStorage not supported. backing off in ${FALLBACK_RELOAD_INTERVAL_MS / 1e3} seconds`
+    );
+    return {
+      lastReloadTime: now + FALLBACK_RELOAD_INTERVAL_MS,
+      nextIntervalMs: MIN_RELOAD_INTERVAL_MS
+    };
+  }
+  const val = sessionStorage.getItem(RELOAD_BACKOFF_STATE_KEY);
+  if (!val) {
+    return { lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS };
+  }
+  let parsed;
+  try {
+    parsed = parse(JSON.parse(val), backoffStateSchema, "passthrough");
+  } catch (e) {
+    lc.warn?.("ignoring unparsable backoff state", val, e);
+    return { lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS };
+  }
+  const { lastReloadTime, nextIntervalMs } = parsed;
+  if (now - lastReloadTime > MAX_RELOAD_INTERVAL_MS * 2) {
+    return { lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS };
+  }
+  if (now < lastReloadTime) {
+    return parsed;
+  }
+  const nextReloadTime = Math.max(now, lastReloadTime + nextIntervalMs);
+  return {
+    lastReloadTime: nextReloadTime,
+    nextIntervalMs: Math.min(nextIntervalMs * 2, MAX_RELOAD_INTERVAL_MS)
+  };
+}
+export {
+  FALLBACK_RELOAD_INTERVAL_MS,
+  MAX_RELOAD_INTERVAL_MS,
+  MIN_RELOAD_INTERVAL_MS,
+  RELOAD_BACKOFF_STATE_KEY,
+  RELOAD_REASON_STORAGE_KEY,
+  reloadScheduled,
+  reloadWithReason,
+  reportReloadReason,
+  resetBackoff
+};
+//# sourceMappingURL=reload-error-handler.js.map

package/out/zero-client/src/client/reload-error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload-error-handler.js","sources":["../../../../../zero-client/src/client/reload-error-handler.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport * as v from '../../../shared/src/valita.ts';\nimport type {ErrorKind} from '../../../zero-protocol/src/error-kind.ts';\nimport {errorKindSchema} from '../../../zero-protocol/src/error.ts';\nimport {updateNeededReasonTypeSchema} from './options.ts';\nimport type {UpdateNeededReasonType} from './update-needed-reason-type.ts';\n\nexport const RELOAD_REASON_STORAGE_KEY = '_zeroReloadReason';\nexport const RELOAD_BACKOFF_STATE_KEY = '_zeroReloadBackoffState';\n\nconst reloadReasonSchema = v.tuple([\n  v.union(updateNeededReasonTypeSchema, errorKindSchema),\n  v.string(),\n]);\n\nconst backoffStateSchema = v.object({\n  lastReloadTime: v.number().default(0),\n  nextIntervalMs: v.number().default(0),\n});\n\nexport type BackoffState = v.Infer<typeof backoffStateSchema>;\n\nexport const MIN_RELOAD_INTERVAL_MS = 500;\nexport const MAX_RELOAD_INTERVAL_MS = 60_000;\n\n// For the fraction of browsers that do not support sessionStorage.\nexport const FALLBACK_RELOAD_INTERVAL_MS = 10_000;\n\nlet reloadTimer: ReturnType<typeof setTimeout> | null = null;\n\n// TODO: This should get pushed down into Replicache and used for reloads we\n// do there.\nexport function reloadWithReason(\n  lc: LogContext,\n  reload: () => void,\n  reason: UpdateNeededReasonType | ErrorKind,\n  message: string,\n) {\n  if (reloadTimer) {\n    lc.info?.('reload timer already scheduled');\n    return;\n  }\n  const now = Date.now();\n  const backoff = nextBackoff(lc, now);\n\n  // Record state immediately so that it persists if the user manually reloads first.\n  if (typeof sessionStorage !== 'undefined') {\n    sessionStorage.setItem(RELOAD_BACKOFF_STATE_KEY, JSON.stringify(backoff));\n    sessionStorage.setItem(\n      RELOAD_REASON_STORAGE_KEY,\n      JSON.stringify([reason, message]),\n    );\n  }\n\n  const delay = backoff.lastReloadTime - now;\n  lc.error?.(\n    reason,\n    '\\n',\n    'reloading',\n    delay > 0 ? `in ${delay / 1000} seconds` : '',\n  );\n  reloadTimer = setTimeout(() => {\n    reloadTimer = null;\n    reload();\n  }, delay);\n}\n\nexport function reportReloadReason(lc: LogContext) {\n  if (typeof sessionStorage !== 'undefined') {\n    const value = sessionStorage.getItem(RELOAD_REASON_STORAGE_KEY);\n    if (value) {\n      sessionStorage.removeItem(RELOAD_REASON_STORAGE_KEY);\n      try {\n        const parsed = JSON.parse(value);\n        const [reasonType, message] = v.parse(parsed, reloadReasonSchema);\n        lc.error?.(reasonType, 'Zero reloaded the page.', message);\n      } catch (e) {\n        lc.error?.('Zero reloaded the page.', e);\n        // ignore if not able to parse\n        return;\n      }\n    }\n  }\n}\n\n/** If a reload is scheduled, do not attempt to reconnect. */\nexport function reloadScheduled() {\n  return reloadTimer !== null;\n}\n\n/** Call upon a successful connection, indicating that backoff should be reset. */\nexport function resetBackoff() {\n  if (typeof sessionStorage !== 'undefined') {\n    sessionStorage.removeItem(RELOAD_BACKOFF_STATE_KEY);\n  }\n}\n\nfunction nextBackoff(lc: LogContext, now: number): BackoffState {\n  if (typeof sessionStorage === 'undefined') {\n    lc.warn?.(\n      `sessionStorage not supported. backing off in ${\n        FALLBACK_RELOAD_INTERVAL_MS / 1000\n      } seconds`,\n    );\n    return {\n      lastReloadTime: now + FALLBACK_RELOAD_INTERVAL_MS,\n      nextIntervalMs: MIN_RELOAD_INTERVAL_MS,\n    };\n  }\n  const val = sessionStorage.getItem(RELOAD_BACKOFF_STATE_KEY);\n  if (!val) {\n    return {lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS};\n  }\n  let parsed: BackoffState;\n  try {\n    parsed = v.parse(JSON.parse(val), backoffStateSchema, 'passthrough');\n  } catch (e) {\n    lc.warn?.('ignoring unparsable backoff state', val, e);\n    return {lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS};\n  }\n  const {lastReloadTime, nextIntervalMs} = parsed;\n\n  // Backoff state might not have been cleared. Reset for sufficiently old state.\n  if (now - lastReloadTime > MAX_RELOAD_INTERVAL_MS * 2) {\n    return {lastReloadTime: now, nextIntervalMs: MIN_RELOAD_INTERVAL_MS};\n  }\n  if (now < lastReloadTime) {\n    // If the user manually reloaded, stick to the existing schedule.\n    return parsed;\n  }\n  const nextReloadTime = Math.max(now, lastReloadTime + nextIntervalMs);\n  return {\n    lastReloadTime: nextReloadTime,\n    nextIntervalMs: Math.min(nextIntervalMs * 2, MAX_RELOAD_INTERVAL_MS),\n  };\n}\n"],"names":["v.tuple","v.union","v.string","v.object","v.number","v.parse"],"mappings":";;;;AAOO,MAAM,4BAA4B;AAClC,MAAM,2BAA2B;AAExC,MAAM,qBAAqBA,MAAQ;AAAA,EACjCC,MAAQ,8BAA8B,eAAe;AAAA,EACrDC,OAAE;AACJ,CAAC;AAED,MAAM,qBAAqBC,OAAS;AAAA,EAClC,gBAAgBC,OAAE,EAAS,QAAQ,CAAC;AAAA,EACpC,gBAAgBA,SAAW,QAAQ,CAAC;AACtC,CAAC;AAIM,MAAM,yBAAyB;AAC/B,MAAM,yBAAyB;AAG/B,MAAM,8BAA8B;AAE3C,IAAI,cAAoD;AAIjD,SAAS,iBACd,IACA,QACA,QACA,SACA;AACA,MAAI,aAAa;AACf,OAAG,OAAO,gCAAgC;AAC1C;AAAA,EACF;AACA,QAAM,MAAM,KAAK,IAAA;AACjB,QAAM,UAAU,YAAY,IAAI,GAAG;AAGnC,MAAI,OAAO,mBAAmB,aAAa;AACzC,mBAAe,QAAQ,0BAA0B,KAAK,UAAU,OAAO,CAAC;AACxE,mBAAe;AAAA,MACb;AAAA,MACA,KAAK,UAAU,CAAC,QAAQ,OAAO,CAAC;AAAA,IAAA;AAAA,EAEpC;AAEA,QAAM,QAAQ,QAAQ,iBAAiB;AACvC,KAAG;AAAA,IACD;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ,IAAI,MAAM,QAAQ,GAAI,aAAa;AAAA,EAAA;AAE7C,gBAAc,WAAW,MAAM;AAC7B,kBAAc;AACd,WAAA;AAAA,EACF,GAAG,KAAK;AACV;AAEO,SAAS,mBAAmB,IAAgB;AACjD,MAAI,OAAO,mBAAmB,aAAa;AACzC,UAAM,QAAQ,eAAe,QAAQ,yBAAyB;AAC9D,QAAI,OAAO;AACT,qBAAe,WAAW,yBAAyB;AACnD,UAAI;AACF,cAAM,SAAS,KAAK,MAAM,KAAK;AAC/B,cAAM,CAAC,YAAY,OAAO,IAAIC,MAAQ,QAAQ,kBAAkB;AAChE,WAAG,QAAQ,YAAY,2BAA2B,OAAO;AAAA,MAC3D,SAAS,GAAG;AACV,WAAG,QAAQ,2BAA2B,CAAC;AAEvC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAGO,SAAS,kBAAkB;AAChC,SAAO,gBAAgB;AACzB;AAGO,SAAS,eAAe;AAC7B,MAAI,OAAO,mBAAmB,aAAa;AACzC,mBAAe,WAAW,wBAAwB;AAAA,EACpD;AACF;AAEA,SAAS,YAAY,IAAgB,KAA2B;AAC9D,MAAI,OAAO,mBAAmB,aAAa;AACzC,OAAG;AAAA,MACD,gDACE,8BAA8B,GAChC;AAAA,IAAA;AAEF,WAAO;AAAA,MACL,gBAAgB,MAAM;AAAA,MACtB,gBAAgB;AAAA,IAAA;AAAA,EAEpB;AACA,QAAM,MAAM,eAAe,QAAQ,wBAAwB;AAC3D,MAAI,CAAC,KAAK;AACR,WAAO,EAAC,gBAAgB,KAAK,gBAAgB,uBAAA;AAAA,EAC/C;AACA,MAAI;AACJ,MAAI;AACF,aAASA,MAAQ,KAAK,MAAM,GAAG,GAAG,oBAAoB,aAAa;AAAA,EACrE,SAAS,GAAG;AACV,OAAG,OAAO,qCAAqC,KAAK,CAAC;AACrD,WAAO,EAAC,gBAAgB,KAAK,gBAAgB,uBAAA;AAAA,EAC/C;AACA,QAAM,EAAC,gBAAgB,eAAA,IAAkB;AAGzC,MAAI,MAAM,iBAAiB,yBAAyB,GAAG;AACrD,WAAO,EAAC,gBAAgB,KAAK,gBAAgB,uBAAA;AAAA,EAC/C;AACA,MAAI,MAAM,gBAAgB;AAExB,WAAO;AAAA,EACT;AACA,QAAM,iBAAiB,KAAK,IAAI,KAAK,iBAAiB,cAAc;AACpE,SAAO;AAAA,IACL,gBAAgB;AAAA,IAChB,gBAAgB,KAAK,IAAI,iBAAiB,GAAG,sBAAsB;AAAA,EAAA;AAEvE;"}

package/out/zero-client/src/client/server-option.js

@@ -0,0 +1,64 @@
+import { getBrowserGlobal } from "../../../shared/src/browser-env.js";
+function validateServerParam(paramName, server) {
+  const expectedProtocol = "http";
+  const forExample = (path = "") => ` For example: "${expectedProtocol}s://myapp-myteam.zero.ms/${path}".`;
+  if (!server.startsWith(`${expectedProtocol}://`) && !server.startsWith(`${expectedProtocol}s://`)) {
+    throw new Error(
+      `ZeroOptions.${paramName} must use the "${expectedProtocol}" or "${expectedProtocol}s" scheme.`
+    );
+  }
+  let url;
+  try {
+    url = new URL(server);
+  } catch {
+    throw new Error(
+      `ZeroOptions.${paramName} must be a valid URL.${forExample()}`
+    );
+  }
+  const urlString = url.toString();
+  const pathComponents = url.pathname.split("/");
+  if (pathComponents[0] === "") {
+    pathComponents.shift();
+  }
+  if (pathComponents[pathComponents.length - 1] === "") {
+    pathComponents.pop();
+  }
+  if (pathComponents.length > 1) {
+    throw new Error(
+      `ZeroOptions.${paramName} may have at most one path component.${forExample(
+        "zero"
+      )}`
+    );
+  }
+  for (const [property, invalidEndsWith] of [
+    ["search", "?"],
+    ["hash", "#"]
+  ]) {
+    if (url[property] || urlString.endsWith(invalidEndsWith)) {
+      throw new Error(
+        `ZeroOptions.${paramName} must not contain a ${property} component.${forExample()}`
+      );
+    }
+  }
+  return urlString;
+}
+function getServer(server) {
+  const WS = getBrowserGlobal("WebSocket");
+  if (!WS) {
+    console.warn(
+      "Zero started in an unsupported environment, no data will be synced."
+    );
+    return null;
+  }
+  if (server === void 0 || server === null) {
+    console.warn(
+      "Zero starting up with no server URL. No data will be synced."
+    );
+    return null;
+  }
+  return validateServerParam("server", server);
+}
+export {
+  getServer
+};
+//# sourceMappingURL=server-option.js.map

package/out/zero-client/src/client/server-option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-option.js","sources":["../../../../../zero-client/src/client/server-option.ts"],"sourcesContent":["import {getBrowserGlobal} from '../../../shared/src/browser-env.ts';\nimport type {HTTPString} from './http-string.ts';\n\nfunction validateServerParam(paramName: string, server: string): HTTPString {\n  const expectedProtocol = 'http';\n  const forExample = (path: string = '') =>\n    ` For example: \"${expectedProtocol}s://myapp-myteam.zero.ms/${path}\".`;\n\n  if (\n    !server.startsWith(`${expectedProtocol}://`) &&\n    !server.startsWith(`${expectedProtocol}s://`)\n  ) {\n    throw new Error(\n      `ZeroOptions.${paramName} must use the \"${expectedProtocol}\" or \"${expectedProtocol}s\" scheme.`,\n    );\n  }\n  let url;\n  try {\n    url = new URL(server);\n  } catch {\n    throw new Error(\n      `ZeroOptions.${paramName} must be a valid URL.${forExample()}`,\n    );\n  }\n\n  const urlString = url.toString();\n\n  const pathComponents = url.pathname.split('/');\n  if (pathComponents[0] === '') {\n    pathComponents.shift();\n  }\n  if (pathComponents[pathComponents.length - 1] === '') {\n    pathComponents.pop();\n  }\n  if (pathComponents.length > 1) {\n    throw new Error(\n      `ZeroOptions.${paramName} may have at most one path component.${forExample(\n        'zero',\n      )}`,\n    );\n  }\n\n  for (const [property, invalidEndsWith] of [\n    ['search', '?'],\n    ['hash', '#'],\n  ] as const) {\n    if (url[property] || urlString.endsWith(invalidEndsWith)) {\n      throw new Error(\n        `ZeroOptions.${paramName} must not contain a ${property} component.${forExample()}`,\n      );\n    }\n  }\n\n  return urlString as HTTPString;\n}\n\nexport function getServer(\n  server: string | undefined | null,\n): HTTPString | null {\n  const WS = getBrowserGlobal('WebSocket');\n  if (!WS) {\n    // oxlint-disable-next-line no-console\n    console.warn(\n      'Zero started in an unsupported environment, no data will be synced.',\n    );\n    return null;\n  }\n  if (server === undefined || server === null) {\n    // oxlint-disable-next-line no-console\n    console.warn(\n      'Zero starting up with no server URL. No data will be synced.',\n    );\n    return null;\n  }\n  return validateServerParam('server', server);\n}\n"],"names":[],"mappings":";AAGA,SAAS,oBAAoB,WAAmB,QAA4B;AAC1E,QAAM,mBAAmB;AACzB,QAAM,aAAa,CAAC,OAAe,OACjC,kBAAkB,gBAAgB,4BAA4B,IAAI;AAEpE,MACE,CAAC,OAAO,WAAW,GAAG,gBAAgB,KAAK,KAC3C,CAAC,OAAO,WAAW,GAAG,gBAAgB,MAAM,GAC5C;AACA,UAAM,IAAI;AAAA,MACR,eAAe,SAAS,kBAAkB,gBAAgB,SAAS,gBAAgB;AAAA,IAAA;AAAA,EAEvF;AACA,MAAI;AACJ,MAAI;AACF,UAAM,IAAI,IAAI,MAAM;AAAA,EACtB,QAAQ;AACN,UAAM,IAAI;AAAA,MACR,eAAe,SAAS,wBAAwB,WAAA,CAAY;AAAA,IAAA;AAAA,EAEhE;AAEA,QAAM,YAAY,IAAI,SAAA;AAEtB,QAAM,iBAAiB,IAAI,SAAS,MAAM,GAAG;AAC7C,MAAI,eAAe,CAAC,MAAM,IAAI;AAC5B,mBAAe,MAAA;AAAA,EACjB;AACA,MAAI,eAAe,eAAe,SAAS,CAAC,MAAM,IAAI;AACpD,mBAAe,IAAA;AAAA,EACjB;AACA,MAAI,eAAe,SAAS,GAAG;AAC7B,UAAM,IAAI;AAAA,MACR,eAAe,SAAS,wCAAwC;AAAA,QAC9D;AAAA,MAAA,CACD;AAAA,IAAA;AAAA,EAEL;AAEA,aAAW,CAAC,UAAU,eAAe,KAAK;AAAA,IACxC,CAAC,UAAU,GAAG;AAAA,IACd,CAAC,QAAQ,GAAG;AAAA,EAAA,GACF;AACV,QAAI,IAAI,QAAQ,KAAK,UAAU,SAAS,eAAe,GAAG;AACxD,YAAM,IAAI;AAAA,QACR,eAAe,SAAS,uBAAuB,QAAQ,cAAc,YAAY;AAAA,MAAA;AAAA,IAErF;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,UACd,QACmB;AACnB,QAAM,KAAK,iBAAiB,WAAW;AACvC,MAAI,CAAC,IAAI;AAEP,YAAQ;AAAA,MACN;AAAA,IAAA;AAEF,WAAO;AAAA,EACT;AACA,MAAI,WAAW,UAAa,WAAW,MAAM;AAE3C,YAAQ;AAAA,MACN;AAAA,IAAA;AAEF,WAAO;AAAA,EACT;AACA,SAAO,oBAAoB,UAAU,MAAM;AAC7C;"}