@dxos/echo-protocol 0.8.4-main.c1de068 → 0.8.4-main.c85a9c8dae

package/dist/lib/{browser → neutral}/index.mjs

@@ -12,13 +12,15 @@ import { visitValues } from "@dxos/util";
 import { assertArgument } from "@dxos/invariant";
 import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
 var Reference = class _Reference {
-  static {
-    /**
-    * Protocol references to runtime registered types.
-    * @deprecated
-    */
-    this.TYPE_PROTOCOL = "protobuf";
-  }
+  _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:
@@ -33,8 +35,8 @@ var Reference = class _Reference {
         return new _Reference(dxn.parts[0], void 0, dxn.parts[0], dxn);
     }
   }
-  static fromValue(value) {
-    return new _Reference(value.objectId, value.protocol, value.host);
+  static fromValue(value2) {
+    return new _Reference(value2.objectId, value2.protocol, value2.host);
   }
   /**
   * Reference an object in the local space.
@@ -122,28 +124,35 @@ var REFERENCE_TYPE_TAG = "dxos.echo.model.document.Reference";
 var encodeReference = (reference) => ({
   "/": reference.toDXN().toString()
 });
-var decodeReference = (value) => {
-  if (typeof value !== "object" || value === null || typeof value["/"] !== "string") {
+var decodeReference = (value2) => {
+  if (typeof value2 !== "object" || value2 === null || typeof value2["/"] !== "string") {
     throw new Error("Invalid reference");
   }
-  const dxnString = value["/"];
+  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 = (value) => typeof value === "object" && value !== null && Object.keys(value).length === 1 && typeof value["/"] === "string";
+var isEncodedReference = (value2) => typeof value2 === "object" && value2 !== null && Object.keys(value2).length === 1 && typeof value2["/"] === "string";
 var EncodedReference = Object.freeze({
   isEncodedReference,
-  getReferenceString: (value) => {
-    assertArgument(isEncodedReference(value), "invalid reference");
-    return value["/"];
+  getReferenceString: (value2) => {
+    assertArgument(isEncodedReference(value2), "value", "invalid reference");
+    return value2["/"];
   },
-  toDXN: (value) => {
-    return DXN.parse(EncodedReference.getReferenceString(value));
+  toDXN: (value2) => {
+    return DXN.parse(EncodedReference.getReferenceString(value2));
   },
   fromDXN: (dxn) => {
-    return encodeReference(Reference.fromDXN(dxn));
+    return {
+      "/": dxn.toString()
+    };
+  },
+  fromLegacyTypename: (typename) => {
+    return {
+      "/": DXN.fromTypename(typename).toString()
+    };
   }
 });
 
@@ -216,29 +225,35 @@ var ObjectStructure = Object.freeze({
   getRelationTarget: (object) => {
     return object.system?.target;
   },
+  getParent: (object) => {
+    return object.system?.parent;
+  },
   /**
   * @returns All references in the data section of the object.
   */
   getAllOutgoingReferences: (object) => {
     const references = [];
-    const visit2 = (path, value) => {
-      if (isEncodedReference(value)) {
+    const visit2 = (path, value2) => {
+      if (isEncodedReference(value2)) {
         references.push({
           path,
-          reference: value
+          reference: value2
         });
       } else {
-        visitValues(value, (value2, key) => visit2([
+        visitValues(value2, (value3, key) => visit2([
           ...path,
           String(key)
-        ], value2));
+        ], value3));
       }
     };
-    visitValues(object.data, (value, key) => visit2([
+    visitValues(object.data, (value2, key) => visit2([
       String(key)
-    ], value));
+    ], value2));
     return references;
   },
+  getTags: (object) => {
+    return object.meta.tags ?? [];
+  },
   makeObject: ({ type, data, keys }) => {
     return {
       system: {
@@ -274,37 +289,63 @@ var ObjectStructure = Object.freeze({
 var PROPERTY_ID = "id";
 var DATA_NAMESPACE = "data";
 
-// src/space-doc-version.ts
-var SpaceDocVersion = Object.freeze({
+// 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
-import { Schema, SchemaAST } from "effect";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 var ForeignKey_ = Schema.Struct({
   /**
   * Name of the foreign database/system.
@@ -315,9 +356,9 @@ var ForeignKey_ = Schema.Struct({
   * Id within the foreign database.
   */
   // TODO(wittjosiah): This annotation is currently used to ensure id field shows up in forms.
-  // TODO(dmaretskyi): `false` is not a valid value for the annotation.
+  // TODO(dmaretskyi): `false` is not a valid value for the annotation. Use a different annotation.
   id: Schema.String.annotations({
-    [SchemaAST.IdentifierAnnotationId]: false
+    [SchemaAST.IdentifierAnnotationId]: "false"
   })
 });
 var ForeignKey = ForeignKey_;
@@ -328,29 +369,42 @@ __export(ast_exports, {
   Filter: () => Filter,
   FilterAnd: () => FilterAnd,
   FilterCompare: () => FilterCompare,
+  FilterContains: () => FilterContains,
   FilterIn: () => FilterIn,
   FilterNot: () => FilterNot,
   FilterObject: () => FilterObject,
   FilterOr: () => FilterOr,
   FilterRange: () => FilterRange,
+  FilterTag: () => FilterTag,
   FilterTextSearch: () => FilterTextSearch,
+  Order: () => Order,
+  OrderDirection: () => OrderDirection,
   Query: () => Query,
   QueryFilterClause: () => QueryFilterClause,
+  QueryFromClause: () => QueryFromClause,
+  QueryFromClause_: () => QueryFromClause_,
+  QueryHierarchyTraversalClause: () => QueryHierarchyTraversalClause,
   QueryIncomingReferencesClause: () => QueryIncomingReferencesClause,
+  QueryLimitClause: () => QueryLimitClause,
   QueryOptions: () => QueryOptions,
   QueryOptionsClause: () => QueryOptionsClause,
+  QueryOrderClause: () => QueryOrderClause,
   QueryReferenceTraversalClause: () => QueryReferenceTraversalClause,
   QueryRelationClause: () => QueryRelationClause,
   QueryRelationTraversalClause: () => QueryRelationTraversalClause,
   QuerySelectClause: () => QuerySelectClause,
   QuerySetDifferenceClause: () => QuerySetDifferenceClause,
   QueryUnionClause: () => QueryUnionClause,
+  Scope: () => Scope,
+  fold: () => fold,
+  map: () => map,
   visit: () => visit
 });
-import { Schema as Schema2 } from "effect";
+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 means any type will match"
+  description: "DXN or null; null matches any type"
 });
 var FilterObject_ = Schema2.Struct({
   type: Schema2.Literal("object"),
@@ -383,6 +437,16 @@ var FilterIn_ = Schema2.Struct({
   values: Schema2.Array(Schema2.Any)
 });
 var FilterIn = FilterIn_;
+var FilterContains_ = Schema2.Struct({
+  type: Schema2.Literal("contains"),
+  value: Schema2.Any
+});
+var FilterContains = FilterContains_;
+var FilterTag_ = Schema2.Struct({
+  type: Schema2.Literal("tag"),
+  tag: Schema2.String
+});
+var FilterTag = FilterTag_;
 var FilterRange_ = Schema2.Struct({
   type: Schema2.Literal("range"),
   from: Schema2.Any,
@@ -410,7 +474,9 @@ var FilterOr_ = Schema2.Struct({
   filters: Schema2.Array(Schema2.suspend(() => Filter))
 });
 var FilterOr = FilterOr_;
-var Filter = Schema2.Union(FilterObject, FilterTextSearch, FilterCompare, FilterIn, FilterRange, FilterNot, FilterAnd, FilterOr);
+var Filter = Schema2.Union(FilterObject, FilterCompare, FilterIn, FilterContains, FilterTag, FilterRange, FilterTextSearch, FilterNot, FilterAnd, FilterOr).annotations({
+  identifier: "dxos.org/schema/Filter"
+});
 var QuerySelectClause_ = Schema2.Struct({
   type: Schema2.Literal("select"),
   filter: Schema2.suspend(() => Filter)
@@ -431,7 +497,11 @@ var QueryReferenceTraversalClause = QueryReferenceTraversalClause_;
 var QueryIncomingReferencesClause_ = Schema2.Struct({
   type: Schema2.Literal("incoming-references"),
   anchor: Schema2.suspend(() => Query),
-  property: Schema2.String,
+  /**
+  * Property path where the reference is located.
+  * If null, matches references from any property.
+  */
+  property: Schema2.NullOr(Schema2.String),
   typename: TypenameSpecifier
 });
 var QueryIncomingReferencesClause = QueryIncomingReferencesClause_;
@@ -453,6 +523,16 @@ var QueryRelationTraversalClause_ = Schema2.Struct({
   direction: Schema2.Literal("source", "target", "both")
 });
 var QueryRelationTraversalClause = QueryRelationTraversalClause_;
+var QueryHierarchyTraversalClause_ = Schema2.Struct({
+  type: Schema2.Literal("hierarchy-traversal"),
+  anchor: Schema2.suspend(() => Query),
+  /**
+  * to-parent: traverse from child to parent.
+  * to-children: traverse from parent to children.
+  */
+  direction: Schema2.Literal("to-parent", "to-children")
+});
+var QueryHierarchyTraversalClause = QueryHierarchyTraversalClause_;
 var QueryUnionClause_ = Schema2.Struct({
   type: Schema2.Literal("union"),
   queries: Schema2.Array(Schema2.suspend(() => Query))
@@ -464,50 +544,257 @@ var QuerySetDifferenceClause_ = Schema2.Struct({
   exclude: Schema2.suspend(() => Query)
 });
 var QuerySetDifferenceClause = QuerySetDifferenceClause_;
+var OrderDirection = Schema2.Literal("asc", "desc");
+var Order_ = Schema2.Union(Schema2.Struct({
+  // How database wants to order them (in practice - by id).
+  kind: Schema2.Literal("natural")
+}), Schema2.Struct({
+  kind: Schema2.Literal("property"),
+  property: Schema2.String,
+  direction: OrderDirection
+}), Schema2.Struct({
+  // Order by relevance rank (for FTS/vector search results).
+  // Default direction is 'desc' (higher rank = better match first).
+  kind: Schema2.Literal("rank"),
+  direction: OrderDirection
+}));
+var Order = Order_;
+var QueryOrderClause_ = Schema2.Struct({
+  type: Schema2.Literal("order"),
+  query: Schema2.suspend(() => Query),
+  order: Schema2.Array(Order)
+});
+var QueryOrderClause = QueryOrderClause_;
 var QueryOptionsClause_ = Schema2.Struct({
   type: Schema2.Literal("options"),
   query: Schema2.suspend(() => Query),
   options: Schema2.suspend(() => QueryOptions)
 });
 var QueryOptionsClause = QueryOptionsClause_;
-var Query_ = Schema2.Union(QuerySelectClause, QueryFilterClause, QueryReferenceTraversalClause, QueryIncomingReferencesClause, QueryRelationClause, QueryRelationTraversalClause, QueryUnionClause, QuerySetDifferenceClause, QueryOptionsClause);
+var QueryLimitClause_ = Schema2.Struct({
+  type: Schema2.Literal("limit"),
+  query: Schema2.suspend(() => Query),
+  limit: Schema2.Number
+});
+var QueryLimitClause = QueryLimitClause_;
+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: "dxos.org/schema/Query"
+});
 var Query = Query_;
 var QueryOptions = Schema2.Struct({
-  spaceIds: Schema2.optional(Schema2.Array(Schema2.String)),
+  /**
+  * Nested select statements will use this option to filter deleted objects.
+  */
   deleted: Schema2.optional(Schema2.Literal("include", "exclude", "only"))
 });
+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.
+  */
+  spaceIds: Schema2.optional(Schema2.Array(Schema2.String)),
+  /**
+  * If true, the nested select statements will select from all queues in the spaces specified by `spaceIds`.
+  */
+  allQueuesFromSpaces: Schema2.optional(Schema2.Boolean),
+  /**
+  * The nested select statemets will select from the given queues.
+  *
+  * NOTE: Spaces and queues are unioned together if both are specified.
+  */
+  queues: Schema2.optional(Schema2.Array(DXN2.Schema))
+});
 var visit = (query, visitor) => {
-  switch (query.type) {
-    case "filter":
-      visit(query.selection, visitor);
-      break;
-    case "reference-traversal":
-      visit(query.anchor, visitor);
-      break;
-    case "incoming-references":
-      visit(query.anchor, visitor);
-      break;
-    case "relation":
-      visit(query.anchor, visitor);
-      break;
-    case "options":
-      visit(query.query, visitor);
-      break;
-    case "relation-traversal":
-      visit(query.anchor, visitor);
-      break;
-    case "union":
-      query.queries.forEach((q) => visit(q, visitor));
-      break;
-    case "set-difference":
-      visit(query.source, visitor);
-      visit(query.exclude, visitor);
-      break;
+  visitor(query);
+  Match.value(query).pipe(Match.when({
+    type: "filter"
+  }, ({ selection }) => visit(selection, visitor)), Match.when({
+    type: "reference-traversal"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "incoming-references"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "relation"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "options"
+  }, ({ query: query2 }) => visit(query2, visitor)), Match.when({
+    type: "relation-traversal"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "hierarchy-traversal"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "union"
+  }, ({ queries }) => queries.forEach((q) => visit(q, visitor))), Match.when({
+    type: "set-difference"
+  }, ({ source, exclude }) => {
+    visit(source, visitor);
+    visit(exclude, visitor);
+  }), Match.when({
+    type: "order"
+  }, ({ 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"
+  }, ({ selection }) => fold(selection, reducer)), Match.when({
+    type: "reference-traversal"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "incoming-references"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "relation"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "options"
+  }, ({ query: query2 }) => fold(query2, reducer)), Match.when({
+    type: "relation-traversal"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "hierarchy-traversal"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "union"
+  }, ({ queries }) => queries.flatMap((q) => fold(q, reducer))), Match.when({
+    type: "set-difference"
+  }, ({ source, exclude }) => fold(source, reducer).concat(fold(exclude, reducer))), Match.when({
+    type: "order"
+  }, ({ 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,