@dxos/echo 0.8.3 → 0.8.4-main.1f223c7

package/README.md

@@ -122,7 +122,7 @@ Defines attributes and encoding placed on objects.
 |                     | Optional                | Runtime prop                           | Runtime type           | JSON prop                   | JSON type  | Description                    |
 | ------------------- | ----------------------- | -------------------------------------- | ---------------------- | --------------------------- | ---------- | ------------------------------ |
 | Id                  | No                      | `id`                                   | `ObjectID` ULID string | `id`                        | string     | Unique object ID               |
-| Self DXN            | Yes                     | `Symbol(@dxos/echo/Self)`              | `DXN`                  | `@self`                     | string     | DXN to the object itself       |
+| Self DXN            | Yes                     | `Symbol(@dxos/echo/DXN)`               | `DXN`                  | `@dxn`                      | string     | DXN to the object itself       |
 | Type                | No                      | `Symbol(@dxos/echo/Type)`              | `DXN`                  | `@type`                     | string     | DXN to the object type         |
 | Schema              | Yes                     | `Symbol(@dxos/echo/Schema)`            | Effect-Schema          | -                           |            | Reference to the object schema |
 | Tombstone marker    | Yes                     | `Symbol(@dxos/echo/Deleted)`           | `boolean`              | `@deleted`                  | boolean    | Deletion marker                |

package/dist/lib/browser/{chunk-UYPR62ZB.mjs → chunk-EIXXFUN5.mjs}

@@ -5,7 +5,30 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// packages/core/echo/echo/src/Key.ts
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var SchemaNotFoundError = class extends BaseError.extend("SCHEMA_NOT_FOUND", "Schema not found") {
+  constructor(schema, options) {
+    super({
+      context: {
+        schema
+      },
+      ...options
+    });
+  }
+};
+var ObjectNotFoundError = class extends BaseError.extend("OBJECT_NOT_FOUND", "Object not found") {
+  constructor(dxn, options) {
+    super({
+      context: {
+        dxn
+      },
+      ...options
+    });
+  }
+};
+
+// src/Key.ts
 var Key_exports = {};
 __export(Key_exports, {
   ObjectId: () => ObjectId,
@@ -13,30 +36,46 @@ __export(Key_exports, {
 });
 import { SpaceId, ObjectId } from "@dxos/keys";
 
-// packages/core/echo/echo/src/Obj.ts
+// src/Obj.ts
 var Obj_exports = {};
 __export(Obj_exports, {
+  Meta: () => Meta,
+  VersionTypeId: () => VersionTypeId2,
+  clone: () => clone,
+  compareVersions: () => compareVersions,
+  decodeVersion: () => decodeVersion,
+  deleteKeys: () => deleteKeys,
+  encodeVersion: () => encodeVersion,
   fromJSON: () => fromJSON,
   getDXN: () => getDXN,
+  getKeys: () => getKeys,
   getLabel: () => getLabel2,
   getMeta: () => getMeta2,
   getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot2,
   getTypeDXN: () => getTypeDXN,
   getTypename: () => getTypename,
   instanceOf: () => instanceOf,
   isDeleted: () => isDeleted2,
   isObject: () => isObject,
+  isVersion: () => isVersion,
   make: () => make,
-  toJSON: () => toJSON
+  setLabel: () => setLabel2,
+  toJSON: () => toJSON,
+  version: () => version,
+  versionValid: () => versionValid
 });
 import { Schema } from "effect";
+import { dual } from "effect/Function";
 import * as EchoSchema from "@dxos/echo-schema";
 import { assertArgument, invariant } from "@dxos/invariant";
+import * as LiveObject from "@dxos/live-object";
 import { live } from "@dxos/live-object";
-import { assumeType } from "@dxos/util";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+import { assumeType, deepMapValues } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+var Meta = EchoSchema.MetaId;
 var make = (schema, props, meta) => {
-  assertArgument(EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Object, "Expected an object schema");
+  assertArgument(EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Object, "schema", "Expected an object schema");
   if (props[EchoSchema.MetaId] != null) {
     meta = props[EchoSchema.MetaId];
     delete props[EchoSchema.MetaId];
@@ -55,11 +94,11 @@ var instanceOf = (...args) => {
 };
 var getSchema2 = EchoSchema.getSchema;
 var getDXN = (obj) => {
-  assertArgument(!Schema.isSchema(obj), "Object should not be a schema.");
+  assertArgument(!Schema.isSchema(obj), "obj", "Object should not be a schema.");
   const dxn = EchoSchema.getObjectDXN(obj);
   invariant(dxn != null, "Invalid object.", {
     F: __dxlog_file,
-    L: 96,
+    L: 113,
     S: void 0,
     A: [
       "dxn != null",
@@ -80,7 +119,7 @@ var getMeta2 = (obj) => {
   const meta = EchoSchema.getMeta(obj);
   invariant(meta != null, "Invalid object.", {
     F: __dxlog_file,
-    L: 124,
+    L: 141,
     S: void 0,
     A: [
       "meta != null",
@@ -89,11 +128,33 @@ var getMeta2 = (obj) => {
   });
   return meta;
 };
+var getKeys = dual(2, (obj, source) => {
+  const meta = EchoSchema.getMeta(obj);
+  invariant(meta != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 153,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta.keys.filter((key) => key.source === source);
+});
+var deleteKeys = (obj, source) => {
+  const meta = EchoSchema.getMeta(obj);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
+  }
+};
 var isDeleted2 = (obj) => {
   const deleted = EchoSchema.isDeleted(obj);
   invariant(typeof deleted === "boolean", "Invalid object.", {
     F: __dxlog_file,
-    L: 131,
+    L: 175,
     S: void 0,
     A: [
       "typeof deleted === 'boolean'",
@@ -108,10 +169,88 @@ var getLabel2 = (obj) => {
     return EchoSchema.getLabel(schema, obj);
   }
 };
+var setLabel2 = (obj, label) => {
+  const schema = getSchema2(obj);
+  if (schema != null) {
+    EchoSchema.setLabel(schema, obj, label);
+  }
+};
 var toJSON = (obj) => EchoSchema.objectToJSON(obj);
 var fromJSON = EchoSchema.objectFromJSON;
+var getSnapshot2 = LiveObject.getSnapshot;
+var clone = (obj, opts) => {
+  const { id, ...data } = obj;
+  const schema = getSchema2(obj);
+  invariant(schema != null, "Object should have a schema", {
+    F: __dxlog_file,
+    L: 240,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues(data, (value, recurse) => {
+    if (EchoSchema.Ref.isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta2(obj);
+  props[EchoSchema.MetaId] = deepMapValues(meta, (value, recurse) => {
+    if (EchoSchema.Ref.isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  return make(schema, props);
+};
+var VersionTypeId2 = EchoSchema.VersionTypeId;
+var unversioned = {
+  [VersionTypeId2]: {},
+  versioned: false
+};
+var isVersion = (obj) => {
+  return obj != null && typeof obj === "object" && VersionTypeId2 in obj;
+};
+var version = (obj) => {
+  const version2 = obj[EchoSchema.ObjectVersionId];
+  if (version2 === void 0) {
+    return unversioned;
+  }
+  return version2;
+};
+var versionValid = (version2) => {
+  assertArgument(isVersion(version2), "version", "Invalid version object");
+  return !!version2.versioned;
+};
+var compareVersions = (version1, version2) => {
+  assertArgument(isVersion(version1), "version1", "Invalid version object");
+  assertArgument(isVersion(version2), "version2", "Invalid version object");
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return "unversioned";
+  }
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return "different";
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return "different";
+  }
+  return "equal";
+};
+var encodeVersion = (version2) => {
+  return JSON.stringify(version2);
+};
+var decodeVersion = (version2) => {
+  const parsed = JSON.parse(version2);
+  parsed[VersionTypeId2] = {};
+  return parsed;
+};
 
-// packages/core/echo/echo/src/Ref.ts
+// src/Ref.ts
 var Ref_exports = {};
 __export(Ref_exports, {
   Array: () => Array2,
@@ -125,7 +264,7 @@ var isRef = EchoSchema2.Ref.isRef;
 var make2 = EchoSchema2.Ref.make;
 var fromDXN = EchoSchema2.Ref.fromDXN;
 
-// packages/core/echo/echo/src/Relation.ts
+// src/Relation.ts
 var Relation_exports = {};
 __export(Relation_exports, {
   Source: () => Source,
@@ -143,11 +282,11 @@ import { assertArgument as assertArgument2, invariant as invariant2 } from "@dxo
 import { DXN } from "@dxos/keys";
 import { live as live2 } from "@dxos/live-object";
 import { assumeType as assumeType2 } from "@dxos/util";
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
 var Source = EchoSchema3.RelationSourceId;
 var Target = EchoSchema3.RelationTargetId;
 var make3 = (schema, props, meta) => {
-  assertArgument2(EchoSchema3.getTypeAnnotation(schema)?.kind === EchoSchema3.EntityKind.Relation, "Expected a relation schema");
+  assertArgument2(EchoSchema3.getTypeAnnotation(schema)?.kind === EchoSchema3.EntityKind.Relation, "schema", "Expected a relation schema");
   if (props[EchoSchema3.MetaId] != null) {
     meta = props[EchoSchema3.MetaId];
     delete props[EchoSchema3.MetaId];
@@ -174,7 +313,7 @@ var getSourceDXN = (value) => {
   const dxn = value[EchoSchema3.RelationSourceDXNId];
   invariant2(dxn instanceof DXN, void 0, {
     F: __dxlog_file2,
-    L: 98,
+    L: 100,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -189,7 +328,7 @@ var getTargetDXN = (value) => {
   const dxn = value[EchoSchema3.RelationTargetDXNId];
   invariant2(dxn instanceof DXN, void 0, {
     F: __dxlog_file2,
-    L: 110,
+    L: 112,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -204,7 +343,7 @@ var getSource = (relation) => {
   const obj = relation[EchoSchema3.RelationSourceId];
   invariant2(obj !== void 0, `Invalid source: ${relation.id}`, {
     F: __dxlog_file2,
-    L: 122,
+    L: 124,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -219,7 +358,7 @@ var getTarget = (relation) => {
   const obj = relation[EchoSchema3.RelationTargetId];
   invariant2(obj !== void 0, `Invalid target: ${relation.id}`, {
     F: __dxlog_file2,
-    L: 134,
+    L: 136,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -229,18 +368,18 @@ var getTarget = (relation) => {
   return obj;
 };
 
-// packages/core/echo/echo/src/Type.ts
+// src/Type.ts
 var Type_exports = {};
 __export(Type_exports, {
   DXN: () => DXN2,
   Expando: () => Expando2,
   Format: () => Format,
   JsonSchema: () => JsonSchemaType,
-  Kind: () => EntityKind3,
+  Kind: () => Kind,
   KindId: () => KindId,
   Obj: () => Obj,
   ObjectId: () => ObjectId2,
-  Ref: () => Ref3,
+  Ref: () => Ref4,
   Relation: () => Relation,
   SpaceId: () => SpaceId2,
   getDXN: () => getDXN2,
@@ -253,19 +392,15 @@ __export(Type_exports, {
 });
 import * as EchoSchema4 from "@dxos/echo-schema";
 import { invariant as invariant3 } from "@dxos/invariant";
-import { EntityKind as EntityKind3 } from "@dxos/echo-schema";
 import { SpaceId as SpaceId2, ObjectId as ObjectId2, DXN as DXN2 } from "@dxos/keys";
-import {
-  Format,
-  JsonSchemaType,
-  toEffectSchema,
-  toJsonSchema
-} from "@dxos/echo-schema";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo/src/Type.ts";
+import { Format, JsonSchemaType, toEffectSchema, toJsonSchema } from "@dxos/echo-schema";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
 var KindId = EchoSchema4.EntityKindId;
+var Kind = EchoSchema4.EntityKind;
 var Obj = EchoSchema4.EchoObject;
+var Expando2 = EchoSchema4.Expando;
 var Relation = EchoSchema4.EchoRelation;
-var Ref3 = EchoSchema4.Ref;
+var Ref4 = EchoSchema4.Ref;
 var getDXN2 = (schema) => {
   return EchoSchema4.getSchemaDXN(schema);
 };
@@ -273,7 +408,7 @@ var getTypename2 = (schema) => {
   const typename = EchoSchema4.getSchemaTypename(schema);
   invariant3(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
     F: __dxlog_file3,
-    L: 182,
+    L: 212,
     S: void 0,
     A: [
       "typeof typename === 'string' && !typename.startsWith('dxn:')",
@@ -283,37 +418,68 @@ var getTypename2 = (schema) => {
   return typename;
 };
 var getVersion = (schema) => {
-  const version = EchoSchema4.getSchemaVersion(schema);
-  invariant3(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
+  const version2 = EchoSchema4.getSchemaVersion(schema);
+  invariant3(typeof version2 === "string" && version2.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
     F: __dxlog_file3,
-    L: 192,
+    L: 222,
     S: void 0,
     A: [
       "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
       "'Invalid version'"
     ]
   });
-  return version;
+  return version2;
 };
+var isMutable2 = EchoSchema4.isMutable;
 var getMeta3 = (schema) => {
   return EchoSchema4.getTypeAnnotation(schema);
 };
-var isMutable2 = EchoSchema4.isMutable;
-var Expando2 = EchoSchema4.Expando;
 
-// packages/core/echo/echo/src/index.ts
+// src/index.ts
 import { DXN as DXN4 } from "@dxos/keys";
 
-// packages/core/echo/echo/src/query/dsl.ts
-import { Schema as Schema2 } from "effect";
+// src/query/dsl.ts
+import { Match, Schema as Schema2 } from "effect";
 import { raise as raise2 } from "@dxos/debug";
 import { getTypeReference } from "@dxos/echo-schema";
 import { assertArgument as assertArgument3 } from "@dxos/invariant";
 import { DXN as DXN3, ObjectId as ObjectId3 } from "@dxos/keys";
-var FilterClass = class _FilterClass {
-  static {
-    this.variance = {};
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var OrderClass = class _OrderClass {
+  static is(value) {
+    return typeof value === "object" && value !== null && "~Order" in value;
   }
+  constructor(ast) {
+    _define_property(this, "ast", void 0);
+    _define_property(this, "~Order", void 0);
+    this.ast = ast;
+    this["~Order"] = _OrderClass.variance;
+  }
+};
+_define_property(OrderClass, "variance", {});
+(function(Order2) {
+  Order2.natural = new OrderClass({
+    kind: "natural"
+  });
+  Order2.property = (property, direction) => new OrderClass({
+    kind: "property",
+    property,
+    direction
+  });
+})(Order || (Order = {}));
+var FilterClass = class _FilterClass {
   static is(value) {
     return typeof value === "object" && value !== null && "~Filter" in value;
   }
@@ -342,7 +508,7 @@ var FilterClass = class _FilterClass {
     });
   }
   static ids(...ids) {
-    assertArgument3(ids.every((id) => ObjectId3.isValid(id)), "ids must be valid");
+    assertArgument3(ids.every((id) => ObjectId3.isValid(id)), "ids", "ids must be valid");
     if (ids.length === 0) {
       return Filter.nothing();
     }
@@ -362,7 +528,7 @@ var FilterClass = class _FilterClass {
     });
   }
   static typename(typename) {
-    assertArgument3(!typename.startsWith("dxn:"), "Typename must no be qualified");
+    assertArgument3(!typename.startsWith("dxn:"), "typename", "Typename must no be qualified");
     return new _FilterClass({
       type: "object",
       typename: DXN3.fromTypename(typename).toString(),
@@ -453,6 +619,12 @@ var FilterClass = class _FilterClass {
       values
     });
   }
+  static contains(value) {
+    return new _FilterClass({
+      type: "contains",
+      value
+    });
+  }
   static between(from, to) {
     return new _FilterClass({
       type: "range",
@@ -479,15 +651,18 @@ var FilterClass = class _FilterClass {
     });
   }
   constructor(ast) {
+    _define_property(this, "ast", void 0);
+    _define_property(this, "~Filter", void 0);
     this.ast = ast;
     this["~Filter"] = _FilterClass.variance;
   }
 };
+_define_property(FilterClass, "variance", {});
 var Filter = FilterClass;
 var propsFilterToAst = (predicates) => {
   let idFilter;
   if ("id" in predicates) {
-    assertArgument3(typeof predicates.id === "string" || Array.isArray(predicates.id), "invalid id filter");
+    assertArgument3(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
     idFilter = typeof predicates.id === "string" ? [
       predicates.id
     ] : predicates.id;
@@ -497,17 +672,39 @@ var propsFilterToAst = (predicates) => {
     id: idFilter,
     props: Object.fromEntries(Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [
       prop,
-      Filter.is(predicate) ? predicate.ast : Filter.eq(predicate).ast
+      processPredicate(predicate)
     ]))
   };
 };
+var processPredicate = (predicate) => {
+  return Match.value(predicate).pipe(
+    Match.withReturnType(),
+    Match.when(Filter.is, (predicate2) => predicate2.ast),
+    // TODO(wittjosiah): Add support for array predicates.
+    Match.when(Array.isArray, (_predicate) => {
+      throw new Error("Array predicates are not yet supported.");
+    }),
+    Match.when((predicate2) => !isRef(predicate2) && typeof predicate2 === "object" && predicate2 !== null, (predicate2) => {
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value]) => [
+        key,
+        processPredicate(value)
+      ]));
+      return {
+        type: "object",
+        typename: null,
+        props: nestedProps
+      };
+    }),
+    Match.orElse((value) => Filter.eq(value).ast)
+  );
+};
 var QueryClass = class _QueryClass {
-  static {
-    this.variance = {};
-  }
   static is(value) {
     return typeof value === "object" && value !== null && "~Query" in value;
   }
+  static fromAst(ast) {
+    return new _QueryClass(ast);
+  }
   static select(filter) {
     return new _QueryClass({
       type: "select",
@@ -536,10 +733,6 @@ var QueryClass = class _QueryClass {
       exclude: exclude.ast
     });
   }
-  constructor(ast) {
-    this.ast = ast;
-    this["~Query"] = _QueryClass.variance;
-  }
   select(filter) {
     if (Filter.is(filter)) {
       return new _QueryClass({
@@ -601,6 +794,13 @@ var QueryClass = class _QueryClass {
       direction: "target"
     });
   }
+  orderBy(...order) {
+    return new _QueryClass({
+      type: "order",
+      query: this.ast,
+      order: order.map((o) => o.ast)
+    });
+  }
   options(options) {
     return new _QueryClass({
       type: "options",
@@ -608,10 +808,23 @@ var QueryClass = class _QueryClass {
       options
     });
   }
+  constructor(ast) {
+    _define_property(this, "ast", void 0);
+    _define_property(this, "~Query", void 0);
+    this.ast = ast;
+    this["~Query"] = _QueryClass.variance;
+  }
 };
+_define_property(QueryClass, "variance", {});
 var Query = QueryClass;
+var Order;
+
+// src/index.ts
+import { QueryAST } from "@dxos/echo-protocol";
 
 export {
+  SchemaNotFoundError,
+  ObjectNotFoundError,
   Key_exports,
   Obj_exports,
   Ref_exports,
@@ -619,6 +832,8 @@ export {
   Type_exports,
   Filter,
   Query,
-  DXN4 as DXN
+  Order,
+  DXN4 as DXN,
+  QueryAST
 };
-//# sourceMappingURL=chunk-UYPR62ZB.mjs.map
+//# sourceMappingURL=chunk-EIXXFUN5.mjs.map