@dxos/echo 0.8.4-main.e098934 → 0.8.4-main.e8ec1fe

package/dist/lib/node-esm/chunk-HWS6VBQC.mjs

@@ -0,0 +1,410 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Ref,
+  RefArray,
+  __export,
+  getTypeReference
+} from "./chunk-3SVRRCUU.mjs";
+
+// src/query/query.ts
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { assertArgument } from "@dxos/invariant";
+import { DXN, ObjectId } from "@dxos/keys";
+
+// src/Ref.ts
+var Ref_exports = {};
+__export(Ref_exports, {
+  Array: () => Array2,
+  fromDXN: () => fromDXN,
+  isRef: () => isRef,
+  make: () => make
+});
+var Array2 = RefArray;
+var isRef = Ref.isRef;
+var make = Ref.make;
+var fromDXN = Ref.fromDXN;
+
+// src/query/query.ts
+var OrderClass = class _OrderClass {
+  ast;
+  static variance = {};
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Order" in value2;
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Order" = _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 {
+  ast;
+  static variance = {};
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Filter" in value2;
+  }
+  static fromAst(ast) {
+    return new _FilterClass(ast);
+  }
+  static everything() {
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      props: {}
+    });
+  }
+  static nothing() {
+    return new _FilterClass({
+      type: "not",
+      filter: {
+        type: "object",
+        typename: null,
+        props: {}
+      }
+    });
+  }
+  static relation() {
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      props: {}
+    });
+  }
+  static ids(...ids) {
+    assertArgument(ids.every((id) => ObjectId.isValid(id)), "ids", "ids must be valid");
+    if (ids.length === 0) {
+      return Filter.nothing();
+    }
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      id: ids,
+      props: {}
+    });
+  }
+  static type(schema, props) {
+    const dxn = getTypeDXNFromSpecifier(schema);
+    return new _FilterClass({
+      type: "object",
+      typename: dxn.toString(),
+      ...propsFilterToAst(props ?? {})
+    });
+  }
+  static typename(typename) {
+    assertArgument(!typename.startsWith("dxn:"), "typename", "Typename must no be qualified");
+    return new _FilterClass({
+      type: "object",
+      typename: DXN.fromTypename(typename).toString(),
+      props: {}
+    });
+  }
+  static typeDXN(dxn) {
+    return new _FilterClass({
+      type: "object",
+      typename: dxn.toString(),
+      props: {}
+    });
+  }
+  static tag(tag) {
+    return new _FilterClass({
+      type: "tag",
+      tag
+    });
+  }
+  static props(props) {
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      ...propsFilterToAst(props)
+    });
+  }
+  static text(text, options) {
+    return new _FilterClass({
+      type: "text-search",
+      text,
+      searchKind: options?.type
+    });
+  }
+  static foreignKeys(schema, keys) {
+    const dxn = getTypeDXNFromSpecifier(schema);
+    return new _FilterClass({
+      type: "object",
+      typename: dxn.toString(),
+      props: {},
+      foreignKeys: keys
+    });
+  }
+  static eq(value2) {
+    if (!isRef(value2) && typeof value2 === "object" && value2 !== null) {
+      throw new TypeError("Cannot use object as a value for eq filter");
+    }
+    return new _FilterClass({
+      type: "compare",
+      operator: "eq",
+      value: isRef(value2) ? value2.noInline().encode() : value2
+    });
+  }
+  static neq(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "neq",
+      value: value2
+    });
+  }
+  static gt(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "gt",
+      value: value2
+    });
+  }
+  static gte(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "gte",
+      value: value2
+    });
+  }
+  static lt(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "lt",
+      value: value2
+    });
+  }
+  static lte(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "lte",
+      value: value2
+    });
+  }
+  static in(...values) {
+    return new _FilterClass({
+      type: "in",
+      values
+    });
+  }
+  static contains(value2) {
+    return new _FilterClass({
+      type: "contains",
+      value: value2
+    });
+  }
+  static between(from, to) {
+    return new _FilterClass({
+      type: "range",
+      from,
+      to
+    });
+  }
+  static not(filter) {
+    return new _FilterClass({
+      type: "not",
+      filter: filter.ast
+    });
+  }
+  static and(...filters) {
+    return new _FilterClass({
+      type: "and",
+      filters: filters.map((f) => f.ast)
+    });
+  }
+  static or(...filters) {
+    return new _FilterClass({
+      type: "or",
+      filters: filters.map((f) => f.ast)
+    });
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Filter" = _FilterClass.variance;
+};
+var Filter = FilterClass;
+var propsFilterToAst = (predicates) => {
+  let idFilter;
+  if ("id" in predicates) {
+    assertArgument(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
+    idFilter = typeof predicates.id === "string" ? [
+      predicates.id
+    ] : predicates.id;
+    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
+  }
+  return {
+    id: idFilter,
+    props: Object.fromEntries(Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [
+      prop,
+      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, value2]) => [
+        key,
+        processPredicate(value2)
+      ]));
+      return {
+        type: "object",
+        typename: null,
+        props: nestedProps
+      };
+    }),
+    Match.orElse((value2) => Filter.eq(value2).ast)
+  );
+};
+var QueryClass = class _QueryClass {
+  ast;
+  static variance = {};
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Query" in value2;
+  }
+  static fromAst(ast) {
+    return new _QueryClass(ast);
+  }
+  static select(filter) {
+    return new _QueryClass({
+      type: "select",
+      filter: filter.ast
+    });
+  }
+  static type(schema, predicates) {
+    return new _QueryClass({
+      type: "select",
+      filter: FilterClass.type(schema, predicates).ast
+    });
+  }
+  static all(...queries) {
+    if (queries.length === 0) {
+      throw new TypeError("Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())");
+    }
+    return new _QueryClass({
+      type: "union",
+      queries: queries.map((q) => q.ast)
+    });
+  }
+  static without(source, exclude) {
+    return new _QueryClass({
+      type: "set-difference",
+      source: source.ast,
+      exclude: exclude.ast
+    });
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Query" = _QueryClass.variance;
+  select(filter) {
+    if (Filter.is(filter)) {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: filter.ast
+      });
+    } else {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: FilterClass.props(filter).ast
+      });
+    }
+  }
+  reference(key) {
+    return new _QueryClass({
+      type: "reference-traversal",
+      anchor: this.ast,
+      property: key
+    });
+  }
+  referencedBy(target, key) {
+    const dxn = getTypeDXNFromSpecifier(target);
+    return new _QueryClass({
+      type: "incoming-references",
+      anchor: this.ast,
+      property: key,
+      typename: dxn.toString()
+    });
+  }
+  sourceOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "outgoing",
+      filter: FilterClass.type(relation, predicates).ast
+    });
+  }
+  targetOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "incoming",
+      filter: FilterClass.type(relation, predicates).ast
+    });
+  }
+  source() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "source"
+    });
+  }
+  target() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      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",
+      query: this.ast,
+      options
+    });
+  }
+};
+var Query = QueryClass;
+var getTypeDXNFromSpecifier = (input) => {
+  if (Schema.isSchema(input)) {
+    return getTypeReference(input)?.toDXN() ?? raise(new TypeError("Schema has no DXN"));
+  } else {
+    assertArgument(typeof input === "string", "input");
+    assertArgument(!input.startsWith("dxn:"), "input");
+    return DXN.fromTypename(input);
+  }
+};
+var Order;
+
+export {
+  Ref_exports,
+  Filter,
+  Query,
+  Order
+};
+//# sourceMappingURL=chunk-HWS6VBQC.mjs.map

package/dist/lib/node-esm/chunk-HWS6VBQC.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/query/query.ts", "../../../src/Ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as EffectArray from 'effect/Array';\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { raise } from '@dxos/debug';\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport { getTypeReference } from '../internal';\nimport type * as Obj from '../Obj';\nimport * as Ref from '../Ref';\nimport type * as Type from '../Type';\n\n// TODO(dmaretskyi): Split up into interfaces for objects and relations so they can have separate verbs.\n// TODO(dmaretskyi): Undirected relation traversals.\n// TODO(wittjosiah): Make Filter & Query pipeable.\n\nexport interface Order<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Order': { value: T };\n\n  ast: QueryAST.Order;\n}\n\nclass OrderClass implements Order<any> {\n  private static variance: Order<any>['~Order'] = {} as Order<any>['~Order'];\n\n  static is(value: unknown): value is Order<any> {\n    return typeof value === 'object' && value !== null && '~Order' in value;\n  }\n\n  constructor(public readonly ast: QueryAST.Order) {}\n\n  '~Order' = OrderClass.variance;\n}\n\nexport namespace Order {\n  export const natural: Order<any> = new OrderClass({ kind: 'natural' });\n  export const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order<T> =>\n    new OrderClass({\n      kind: 'property',\n      property,\n      direction,\n    });\n}\n\nexport interface Query<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Query': { value: T };\n\n  ast: QueryAST.Query;\n\n  /**\n   * Filter the current selection based on a filter.\n   * @param filter - Filter to select the objects.\n   * @returns Query for the selected objects.\n   */\n  select(filter: Filter<T>): Query<T>;\n  select(props: Filter.Props<T>): Query<T>;\n\n  /**\n   * Traverse an outgoing reference.\n   * @param key - Property path inside T that is a reference or optional reference.\n   * @returns Query for the target of the reference.\n   */\n  reference<K extends RefPropKey<T>>(\n    key: K,\n  ): Query<\n    T[K] extends Ref.Any\n      ? Ref.Target<T[K]>\n      : T[K] extends Ref.Any | undefined\n        ? Ref.Target<Exclude<T[K], undefined>>\n        : never\n  >;\n\n  /**\n   * Find objects referencing this object.\n   * @param target - Schema of the referencing object.\n   * @param key - Property path inside the referencing object that is a reference.\n   * @returns Query for the referencing objects.\n   */\n  // TODO(dmaretskyi): any way to enforce `Ref.Target<Schema.Schema.Type<S>[key]> == T`?\n  // TODO(dmaretskyi): Ability to go through arrays of references.\n  referencedBy<S extends Schema.Schema.All>(\n    target: S | string,\n    key: RefPropKey<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the source.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  sourceOf<S extends Schema.Schema.All>(\n    relation: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the target.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  targetOf<S extends Schema.Schema.All>(\n    relation: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * For a query for relations, get the source objects.\n   * @returns Query for the source objects.\n   */\n  source(): Query<Type.Relation.Source<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  target(): Query<Type.Relation.Target<T>>;\n\n  /**\n   * Order the query results.\n   * Orders are specified in priority order. The first order will be applied first, etc.\n   * @param order - Order to sort the results.\n   * @returns Query for the ordered results.\n   */\n  orderBy(...order: EffectArray.NonEmptyArray<Order<T>>): Query<T>;\n\n  /**\n   * Add options to a query.\n   */\n  options(options: QueryAST.QueryOptions): Query<T>;\n}\n\ninterface QueryAPI {\n  is(value: unknown): value is Query.Any;\n\n  /** Construct a query from an ast. */\n  fromAst(ast: QueryAST.Query): Query<any>;\n\n  /**\n   * Select objects based on a filter.\n   * @param filter - Filter to select the objects.\n   * @returns Query for the selected objects.\n   */\n  select<F extends Filter.Any>(filter: F): Query<Filter.Type<F>>;\n\n  /**\n   * Query for objects of a given schema.\n   * @param schema - Schema of the objects.\n   * @param predicates - Predicates to filter the objects.\n   * @returns Query for the objects.\n   *\n   * Shorthand for: `Query.select(Filter.type(schema, predicates))`.\n   */\n  type<S extends Schema.Schema.All>(\n    schema: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Combine results of multiple queries.\n   * @param queries - Queries to combine.\n   * @returns Query for the combined results.\n   */\n  // TODO(dmaretskyi): Rename to `combine` or `union`.\n  all<T>(...queries: Query<T>[]): Query<T>;\n\n  /**\n   * Subtract one query from another.\n   * @param source - Query to subtract from.\n   * @param exclude - Query to subtract.\n   * @returns Query for the results of the source query minus the results of the exclude query.\n   */\n  without<T>(source: Query<T>, exclude: Query<T>): Query<T>;\n}\n\nexport declare namespace Query {\n  export type Any = Query<any>;\n\n  export type Type<Q extends Any> = Q extends Query<infer T> ? T : never;\n\n  export type TextSearchOptions = {\n    // TODO(dmaretskyi): Hybrid search.\n    type?: 'full-text' | 'vector';\n  };\n}\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Contravariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\ntype Intersection<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First & Intersection<Rest>\n  : unknown;\n\ninterface FilterAPI {\n  is(value: unknown): value is Filter.Any;\n\n  /** Construct a filter from an ast. */\n  fromAst(ast: QueryAST.Filter): Filter<Obj.Any>;\n\n  /**\n   * Filter that matches all objects.\n   */\n  // TODO(dmaretskyi): `Obj.Any` would be more type-safe, but causes annoying errors in existing code\n  everything(): Filter<Obj.AnyProps>;\n\n  /**\n   * Filter that matches no objects.\n   */\n  // TODO(dmaretskyi): Filter<never>?\n  nothing(): Filter<any>;\n\n  /**\n   * Filter by object IDs.\n   */\n  // TODO(dmaretskyi): Rename to `Filter.id`.\n  ids(...id: ObjectId[]): Filter<Obj.AnyProps>;\n\n  /**\n   * Filter by type.\n   */\n  type<S extends Schema.Schema.All>(\n    schema: S | string,\n    props?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n\n  /**\n   * Filter by non-qualified typename.\n   */\n  typename(typename: string): Filter<Obj.AnyProps>;\n\n  /**\n   * Filter by fully qualified type DXN.\n   */\n  typeDXN(dxn: DXN): Filter<Obj.AnyProps>;\n\n  /**\n   * Filter by tag.\n   */\n  tag(tag: string): Filter<Obj.Any>;\n\n  /**\n   * Filter by properties.\n   */\n  props<T>(props: Filter.Props<T>): Filter<T>;\n\n  /**\n   * Full-text or vector search.\n   */\n  text(\n    // TODO(dmaretskyi): Consider passing a vector here, but really the embedding should be done on the query-executor side.\n    text: string,\n    options?: Query.TextSearchOptions,\n  ): Filter<any>;\n\n  /**\n   * Filter by foreign keys.\n   */\n  foreignKeys<S extends Schema.Schema.All>(schema: S, keys: ForeignKey[]): Filter<Schema.Schema.Type<S>>;\n\n  /**\n   * Predicate for property to be equal to the provided value.\n   */\n  eq<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be not equal to the provided value.\n   */\n  neq<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be greater than the provided value.\n   */\n  gt<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be greater than the provided value.\n   */\n  gt<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be greater than or equal to the provided value.\n   */\n  gte<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be less than the provided value.\n   */\n  lt<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be less than or equal to the provided value.\n   */\n  lte<T>(value: T): Filter<T>;\n\n  /**\n   * Predicate for property to be in the provided array.\n   * @param values - Values to check against.\n   */\n  in<T>(...values: T[]): Filter<T>;\n\n  /**\n   * Predicate for an array property to contain the provided value.\n   * @param value - Value to check against.\n   */\n  contains<T>(value: T): Filter<readonly T[] | undefined>;\n\n  /**\n   * Predicate for property to be in the provided range.\n   * @param from - Start of the range (inclusive).\n   * @param to - End of the range (exclusive).\n   */\n  between<T>(from: T, to: T): Filter<unknown>;\n\n  /**\n   * Negate the filter.\n   */\n  not<F extends Filter.Any>(filter: F): Filter<Filter.Type<F>>;\n\n  /**\n   * Combine filters with a logical AND.\n   */\n  and<FS extends Filter.Any[]>(...filters: FS): Filter<Filter.And<FS>>;\n\n  /**\n   * Combine filters with a logical OR.\n   */\n  or<FS extends Filter.Any[]>(...filters: FS): Filter<Filter.Or<FS>>;\n\n  // TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n}\n\nexport declare namespace Filter {\n  type Props<T> = {\n    // Predicate or a value as a shorthand for `eq`.\n    [K in keyof T & string]?: Filter<T[K]> | T[K];\n  };\n\n  type Any = Filter<any>;\n\n  type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\n  type And<FS extends readonly Any[]> = Schema.Simplify<Intersection<{ [K in keyof FS]: Type<FS[K]> }>>;\n\n  type Or<FS extends readonly Any[]> = Schema.Simplify<{ [K in keyof FS]: Type<FS[K]> }[number]>;\n}\n\n// TODO(dmaretskyi): Separate object instead of statics for better devex with type errors.\nclass FilterClass implements Filter<any> {\n  private static variance: Filter<any>['~Filter'] = {} as Filter<any>['~Filter'];\n\n  static is(value: unknown): value is Filter<any> {\n    return typeof value === 'object' && value !== null && '~Filter' in value;\n  }\n\n  static fromAst(ast: QueryAST.Filter): Filter<any> {\n    return new FilterClass(ast);\n  }\n\n  static everything(): FilterClass {\n    return new FilterClass({\n      type: 'object',\n      typename: null,\n      props: {},\n    });\n  }\n\n  static nothing(): FilterClass {\n    return new FilterClass({\n      type: 'not',\n      filter: {\n        type: 'object',\n        typename: null,\n        props: {},\n      },\n    });\n  }\n\n  static relation() {\n    return new FilterClass({\n      type: 'object',\n      typename: null,\n      props: {},\n    });\n  }\n\n  static ids(...ids: ObjectId[]): Filter<any> {\n    assertArgument(\n      ids.every((id) => ObjectId.isValid(id)),\n      'ids',\n      'ids must be valid',\n    );\n\n    if (ids.length === 0) {\n      return Filter.nothing();\n    }\n\n    return new FilterClass({\n      type: 'object',\n      typename: null,\n      id: ids,\n      props: {},\n    });\n  }\n\n  static type<S extends Schema.Schema.All>(\n    schema: S | string,\n    props?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>> {\n    const dxn = getTypeDXNFromSpecifier(schema);\n    return new FilterClass({\n      type: 'object',\n      typename: dxn.toString(),\n      ...propsFilterToAst(props ?? {}),\n    });\n  }\n\n  static typename(typename: string): Filter<any> {\n    assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');\n    return new FilterClass({\n      type: 'object',\n      typename: DXN.fromTypename(typename).toString(),\n      props: {},\n    });\n  }\n\n  static typeDXN(dxn: DXN): Filter<any> {\n    return new FilterClass({\n      type: 'object',\n      typename: dxn.toString(),\n      props: {},\n    });\n  }\n\n  static tag(tag: string): Filter<any> {\n    return new FilterClass({\n      type: 'tag',\n      tag,\n    });\n  }\n\n  static props<T>(props: Filter.Props<T>): Filter<T> {\n    return new FilterClass({\n      type: 'object',\n      typename: null,\n      ...propsFilterToAst(props),\n    });\n  }\n\n  static text(text: string, options?: Query.TextSearchOptions): Filter<any> {\n    return new FilterClass({\n      type: 'text-search',\n      text,\n      searchKind: options?.type,\n    });\n  }\n\n  static foreignKeys<S extends Schema.Schema.All>(\n    schema: S | string,\n    keys: ForeignKey[],\n  ): Filter<Schema.Schema.Type<S>> {\n    const dxn = getTypeDXNFromSpecifier(schema);\n    return new FilterClass({\n      type: 'object',\n      typename: dxn.toString(),\n      props: {},\n      foreignKeys: keys,\n    });\n  }\n\n  static eq<T>(value: T): Filter<T> {\n    if (!Ref.isRef(value) && typeof value === 'object' && value !== null) {\n      throw new TypeError('Cannot use object as a value for eq filter');\n    }\n\n    return new FilterClass({\n      type: 'compare',\n      operator: 'eq',\n      value: Ref.isRef(value) ? value.noInline().encode() : value,\n    });\n  }\n\n  static neq<T>(value: T): Filter<T> {\n    return new FilterClass({\n      type: 'compare',\n      operator: 'neq',\n      value,\n    });\n  }\n\n  static gt<T>(value: T): Filter<T> {\n    return new FilterClass({\n      type: 'compare',\n      operator: 'gt',\n      value,\n    });\n  }\n\n  static gte<T>(value: T): Filter<T> {\n    return new FilterClass({\n      type: 'compare',\n      operator: 'gte',\n      value,\n    });\n  }\n\n  static lt<T>(value: T): Filter<T> {\n    return new FilterClass({\n      type: 'compare',\n      operator: 'lt',\n      value,\n    });\n  }\n\n  static lte<T>(value: T): Filter<T> {\n    return new FilterClass({\n      type: 'compare',\n      operator: 'lte',\n      value,\n    });\n  }\n\n  static in<T>(...values: T[]): Filter<T> {\n    return new FilterClass({\n      type: 'in',\n      values,\n    });\n  }\n\n  static contains<T>(value: T): Filter<readonly T[] | undefined> {\n    return new FilterClass({\n      type: 'contains',\n      value,\n    });\n  }\n\n  static between<T>(from: T, to: T): Filter<unknown> {\n    return new FilterClass({\n      type: 'range',\n      from,\n      to,\n    });\n  }\n\n  static not<F extends Filter.Any>(filter: F): Filter<Filter.Type<F>> {\n    return new FilterClass({\n      type: 'not',\n      filter: filter.ast,\n    });\n  }\n\n  static and<T>(...filters: Filter<T>[]): Filter<T> {\n    return new FilterClass({\n      type: 'and',\n      filters: filters.map((f) => f.ast),\n    });\n  }\n\n  static or<T>(...filters: Filter<T>[]): Filter<T> {\n    return new FilterClass({\n      type: 'or',\n      filters: filters.map((f) => f.ast),\n    });\n  }\n\n  private constructor(public readonly ast: QueryAST.Filter) {}\n\n  '~Filter' = FilterClass.variance;\n}\n\nexport const Filter: FilterAPI = FilterClass;\n\n/**\n * All property paths inside T that are references.\n */\n// TODO(dmaretskyi): Filter only properties that are references (or optional references, or unions that include references).\ntype RefPropKey<T> = keyof T & string;\n\nconst propsFilterToAst = (predicates: Filter.Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly ObjectId[] | undefined;\n  if ('id' in predicates) {\n    assertArgument(\n      typeof predicates.id === 'string' || Array.isArray(predicates.id),\n      'predicates.id',\n      'invalid id filter',\n    );\n    idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;\n    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);\n  }\n\n  return {\n    id: idFilter,\n    props: Object.fromEntries(\n      Object.entries(predicates)\n        .filter(([prop, _value]) => prop !== 'id')\n        .map(([prop, predicate]) => [prop, processPredicate(predicate)]),\n    ) as Record<string, QueryAST.Filter>,\n  };\n};\n\nconst processPredicate = (predicate: any): QueryAST.Filter => {\n  return Match.value(predicate).pipe(\n    Match.withReturnType<QueryAST.Filter>(),\n    Match.when(Filter.is, (predicate) => predicate.ast),\n    // TODO(wittjosiah): Add support for array predicates.\n    Match.when(Array.isArray, (_predicate) => {\n      throw new Error('Array predicates are not yet supported.');\n    }),\n    Match.when(\n      (predicate: any) => !Ref.isRef(predicate) && typeof predicate === 'object' && predicate !== null,\n      (predicate) => {\n        const nestedProps = Object.fromEntries(\n          Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]),\n        );\n\n        return {\n          type: 'object',\n          typename: null,\n          props: nestedProps,\n        };\n      },\n    ),\n    Match.orElse((value) => Filter.eq(value).ast),\n  );\n};\n\n// TODO(dmaretskyi): Separate object instead of statics for better devex with type errors.\nclass QueryClass implements Query<any> {\n  private static variance: Query<any>['~Query'] = {} as Query<any>['~Query'];\n\n  static is(value: unknown): value is Query<any> {\n    return typeof value === 'object' && value !== null && '~Query' in value;\n  }\n\n  static fromAst(ast: QueryAST.Query): Query<any> {\n    return new QueryClass(ast);\n  }\n\n  static select<F extends Filter.Any>(filter: F): Query<Filter.Type<F>> {\n    return new QueryClass({\n      type: 'select',\n      filter: filter.ast,\n    });\n  }\n\n  static type(schema: Schema.Schema.All | string, predicates?: Filter.Props<unknown>): Query<any> {\n    return new QueryClass({\n      type: 'select',\n      filter: FilterClass.type(schema, predicates).ast,\n    });\n  }\n\n  static all(...queries: Query<any>[]): Query<any> {\n    if (queries.length === 0) {\n      throw new TypeError(\n        'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',\n      );\n    }\n    return new QueryClass({\n      type: 'union',\n      queries: queries.map((q) => q.ast),\n    });\n  }\n\n  static without<T>(source: Query<T>, exclude: Query<T>): Query<T> {\n    return new QueryClass({\n      type: 'set-difference',\n      source: source.ast,\n      exclude: exclude.ast,\n    });\n  }\n\n  constructor(public readonly ast: QueryAST.Query) {}\n\n  '~Query' = QueryClass.variance;\n\n  select(filter: Filter.Any | Filter.Props<any>): Query.Any {\n    if (Filter.is(filter)) {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: filter.ast,\n      });\n    } else {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: FilterClass.props(filter).ast,\n      });\n    }\n  }\n\n  reference(key: string): Query.Any {\n    return new QueryClass({\n      type: 'reference-traversal',\n      anchor: this.ast,\n      property: key,\n    });\n  }\n\n  referencedBy(target: Schema.Schema.All | string, key: string): Query.Any {\n    const dxn = getTypeDXNFromSpecifier(target);\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key,\n      typename: dxn.toString(),\n    });\n  }\n\n  sourceOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Query.Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'outgoing',\n      filter: FilterClass.type(relation, predicates).ast,\n    });\n  }\n\n  targetOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Query.Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'incoming',\n      filter: FilterClass.type(relation, predicates).ast,\n    });\n  }\n\n  source(): Query.Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'source',\n    });\n  }\n\n  target(): Query.Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'target',\n    });\n  }\n\n  orderBy(...order: Order<any>[]): Query.Any {\n    return new QueryClass({\n      type: 'order',\n      query: this.ast,\n      order: order.map((o) => o.ast),\n    });\n  }\n\n  options(options: QueryAST.QueryOptions): Query.Any {\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options,\n    });\n  }\n}\n\nexport const Query: QueryAPI = QueryClass;\n\n/**\n * @param input schema or a typename string\n * @return type DXN\n */\nconst getTypeDXNFromSpecifier = (input: Schema.Schema.All | string): DXN => {\n  if (Schema.isSchema(input)) {\n    return getTypeReference(input)?.toDXN() ?? raise(new TypeError('Schema has no DXN'));\n  } else {\n    assertArgument(typeof input === 'string', 'input');\n    assertArgument(!input.startsWith('dxn:'), 'input');\n    return DXN.fromTypename(input);\n  }\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as EchoSchema from './internal';\nimport type * as Obj from './Obj';\n\nexport type Ref<T> = EchoSchema.Ref<T>;\nexport type Any = EchoSchema.Ref<Obj.Any>;\n\nexport const Array = EchoSchema.RefArray;\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Any> = R extends EchoSchema.Ref<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = EchoSchema.RefResolver;\n\nexport const isRef: (value: unknown) => value is Any = EchoSchema.Ref.isRef;\n\nexport const make = EchoSchema.Ref.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept DXN.\nexport const fromDXN = EchoSchema.Ref.fromDXN;\n"],
+  "mappings": "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",
+  "names": ["Match", "Schema", "raise", "assertArgument", "DXN", "ObjectId", "Array", "Array", "RefArray", "isRef", "Ref", "make", "fromDXN", "OrderClass", "variance", "is", "value", "ast", "Order", "natural", "kind", "property", "direction", "FilterClass", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "relation", "ids", "assertArgument", "every", "id", "ObjectId", "isValid", "length", "Filter", "schema", "dxn", "getTypeDXNFromSpecifier", "toString", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "text", "options", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in", "values", "contains", "between", "from", "to", "not", "and", "filters", "map", "f", "or", "predicates", "idFilter", "Array", "isArray", "Schema", "pipe", "validateSync", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "_predicate", "Error", "nestedProps", "key", "orElse", "QueryClass", "select", "all", "queries", "q", "without", "source", "exclude", "selection", "reference", "anchor", "referencedBy", "target", "sourceOf", "targetOf", "orderBy", "order", "query", "o", "Query", "input", "isSchema", "getTypeReference", "toDXN", "raise"]
+}

package/dist/lib/node-esm/index.mjs

@@ -1,18 +1,22 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
   DXN,
-  Filter,
   Key_exports,
   Obj_exports,
   ObjectNotFoundError,
-  Order,
-  Query,
   QueryAST,
-  Ref_exports,
   Relation_exports,
   SchemaNotFoundError,
+  Tag_exports,
   Type_exports
-} from "./chunk-TCY7IVTS.mjs";
+} from "./chunk-CGDHRZWH.mjs";
+import {
+  Filter,
+  Order,
+  Query,
+  Ref_exports
+} from "./chunk-HWS6VBQC.mjs";
+import "./chunk-3SVRRCUU.mjs";
 export {
   DXN,
   Filter,
@@ -25,6 +29,7 @@ export {
   Ref_exports as Ref,
   Relation_exports as Relation,
   SchemaNotFoundError,
+  Tag_exports as Tag,
   Type_exports as Type
 };
 //# sourceMappingURL=index.mjs.map