@dxos/echo 0.10.0 → 0.11.1

package/dist/lib/Filter.mjs

@@ -0,0 +1,380 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { Dt as isProjection, vt as prettyFilter, y as filterMatchEntity } from "./chunk-internal.mjs";
+import { T as getUri, x as getTypeURIFromSpecifier } from "./chunk-Database.mjs";
+import { isRef } from "./Ref.mjs";
+import { EID, EntityId } from "@dxos/keys";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument } from "@dxos/invariant";
+import * as Match from "effect/Match";
+//#region src/Filter.ts
+var Filter_exports = /* @__PURE__ */ __exportAll({
+	FilterTypeId: () => FilterTypeId,
+	and: () => and,
+	between: () => between,
+	childOf: () => childOf,
+	contains: () => contains,
+	created: () => created,
+	eq: () => eq,
+	everything: () => everything,
+	foreignKeys: () => foreignKeys,
+	fromAst: () => fromAst,
+	gt: () => gt,
+	gte: () => gte,
+	id: () => id,
+	in: () => in$,
+	is: () => is,
+	key: () => key,
+	lt: () => lt,
+	lte: () => lte,
+	neq: () => neq,
+	not: () => not,
+	nothing: () => nothing,
+	or: () => or,
+	pretty: () => pretty,
+	props: () => props,
+	tag: () => tag,
+	text: () => text,
+	toPredicate: () => toPredicate,
+	type: () => type,
+	updated: () => updated
+});
+var FilterTypeId = "~@dxos/echo/Filter";
+var FilterClass = class FilterClass {
+	ast;
+	static "variance" = {};
+	constructor(ast) {
+		this.ast = ast;
+	}
+	[FilterTypeId] = FilterClass.variance;
+};
+var is = (value) => {
+	return typeof value === "object" && value !== null && "~@dxos/echo/Filter" in value;
+};
+/** Construct a filter from an ast. */
+var fromAst = (ast) => {
+	return new FilterClass(ast);
+};
+/**
+* Filter that matches all objects.
+*/
+var everything = () => {
+	return new FilterClass({
+		type: "object",
+		typename: null,
+		props: {}
+	});
+};
+/**
+* Filter that matches no objects.
+*/
+var nothing = () => {
+	return new FilterClass({
+		type: "not",
+		filter: {
+			type: "object",
+			typename: null,
+			props: {}
+		}
+	});
+};
+var id = (...ids) => {
+	assertArgument(ids.every((id) => EntityId.isValid(id)), "ids", "ids must be valid");
+	if (ids.length === 0) return nothing();
+	return new FilterClass({
+		type: "object",
+		typename: null,
+		id: ids,
+		props: {}
+	});
+};
+/**
+* Filter by type.
+*
+* Accepts a `Type.Type` entity (the value produced by `Type.makeObject` /
+* `Type.makeRelation`), a `Schema.Union` of such entities (for filtering across a
+* union of ECHO types), or a fully-qualified type URI — an `echo:` EID (stored schema)
+* or a `dxn:` DXN (static schema). To filter by a bare typename, wrap it: `DXN.make(typename)`.
+*/
+var type = (input, props) => {
+	if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) return new FilterClass({
+		type: "or",
+		filters: input.ast.types.map((t) => getTypeURIFromSpecifier(Schema.make(t))).map((typename) => ({
+			type: "object",
+			typename,
+			props: {}
+		}))
+	});
+	return new FilterClass({
+		type: "object",
+		typename: getTypeURIFromSpecifier(input),
+		...propsFilterToAst(props ?? {})
+	});
+};
+/**
+* Filter by tag.
+*/
+var tag = (tag) => {
+	return new FilterClass({
+		type: "tag",
+		tag
+	});
+};
+/**
+* Filter by registry key stored in object meta.
+*
+* @example
+* ```ts
+* Filter.key('org.example.type.foo');
+* Filter.key('org.example.type.foo', { version: '^1.2.3' });
+* ```
+*/
+var key = (key, options) => {
+	return new FilterClass({
+		type: "object",
+		typename: null,
+		props: {},
+		metaKey: key,
+		metaVersion: options?.version
+	});
+};
+/**
+* Filter by properties.
+*/
+var props = (props) => {
+	return new FilterClass({
+		type: "object",
+		typename: null,
+		...propsFilterToAst(props)
+	});
+};
+/**
+* Full-text or vector search.
+*/
+var text = (text, options) => {
+	return new FilterClass({
+		type: "text-search",
+		text,
+		searchKind: options?.type
+	});
+};
+/**
+* Filter by foreign keys.
+*/
+var foreignKeys = (schema, keys) => {
+	return new FilterClass({
+		type: "object",
+		typename: getTypeURIFromSpecifier(schema),
+		props: {},
+		foreignKeys: keys
+	});
+};
+/**
+* Predicate for property to be equal to the provided value.
+*/
+var eq = (value) => {
+	if (!isRef(value) && typeof value === "object" && value !== null) throw new TypeError("Cannot use object as a value for eq filter");
+	return new FilterClass({
+		type: "compare",
+		operator: "eq",
+		value: isRef(value) ? value.noInline().encode() : value
+	});
+};
+/**
+* Predicate for property to be not equal to the provided value.
+*/
+var neq = (value) => {
+	return new FilterClass({
+		type: "compare",
+		operator: "neq",
+		value
+	});
+};
+/**
+* Predicate for property to be greater than the provided value.
+*/
+var gt = (value) => {
+	return new FilterClass({
+		type: "compare",
+		operator: "gt",
+		value
+	});
+};
+/**
+* Predicate for property to be greater than or equal to the provided value.
+*/
+var gte = (value) => {
+	return new FilterClass({
+		type: "compare",
+		operator: "gte",
+		value
+	});
+};
+/**
+* Predicate for property to be less than the provided value.
+*/
+var lt = (value) => {
+	return new FilterClass({
+		type: "compare",
+		operator: "lt",
+		value
+	});
+};
+/**
+* Predicate for property to be less than or equal to the provided value.
+*/
+var lte = (value) => {
+	return new FilterClass({
+		type: "compare",
+		operator: "lte",
+		value
+	});
+};
+/**
+* Predicate for property to be in the provided array, or in the set of values projected
+* from a subquery's results (an uncorrelated `col IN (SELECT property FROM ...)` semi-join —
+* see `Query.project`). The subquery may target a different scope than the parent query; it
+* is resolved once at execution time.
+* @param values - Values to check against, or a single subquery projection.
+*/
+var in$ = (...args) => {
+	if (args.length === 1 && isProjection(args[0])) {
+		const projection = args[0];
+		return new FilterClass({
+			type: "in-query",
+			subquery: projection.query,
+			property: projection.property
+		});
+	}
+	return new FilterClass({
+		type: "in",
+		values: args
+	});
+};
+/**
+* Predicate for an array property to contain the provided value.
+* @param value - Value to check against.
+*/
+var contains = (value) => {
+	return new FilterClass({
+		type: "contains",
+		value
+	});
+};
+/**
+* Predicate for property to be in the provided range.
+* @param from - Start of the range (inclusive).
+* @param to - End of the range (exclusive).
+*/
+var between = (from, to) => {
+	return new FilterClass({
+		type: "range",
+		from,
+		to
+	});
+};
+var _toUnixMs = (date) => typeof date === "number" ? date : date.getTime();
+var _timeRangeFilter = (field, range) => {
+	const filters = [];
+	if (range.after != null) filters.push(new FilterClass({
+		type: "timestamp",
+		field,
+		operator: "gte",
+		value: _toUnixMs(range.after)
+	}));
+	if (range.before != null) filters.push(new FilterClass({
+		type: "timestamp",
+		field,
+		operator: "lte",
+		value: _toUnixMs(range.before)
+	}));
+	if (filters.length === 0) return everything();
+	return filters.length === 1 ? filters[0] : and(...filters);
+};
+/**
+* Filter objects by updatedAt timestamp.
+*/
+var updated = (range) => _timeRangeFilter("updatedAt", range);
+/**
+* Filter objects by createdAt timestamp.
+*/
+var created = (range) => _timeRangeFilter("createdAt", range);
+/**
+* Filter objects that are children of the specified parent(s).
+* Accepts ECHO objects, Refs, or arrays of either.
+* Refs are resolved to DXNs without loading; objects use {@link Obj.getURI}.
+* With transitive=true (default), also matches grandchildren and beyond.
+*/
+var childOf = (parents, options) => {
+	return new FilterClass({
+		type: "child-of",
+		parents: (Array.isArray(parents) ? parents : [parents]).map((item) => {
+			if (isRef(item)) return EID.parse(item.uri);
+			return EID.parse(getUri(item));
+		}),
+		transitive: options?.transitive ?? true
+	});
+};
+/**
+* Negate the filter.
+*/
+var not = (filter) => {
+	return new FilterClass({
+		type: "not",
+		filter: filter.ast
+	});
+};
+/**
+* Combine filters with a logical AND.
+*/
+var and = (...filters) => {
+	return new FilterClass({
+		type: "and",
+		filters: filters.map((f) => f.ast)
+	});
+};
+/**
+* Combine filters with a logical OR.
+*/
+var or = (...filters) => {
+	return new FilterClass({
+		type: "or",
+		filters: filters.map((f) => f.ast)
+	});
+};
+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(EntityId).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(is, (predicate) => predicate.ast), Match.when(Array.isArray, (_predicate) => {
+		throw new Error("Array predicates are not yet supported.");
+	}), Match.when((predicate) => !isRef(predicate) && typeof predicate === "object" && predicate !== null, (predicate) => {
+		return {
+			type: "object",
+			typename: null,
+			props: Object.fromEntries(Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]))
+		};
+	}), Match.orElse((value) => eq(value).ast));
+};
+/**
+* Returns a human-readable string representation of a Filter AST.
+*/
+var pretty = (filter) => prettyFilter(filter.ast);
+/**
+* Create a predicate from a filter.
+*/
+var toPredicate = Function.dual(2, (entity, filter) => filterMatchEntity(filter.ast, entity));
+//#endregion
+export { FilterTypeId, and, between, childOf, contains, created, eq, everything, foreignKeys, fromAst, gt, gte, id, in$ as in, is, key, lt, lte, neq, not, nothing, or, pretty, props, Filter_exports as t, tag, text, toPredicate, type, updated };
+
+//# sourceMappingURL=Filter.mjs.map

package/dist/lib/Filter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filter.mjs","names":[],"sources":["../../src/Filter.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Function from 'effect/Function';\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { EID, EntityId, type URI } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as internal from './internal';\nimport type * as Obj from './Obj';\nimport * as Ref from './Ref';\n// eslint-disable-next-line @dxos/rules/import-as-namespace\nimport type * as Type$ from './Type';\n\nexport const FilterTypeId = '~@dxos/echo/Filter' as const;\nexport type FilterTypeId = typeof FilterTypeId;\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  readonly [FilterTypeId]: { value: Types.Covariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\nexport 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\nexport type Any = Filter<any>;\n\nexport type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\nclass FilterClass implements Any {\n  private static 'variance': Any[FilterTypeId] = {} as Any[FilterTypeId];\n\n  constructor(public readonly ast: QueryAST.Filter) {}\n\n  [FilterTypeId] = FilterClass.variance;\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && FilterTypeId in value;\n};\n\n/** Construct a filter from an ast. */\nexport const fromAst = (ast: QueryAST.Filter): Any => {\n  return new FilterClass(ast);\n};\n\n/**\n * Filter that matches all objects.\n */\n// TODO(dmaretskyi): `Entity.Any` would be more type-safe, but causes annoying errors in existing code\nexport const everything = (): FilterClass => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n  });\n};\n\n/**\n * Filter that matches no objects.\n */\nexport const nothing = (): FilterClass => {\n  return new FilterClass({\n    type: 'not',\n    filter: {\n      type: 'object',\n      typename: null,\n      props: {},\n    },\n  });\n};\n\n/*\n * Filter by EntityId.\n */\nexport const id = (...ids: EntityId[]): Any => {\n  assertArgument(\n    ids.every((id) => EntityId.isValid(id)),\n    'ids',\n    'ids must be valid',\n  );\n\n  if (ids.length === 0) {\n    return nothing();\n  }\n\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    id: ids,\n    props: {},\n  });\n};\n\n/**\n * Filter by type.\n *\n * Accepts a `Type.Type` entity (the value produced by `Type.makeObject` /\n * `Type.makeRelation`), a `Schema.Union` of such entities (for filtering across a\n * union of ECHO types), or a fully-qualified type URI — an `echo:` EID (stored schema)\n * or a `dxn:` DXN (static schema). To filter by a bare typename, wrap it: `DXN.make(typename)`.\n */\nexport const type: {\n  <T extends Type$.AnyEntity>(type: T, props?: Props<Type$.InstanceType<T>>): Filter<Type$.InstanceType<T>>;\n  // Schema-side overload restricted to the well-known unknown schemas and to\n  // `Schema.Union(...)` of `Type.Type` entities (for filtering across a union\n  // of ECHO types). Other raw schemas are rejected.\n  <S extends internal.UnknownTypeSchema<any, any>>(\n    schema: S,\n    props?: Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n  <S extends Schema.Union<readonly Schema.Schema.AnyNoContext[]>>(\n    union: S,\n    props?: Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n  (uri: URI.URI, props?: Props<unknown>): Filter<any>;\n  // Passthrough overload for callers that hold a `Type.AnyEntity | URI.URI` union\n  // (e.g. Query.type / Query.sourceOf / Query.targetOf impls). Listed last so the\n  // typed overloads above still win for monomorphic inputs.\n  (input: Type$.AnyEntity | URI.URI, props?: Props<unknown>): Filter<unknown>;\n} = (input: Type$.AnyEntity | Schema.Schema.AnyNoContext | URI.URI, props?: Props<unknown>): any => {\n  if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) {\n    const typenames = input.ast.types.map((t) => internal.getTypeURIFromSpecifier(Schema.make(t)));\n    return new FilterClass({\n      type: 'or',\n      filters: typenames.map((typename) => ({\n        type: 'object',\n        typename,\n        props: {},\n      })),\n    });\n  }\n\n  const uri = internal.getTypeURIFromSpecifier(input);\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\n    ...propsFilterToAst(props ?? {}),\n  });\n};\n\n/**\n * Filter by tag.\n */\nexport const tag = (tag: string): Any => {\n  return new FilterClass({\n    type: 'tag',\n    tag,\n  });\n};\n\n/**\n * Options for {@link key} filter.\n */\nexport type KeyFilterOptions = {\n  /**\n   * Optional semver range expression (e.g. `^1.2.3`, `~2.0.0`, `>=1.0.0 <2.0.0`).\n   * Matches the object's meta `version` field against the range.\n   * If omitted, matches any version (including objects with no version).\n   */\n  version?: string;\n};\n\n/**\n * Filter by registry key stored in object meta.\n *\n * @example\n * ```ts\n * Filter.key('org.example.type.foo');\n * Filter.key('org.example.type.foo', { version: '^1.2.3' });\n * ```\n */\nexport const key = (key: string, options?: KeyFilterOptions): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n    metaKey: key,\n    metaVersion: options?.version,\n  });\n};\n\n/**\n * Filter by properties.\n */\nexport const props = <T>(props: Props<T>): Filter<T> => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    ...propsFilterToAst(props),\n  });\n};\n\nexport type TextSearchOptions = {\n  // TODO(dmaretskyi): Hybrid search.\n  type?: 'full-text' | 'vector';\n};\n\n/**\n * Full-text or vector search.\n */\nexport const 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?: TextSearchOptions,\n): Any => {\n  return new FilterClass({\n    type: 'text-search',\n    text,\n    searchKind: options?.type,\n  });\n};\n\n/**\n * Filter by foreign keys.\n */\nexport const foreignKeys = <S extends Type$.AnyEntity | URI.URI>(\n  schema: S,\n  keys: ForeignKey[],\n): Filter<S extends Type$.AnyEntity ? Type$.InstanceType<S> : unknown> => {\n  const uri = internal.getTypeURIFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\n    props: {},\n    foreignKeys: keys,\n  });\n};\n\n/**\n * Predicate for property to be equal to the provided value.\n */\nexport const eq = <T>(value: T): Filter<T | undefined> => {\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/**\n * Predicate for property to be not equal to the provided value.\n */\nexport const neq = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'neq',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than the provided value.\n */\nexport const gt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than or equal to the provided value.\n */\nexport const gte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than the provided value.\n */\nexport const lt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than or equal to the provided value.\n */\nexport const lte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided array, or in the set of values projected\n * from a subquery's results (an uncorrelated `col IN (SELECT property FROM ...)` semi-join —\n * see `Query.project`). The subquery may target a different scope than the parent query; it\n * is resolved once at execution time.\n * @param values - Values to check against, or a single subquery projection.\n */\nconst in$: {\n  <T>(projection: internal.Projection<T>): Filter<T>;\n  <T>(...values: T[]): Filter<T>;\n} = <T>(...args: [internal.Projection<T>] | T[]): Filter<T> => {\n  if (args.length === 1 && internal.isProjection(args[0])) {\n    const projection = args[0];\n    return new FilterClass({\n      type: 'in-query',\n      subquery: projection.query,\n      property: projection.property,\n    });\n  }\n  return new FilterClass({\n    type: 'in',\n    values: args,\n  });\n};\nexport { in$ as in };\n\n/**\n * Predicate for an array property to contain the provided value.\n * @param value - Value to check against.\n */\nexport const contains = <T>(value: T): Filter<readonly T[] | undefined> => {\n  return new FilterClass({\n    type: 'contains',\n    value,\n  });\n};\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 */\nexport const between = <T>(from: T, to: T): Filter<T> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\ntype TimeRange = { after?: Date | number; before?: Date | number };\n\nconst _toUnixMs = (date: Date | number): number => (typeof date === 'number' ? date : date.getTime());\n\nconst _timeRangeFilter = (field: 'updatedAt' | 'createdAt', range: TimeRange): Any => {\n  const filters: Any[] = [];\n  if (range.after != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: _toUnixMs(range.after) }));\n  }\n  if (range.before != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: _toUnixMs(range.before) }));\n  }\n  if (filters.length === 0) {\n    return everything();\n  }\n  return filters.length === 1 ? filters[0] : and(...filters);\n};\n\n/**\n * Filter objects by updatedAt timestamp.\n */\nexport const updated = (range: TimeRange): Any => _timeRangeFilter('updatedAt', range);\n\n/**\n * Filter objects by createdAt timestamp.\n */\nexport const created = (range: TimeRange): Any => _timeRangeFilter('createdAt', range);\n\nexport type ChildOfOptions = {\n  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */\n  transitive?: boolean;\n};\n\n/**\n * Filter objects that are children of the specified parent(s).\n * Accepts ECHO objects, Refs, or arrays of either.\n * Refs are resolved to DXNs without loading; objects use {@link Obj.getURI}.\n * With transitive=true (default), also matches grandchildren and beyond.\n */\nexport const childOf = (\n  parents: Obj.Unknown | Ref.Unknown | readonly (Obj.Unknown | Ref.Unknown)[],\n  options?: ChildOfOptions,\n): Any => {\n  const items = Array.isArray(parents) ? parents : [parents];\n  const dxns = items.map((item) => {\n    if (Ref.isRef(item)) {\n      return EID.parse(item.uri);\n    }\n    return EID.parse(internal.getUri(item));\n  });\n  return new FilterClass({\n    type: 'child-of',\n    parents: dxns,\n    transitive: options?.transitive ?? true,\n  });\n};\n\n/**\n * Negate the filter.\n */\nexport const not = <F extends Any>(filter: F): Filter<Type<F>> => {\n  return new FilterClass({\n    type: 'not',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Combine filters with a logical AND.\n */\nexport const and = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'and',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n/**\n * Combine filters with a logical OR.\n */\nexport const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'or',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n// TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n\nconst propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly EntityId[] | 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(EntityId).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(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) => eq(value).ast),\n  );\n};\n\n/**\n * Returns a human-readable string representation of a Filter AST.\n */\nexport const pretty = (filter: Any): string => internal.prettyFilter(filter.ast);\n\n/**\n * Create a predicate from a filter.\n */\nexport const toPredicate: {\n  <T extends Entity.Unknown>(filter: Filter<T>): (entity: Entity.Unknown) => entity is T;\n  <T extends Entity.Unknown>(entity: Entity.Unknown, filter: Filter<T>): entity is T;\n} = Function.dual<\n  <T extends Entity.Unknown>(filter: Filter<T>) => (entity: Entity.Unknown) => entity is T,\n  <T extends Entity.Unknown>(entity: Entity.Unknown, filter: Filter<T>) => entity is T\n>(2, <T extends Entity.Unknown>(entity: Entity.Unknown, filter: Filter<T>): entity is T =>\n  internal.filterMatchEntity(filter.ast, entity),\n);\n"],"mappings":"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"}

package/dist/lib/Format.mjs

@@ -0,0 +1,47 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { _ as getOptionsAnnotation, c as FormatAnnotationId, d as OptionsAnnotationId, f as PropertyKind, g as getFormatAnnotation, h as formatToType, l as FormatEnums, m as TypeFormat, n as CurrencyAnnotationId, p as TypeEnum, r as DecimalPrecision, s as FormatAnnotation, t as Currency, u as OptionsAnnotation, v as getTypeEnum, y as typeToFormat } from "./chunk-number.mjs";
+import { _ as SimpleTime, a as Hostname, b as toSimpleDateTime, c as URL, d as GeoPoint, f as DateOnly, g as SimpleDateTime, h as SimpleDate, i as Formula, l as UUID, m as Duration, n as Format, o as Regex, p as DateTime, r as Email, s as Text, t as SelectOption, u as GeoLocation, v as TimeOnly, x as toSimpleTime, y as toSimpleDate } from "./chunk-select.mjs";
+//#region src/Format.ts
+var Format_exports = /* @__PURE__ */ __exportAll({
+	Currency: () => Currency,
+	CurrencyAnnotationId: () => CurrencyAnnotationId,
+	DateOnly: () => DateOnly,
+	DateTime: () => DateTime,
+	DecimalPrecision: () => DecimalPrecision,
+	Duration: () => Duration,
+	Email: () => Email,
+	Format: () => Format,
+	FormatAnnotation: () => FormatAnnotation,
+	FormatAnnotationId: () => FormatAnnotationId,
+	FormatEnums: () => FormatEnums,
+	Formula: () => Formula,
+	GeoLocation: () => GeoLocation,
+	GeoPoint: () => GeoPoint,
+	Hostname: () => Hostname,
+	OptionsAnnotation: () => OptionsAnnotation,
+	OptionsAnnotationId: () => OptionsAnnotationId,
+	PropertyKind: () => PropertyKind,
+	Regex: () => Regex,
+	SelectOption: () => SelectOption,
+	SimpleDate: () => SimpleDate,
+	SimpleDateTime: () => SimpleDateTime,
+	SimpleTime: () => SimpleTime,
+	Text: () => Text,
+	TimeOnly: () => TimeOnly,
+	TypeEnum: () => TypeEnum,
+	TypeFormat: () => TypeFormat,
+	URL: () => URL,
+	UUID: () => UUID,
+	formatToType: () => formatToType,
+	getFormatAnnotation: () => getFormatAnnotation,
+	getOptionsAnnotation: () => getOptionsAnnotation,
+	getTypeEnum: () => getTypeEnum,
+	toSimpleDate: () => toSimpleDate,
+	toSimpleDateTime: () => toSimpleDateTime,
+	toSimpleTime: () => toSimpleTime,
+	typeToFormat: () => typeToFormat
+});
+//#endregion
+export { Currency, CurrencyAnnotationId, DateOnly, DateTime, DecimalPrecision, Duration, Email, Format, FormatAnnotation, FormatAnnotationId, FormatEnums, Formula, GeoLocation, GeoPoint, Hostname, OptionsAnnotation, OptionsAnnotationId, PropertyKind, Regex, SelectOption, SimpleDate, SimpleDateTime, SimpleTime, Text, TimeOnly, TypeEnum, TypeFormat, URL, UUID, formatToType, getFormatAnnotation, getOptionsAnnotation, getTypeEnum, Format_exports as t, toSimpleDate, toSimpleDateTime, toSimpleTime, typeToFormat };
+
+//# sourceMappingURL=Format.mjs.map

package/dist/lib/Format.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Format.mjs","names":[],"sources":["../../src/Format.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nexport * from './internal/Format';\n"],"mappings":""}

package/dist/lib/JsonSchema.mjs

@@ -0,0 +1,21 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { l as JsonSchemaType, n as toEffectSchema$1, r as toJsonSchema$1 } from "./chunk-json-schema.mjs";
+//#region src/JsonSchema.ts
+var JsonSchema_exports = /* @__PURE__ */ __exportAll({
+	JsonSchema: () => JsonSchema,
+	toEffectSchema: () => toEffectSchema,
+	toJsonSchema: () => toJsonSchema
+});
+/**
+* Decode JSON Schema to Effect Schema.
+*/
+var toEffectSchema = toEffectSchema$1;
+/**
+* Encode Effect Schema to JSON Schema.
+*/
+var toJsonSchema = toJsonSchema$1;
+var JsonSchema = JsonSchemaType;
+//#endregion
+export { JsonSchema, JsonSchema_exports as t, toEffectSchema, toJsonSchema };
+
+//# sourceMappingURL=JsonSchema.mjs.map

package/dist/lib/JsonSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSchema.mjs","names":[],"sources":["../../src/JsonSchema.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as jsonSchemaInternal from './internal/JsonSchema';\n\n/**\n * Decode JSON Schema to Effect Schema.\n */\nexport const toEffectSchema = jsonSchemaInternal.toEffectSchema;\n\n/**\n * Encode Effect Schema to JSON Schema.\n */\nexport const toJsonSchema = jsonSchemaInternal.toJsonSchema;\n\n/**\n * Serializable JsonSchema type definition.\n */\nexport type JsonSchema = jsonSchemaInternal.JsonSchemaType;\n\nexport const JsonSchema: Schema.Schema<jsonSchemaInternal.JsonSchemaType> = jsonSchemaInternal.JsonSchemaType;\n"],"mappings":";;;;;;;;;;;AAaA,IAAa,iBAAiB;;;;AAK9B,IAAa,eAAe;AAO5B,IAAa,aAA+D"}

package/dist/lib/Key.mjs

@@ -0,0 +1,15 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { ForeignKey } from "@dxos/echo-protocol";
+import { EID, EntityId, SpaceId, URI } from "@dxos/keys";
+//#region src/Key.ts
+var Key_exports = /* @__PURE__ */ __exportAll({
+	EID: () => EID,
+	EntityId: () => EntityId,
+	ForeignKey: () => ForeignKey,
+	SpaceId: () => SpaceId,
+	URI: () => URI
+});
+//#endregion
+export { EID, EntityId, ForeignKey, SpaceId, URI, Key_exports as t };
+
+//# sourceMappingURL=Key.mjs.map

package/dist/lib/Key.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Key.mjs","names":[],"sources":["../../src/Key.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// TODO(wittjosiah): Should this be a subset of Type?\n\nexport { ForeignKey } from '@dxos/echo-protocol';\nexport { EID, EntityId, SpaceId, URI } from '@dxos/keys';\n"],"mappings":""}

package/dist/lib/Migration.mjs

@@ -0,0 +1,38 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { vt as getSchemaURI } from "./chunk-Database.mjs";
+import { getSchema } from "./Type.mjs";
+//#region src/Migration.ts
+var Migration_exports = /* @__PURE__ */ __exportAll({ define: () => define });
+/**
+* Define a migration between two object schemas.
+*
+* @example
+* ```ts
+* const migration = Migration.define({
+*   from: ContactV1,
+*   to: ContactV2,
+*   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),
+*   onMigration: async () => {},
+* });
+* ```
+*/
+var define = (options) => {
+	const fromSchema = getSchema(options.from);
+	const toSchema = getSchema(options.to);
+	const fromType = getSchemaURI(fromSchema);
+	if (!fromType) throw new Error("Invalid from schema");
+	const toType = getSchemaURI(toSchema);
+	if (!toType) throw new Error("Invalid to schema");
+	return {
+		fromType,
+		toType,
+		fromSchema,
+		toSchema,
+		transform: options.transform,
+		onMigration: options.onMigration
+	};
+};
+//#endregion
+export { define, Migration_exports as t };
+
+//# sourceMappingURL=Migration.mjs.map

package/dist/lib/Migration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Migration.mjs","names":[],"sources":["../../src/Migration.ts"],"sourcesContent":["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { type EntityMeta, MetaId, getSchemaURI } from './internal';\nimport * as Type from './Type';\n\n/**\n * Result returned by a migration's `transform` callback.\n * The data shape matches the target schema; the optional `[Obj.Meta]` symbol key lets the\n * transform update the object's meta (e.g. `key` / `version`) atomically with the data swap.\n */\ntype MigrationSchemaInput = Type.AnyEntity;\n\ntype MigrationInstanceType<S> = S extends Type.AnyEntity\n  ? Type.InstanceType<S>\n  : S extends Schema.Schema.AnyNoContext\n    ? Schema.Schema.Type<S>\n    : never;\n\nexport type TransformResult<To> = Omit<MigrationInstanceType<To>, 'id' | Entity.KindId> & {\n  [MetaId]?: Partial<EntityMeta>;\n};\n\ntype DefineObjectMigrationOptions<From extends MigrationSchemaInput, To extends MigrationSchemaInput> = {\n  from: From;\n  to: To;\n  /**\n   * Pure function that converts the old object data to the new object data.\n   *\n   * The returned object may include an optional `[Obj.Meta]` entry to update the object's meta\n   * (e.g. registry `key` / `version`) atomically with the data swap.\n   */\n  // TODO(dmaretskyi): `id` should not be a part of the schema.\n  transform: (from: MigrationInstanceType<From>, context: ObjectMigrationContext) => Promise<TransformResult<To>>;\n\n  /**\n   * Callback that is called after the object is migrated. Called for every object that is migrated.\n   *\n   * NOTE: Database mutations performed in this callback are not guaranteed to be idempotent.\n   *       If multiple peers run the migration separately, the effects may be applied multiple times.\n   */\n  onMigration?: (params: OnMigrateProps<From, To>) => Promise<void>;\n};\n\n/**\n * Context passed to object migration callbacks.\n */\nexport type ObjectMigrationContext = {\n  db: Database.Database;\n};\n\ntype OnMigrateProps<From, To> = {\n  before: MigrationInstanceType<From>;\n  object: MigrationInstanceType<To>;\n  db: Database.Database;\n};\n\n/**\n * Definition of a migration from one object schema version to another.\n */\nexport type ObjectMigration = {\n  fromType: URI.URI;\n  toType: URI.URI;\n  fromSchema: Schema.Schema.AnyNoContext;\n  toSchema: Schema.Schema.AnyNoContext;\n  transform: (from: unknown, context: ObjectMigrationContext) => Promise<unknown>;\n  onMigration?: (params: OnMigrateProps<any, any>) => Promise<void>;\n};\n\n/**\n * Define a migration between two object schemas.\n *\n * @example\n * ```ts\n * const migration = Migration.define({\n *   from: ContactV1,\n *   to: ContactV2,\n *   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),\n *   onMigration: async () => {},\n * });\n * ```\n */\nexport const define = <From extends MigrationSchemaInput, To extends MigrationSchemaInput>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromSchema = Type.getSchema(options.from);\n  const toSchema = Type.getSchema(options.to);\n  const fromType = getSchemaURI(fromSchema);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaURI(toSchema);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema,\n    toSchema,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AA2FA,IAAa,UACX,YACoB;CACpB,MAAM,aAAa,UAAe,QAAQ,IAAI;CAC9C,MAAM,WAAW,UAAe,QAAQ,EAAE;CAC1C,MAAM,WAAW,aAAa,UAAU;CACxC,IAAI,CAAC,UACH,MAAM,IAAI,MAAM,qBAAqB;CAEvC,MAAM,SAAS,aAAa,QAAQ;CACpC,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,mBAAmB;CAGrC,OAAO;EACL;EACA;EACA;EACA;EACA,WAAW,QAAQ;EACnB,aAAa,QAAQ;CACvB;AACF"}