@dxos/echo-query 0.9.1-main.c7dcc2e112 → 0.10.0

package/dist/query-lite/index.js

@@ -11,10 +11,10 @@ var assertArgument = (condition, argumentName, message) => {
 //#region src/query-lite/query-lite.ts
 var OrderClass = class OrderClass {
 	static "variance" = {};
-	static is(value) {
+	static "is"(value) {
 		return typeof value === "object" && value !== null && "~Order" in value;
 	}
-	constructor(ast) {
+	"constructor"(ast) {
 		this.ast = ast;
 	}
 	"~Order" = OrderClass.variance;
@@ -43,22 +43,66 @@ let Order1;
 	});
 })(Order1 || (Order1 = {}));
 const Order2 = Order1;
+const _filterMatchValueLocal = (filter, value) => {
+	switch (filter.type) {
+		case "compare": switch (filter.operator) {
+			case "eq": return value === filter.value;
+			case "neq": return value !== filter.value;
+			case "gt": return value > filter.value;
+			case "gte": return value >= filter.value;
+			case "lt": return value < filter.value;
+			case "lte": return value <= filter.value;
+			default: return false;
+		}
+		case "object":
+			if (typeof value !== "object" || value === null) return false;
+			if (filter.props) {
+				for (const [key, vf] of Object.entries(filter.props)) if (!_filterMatchValueLocal(vf, value[key])) return false;
+			}
+			return true;
+		case "in": return filter.values.includes(value);
+		case "range": return value >= filter.from && value <= filter.to;
+		case "not": return !_filterMatchValueLocal(filter.filter, value);
+		case "and": return filter.filters.every((f) => _filterMatchValueLocal(f, value));
+		case "or": return filter.filters.some((f) => _filterMatchValueLocal(f, value));
+		default: return false;
+	}
+};
+const _filterMatchEntityLocal = (filter, entity) => {
+	switch (filter.type) {
+		case "object":
+			if (filter.typename !== null) {
+				const typeURI = entity?.["@type"] ?? entity?.system?.type;
+				if (!typeURI || typeURI !== filter.typename) return false;
+			}
+			if (filter.id && filter.id.length > 0 && !filter.id.includes(entity?.id)) return false;
+			if (filter.props) for (const [key, vf] of Object.entries(filter.props)) {
+				if (key.startsWith("@")) continue;
+				if (!_filterMatchValueLocal(vf, entity?.[key])) return false;
+			}
+			return true;
+		case "not": return !_filterMatchEntityLocal(filter.filter, entity);
+		case "and": return filter.filters.every((f) => _filterMatchEntityLocal(f, entity));
+		case "or": return filter.filters.some((f) => _filterMatchEntityLocal(f, entity));
+		default: throw new Error(`Filter type '${filter.type}' is not supported in toPredicate.`);
+	}
+};
 var FilterClass = class FilterClass {
 	static "variance" = {};
-	static is(value) {
+	static "is"(value) {
 		return typeof value === "object" && value !== null && "~Filter" in value;
 	}
-	static fromAst(ast) {
+	static "fromAst"(ast) {
 		return new FilterClass(ast);
 	}
-	static everything() {
+	static "everything"() {
 		return new FilterClass({
 			type: "object",
 			typename: null,
 			props: {}
 		});
 	}
-	static nothing() {
+	static "nothing"() {
 		return new FilterClass({
 			type: "not",
 			filter: {
@@ -68,14 +112,14 @@ var FilterClass = class FilterClass {
 			}
 		});
 	}
-	static relation() {
+	static "relation"() {
 		return new FilterClass({
 			type: "object",
 			typename: null,
 			props: {}
 		});
 	}
-	static id(...ids) {
+	static "id"(...ids) {
 		if (ids.length === 0) return FilterClass.nothing();
 		return new FilterClass({
 			type: "object",
@@ -84,7 +128,7 @@ var FilterClass = class FilterClass {
 			props: {}
 		});
 	}
-	static type(schema, props) {
+	static "type"(schema, props) {
 		if (typeof schema !== "string") throw new TypeError("expected typename as the first paramter");
 		return new FilterClass({
 			type: "object",
@@ -92,27 +136,27 @@ var FilterClass = class FilterClass {
 			...propsFilterToAst(props ?? {})
 		});
 	}
-	static typename(typename) {
+	static "typename"(typename) {
 		return new FilterClass({
 			type: "object",
 			typename: makeTypeDxn(typename),
 			props: {}
 		});
 	}
-	static typeURI(uri) {
+	static "typeURI"(uri) {
 		return new FilterClass({
 			type: "object",
 			typename: uri,
 			props: {}
 		});
 	}
-	static tag(tag) {
+	static "tag"(tag) {
 		return new FilterClass({
 			type: "tag",
 			tag
 		});
 	}
-	static key(key, options) {
+	static "key"(key, options) {
 		return new FilterClass({
 			type: "object",
 			typename: null,
@@ -121,21 +165,21 @@ var FilterClass = class FilterClass {
 			metaVersion: options?.version
 		});
 	}
-	static props(props) {
+	static "props"(props) {
 		return new FilterClass({
 			type: "object",
 			typename: null,
 			...propsFilterToAst(props)
 		});
 	}
-	static text(text, options) {
+	static "text"(text, options) {
 		return new FilterClass({
 			type: "text-search",
 			text,
 			searchKind: options?.type
 		});
 	}
-	static foreignKeys(schema, keys) {
+	static "foreignKeys"(schema, keys) {
 		assertArgument(typeof schema === "string", "schema");
 		assertArgument(!schema.startsWith("dxn:"), "schema");
 		return new FilterClass({
@@ -145,7 +189,7 @@ var FilterClass = class FilterClass {
 			foreignKeys: keys
 		});
 	}
-	static eq(value) {
+	static "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",
@@ -153,67 +197,67 @@ var FilterClass = class FilterClass {
 			value: isRef(value) ? value.noInline().encode() : value
 		});
 	}
-	static neq(value) {
+	static "neq"(value) {
 		return new FilterClass({
 			type: "compare",
 			operator: "neq",
 			value
 		});
 	}
-	static gt(value) {
+	static "gt"(value) {
 		return new FilterClass({
 			type: "compare",
 			operator: "gt",
 			value
 		});
 	}
-	static gte(value) {
+	static "gte"(value) {
 		return new FilterClass({
 			type: "compare",
 			operator: "gte",
 			value
 		});
 	}
-	static lt(value) {
+	static "lt"(value) {
 		return new FilterClass({
 			type: "compare",
 			operator: "lt",
 			value
 		});
 	}
-	static lte(value) {
+	static "lte"(value) {
 		return new FilterClass({
 			type: "compare",
 			operator: "lte",
 			value
 		});
 	}
-	static in(...values) {
+	static "in"(...values) {
 		return new FilterClass({
 			type: "in",
 			values
 		});
 	}
-	static contains(value) {
+	static "contains"(value) {
 		return new FilterClass({
 			type: "contains",
 			value
 		});
 	}
-	static between(from, to) {
+	static "between"(from, to) {
 		return new FilterClass({
 			type: "range",
 			from,
 			to
 		});
 	}
-	static updated(range) {
+	static "updated"(range) {
 		return FilterClass._timeRangeFilter("updatedAt", range);
 	}
-	static created(range) {
+	static "created"(range) {
 		return FilterClass._timeRangeFilter("createdAt", range);
 	}
-	static childOf(parents, options) {
+	static "childOf"(parents, options) {
 		return new FilterClass({
 			type: "child-of",
 			parents: (Array.isArray(parents) ? parents : [parents]).map((item) => {
@@ -223,7 +267,7 @@ var FilterClass = class FilterClass {
 			transitive: options?.transitive ?? true
 		});
 	}
-	static _timeRangeFilter(field, range) {
+	static "_timeRangeFilter"(field, range) {
 		const toMs = (d) => typeof d === "number" ? d : d.getTime();
 		const filters = [];
 		if (range.after != null) filters.push(new FilterClass({
@@ -241,29 +285,34 @@ var FilterClass = class FilterClass {
 		if (filters.length === 0) return FilterClass.everything();
 		return filters.length === 1 ? filters[0] : FilterClass.and(...filters);
 	}
-	static not(filter) {
+	static "not"(filter) {
 		return new FilterClass({
 			type: "not",
 			filter: filter.ast
 		});
 	}
-	static and(...filters) {
+	static "and"(...filters) {
 		return new FilterClass({
 			type: "and",
 			filters: filters.map((f) => f.ast)
 		});
 	}
-	static or(...filters) {
+	static "or"(...filters) {
 		return new FilterClass({
 			type: "or",
 			filters: filters.map((f) => f.ast)
 		});
 	}
 	/** Returns a human-readable string representation of a Filter AST. */
-	static pretty(filter) {
+	static "pretty"(filter) {
 		return prettyFilter(filter.ast);
 	}
-	constructor(ast) {
+	/** Create a predicate from a filter. */
+	static "toPredicate" = ((entityOrFilter, filter) => {
+		if (filter === void 0) return (entity) => _filterMatchEntityLocal(entityOrFilter.ast, entity);
+		return _filterMatchEntityLocal(filter.ast, entityOrFilter);
+	});
+	"constructor"(ast) {
 		this.ast = ast;
 	}
 	"~Filter" = FilterClass.variance;
@@ -292,19 +341,19 @@ const processPredicate = (predicate) => {
 };
 var QueryClass = class QueryClass {
 	static "variance" = {};
-	static is(value) {
+	static "is"(value) {
 		return typeof value === "object" && value !== null && "~Query" in value;
 	}
-	static fromAst(ast) {
+	static "fromAst"(ast) {
 		return new QueryClass(ast);
 	}
-	static select(filter) {
+	static "select"(filter) {
 		return new QueryClass({
 			type: "select",
 			filter: filter.ast
 		});
 	}
-	select(filter) {
+	"select"(filter) {
 		if (FilterClass.is(filter)) return new QueryClass({
 			type: "filter",
 			selection: this.ast,
@@ -316,34 +365,34 @@ var QueryClass = class QueryClass {
 			filter: FilterClass.props(filter).ast
 		});
 	}
-	static type(schema, predicates) {
+	static "type"(schema, predicates) {
 		if (typeof schema !== "string") throw new TypeError("expected typename as the first paramter");
 		return new QueryClass({
 			type: "select",
 			filter: FilterClass.type(schema, predicates).ast
 		});
 	}
-	static all(...queries) {
+	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) {
+	static "without"(source, exclude) {
 		return new QueryClass({
 			type: "set-difference",
 			source: source.ast,
 			exclude: exclude.ast
 		});
 	}
-	static from(...args) {
+	static "from"(...args) {
 		return new QueryClass({
 			type: "select",
 			filter: FilterClass.everything().ast
 		}).from(...args);
 	}
-	from(...args) {
+	"from"(...args) {
 		if (args.length > 1 && args.every((arg$1) => _isScopeLike(arg$1))) return new QueryClass({
 			type: "from",
 			query: this.ast,
@@ -372,21 +421,21 @@ var QueryClass = class QueryClass {
 		throw new TypeError("Database and Feed objects are not supported in query-lite sandbox");
 	}
 	/** Returns a human-readable string representation of a Query AST. */
-	static pretty(query) {
+	static "pretty"(query) {
 		return prettyQuery(query.ast);
 	}
-	constructor(ast) {
+	"constructor"(ast) {
 		this.ast = ast;
 	}
 	"~Query" = QueryClass.variance;
-	reference(key) {
+	"reference"(key) {
 		return new QueryClass({
 			type: "reference-traversal",
 			anchor: this.ast,
 			property: key
 		});
 	}
-	referencedBy(target, key) {
+	"referencedBy"(target, key) {
 		if (target !== void 0 && typeof target !== "string") throw new TypeError("referencedBy requires a typename string in query-lite");
 		const typename = target !== void 0 ? makeTypeDxn(target) : null;
 		return new QueryClass({
@@ -396,7 +445,7 @@ var QueryClass = class QueryClass {
 			typename
 		});
 	}
-	sourceOf(relation, predicates) {
+	"sourceOf"(relation, predicates) {
 		return new QueryClass({
 			type: "relation",
 			anchor: this.ast,
@@ -404,7 +453,7 @@ var QueryClass = class QueryClass {
 			filter: relation === void 0 ? void 0 : typeof relation === "string" ? FilterClass.type(relation, predicates).ast : FilterClass.type(relation, predicates).ast
 		});
 	}
-	targetOf(relation, predicates) {
+	"targetOf"(relation, predicates) {
 		return new QueryClass({
 			type: "relation",
 			anchor: this.ast,
@@ -412,56 +461,56 @@ var QueryClass = class QueryClass {
 			filter: relation === void 0 ? void 0 : typeof relation === "string" ? FilterClass.type(relation, predicates).ast : FilterClass.type(relation, predicates).ast
 		});
 	}
-	source() {
+	"source"() {
 		return new QueryClass({
 			type: "relation-traversal",
 			anchor: this.ast,
 			direction: "source"
 		});
 	}
-	target() {
+	"target"() {
 		return new QueryClass({
 			type: "relation-traversal",
 			anchor: this.ast,
 			direction: "target"
 		});
 	}
-	parent() {
+	"parent"() {
 		return new QueryClass({
 			type: "hierarchy-traversal",
 			anchor: this.ast,
 			direction: "to-parent"
 		});
 	}
-	children() {
+	"children"() {
 		return new QueryClass({
 			type: "hierarchy-traversal",
 			anchor: this.ast,
 			direction: "to-children"
 		});
 	}
-	orderBy(...order) {
+	"orderBy"(...order) {
 		return new QueryClass({
 			type: "order",
 			query: this.ast,
 			order: order.map((o) => o.ast)
 		});
 	}
-	limit(limit) {
+	"limit"(limit) {
 		return new QueryClass({
 			type: "limit",
 			query: this.ast,
 			limit
 		});
 	}
-	options(options) {
+	"options"(options) {
 		return new QueryClass({
 			type: "options",
 			query: this.ast,
 			options
 		});
 	}
-	debugLabel(label) {
+	"debugLabel"(label) {
 		if (this.ast.type === "options") return new QueryClass({
 			type: "options",
 			query: this.ast.query,