@dxos/echo-query 0.10.0 → 0.11.1

package/dist/query-lite/index.js

@@ -1,4 +1,14 @@
-//#region ../../../common/invariant/dist/lib/browser/index.mjs
+//#region ../../../common/invariant/dist/lib/index.mjs
+/**
+* Use this to assert the arguments of a function.
+*
+* @example
+* ```ts
+* function foo(arg: string) {
+*   assertArgument(typeof arg === 'string', 'arg must be a string');
+* }
+* ```
+*/
 var assertArgument = (condition, argumentName, message) => {
 	if (!condition) {
 		const error = /* @__PURE__ */ new TypeError(`Invalid argument \`${argumentName}\`` + (message ? `: ${message}` : ""));
@@ -9,19 +19,27 @@ var assertArgument = (condition, argumentName, message) => {
 
 //#endregion
 //#region src/query-lite/query-lite.ts
+const OrderTypeId = "~@dxos/echo/Order";
+const FilterTypeId = "~@dxos/echo/Filter";
+const QueryTypeId = "~@dxos/echo/Query";
+const ProjectionTypeId = "~@dxos/echo/Query.Projection";
 var OrderClass = class OrderClass {
 	static "variance" = {};
-	static "is"(value) {
-		return typeof value === "object" && value !== null && "~Order" in value;
+	static is(value) {
+		return typeof value === "object" && value !== null && OrderTypeId in value;
 	}
-	"constructor"(ast) {
+	constructor(ast) {
 		this.ast = ast;
 	}
-	"~Order" = OrderClass.variance;
+	[OrderTypeId] = OrderClass.variance;
 };
 let Order1;
 (function(_Order) {
-	_Order.natural = new OrderClass({ kind: "natural" });
+	_Order.OrderTypeId = "~@dxos/echo/Order";
+	_Order.natural = (direction = "asc") => new OrderClass({
+		kind: "natural",
+		direction
+	});
 	_Order.property = (property, direction) => new OrderClass({
 		kind: "property",
 		property,
@@ -61,6 +79,7 @@ const _filterMatchValueLocal = (filter, value) => {
 			}
 			return true;
 		case "in": return filter.values.includes(value);
+		case "in-query": throw new Error("in-query filters are not supported in the sandboxed toPredicate matcher.");
 		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));
@@ -88,21 +107,22 @@ const _filterMatchEntityLocal = (filter, entity) => {
 	}
 };
 var FilterClass = class FilterClass {
+	static "FilterTypeId" = FilterTypeId;
 	static "variance" = {};
-	static "is"(value) {
-		return typeof value === "object" && value !== null && "~Filter" in value;
+	static is(value) {
+		return typeof value === "object" && value !== null && FilterTypeId 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: {
@@ -112,14 +132,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",
@@ -128,7 +148,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",
@@ -136,27 +156,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,
@@ -165,21 +185,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({
@@ -189,7 +209,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",
@@ -197,67 +217,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) => {
@@ -267,7 +287,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({
@@ -285,26 +305,26 @@ 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)
+			filters: filters.map((filter) => filter.ast)
 		});
 	}
-	static "or"(...filters) {
+	static or(...filters) {
 		return new FilterClass({
 			type: "or",
-			filters: filters.map((f) => f.ast)
+			filters: filters.map((filter) => filter.ast)
 		});
 	}
 	/** Returns a human-readable string representation of a Filter AST. */
-	static "pretty"(filter) {
+	static pretty(filter) {
 		return prettyFilter(filter.ast);
 	}
 	/** Create a predicate from a filter. */
@@ -312,10 +332,10 @@ var FilterClass = class FilterClass {
 		if (filter === void 0) return (entity) => _filterMatchEntityLocal(entityOrFilter.ast, entity);
 		return _filterMatchEntityLocal(filter.ast, entityOrFilter);
 	});
-	"constructor"(ast) {
+	constructor(ast) {
 		this.ast = ast;
 	}
-	"~Filter" = FilterClass.variance;
+	[FilterTypeId] = FilterClass.variance;
 };
 const Filter1 = FilterClass;
 const propsFilterToAst = (predicates) => {
@@ -340,20 +360,22 @@ const processPredicate = (predicate) => {
 	return FilterClass.eq(predicate).ast;
 };
 var QueryClass = class QueryClass {
+	static "QueryTypeId" = QueryTypeId;
 	static "variance" = {};
-	static "is"(value) {
-		return typeof value === "object" && value !== null && "~Query" in value;
+	static "projectionVariance" = {};
+	static is(value) {
+		return typeof value === "object" && value !== null && QueryTypeId 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,
@@ -365,34 +387,48 @@ var QueryClass = class QueryClass {
 			filter: FilterClass.props(filter).ast
 		});
 	}
-	static "type"(schema, predicates) {
+	project(property) {
+		return {
+			[ProjectionTypeId]: QueryClass.projectionVariance,
+			query: this.ast,
+			property
+		};
+	}
+	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 project(query, property) {
+		return {
+			[ProjectionTypeId]: QueryClass.projectionVariance,
+			query: query.ast,
+			property
+		};
+	}
+	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,
@@ -421,21 +457,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) {
+	[QueryTypeId] = QueryClass.variance;
+	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({
@@ -445,7 +481,7 @@ var QueryClass = class QueryClass {
 			typename
 		});
 	}
-	"sourceOf"(relation, predicates) {
+	sourceOf(relation, predicates) {
 		return new QueryClass({
 			type: "relation",
 			anchor: this.ast,
@@ -453,7 +489,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,
@@ -461,56 +497,73 @@ 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)
+			order: order.map((orderItem) => orderItem.ast)
 		});
 	}
-	"limit"(limit) {
+	limit(limit) {
 		return new QueryClass({
 			type: "limit",
 			query: this.ast,
 			limit
 		});
 	}
-	"options"(options) {
+	skip(skip) {
+		return new QueryClass({
+			type: "skip",
+			query: this.ast,
+			skip
+		});
+	}
+	aggregate(aggregates) {
+		return new QueryClass({
+			type: "aggregate",
+			query: this.ast,
+			aggregates: Object.entries(aggregates).map(([name, aggregate]) => ({
+				name,
+				...aggregate.spec
+			}))
+		});
+	}
+	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,
@@ -567,6 +620,7 @@ const prettyFilter = (filter) => {
 		}
 		case "compare": return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
 		case "in": return `Filter.in(${filter.values.map((v) => JSON.stringify(v)).join(", ")})`;
+		case "in-query": return `Filter.in(${prettyQuery(filter.subquery)}.project(${JSON.stringify(filter.property)}))`;
 		case "contains": return `Filter.contains(${JSON.stringify(filter.value)})`;
 		case "range": return `Filter.between(${JSON.stringify(filter.from)}, ${JSON.stringify(filter.to)})`;
 		case "text-search": return `Filter.text(${JSON.stringify(filter.text)})`;
@@ -600,7 +654,7 @@ const prettyQuery = (query) => {
 		case "set-difference": return `Query.without(${prettyQuery(query.source)}, ${prettyQuery(query.exclude)})`;
 		case "order": {
 			const orders = query.order.map((o) => {
-				if (o.kind === "natural") return "Order.natural";
+				if (o.kind === "natural") return `Order.natural(${JSON.stringify(o.direction)})`;
 				if (o.kind === "rank") return `Order.rank(${JSON.stringify(o.direction)})`;
 				if (o.kind === "timestamp") return `Order.${o.field === "updatedAt" ? "updated" : "created"}(${JSON.stringify(o.direction)})`;
 				return `Order.property(${JSON.stringify(o.property)}, ${JSON.stringify(o.direction)})`;
@@ -625,6 +679,14 @@ const prettyQuery = (query) => {
 			}
 			return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
 		case "limit": return `${prettyQuery(query.query)}.limit(${query.limit})`;
+		case "skip": return `${prettyQuery(query.query)}.skip(${query.skip})`;
+		case "aggregate": {
+			const aggregates = query.aggregates.map((aggregate) => {
+				const arg = aggregate.kind === "items" ? aggregate.limit !== void 0 ? `{ limit: ${aggregate.limit} }` : "" : aggregate.kind === "count" ? "" : JSON.stringify(aggregate.property);
+				return `${JSON.stringify(aggregate.name)}: Aggregate.${aggregate.kind}(${arg})`;
+			});
+			return `${prettyQuery(query.query)}.aggregate({ ${aggregates.join(", ")} })`;
+		}
 	}
 };