@dxos/echo-protocol 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/dist/lib/neutral/index.mjs

@@ -10,148 +10,24 @@ import { visitValues } from "@dxos/util";
 
 // src/reference.ts
 import { assertArgument } from "@dxos/invariant";
-import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
-var Reference = class _Reference {
-  _objectId;
-  _protocol;
-  _host;
-  _dxn;
-  /**
-  * Protocol references to runtime registered types.
-  * @deprecated
-  */
-  static TYPE_PROTOCOL = "protobuf";
-  static fromDXN(dxn) {
-    switch (dxn.kind) {
-      case DXN.kind.TYPE:
-        return new _Reference(dxn.parts[0], _Reference.TYPE_PROTOCOL, "dxos.org", dxn);
-      case DXN.kind.ECHO:
-        if (dxn.parts[0] === LOCAL_SPACE_TAG) {
-          return new _Reference(dxn.parts[1], void 0, void 0, dxn);
-        } else {
-          return new _Reference(dxn.parts[1], void 0, dxn.parts[0], dxn);
-        }
-      default:
-        return new _Reference(dxn.parts[0], void 0, dxn.parts[0], dxn);
-    }
-  }
-  static fromValue(value2) {
-    return new _Reference(value2.objectId, value2.protocol, value2.host);
-  }
-  /**
-  * Reference an object in the local space.
-  */
-  static localObjectReference(objectId) {
-    return new _Reference(objectId);
-  }
-  /**
-  * @deprecated
-  */
-  // TODO(dmaretskyi): Remove.
-  static fromLegacyTypename(type) {
-    return new _Reference(type, _Reference.TYPE_PROTOCOL, "dxos.org");
-  }
-  /**
-  * @deprecated
-  */
-  // TODO(dmaretskyi): Remove
-  static fromObjectIdAndSpaceKey(objectId, spaceKey) {
-    return new _Reference(objectId, void 0, spaceKey.toHex());
-  }
-  // prettier-ignore
-  constructor(_objectId, _protocol, _host, _dxn) {
-    this._objectId = _objectId;
-    this._protocol = _protocol;
-    this._host = _host;
-    this._dxn = _dxn;
-  }
-  get dxn() {
-    return this._dxn;
-  }
-  /**
-  * @deprecated
-  */
-  // TODO(dmaretskyi): Remove.
-  get objectId() {
-    return this._objectId;
-  }
-  /**
-  * @deprecated
-  */
-  // TODO(dmaretskyi): Remove.
-  get protocol() {
-    return this._protocol;
-  }
-  /**
-  * @deprecated
-  */
-  // TODO(dmaretskyi): Remove.
-  get host() {
-    return this._host;
-  }
-  encode() {
-    return {
-      objectId: this.objectId,
-      host: this.host,
-      protocol: this.protocol
-    };
-  }
-  // TODO(dmaretskyi): Remove in favor of `reference.dxn`.
-  toDXN() {
-    if (this._dxn) {
-      return this._dxn;
-    }
-    if (this.protocol === _Reference.TYPE_PROTOCOL) {
-      return new DXN(DXN.kind.TYPE, [
-        this.objectId
-      ]);
-    } else {
-      if (this.host) {
-        return new DXN(DXN.kind.ECHO, [
-          this.host,
-          this.objectId
-        ]);
-      } else {
-        return new DXN(DXN.kind.ECHO, [
-          LOCAL_SPACE_TAG,
-          this.objectId
-        ]);
-      }
-    }
-  }
-};
 var REFERENCE_TYPE_TAG = "dxos.echo.model.document.Reference";
-var encodeReference = (reference) => ({
-  "/": reference.toDXN().toString()
-});
-var decodeReference = (value2) => {
-  if (typeof value2 !== "object" || value2 === null || typeof value2["/"] !== "string") {
-    throw new Error("Invalid reference");
-  }
-  const dxnString = value2["/"];
-  if (dxnString.length % 2 === 0 && dxnString.slice(0, dxnString.length / 2) === dxnString.slice(dxnString.length / 2) && dxnString.includes("dxn:echo")) {
-    throw new Error("Automerge bug detected!");
-  }
-  return Reference.fromDXN(DXN.parse(dxnString));
-};
 var isEncodedReference = (value2) => typeof value2 === "object" && value2 !== null && Object.keys(value2).length === 1 && typeof value2["/"] === "string";
 var EncodedReference = Object.freeze({
   isEncodedReference,
-  getReferenceString: (value2) => {
+  /**
+  * Returns the opaque URI stored in the encoded reference (any scheme: `echo:` or `dxn:`).
+  * Consumers can narrow with `EchoURI.isEchoURI(uri)` / `DXN.isDXN(uri)`.
+  */
+  toURI: (value2) => {
     assertArgument(isEncodedReference(value2), "value", "invalid reference");
     return value2["/"];
   },
-  toDXN: (value2) => {
-    return DXN.parse(EncodedReference.getReferenceString(value2));
-  },
-  fromDXN: (dxn) => {
-    return {
-      "/": dxn.toString()
-    };
-  },
-  fromLegacyTypename: (typename) => {
+  /**
+  * Creates an encoded reference from an opaque URI.
+  */
+  fromURI: (uri) => {
     return {
-      "/": DXN.fromTypename(typename).toString()
+      "/": uri
     };
   }
 });
@@ -168,15 +44,7 @@ var DatabaseDirectory = Object.freeze({
       return null;
     }
     const rawKey = String(rawSpaceKey);
-    invariant(!rawKey.startsWith("0x"), "Space key must not start with 0x", {
-      F: __dxlog_file,
-      L: 66,
-      S: void 0,
-      A: [
-        "!rawKey.startsWith('0x')",
-        "'Space key must not start with 0x'"
-      ]
-    });
+    invariant(!rawKey.startsWith("0x"), "Space key must not start with 0x", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 17, S: void 0, A: ["!rawKey.startsWith('0x')", "'Space key must not start with 0x'"] });
     return rawKey;
   },
   getInlineObject: (doc, id) => {
@@ -205,15 +73,7 @@ var ObjectStructure = Object.freeze({
   */
   getEntityKind: (object) => {
     const kind = object.system?.kind ?? "object";
-    invariant(kind === "object" || kind === "relation", "Invalid kind", {
-      F: __dxlog_file,
-      L: 124,
-      S: void 0,
-      A: [
-        "kind === 'object' || kind === 'relation'",
-        "'Invalid kind'"
-      ]
-    });
+    invariant(kind === "object" || kind === "relation" || kind === "type", "Invalid kind", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 45, S: void 0, A: ["kind === 'object' || kind === 'relation' || kind === 'type'", "'Invalid kind'"] });
     return kind;
   },
   isDeleted: (object) => {
@@ -284,38 +144,86 @@ var ObjectStructure = Object.freeze({
       },
       data: data ?? {}
     };
+  },
+  makeType: ({ type, keys, data }) => {
+    return {
+      system: {
+        kind: "type",
+        type: {
+          "/": type
+        }
+      },
+      meta: {
+        keys: keys ?? []
+      },
+      data: data ?? {}
+    };
   }
 });
 var PROPERTY_ID = "id";
 var DATA_NAMESPACE = "data";
 
-// src/space-doc-version.ts
-var SpaceDocVersion = Object.freeze({
+// src/edge-peer.ts
+import { EdgeService } from "@dxos/protocols";
+import { compositeKey } from "@dxos/util";
+var isEdgePeerId = (peerId, spaceId) => {
+  const automergePrefix = spaceId !== void 0 ? compositeKey(EdgeService.AUTOMERGE_REPLICATOR, spaceId) : `${EdgeService.AUTOMERGE_REPLICATOR}:`;
+  const subductionPrefix = spaceId !== void 0 ? compositeKey(EdgeService.SUBDUCTION_REPLICATOR, spaceId) : `${EdgeService.SUBDUCTION_REPLICATOR}:`;
+  return peerId.startsWith(automergePrefix) || peerId.startsWith(subductionPrefix);
+};
+
+// src/echo-feed-codec.ts
+import { FeedProtocol } from "@dxos/protocols";
+var ATTR_META = "@meta";
+var EchoFeedCodec = class _EchoFeedCodec {
+  static #encoder = new TextEncoder();
+  static #decoder = new TextDecoder();
   /**
-  * For the documents created before the versioning was introduced.
+  * Prepares a value for feed storage (strips queue position from metadata) and encodes to bytes.
   */
-  LEGACY: 0,
+  static encode(value2) {
+    const prepared = _EchoFeedCodec.#stripQueuePosition(value2);
+    return _EchoFeedCodec.#encoder.encode(JSON.stringify(prepared));
+  }
   /**
-  * Current version.
+  * Decodes feed block bytes to a JSON value.
+  * If position is provided, injects queue position into the decoded object's metadata.
   */
-  CURRENT: 1
-});
-
-// src/space-id.ts
-import { subtleCrypto } from "@dxos/crypto";
-import { PublicKey, SpaceId } from "@dxos/keys";
-import { ComplexMap } from "@dxos/util";
-var SPACE_IDS_CACHE = new ComplexMap(PublicKey.hash);
-var createIdFromSpaceKey = async (spaceKey) => {
-  const cachedValue = SPACE_IDS_CACHE.get(spaceKey);
-  if (cachedValue !== void 0) {
-    return cachedValue;
+  static decode(data, position) {
+    const decoded = JSON.parse(_EchoFeedCodec.#decoder.decode(data));
+    if (position !== void 0 && typeof decoded === "object" && decoded !== null) {
+      _EchoFeedCodec.#setQueuePosition(decoded, position);
+    }
+    return decoded;
+  }
+  static #stripQueuePosition(value2) {
+    if (typeof value2 !== "object" || value2 === null) {
+      return value2;
+    }
+    const obj = structuredClone(value2);
+    const meta = obj[ATTR_META];
+    if (meta?.keys?.some((key) => key.source === FeedProtocol.KEY_QUEUE_POSITION)) {
+      meta.keys = meta.keys.filter((key) => key.source !== FeedProtocol.KEY_QUEUE_POSITION);
+    }
+    return obj;
+  }
+  static #setQueuePosition(obj, position) {
+    obj[ATTR_META] ??= {
+      keys: []
+    };
+    obj[ATTR_META].keys ??= [];
+    const keys = obj[ATTR_META].keys;
+    for (let i = 0; i < keys.length; i++) {
+      if (keys[i].source === FeedProtocol.KEY_QUEUE_POSITION) {
+        keys.splice(i, 1);
+        i--;
+      }
+    }
+    keys.push({
+      source: FeedProtocol.KEY_QUEUE_POSITION,
+      id: position.toString()
+    });
   }
-  const digest = await subtleCrypto.digest("SHA-256", spaceKey.asUint8Array());
-  const bytes = new Uint8Array(digest).slice(0, SpaceId.byteLength);
-  const spaceId = SpaceId.encode(bytes);
-  SPACE_IDS_CACHE.set(spaceKey, spaceId);
-  return spaceId;
 };
 
 // src/foreign-key.ts
@@ -343,6 +251,7 @@ var ast_exports = {};
 __export(ast_exports, {
   Filter: () => Filter,
   FilterAnd: () => FilterAnd,
+  FilterChildOf: () => FilterChildOf,
   FilterCompare: () => FilterCompare,
   FilterContains: () => FilterContains,
   FilterIn: () => FilterIn,
@@ -352,10 +261,13 @@ __export(ast_exports, {
   FilterRange: () => FilterRange,
   FilterTag: () => FilterTag,
   FilterTextSearch: () => FilterTextSearch,
+  FilterTimestamp: () => FilterTimestamp,
   Order: () => Order,
   OrderDirection: () => OrderDirection,
   Query: () => Query,
   QueryFilterClause: () => QueryFilterClause,
+  QueryFromClause: () => QueryFromClause,
+  QueryFromClause_: () => QueryFromClause_,
   QueryHierarchyTraversalClause: () => QueryHierarchyTraversalClause,
   QueryIncomingReferencesClause: () => QueryIncomingReferencesClause,
   QueryLimitClause: () => QueryLimitClause,
@@ -368,15 +280,15 @@ __export(ast_exports, {
   QuerySelectClause: () => QuerySelectClause,
   QuerySetDifferenceClause: () => QuerySetDifferenceClause,
   QueryUnionClause: () => QueryUnionClause,
+  Scope: () => Scope,
   fold: () => fold,
+  map: () => map,
   visit: () => visit
 });
 import * as Match from "effect/Match";
 import * as Schema2 from "effect/Schema";
-import { DXN as DXN2, ObjectId } from "@dxos/keys";
-var TypenameSpecifier = Schema2.Union(DXN2.Schema, Schema2.Null).annotations({
-  description: "DXN or null; null matches any type"
-});
+import { EchoURI, ObjectId, URI } from "@dxos/keys";
+var TypenameSpecifier = Schema2.Union(URI.Schema, Schema2.Null);
 var FilterObject_ = Schema2.Struct({
   type: Schema2.Literal("object"),
   typename: TypenameSpecifier,
@@ -394,7 +306,16 @@ var FilterObject_ = Schema2.Struct({
   /**
   * Objects that have any of the given foreign keys.
   */
-  foreignKeys: Schema2.optional(Schema2.Array(ForeignKey))
+  foreignKeys: Schema2.optional(Schema2.Array(ForeignKey)),
+  /**
+  * Match objects whose meta `key` equals this fully-qualified registry key (FQN format).
+  */
+  metaKey: Schema2.optional(Schema2.String),
+  /**
+  * Semver range matched against the object's meta `version`.
+  * Only consulted when {@link metaKey} is set. Objects with no `version` do not satisfy a version-constrained filter.
+  */
+  metaVersion: Schema2.optional(Schema2.String)
 });
 var FilterObject = FilterObject_;
 var FilterCompare_ = Schema2.Struct({
@@ -424,6 +345,13 @@ var FilterRange_ = Schema2.Struct({
   to: Schema2.Any
 });
 var FilterRange = FilterRange_;
+var FilterTimestamp_ = Schema2.Struct({
+  type: Schema2.Literal("timestamp"),
+  field: Schema2.Literal("createdAt", "updatedAt"),
+  operator: Schema2.Literal("gt", "gte", "lt", "lte"),
+  value: Schema2.Number
+});
+var FilterTimestamp = FilterTimestamp_;
 var FilterTextSearch_ = Schema2.Struct({
   type: Schema2.Literal("text-search"),
   text: Schema2.String,
@@ -445,8 +373,16 @@ var FilterOr_ = Schema2.Struct({
   filters: Schema2.Array(Schema2.suspend(() => Filter))
 });
 var FilterOr = FilterOr_;
-var Filter = Schema2.Union(FilterObject, FilterCompare, FilterIn, FilterContains, FilterTag, FilterRange, FilterTextSearch, FilterNot, FilterAnd, FilterOr).annotations({
-  identifier: "dxos.org/schema/Filter"
+var FilterChildOf_ = Schema2.Struct({
+  type: Schema2.Literal("child-of"),
+  /** Parent DXNs to match children of. */
+  parents: Schema2.Array(EchoURI.Schema),
+  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */
+  transitive: Schema2.Boolean
+});
+var FilterChildOf = FilterChildOf_;
+var Filter = Schema2.Union(FilterObject, FilterCompare, FilterIn, FilterContains, FilterTag, FilterRange, FilterTimestamp, FilterTextSearch, FilterChildOf, FilterNot, FilterAnd, FilterOr).annotations({
+  identifier: "org.dxos.schema.filter"
 });
 var QuerySelectClause_ = Schema2.Struct({
   type: Schema2.Literal("select"),
@@ -548,31 +484,47 @@ var QueryLimitClause_ = Schema2.Struct({
   limit: Schema2.Number
 });
 var QueryLimitClause = QueryLimitClause_;
-var Query_ = Schema2.Union(QuerySelectClause, QueryFilterClause, QueryReferenceTraversalClause, QueryIncomingReferencesClause, QueryRelationClause, QueryRelationTraversalClause, QueryHierarchyTraversalClause, QueryUnionClause, QuerySetDifferenceClause, QueryOrderClause, QueryOptionsClause, QueryLimitClause).annotations({
-  identifier: "dxos.org/schema/Query"
+var QueryFromClause_ = Schema2.Struct({
+  type: Schema2.Literal("from"),
+  query: Schema2.suspend(() => Query),
+  from: Schema2.Union(Schema2.TaggedStruct("scope", {
+    scope: Schema2.suspend(() => Scope)
+  }), Schema2.TaggedStruct("query", {
+    query: Schema2.suspend(() => Query)
+  }))
+});
+var QueryFromClause = QueryFromClause_;
+var Query_ = Schema2.Union(QuerySelectClause, QueryFilterClause, QueryReferenceTraversalClause, QueryIncomingReferencesClause, QueryRelationClause, QueryRelationTraversalClause, QueryHierarchyTraversalClause, QueryUnionClause, QuerySetDifferenceClause, QueryOrderClause, QueryOptionsClause, QueryLimitClause, QueryFromClause).annotations({
+  identifier: "org.dxos.schema.query"
 });
 var Query = Query_;
 var QueryOptions = Schema2.Struct({
+  /**
+  * Nested select statements will use this option to filter deleted objects.
+  */
+  deleted: Schema2.optional(Schema2.Literal("include", "exclude", "only")),
+  /**
+  * Diagnostics-only label for logs / tooling (not used by execution semantics).
+  */
+  debugLabel: Schema2.optional(Schema2.String)
+});
+var Scope = Schema2.Struct({
   /**
   * The nested select statemets will select from the given spaces.
   *
-  * NOTE: Spaces and queues are unioned together if both are specified.
+  * NOTE: Spaces and feeds are unioned together if both are specified.
   */
   spaceIds: Schema2.optional(Schema2.Array(Schema2.String)),
   /**
-  * If true, the nested select statements will select from all queues in the spaces specified by `spaceIds`.
+  * If true, the nested select statements will select from all feeds in the spaces specified by `spaceIds`.
   */
-  allQueuesFromSpaces: Schema2.optional(Schema2.Boolean),
+  allFeedsFromSpaces: Schema2.optional(Schema2.Boolean),
   /**
-  * The nested select statemets will select from the given queues.
+  * The nested select statemets will select from the given feeds (by EchoURI or legacy DXN).
   *
-  * NOTE: Spaces and queues are unioned together if both are specified.
+  * NOTE: Spaces and feeds are unioned together if both are specified.
   */
-  queues: Schema2.optional(Schema2.Array(DXN2.Schema)),
-  /**
-  * Nested select statements will use this option to filter deleted objects.
-  */
-  deleted: Schema2.optional(Schema2.Literal("include", "exclude", "only"))
+  feeds: Schema2.optional(Schema2.Array(EchoURI.Schema))
 });
 var visit = (query, visitor) => {
   visitor(query);
@@ -602,10 +554,90 @@ var visit = (query, visitor) => {
   }, ({ query: query2 }) => visit(query2, visitor)), Match.when({
     type: "limit"
   }, ({ query: query2 }) => visit(query2, visitor)), Match.when({
+    type: "from"
+  }, (node) => {
+    visit(node.query, visitor);
+    if (node.from._tag === "query") {
+      visit(node.from.query, visitor);
+    }
+  }), Match.when({
     type: "select"
   }, () => {
   }), Match.exhaustive);
 };
+var map = (query, mapper) => {
+  const mapped = Match.value(query).pipe(Match.when({
+    type: "filter"
+  }, (node) => ({
+    ...node,
+    selection: map(node.selection, mapper)
+  })), Match.when({
+    type: "reference-traversal"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "incoming-references"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "relation"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "relation-traversal"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "hierarchy-traversal"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "options"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper)
+  })), Match.when({
+    type: "order"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper)
+  })), Match.when({
+    type: "limit"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper)
+  })), Match.when({
+    type: "from"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper),
+    ...node.from._tag === "query" ? {
+      from: {
+        _tag: "query",
+        query: map(node.from.query, mapper)
+      }
+    } : {}
+  })), Match.when({
+    type: "union"
+  }, (node) => ({
+    ...node,
+    queries: node.queries.map((q) => map(q, mapper))
+  })), Match.when({
+    type: "set-difference"
+  }, (node) => ({
+    ...node,
+    source: map(node.source, mapper),
+    exclude: map(node.exclude, mapper)
+  })), Match.when({
+    type: "select"
+  }, (node) => node), Match.exhaustive);
+  return mapper(mapped);
+};
 var fold = (query, reducer) => {
   return Match.value(query).pipe(Match.withReturnType(), Match.when({
     type: "filter"
@@ -630,23 +662,59 @@ var fold = (query, reducer) => {
   }, ({ query: query2 }) => fold(query2, reducer)), Match.when({
     type: "limit"
   }, ({ query: query2 }) => fold(query2, reducer)), Match.when({
+    type: "from"
+  }, (node) => {
+    const results = fold(node.query, reducer);
+    if (node.from._tag === "query") {
+      return results.concat(fold(node.from.query, reducer));
+    }
+    return results;
+  }), Match.when({
     type: "select"
   }, () => []), Match.exhaustive);
 };
+
+// src/space-doc-version.ts
+var SpaceDocVersion = Object.freeze({
+  /**
+  * For the documents created before the versioning was introduced.
+  */
+  LEGACY: 0,
+  /**
+  * Current version.
+  */
+  CURRENT: 1
+});
+
+// src/space-id.ts
+import { subtleCrypto } from "@dxos/crypto";
+import { PublicKey, SpaceId } from "@dxos/keys";
+import { ComplexMap } from "@dxos/util";
+var SPACE_IDS_CACHE = new ComplexMap(PublicKey.hash);
+var createIdFromSpaceKey = async (spaceKey) => {
+  const cachedValue = SPACE_IDS_CACHE.get(spaceKey);
+  if (cachedValue !== void 0) {
+    return cachedValue;
+  }
+  const digest = await subtleCrypto.digest("SHA-256", spaceKey.asUint8Array());
+  const bytes = new Uint8Array(digest).slice(0, SpaceId.byteLength);
+  const spaceId = SpaceId.encode(bytes);
+  SPACE_IDS_CACHE.set(spaceKey, spaceId);
+  return spaceId;
+};
 export {
   DATA_NAMESPACE,
   DatabaseDirectory,
+  EchoFeedCodec,
   EncodedReference,
   ForeignKey,
   ObjectStructure,
   PROPERTY_ID,
   ast_exports as QueryAST,
   REFERENCE_TYPE_TAG,
-  Reference,
   SpaceDocVersion,
   createIdFromSpaceKey,
-  decodeReference,
-  encodeReference,
+  isEdgePeerId,
   isEncodedReference
 };
 //# sourceMappingURL=index.mjs.map