joist-core 2.3.0 → 2.4.0-next.2

package/build/queries/find/scopes.js

@@ -0,0 +1,296 @@
+import { maybeGetMetadataForType } from "../../configure.js";
+//#region src/queries/find/scopes.ts
+/**
+* Discriminates an {@link AliasFn} result that is a {@link ScopeJoinFilter} from a bare
+* condition / condition array.
+*
+* A `ScopeJoinFilter` is the only `AliasFn` return that carries both `where` and `conditions`
+* keys; `ExpressionFilter` (`and`/`or`), `ColumnCondition`/`RawCondition` (`kind`), and arrays
+* have neither, so the two-key check is unambiguous.
+*/
+function isScopeJoinFilter(result) {
+	return typeof result === "object" && result !== null && !Array.isArray(result) && "where" in result && "conditions" in result;
+}
+const kOps = Symbol("scopeOps");
+const kResolver = Symbol("scopeResolver");
+const kWithScopeOp = Symbol("scopeWithOp");
+const kResolve = Symbol("scopeResolve");
+/** Creates a per-entity, pre-typed scope function. */
+function newScopeFn(entityType) {
+	const resolver = {
+		entityType,
+		maybeGet: () => maybeGetMetadataForType(entityType)?.cstr
+	};
+	function scopeFn(arg) {
+		return newScope(resolver, [toOp(arg)]);
+	}
+	scopeFn.fn = function scopeFn(fn) {
+		return (...args) => newScope(resolver, [toOp(fn(...args))]);
+	};
+	return scopeFn;
+}
+/** Returns true if `value` is one of our scope proxies. */
+function isScope(value) {
+	return typeof value === "function" && kOps in value && kResolver in value;
+}
+/** Resolves a scope proxy into ordered filter fragments plus collapsed settings. */
+function resolveScope(scope) {
+	return asScopeInternalApi(scope)[kResolve]();
+}
+/**
+* Returns true for find filters that select every row of the entity type, i.e. an empty `{}` filter
+* or a scope that resolved to no fragments.
+*
+* Used by `em.findCount` and the count dataloader to short-circuit in-memory delete adjustments, which
+* are only safe when the query has no `where`/`conditions` to evaluate created/deleted entities against.
+*/
+function isSelectAllFilter(where, conditions) {
+	if (conditions !== void 0) return false;
+	if (isScope(where)) return resolveScope(where).fragments.length === 0;
+	return Object.keys(where).length === 0;
+}
+/**
+* Creates an immutable scope proxy with `ops` as its current scope fragments.
+*
+* The proxy target is a function so the proxy is callable (for parameterized refs
+* like `Author.adult.named("a")`); unknown property accesses always record a `ref`
+* op, with validation against the entity constructor deferred until `compile` runs.
+*/
+function newScope(resolver, ops) {
+	const terminals = new ScopeTerminals(resolver, ops);
+	function callable() {}
+	Object.defineProperty(callable, kOps, { value: ops });
+	Object.defineProperty(callable, kResolver, { value: resolver });
+	return new Proxy(callable, {
+		get(target, prop) {
+			if (prop === kOps || prop === kResolver) return Reflect.get(target, prop);
+			if (typeof prop === "symbol" || prop in terminals) {
+				const value = Reflect.get(terminals, prop, terminals);
+				return typeof value === "function" ? value.bind(terminals) : value;
+			}
+			if (prop === "then") return void 0;
+			return newScope(resolver, [...ops, {
+				kind: "ref",
+				name: prop
+			}]);
+		},
+		apply(_target, _thisArg, args) {
+			const lastOp = ops[ops.length - 1];
+			if (lastOp?.kind !== "ref") throw new Error(`Scope is not parameterized`);
+			return newScope(resolver, [...ops.slice(0, -1), {
+				...lastOp,
+				args
+			}]);
+		}
+	});
+}
+/**
+* Concrete builder/terminal methods for a scope proxy.
+*
+* The outer proxy handles dynamic named-scope access like `.popular`; this class handles
+* fixed methods like `.where`, `.find`, and `.toFindArgs`.
+*/
+var ScopeTerminals = class {
+	#ops;
+	#resolver;
+	constructor(resolver, ops) {
+		this.#resolver = resolver;
+		this.#ops = ops;
+	}
+	get [kOps]() {
+		return this.#ops;
+	}
+	/** Flattens our recorded ops (resolving named refs, collapsing settings) into a {@link ResolvedScope}. */
+	[kResolve]() {
+		return resolveScopeOps(this.#resolver, this.#ops);
+	}
+	where(arg) {
+		return this[kWithScopeOp](toOp(arg));
+	}
+	orderBy(orderBy) {
+		return this[kWithScopeOp]({
+			kind: "orderBy",
+			orderBy
+		});
+	}
+	limit(limit) {
+		return this[kWithScopeOp]({
+			kind: "limit",
+			limit
+		});
+	}
+	offset(offset) {
+		return this[kWithScopeOp]({
+			kind: "offset",
+			offset
+		});
+	}
+	softDeletes(value) {
+		return this[kWithScopeOp]({
+			kind: "softDeletes",
+			value
+		});
+	}
+	toFindArgs() {
+		return compile(this.#resolver, this.#ops);
+	}
+	find(em, opts) {
+		const args = compile(this.#resolver, this.#ops);
+		return em.find(resolveCstr(this.#resolver), args.where, toFindOptions(args, opts));
+	}
+	findOne(em, opts) {
+		const args = compile(this.#resolver, this.#ops);
+		return em.findOne(resolveCstr(this.#resolver), args.where, toFindOptions(args, opts));
+	}
+	findOneOrFail(em, opts) {
+		const args = compile(this.#resolver, this.#ops);
+		return em.findOneOrFail(resolveCstr(this.#resolver), args.where, toFindOptions(args, opts));
+	}
+	findCount(em) {
+		const args = compile(this.#resolver, this.#ops);
+		return em.findCount(resolveCstr(this.#resolver), args.where, toCountOptions(args));
+	}
+	findIds(em) {
+		const args = compile(this.#resolver, this.#ops);
+		return em.findIds(resolveCstr(this.#resolver), args.where, toCountOptions(args));
+	}
+	/** Returns a new scope with one more recorded operation. */
+	[kWithScopeOp](op) {
+		return newScope(this.#resolver, [...this.#ops, op]);
+	}
+};
+/** Compiles the ordered scope ops into Joist's existing find args shape. */
+function compile(resolver, ops) {
+	const resolved = resolveScopeOps(resolver, ops);
+	return {
+		where: newScope(resolver, resolved.fragments),
+		orderBy: resolved.orderBys.length ? resolved.orderBys : void 0,
+		limit: resolved.limit,
+		offset: resolved.offset,
+		softDeletes: resolved.softDeletes
+	};
+}
+/** Resolves ordered scope ops into filter fragments and root-only settings. */
+function resolveScopeOps(resolver, ops) {
+	const fragments = [];
+	const orderBys = [];
+	const refArgKeys = /* @__PURE__ */ new WeakMap();
+	const nextRefArgKey = { value: 0 };
+	let limit;
+	let offset;
+	let softDeletes;
+	function expand(currentOps, seen) {
+		for (const op of currentOps) switch (op.kind) {
+			case "alias":
+			case "filter":
+				fragments.push(op);
+				break;
+			case "orderBy":
+				if (Array.isArray(op.orderBy)) orderBys.push(...op.orderBy);
+				else orderBys.push(op.orderBy);
+				break;
+			case "limit":
+				limit = op.limit;
+				break;
+			case "offset":
+				offset = op.offset;
+				break;
+			case "softDeletes":
+				softDeletes = op.value;
+				break;
+			case "ref": {
+				const key = scopeRefKey(op, refArgKeys, nextRefArgKey);
+				if (seen.has(key)) break;
+				seen.add(key);
+				expand(scopeOpsForRef(resolver, op), seen);
+				break;
+			}
+		}
+	}
+	expand(ops, /* @__PURE__ */ new Set());
+	return {
+		fragments,
+		orderBys,
+		limit,
+		offset,
+		softDeletes
+	};
+}
+/** Resolves a recorded named-scope ref to its underlying ops. */
+function scopeOpsForRef(resolver, op) {
+	const sibling = resolveCstr(resolver)[op.name];
+	if (op.args) {
+		if (typeof sibling !== "function" || isScope(sibling)) throw new Error(`Scope ${resolver.entityType}.${op.name} is not parameterized`);
+		return scopeOpsFromValue(resolver, op.name, sibling(...op.args));
+	}
+	return scopeOpsFromValue(resolver, op.name, sibling);
+}
+/** Extracts recorded scope ops from a resolved static field. */
+function scopeOpsFromValue(resolver, name, value) {
+	if (isScope(value)) return asScopeInternalApi(value)[kOps];
+	if (value === void 0) throw new Error(`Invalid scope ${resolver.entityType}.${name}`);
+	if (typeof value === "function") throw new Error(`Scope ${resolver.entityType}.${name} requires arguments`);
+	throw new Error(`${resolver.entityType}.${name} is not a scope`);
+}
+/** Creates a cycle key for named-scope refs without serializing arbitrary entities/functions. */
+function scopeRefKey(op, refArgKeys, nextRefArgKey) {
+	return op.args ? `${op.name}(${op.args.map((arg) => scopeRefArgKey(arg, refArgKeys, nextRefArgKey)).join(",")})` : op.name;
+}
+/** Creates a stable per-resolution key for one named-scope argument. */
+function scopeRefArgKey(arg, refArgKeys, nextRefArgKey) {
+	if (typeof arg === "object" && arg !== null || typeof arg === "function") {
+		let key = refArgKeys.get(arg);
+		if (key === void 0) {
+			key = nextRefArgKey.value;
+			nextRefArgKey.value += 1;
+			refArgKeys.set(arg, key);
+		}
+		return `${typeof arg}:${key}`;
+	}
+	return `${typeof arg}:${JSON.stringify(String(arg))}`;
+}
+/** Narrows a known scope proxy to its internal-only (symbol-keyed) API. */
+function asScopeInternalApi(scope) {
+	if (!isScope(scope)) throw new Error("Invalid scope");
+	return scope;
+}
+/** Resolves the lazy entity constructor. */
+function resolveCstr(resolver) {
+	const cstr = resolver.maybeGet();
+	if (cstr === void 0) throw new Error(`Unknown type ${resolver.entityType}`);
+	return cstr;
+}
+/** Converts a scope declaration argument into a recorded op. */
+function toOp(arg) {
+	return typeof arg === "function" ? {
+		kind: "alias",
+		fn: arg
+	} : {
+		kind: "filter",
+		filter: arg
+	};
+}
+/**
+* Pulls the option half of `FilterAndSettings` back out for `em.find`.
+*
+* The scope's recorded settings are the defaults; terminal `opts` (orderBy/limit/offset/conditions/
+* populate) override. The scope itself carries no `conditions` — it compiles to a `where` scope that
+* `em.find` expands — so the only conditions are the caller's, which flow through the `...opts` spread.
+*/
+function toFindOptions(args, opts) {
+	return {
+		orderBy: args.orderBy,
+		limit: args.limit,
+		offset: args.offset,
+		softDeletes: args.softDeletes,
+		...opts
+	};
+}
+/** Like `toFindOptions`, but drops the `orderBy`/`limit`/`offset` that `findCount`/`findIds` ignore. */
+function toCountOptions(args) {
+	return { softDeletes: args.softDeletes };
+}
+//#endregion
+export { isScope, isScopeJoinFilter, isSelectAllFilter, newScopeFn, resolveScope };
+
+//# sourceMappingURL=scopes.js.map

package/build/queries/find/scopes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.js","names":["#ops","#resolver"],"sources":["../../../src/queries/find/scopes.ts"],"sourcesContent":["import { maybeGetMetadataForType } from \"src/configure.ts\";\nimport type { Entity } from \"src/Entity.ts\";\nimport type { EntityManager, FindFilterOptions, MaybeAbstractEntityConstructor } from \"src/EntityManager.ts\";\nimport type { LoadHint, Loaded } from \"src/loading/loadHints.ts\";\nimport type { Alias } from \"src/queries/find/Aliases.ts\";\nimport type {\n  ExpressionCondition,\n  ExpressionFilter,\n  FilterAndSettings,\n  FilterWithAlias,\n  FindFilter,\n} from \"src/queries/find/EntityFilter.ts\";\nimport type { GraphQLFilterWithAlias } from \"src/queries/find/EntityGraphQLFilter.ts\";\nimport type { OrderOf } from \"src/typeMap.ts\";\n\n/**\n * A scope fragment that introduces its own join aliases: a join tree plus conditions\n * that reference the aliases it binds.\n *\n * Lets a scope express predicates a plain nested filter can't, e.g. a top-level `OR`\n * spanning two different joined tables. Both halves are required — the `where` tree binds\n * the aliases (via `as:`) that `conditions` reference, so neither is meaningful alone.\n */\nexport interface ScopeJoinFilter<T extends Entity> {\n  where: FilterWithAlias<T>;\n  conditions: ExpressionFilter;\n}\n\n/** A predicate expressed against a bound alias, i.e. `(a) => a.age.gte(18)`. */\nexport type AliasFn<T extends Entity> = (\n  a: Alias<T>,\n) => ExpressionCondition | ExpressionCondition[] | ScopeJoinFilter<T>;\n\n/**\n * Discriminates an {@link AliasFn} result that is a {@link ScopeJoinFilter} from a bare\n * condition / condition array.\n *\n * A `ScopeJoinFilter` is the only `AliasFn` return that carries both `where` and `conditions`\n * keys; `ExpressionFilter` (`and`/`or`), `ColumnCondition`/`RawCondition` (`kind`), and arrays\n * have neither, so the two-key check is unambiguous.\n */\nexport function isScopeJoinFilter<T extends Entity>(\n  result: ExpressionCondition | ExpressionCondition[] | ScopeJoinFilter<T>,\n): result is ScopeJoinFilter<T> {\n  return (\n    typeof result === \"object\" &&\n    result !== null &&\n    !Array.isArray(result) &&\n    \"where\" in result &&\n    \"conditions\" in result\n  );\n}\n\n/**\n * The fluent builder to either a) terminate/invoke or b) chain scope methods.\n *\n * I.e. `Author.adult` is a ScopeQuery that can either do `.find` or `.popular`.\n *\n * This `ScopeQuery` is just the terminal/invocation methods, the `.popular` methods\n * are chained on via the `Scope` mapped type below.\n */\nexport interface ScopeQuery<T extends Entity> {\n  /**\n   * ANDs an ad-hoc filter onto the scope, i.e. `Author.adult.where({ firstName: \"a1\" })`.\n   *\n   * Accepts either a plain find filter (`{ field: value }`) or an alias callback\n   * (`(a) => a.field.eq(value)`) and appends it to the recorded ops — multiple\n   * `.where(...)` calls on the same field AND together rather than override.\n   */\n  where(where: FilterWithAlias<T>): this;\n  where(fn: AliasFn<T>): this;\n\n  /**\n   * Appends an `orderBy` to the scope, i.e. `Author.adult.orderBy({ age: \"DESC\" })`.\n   *\n   * Chained `.orderBy(...)` calls **accumulate** (the resulting query has every recorded\n   * orderBy in declaration order), unlike `.limit`/`.offset`/`.softDeletes` which are\n   * last-wins. To replace an existing scope's ordering, pass `orderBy` to the terminal\n   * `.find(em, { orderBy: ... })` instead — terminal options override the scope's.\n   */\n  orderBy(orderBy: OrderOf<T> | OrderOf<T>[]): this;\n\n  /**\n   * Sets the row limit on the scope, i.e. `Author.adult.limit(10)`.\n   *\n   * Chained `.limit(...)` calls are last-wins — only the most recent value survives compile.\n   */\n  limit(limit: number): this;\n\n  /**\n   * Sets the row offset on the scope, i.e. `Author.adult.offset(10)`.\n   *\n   * Chained `.offset(...)` calls are last-wins — only the most recent value survives compile.\n   */\n  offset(offset: number): this;\n\n  /**\n   * Overrides Joist's default soft-delete handling for this query, i.e.\n   * `Author.adult.softDeletes(\"include\")` to see soft-deleted rows.\n   *\n   * Chained `.softDeletes(...)` calls are last-wins. The effective value also gates\n   * how `.where({ relation: ... })` filters that touch soft-delete-aware entities are\n   * composed at compile time.\n   */\n  softDeletes(softDeletes: \"include\" | \"exclude\"): this;\n\n  /**\n   * Runs the scope against `em`, returning all matching rows.\n   *\n   * Terminal options (`orderBy`, `limit`, `offset`, `softDeletes`) passed here\n   * **override** anything the scope recorded via `.orderBy(...)`, `.limit(...)`, etc.;\n   * `conditions` passed here are ANDed with the scope's compiled conditions rather than\n   * replacing them. To extend the scope's ordering instead of replacing it, chain\n   * `.orderBy(...)` before `.find(em)`.\n   */\n  find(em: EntityManager): Promise<T[]>;\n  find<const H extends LoadHint<T>>(\n    em: EntityManager,\n    opts?: FindFilterOptions<T> & { populate?: H },\n  ): Promise<Loaded<T, H>[]>;\n\n  /** Like {@link find} but returns a single match or `undefined`. Same options precedence as `find`. */\n  findOne(em: EntityManager): Promise<T | undefined>;\n  findOne<const H extends LoadHint<T>>(\n    em: EntityManager,\n    opts?: FindFilterOptions<T> & { populate?: H },\n  ): Promise<Loaded<T, H> | undefined>;\n\n  /** Like {@link findOne} but throws if no row matches. Same options precedence as `find`. */\n  findOneOrFail(em: EntityManager): Promise<T>;\n  findOneOrFail<const H extends LoadHint<T>>(\n    em: EntityManager,\n    opts?: FindFilterOptions<T> & { populate?: H },\n  ): Promise<Loaded<T, H>>;\n\n  /**\n   * Returns the count of rows matching the scope.\n   *\n   * Recorded `orderBy`/`limit`/`offset` ops are dropped (they're meaningless for a count);\n   * `softDeletes` and conditions still apply.\n   */\n  findCount(em: EntityManager): Promise<number>;\n\n  /**\n   * Returns the tagged ids of rows matching the scope.\n   *\n   * Like {@link findCount}, recorded `orderBy`/`limit`/`offset` ops are dropped.\n   */\n  findIds(em: EntityManager): Promise<string[]>;\n\n  /**\n   * Compiles the scope into Joist's `FilterAndSettings` shape for passing to other APIs\n   * or for inspection in tests.\n   *\n   * Useful primarily for debugging — the returned shape captures whatever the terminal\n   * `find` methods would have sent to `em.find`, before terminal-options precedence is\n   * applied.\n   */\n  toFindArgs(): FilterAndSettings<T>;\n}\n\n/** A scope for entity `T`, with chainable named accessors supplied by `S`. */\nexport type Scope<T extends Entity, S = {}> = ScopeQuery<T> & S;\n\n/**\n * A per-entity, pre-typed function for declaring scopes.\n *\n * I.e. this is the type of the `import { authorScope as scope }` that entity files\n * use to declare their scopes.\n *\n * Because of the `authorScope as scope` rename, we can bake into the API that this\n * is the Author entity, and so simplify its usage.\n */\nexport interface ScopeFn<T extends Entity, R extends Scope<T>> {\n  /** Defines a scope based on a filter condition, i.e. `scope({ name: \"John\" })` or `scope(a => a.name.eq(\"John\")`. */\n  (arg: FilterWithAlias<T> | AliasFn<T>): R;\n  /** Defines a parametrized filter, i.e. `scope(name => ({ name: { startsWith: name } }))`. */\n  fn<A extends unknown[]>(fn: (...args: A) => FilterWithAlias<T> | AliasFn<T>): (...args: A) => R;\n}\n\n/** A scope fragment that can be expanded against any current query alias. */\nexport type ScopeFilterFragment<T extends Entity> =\n  | { kind: \"alias\"; fn: AliasFn<T> }\n  | { kind: \"filter\"; filter: FilterWithAlias<T> };\n\n/**\n * Fully-expanded scope contents, with named refs resolved and settings collapsed.\n *\n * Deliberately *not* a `ParsedFindQuery`, even though they look adjacent: this is the pre-parse,\n * alias-free *input* we feed into `parseFindQuery`, not its alias-committed AST output. Two reasons\n * the distinction matters:\n * - `fragments` are un-parsed DSL — filter objects plus un-invoked `AliasFn` closures — so the same\n *   scope can be re-rooted onto the query's primary alias (`Author.adult.find(em)`) or onto a joined\n *   relation alias (`em.find(Book, { author: Author.adult })`). A `ParsedFindQuery` has already baked\n *   in concrete aliases like `a`/`b1` and could only be reused via alias-rewrite surgery.\n * - keeping `fragments` as a *list* (rather than one merged condition tree) preserves independent-EXISTS\n *   semantics: `.where({ books: ... }).where({ books: ... })` must stay two predicates — one EXISTS each —\n *   which a collapsed `ParsedFindQuery.condition` can no longer be split back into.\n */\nexport interface ResolvedScope<T extends Entity> {\n  fragments: ScopeFilterFragment<T>[];\n  orderBys: OrderOf<T>[];\n  limit: number | undefined;\n  offset: number | undefined;\n  softDeletes: \"include\" | \"exclude\" | undefined;\n}\n\ninterface EntityCstrResolver<T extends Entity> {\n  entityType: string;\n  /** Returns undefined while entity static fields run, before `configureMetadata` has populated the type map. */\n  maybeGet(): MaybeAbstractEntityConstructor<T> | undefined;\n}\ntype FindOptionsWithPopulate<T extends Entity> = FindFilterOptions<T> & { populate?: LoadHint<T> };\n\ntype ScopeOp<T extends Entity> =\n  | ScopeFilterFragment<T>\n  | { kind: \"orderBy\"; orderBy: OrderOf<T> | OrderOf<T>[] }\n  | { kind: \"limit\"; limit: number }\n  | { kind: \"offset\"; offset: number }\n  | { kind: \"softDeletes\"; value: \"include\" | \"exclude\" }\n  | { kind: \"ref\"; name: string; args?: unknown[] };\n\n/** A named-scope reference captured during chaining, i.e. `.popular` in `Author.adult.popular`. */\ntype ScopeRefOp<T extends Entity> = Extract<ScopeOp<T>, { kind: \"ref\" }>;\n\n// Use a symbol so stored scope fragments cannot collide with user-defined scope names.\nconst kOps = Symbol(\"scopeOps\");\nconst kResolver = Symbol(\"scopeResolver\");\nconst kWithScopeOp = Symbol(\"scopeWithOp\");\n// Symbol-keyed so it can't collide with a user's named scope (e.g. `Author.resolve`), which the\n// proxy would otherwise treat as a chained ref.\nconst kResolve = Symbol(\"scopeResolve\");\n\n/** The internal-only view of a scope proxy: its symbol-keyed members, hidden from the public `Scope<T>`. */\ntype ScopeInternalApi<T extends Entity> = Scope<T> & {\n  readonly [kOps]: ScopeOp<T>[];\n  readonly [kResolver]: EntityCstrResolver<T>;\n  [kResolve](): ResolvedScope<T>;\n};\n\n/** Creates a per-entity, pre-typed scope function. */\nexport function newScopeFn<T extends Entity, R extends Scope<T>>(entityType: string): ScopeFn<T, R> {\n  // We won't immediately have access to the EntityMetadata during static field assignment, so provide a lazy handle\n  const resolver: EntityCstrResolver<T> = {\n    entityType,\n    maybeGet: () => maybeGetMetadataForType<T>(entityType)?.cstr,\n  };\n  // Create the scopeFn\n  function scopeFn(arg: FilterWithAlias<T> | AliasFn<T>): R {\n    return newScope(resolver, [toOp(arg)]) as R;\n  }\n  // But then also add the `.fn(...)` for parameterized scopes\n  scopeFn.fn = function scopeFn<A extends unknown[]>(\n    fn: (...args: A) => FilterWithAlias<T> | AliasFn<T>,\n  ): (...args: A) => R {\n    return (...args) => newScope(resolver, [toOp(fn(...args))]) as R;\n  };\n  return scopeFn;\n}\n\n/** Returns true if `value` is one of our scope proxies. */\nexport function isScope<T extends Entity>(value: unknown): value is Scope<T> {\n  // A scope is a callable Proxy (so parameterized refs like `Author.adult.named(\"a\")` work), so it's\n  // always `typeof === \"function\"`; that guard also keeps the `in` checks from throwing on primitives.\n  return typeof value === \"function\" && kOps in value && kResolver in value;\n}\n\n/** Resolves a scope proxy into ordered filter fragments plus collapsed settings. */\nexport function resolveScope<T extends Entity>(scope: Scope<T>): ResolvedScope<T> {\n  return asScopeInternalApi(scope)[kResolve]();\n}\n\n/**\n * Returns true for find filters that select every row of the entity type, i.e. an empty `{}` filter\n * or a scope that resolved to no fragments.\n *\n * Used by `em.findCount` and the count dataloader to short-circuit in-memory delete adjustments, which\n * are only safe when the query has no `where`/`conditions` to evaluate created/deleted entities against.\n */\nexport function isSelectAllFilter<T extends Entity>(\n  where: FindFilter<T> | GraphQLFilterWithAlias<T>,\n  conditions: ExpressionFilter | undefined,\n): boolean {\n  if (conditions !== undefined) return false;\n  if (isScope<T>(where)) return resolveScope(where).fragments.length === 0;\n  return Object.keys(where).length === 0;\n}\n\n/**\n * Creates an immutable scope proxy with `ops` as its current scope fragments.\n *\n * The proxy target is a function so the proxy is callable (for parameterized refs\n * like `Author.adult.named(\"a\")`); unknown property accesses always record a `ref`\n * op, with validation against the entity constructor deferred until `compile` runs.\n */\nfunction newScope<T extends Entity>(resolver: EntityCstrResolver<T>, ops: ScopeOp<T>[]): Scope<T> {\n  const terminals = new ScopeTerminals(resolver, ops);\n  function callable() {}\n  Object.defineProperty(callable, kOps, { value: ops });\n  Object.defineProperty(callable, kResolver, { value: resolver });\n  return new Proxy(callable, {\n    get(target, prop) {\n      if (prop === kOps || prop === kResolver) return Reflect.get(target, prop);\n      if (typeof prop === \"symbol\" || prop in terminals) {\n        const value = Reflect.get(terminals, prop, terminals);\n        return typeof value === \"function\" ? value.bind(terminals) : value;\n      }\n      // `await scope` probes `.then`; returning undefined lets await resolve to the scope itself\n      // instead of treating the proxy as a thenable.\n      if (prop === \"then\") return undefined;\n      return newScope(resolver, [...ops, { kind: \"ref\", name: prop }]);\n    },\n    apply(_target, _thisArg, args: unknown[]) {\n      // Invoked for chained parameterized refs, i.e. the `(\"a\")` in `Author.adult.named(\"a\")`.\n      const lastOp = ops[ops.length - 1];\n      if (lastOp?.kind !== \"ref\") throw new Error(`Scope is not parameterized`);\n      return newScope(resolver, [...ops.slice(0, -1), { ...lastOp, args }]);\n    },\n  }) as unknown as Scope<T>;\n}\n\n/**\n * Concrete builder/terminal methods for a scope proxy.\n *\n * The outer proxy handles dynamic named-scope access like `.popular`; this class handles\n * fixed methods like `.where`, `.find`, and `.toFindArgs`.\n */\nclass ScopeTerminals<T extends Entity> {\n  readonly #ops: ScopeOp<T>[];\n  readonly #resolver: EntityCstrResolver<T>;\n\n  constructor(resolver: EntityCstrResolver<T>, ops: ScopeOp<T>[]) {\n    this.#resolver = resolver;\n    this.#ops = ops;\n  }\n\n  get [kOps](): ScopeOp<T>[] {\n    return this.#ops;\n  }\n\n  /** Flattens our recorded ops (resolving named refs, collapsing settings) into a {@link ResolvedScope}. */\n  [kResolve](): ResolvedScope<T> {\n    return resolveScopeOps(this.#resolver, this.#ops);\n  }\n\n  where(arg: FilterWithAlias<T> | AliasFn<T>): Scope<T> {\n    return this[kWithScopeOp](toOp(arg));\n  }\n\n  orderBy(orderBy: OrderOf<T> | OrderOf<T>[]): Scope<T> {\n    return this[kWithScopeOp]({ kind: \"orderBy\", orderBy });\n  }\n\n  limit(limit: number): Scope<T> {\n    return this[kWithScopeOp]({ kind: \"limit\", limit });\n  }\n\n  offset(offset: number): Scope<T> {\n    return this[kWithScopeOp]({ kind: \"offset\", offset });\n  }\n\n  softDeletes(value: \"include\" | \"exclude\"): Scope<T> {\n    return this[kWithScopeOp]({ kind: \"softDeletes\", value });\n  }\n\n  toFindArgs(): FilterAndSettings<T> {\n    return compile(this.#resolver, this.#ops);\n  }\n\n  find(em: EntityManager): Promise<T[]>;\n  find<const H extends LoadHint<T>>(\n    em: EntityManager,\n    opts?: FindOptionsWithPopulate<T> & { populate?: H },\n  ): Promise<Loaded<T, H>[]>;\n  find(em: EntityManager, opts?: FindOptionsWithPopulate<T>): Promise<T[]> {\n    const args = compile(this.#resolver, this.#ops);\n    return em.find(resolveCstr(this.#resolver), args.where, toFindOptions(args, opts));\n  }\n\n  findOne(em: EntityManager): Promise<T | undefined>;\n  findOne<const H extends LoadHint<T>>(\n    em: EntityManager,\n    opts?: FindOptionsWithPopulate<T> & { populate?: H },\n  ): Promise<Loaded<T, H> | undefined>;\n  findOne(em: EntityManager, opts?: FindOptionsWithPopulate<T>): Promise<T | undefined> {\n    const args = compile(this.#resolver, this.#ops);\n    return em.findOne(resolveCstr(this.#resolver), args.where, toFindOptions(args, opts));\n  }\n\n  findOneOrFail(em: EntityManager): Promise<T>;\n  findOneOrFail<const H extends LoadHint<T>>(\n    em: EntityManager,\n    opts?: FindOptionsWithPopulate<T> & { populate?: H },\n  ): Promise<Loaded<T, H>>;\n  findOneOrFail(em: EntityManager, opts?: FindOptionsWithPopulate<T>): Promise<T> {\n    const args = compile(this.#resolver, this.#ops);\n    return em.findOneOrFail(resolveCstr(this.#resolver), args.where, toFindOptions(args, opts));\n  }\n\n  findCount(em: EntityManager): Promise<number> {\n    const args = compile(this.#resolver, this.#ops);\n    return em.findCount(resolveCstr(this.#resolver), args.where, toCountOptions(args));\n  }\n\n  findIds(em: EntityManager): Promise<string[]> {\n    const args = compile(this.#resolver, this.#ops);\n    return em.findIds(resolveCstr(this.#resolver), args.where, toCountOptions(args));\n  }\n\n  /** Returns a new scope with one more recorded operation. */\n  [kWithScopeOp](op: ScopeOp<T>): Scope<T> {\n    return newScope(this.#resolver, [...this.#ops, op]);\n  }\n}\n\n/** Compiles the ordered scope ops into Joist's existing find args shape. */\nfunction compile<T extends Entity>(resolver: EntityCstrResolver<T>, ops: ScopeOp<T>[]): FilterAndSettings<T> {\n  const resolved = resolveScopeOps(resolver, ops);\n\n  return {\n    // A scope is a valid `FindFilter` `where`, so `em.find` re-parses & expands its fragments.\n    where: newScope(resolver, resolved.fragments),\n    orderBy: resolved.orderBys.length ? resolved.orderBys : undefined,\n    limit: resolved.limit,\n    offset: resolved.offset,\n    softDeletes: resolved.softDeletes,\n  };\n}\n\n/** Resolves ordered scope ops into filter fragments and root-only settings. */\nfunction resolveScopeOps<T extends Entity>(resolver: EntityCstrResolver<T>, ops: ScopeOp<T>[]): ResolvedScope<T> {\n  const fragments: ScopeFilterFragment<T>[] = [];\n  const orderBys: OrderOf<T>[] = [];\n  const refArgKeys = new WeakMap<object, number>();\n  const nextRefArgKey = { value: 0 };\n  let limit: number | undefined;\n  let offset: number | undefined;\n  let softDeletes: \"include\" | \"exclude\" | undefined;\n\n  function expand(currentOps: ScopeOp<T>[], seen: Set<string>): void {\n    for (const op of currentOps) {\n      switch (op.kind) {\n        case \"alias\":\n        case \"filter\":\n          fragments.push(op);\n          break;\n        case \"orderBy\":\n          if (Array.isArray(op.orderBy)) orderBys.push(...op.orderBy);\n          else orderBys.push(op.orderBy);\n          break;\n        case \"limit\":\n          limit = op.limit;\n          break;\n        case \"offset\":\n          offset = op.offset;\n          break;\n        case \"softDeletes\":\n          softDeletes = op.value;\n          break;\n        case \"ref\": {\n          const key = scopeRefKey(op, refArgKeys, nextRefArgKey);\n          if (seen.has(key)) break;\n          seen.add(key);\n          expand(scopeOpsForRef(resolver, op), seen);\n          break;\n        }\n      }\n    }\n  }\n\n  expand(ops, new Set());\n  return { fragments, orderBys, limit, offset, softDeletes };\n}\n\n/** Resolves a recorded named-scope ref to its underlying ops. */\nfunction scopeOpsForRef<T extends Entity>(resolver: EntityCstrResolver<T>, op: ScopeRefOp<T>): ScopeOp<T>[] {\n  const cstr = resolveCstr(resolver) as MaybeAbstractEntityConstructor<T> & Record<string, unknown>;\n  const sibling = cstr[op.name];\n  if (op.args) {\n    // Scope proxies are also `typeof === \"function\"`, so explicitly reject them via `isScope`.\n    if (typeof sibling !== \"function\" || isScope(sibling)) {\n      throw new Error(`Scope ${resolver.entityType}.${op.name} is not parameterized`);\n    }\n    return scopeOpsFromValue(resolver, op.name, (sibling as (...args: unknown[]) => unknown)(...op.args));\n  }\n  return scopeOpsFromValue(resolver, op.name, sibling);\n}\n\n/** Extracts recorded scope ops from a resolved static field. */\nfunction scopeOpsFromValue<T extends Entity>(\n  resolver: EntityCstrResolver<T>,\n  name: string,\n  value: unknown,\n): ScopeOp<T>[] {\n  if (isScope<T>(value)) return asScopeInternalApi(value)[kOps];\n  if (value === undefined) throw new Error(`Invalid scope ${resolver.entityType}.${name}`);\n  if (typeof value === \"function\") throw new Error(`Scope ${resolver.entityType}.${name} requires arguments`);\n  throw new Error(`${resolver.entityType}.${name} is not a scope`);\n}\n\n/** Creates a cycle key for named-scope refs without serializing arbitrary entities/functions. */\nfunction scopeRefKey<T extends Entity>(\n  op: ScopeRefOp<T>,\n  refArgKeys: WeakMap<object, number>,\n  nextRefArgKey: { value: number },\n): string {\n  return op.args\n    ? `${op.name}(${op.args.map((arg) => scopeRefArgKey(arg, refArgKeys, nextRefArgKey)).join(\",\")})`\n    : op.name;\n}\n\n/** Creates a stable per-resolution key for one named-scope argument. */\nfunction scopeRefArgKey(arg: unknown, refArgKeys: WeakMap<object, number>, nextRefArgKey: { value: number }): string {\n  if ((typeof arg === \"object\" && arg !== null) || typeof arg === \"function\") {\n    let key = refArgKeys.get(arg);\n    if (key === undefined) {\n      key = nextRefArgKey.value;\n      nextRefArgKey.value += 1;\n      refArgKeys.set(arg, key);\n    }\n    return `${typeof arg}:${key}`;\n  }\n  return `${typeof arg}:${JSON.stringify(String(arg))}`;\n}\n\n/** Narrows a known scope proxy to its internal-only (symbol-keyed) API. */\nfunction asScopeInternalApi<T extends Entity>(scope: Scope<T>): ScopeInternalApi<T> {\n  if (!isScope(scope)) throw new Error(\"Invalid scope\");\n  return scope as ScopeInternalApi<T>;\n}\n\n/** Resolves the lazy entity constructor. */\nfunction resolveCstr<T extends Entity>(resolver: EntityCstrResolver<T>): MaybeAbstractEntityConstructor<T> {\n  const cstr = resolver.maybeGet();\n  if (cstr === undefined) throw new Error(`Unknown type ${resolver.entityType}`);\n  return cstr;\n}\n\n/** Converts a scope declaration argument into a recorded op. */\nfunction toOp<T extends Entity>(arg: FilterWithAlias<T> | AliasFn<T>): ScopeOp<T> {\n  return typeof arg === \"function\"\n    ? { kind: \"alias\", fn: arg as AliasFn<T> }\n    : { kind: \"filter\", filter: arg as FilterWithAlias<T> };\n}\n\n/**\n * Pulls the option half of `FilterAndSettings` back out for `em.find`.\n *\n * The scope's recorded settings are the defaults; terminal `opts` (orderBy/limit/offset/conditions/\n * populate) override. The scope itself carries no `conditions` — it compiles to a `where` scope that\n * `em.find` expands — so the only conditions are the caller's, which flow through the `...opts` spread.\n */\nfunction toFindOptions<T extends Entity>(\n  args: FilterAndSettings<T>,\n  opts?: FindOptionsWithPopulate<T>,\n): FindOptionsWithPopulate<T> {\n  return { orderBy: args.orderBy, limit: args.limit, offset: args.offset, softDeletes: args.softDeletes, ...opts };\n}\n\n/** Like `toFindOptions`, but drops the `orderBy`/`limit`/`offset` that `findCount`/`findIds` ignore. */\nfunction toCountOptions<T extends Entity>(args: FilterAndSettings<T>): FindFilterOptions<T> {\n  return { softDeletes: args.softDeletes };\n}\n"],"mappings":"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"}

package/build/queries/parsedConditions.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("../utils.cjs");
+//#region src/queries/parsedConditions.ts
+/** Pulls out a flat list of all `ColumnCondition`s from a `ParsedExpressionFilter` tree. */
+function deepFindConditions(condition, filterPruneable) {
+	const todo = condition ? [condition] : [];
+	const result = [];
+	while (todo.length !== 0) {
+		const cc = todo.pop();
+		for (const c of cc.conditions) if (c.kind === "exp") todo.push(c);
+		else if (c.kind === "column" || c.kind === "raw") {
+			if (!filterPruneable || !c.pruneable) result.push(c);
+		} else if (c.kind === "exists") result.push(c);
+		else require_utils.assertNever(c);
+	}
+	return result;
+}
+//#endregion
+exports.deepFindConditions = deepFindConditions;
+
+//# sourceMappingURL=parsedConditions.cjs.map

package/build/queries/parsedConditions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsedConditions.cjs","names":[],"sources":["../../src/queries/parsedConditions.ts"],"sourcesContent":["import type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n/** A tree of ANDs/ORs with conditions or nested conditions. */\nexport interface ParsedExpressionFilter {\n  kind: \"exp\";\n  op: \"and\" | \"or\";\n  conditions: ParsedExpressionCondition[];\n}\n\n/** A condition or nested condition in a `ParsedExpressionFilter`. */\nexport type ParsedExpressionCondition = ParsedExpressionFilter | ColumnCondition | RawCondition | ExistsCondition;\n\nexport interface ColumnCondition {\n  kind: \"column\";\n  alias: string;\n  column: string;\n  dbType: string;\n  cond: ParsedValueFilter<any>;\n  /**\n   * A pruneable condition is one that was auto-added by something like soft-delete, and shouldn't\n   * be something that marks a join as actually used by the user's query.\n   */\n  pruneable?: boolean;\n}\n\n/** A user-provided condition like `SUM(${alias}.amount) > 1000` or `a1.last_name = b1.title`. */\nexport interface RawCondition {\n  kind: \"raw\";\n  /** The aliases, i.e. `[a, b]`, used within the condition, to ensure we don't prune them. */\n  aliases: string[];\n  /** The condition itself, i.e. `SUM(a.age) DESC`. */\n  condition: string;\n  /** The bindings within `condition`, i.e. `SUM(${alias}.amount) > ?`. */\n  bindings: readonly any[];\n  /** Used to mark system-added conditions (like `LATERAL JOIN` conditions), which can be ignored when pruning unused joins. */\n  pruneable: boolean;\n}\n\n/** An EXISTS or NOT EXISTS subquery condition. */\nexport interface ExistsCondition {\n  kind: \"exists\";\n  /** When true, renders as NOT EXISTS. */\n  negate: boolean;\n  /** The subquery: SELECT 1 FROM child WHERE correlation AND filter. */\n  subquery: ParsedFindQuery;\n  /** Outer aliases referenced by the correlation predicate, for join pruning. */\n  outerAliases: string[];\n}\n\n/** An ADT version of `ValueFilter`. */\nexport type ParsedValueFilter<V> =\n  | { kind: \"eq\"; value: V }\n  | { kind: \"in\"; value: readonly V[] }\n  | { kind: \"nin\"; value: readonly V[] }\n  | { kind: \"gt\"; value: V }\n  | { kind: \"gte\"; value: V }\n  | { kind: \"ne\"; value: V }\n  | { kind: \"is-null\" }\n  | { kind: \"not-null\" }\n  | { kind: \"lt\"; value: V }\n  | { kind: \"lte\"; value: V }\n  | { kind: \"like\"; value: V }\n  | { kind: \"nlike\"; value: V }\n  | { kind: \"ilike\"; value: V }\n  | { kind: \"nilike\"; value: V }\n  | { kind: \"regex\"; value: V }\n  | { kind: \"nregex\"; value: V }\n  | { kind: \"iregex\"; value: V }\n  | { kind: \"niregex\"; value: V }\n  | { kind: \"contains\"; value: readonly V[] }\n  | { kind: \"ncontains\"; value: readonly V[] }\n  | { kind: \"overlaps\"; value: readonly V[] }\n  | { kind: \"noverlaps\"; value: readonly V[] }\n  | { kind: \"containedBy\"; value: readonly V[] }\n  | { kind: \"between\"; value: [V, V] }\n  | { kind: \"jsonPathExists\"; value: string }\n  | { kind: \"jsonPathPredicate\"; value: string };\n\n/** Pulls out a flat list of all `ColumnCondition`s from a `ParsedExpressionFilter` tree. */\nexport function deepFindConditions(\n  condition: ParsedExpressionFilter | undefined,\n  filterPruneable: boolean,\n): (ColumnCondition | RawCondition | ExistsCondition)[] {\n  const todo = condition ? [condition] : [];\n  const result: (ColumnCondition | RawCondition | ExistsCondition)[] = [];\n  while (todo.length !== 0) {\n    const cc = todo.pop()!;\n    for (const c of cc.conditions) {\n      if (c.kind === \"exp\") {\n        todo.push(c);\n      } else if (c.kind === \"column\" || c.kind === \"raw\") {\n        if (!filterPruneable || !c.pruneable) result.push(c);\n      } else if (c.kind === \"exists\") {\n        result.push(c);\n      } else {\n        assertNever(c);\n      }\n    }\n  }\n  return result;\n}\n"],"mappings":";;;;AAgFA,SAAgB,mBACd,WACA,iBACsD;CACtD,MAAM,OAAO,YAAY,CAAC,SAAS,IAAI,CAAC;CACxC,MAAM,SAA+D,CAAC;CACtE,OAAO,KAAK,WAAW,GAAG;EACxB,MAAM,KAAK,KAAK,IAAI;EACpB,KAAK,MAAM,KAAK,GAAG,YACjB,IAAI,EAAE,SAAS,OACb,KAAK,KAAK,CAAC;OACN,IAAI,EAAE,SAAS,YAAY,EAAE,SAAS,OACvC;OAAA,CAAC,mBAAmB,CAAC,EAAE,WAAW,OAAO,KAAK,CAAC;EAAA,OAC9C,IAAI,EAAE,SAAS,UACpB,OAAO,KAAK,CAAC;OAEb,cAAA,YAAY,CAAC;CAGnB;CACA,OAAO;AACT"}

package/build/queries/parsedConditions.d.cts

@@ -0,0 +1,127 @@
+import { ParsedFindQuery } from "./find/QueryParser.cjs";
+//#region src/queries/parsedConditions.d.ts
+/** A tree of ANDs/ORs with conditions or nested conditions. */
+interface ParsedExpressionFilter {
+  kind: "exp";
+  op: "and" | "or";
+  conditions: ParsedExpressionCondition[];
+}
+/** A condition or nested condition in a `ParsedExpressionFilter`. */
+type ParsedExpressionCondition = ParsedExpressionFilter | ColumnCondition | RawCondition | ExistsCondition;
+interface ColumnCondition {
+  kind: "column";
+  alias: string;
+  column: string;
+  dbType: string;
+  cond: ParsedValueFilter<any>;
+  /**
+   * A pruneable condition is one that was auto-added by something like soft-delete, and shouldn't
+   * be something that marks a join as actually used by the user's query.
+   */
+  pruneable?: boolean;
+}
+/** A user-provided condition like `SUM(${alias}.amount) > 1000` or `a1.last_name = b1.title`. */
+interface RawCondition {
+  kind: "raw";
+  /** The aliases, i.e. `[a, b]`, used within the condition, to ensure we don't prune them. */
+  aliases: string[];
+  /** The condition itself, i.e. `SUM(a.age) DESC`. */
+  condition: string;
+  /** The bindings within `condition`, i.e. `SUM(${alias}.amount) > ?`. */
+  bindings: readonly any[];
+  /** Used to mark system-added conditions (like `LATERAL JOIN` conditions), which can be ignored when pruning unused joins. */
+  pruneable: boolean;
+}
+/** An EXISTS or NOT EXISTS subquery condition. */
+interface ExistsCondition {
+  kind: "exists";
+  /** When true, renders as NOT EXISTS. */
+  negate: boolean;
+  /** The subquery: SELECT 1 FROM child WHERE correlation AND filter. */
+  subquery: ParsedFindQuery;
+  /** Outer aliases referenced by the correlation predicate, for join pruning. */
+  outerAliases: string[];
+}
+/** An ADT version of `ValueFilter`. */
+type ParsedValueFilter<V> = {
+  kind: "eq";
+  value: V;
+} | {
+  kind: "in";
+  value: readonly V[];
+} | {
+  kind: "nin";
+  value: readonly V[];
+} | {
+  kind: "gt";
+  value: V;
+} | {
+  kind: "gte";
+  value: V;
+} | {
+  kind: "ne";
+  value: V;
+} | {
+  kind: "is-null";
+} | {
+  kind: "not-null";
+} | {
+  kind: "lt";
+  value: V;
+} | {
+  kind: "lte";
+  value: V;
+} | {
+  kind: "like";
+  value: V;
+} | {
+  kind: "nlike";
+  value: V;
+} | {
+  kind: "ilike";
+  value: V;
+} | {
+  kind: "nilike";
+  value: V;
+} | {
+  kind: "regex";
+  value: V;
+} | {
+  kind: "nregex";
+  value: V;
+} | {
+  kind: "iregex";
+  value: V;
+} | {
+  kind: "niregex";
+  value: V;
+} | {
+  kind: "contains";
+  value: readonly V[];
+} | {
+  kind: "ncontains";
+  value: readonly V[];
+} | {
+  kind: "overlaps";
+  value: readonly V[];
+} | {
+  kind: "noverlaps";
+  value: readonly V[];
+} | {
+  kind: "containedBy";
+  value: readonly V[];
+} | {
+  kind: "between";
+  value: [V, V];
+} | {
+  kind: "jsonPathExists";
+  value: string;
+} | {
+  kind: "jsonPathPredicate";
+  value: string;
+};
+/** Pulls out a flat list of all `ColumnCondition`s from a `ParsedExpressionFilter` tree. */
+declare function deepFindConditions(condition: ParsedExpressionFilter | undefined, filterPruneable: boolean): (ColumnCondition | RawCondition | ExistsCondition)[];
+//#endregion
+export { ColumnCondition, ExistsCondition, ParsedExpressionCondition, ParsedExpressionFilter, ParsedValueFilter, RawCondition, deepFindConditions };
+//# sourceMappingURL=parsedConditions.d.cts.map

package/build/queries/parsedConditions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsedConditions.d.cts","names":[],"sources":["../../src/queries/parsedConditions.ts"],"mappings":";;;UAIiB;EACf;EACA;EACA,YAAY;;;KAIF,4BAA4B,yBAAyB,kBAAkB,eAAe;UAEjF;EACf;EACA;EACA;EACA;EACA,MAAM;;;;;EAKN;;;UAIe;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf;;EAEA;;EAEA,UAAU;;EAEV;;;KAIU,kBAAkB;EACxB;EAAY,OAAO;;EACnB;EAAY,gBAAgB;;EAC5B;EAAa,gBAAgB;;EAC7B;EAAY,OAAO;;EACnB;EAAa,OAAO;;EACpB;EAAY,OAAO;;EACnB;;EACA;;EACA;EAAY,OAAO;;EACnB;EAAa,OAAO;;EACpB;EAAc,OAAO;;EACrB;EAAe,OAAO;;EACtB;EAAe,OAAO;;EACtB;EAAgB,OAAO;;EACvB;EAAe,OAAO;;EACtB;EAAgB,OAAO;;EACvB;EAAgB,OAAO;;EACvB;EAAiB,OAAO;;EACxB;EAAkB,gBAAgB;;EAClC;EAAmB,gBAAgB;;EACnC;EAAkB,gBAAgB;;EAClC;EAAmB,gBAAgB;;EACnC;EAAqB,gBAAgB;;EACrC;EAAiB,QAAQ,GAAG;;EAC5B;EAAwB;;EACxB;EAA2B;;;iBAGjB,mBACd,WAAW,oCACX,4BACE,kBAAkB,eAAe"}

package/build/queries/parsedConditions.d.mts

@@ -0,0 +1,127 @@
+import { ParsedFindQuery } from "./find/QueryParser.mjs";
+//#region src/queries/parsedConditions.d.ts
+/** A tree of ANDs/ORs with conditions or nested conditions. */
+interface ParsedExpressionFilter {
+  kind: "exp";
+  op: "and" | "or";
+  conditions: ParsedExpressionCondition[];
+}
+/** A condition or nested condition in a `ParsedExpressionFilter`. */
+type ParsedExpressionCondition = ParsedExpressionFilter | ColumnCondition | RawCondition | ExistsCondition;
+interface ColumnCondition {
+  kind: "column";
+  alias: string;
+  column: string;
+  dbType: string;
+  cond: ParsedValueFilter<any>;
+  /**
+   * A pruneable condition is one that was auto-added by something like soft-delete, and shouldn't
+   * be something that marks a join as actually used by the user's query.
+   */
+  pruneable?: boolean;
+}
+/** A user-provided condition like `SUM(${alias}.amount) > 1000` or `a1.last_name = b1.title`. */
+interface RawCondition {
+  kind: "raw";
+  /** The aliases, i.e. `[a, b]`, used within the condition, to ensure we don't prune them. */
+  aliases: string[];
+  /** The condition itself, i.e. `SUM(a.age) DESC`. */
+  condition: string;
+  /** The bindings within `condition`, i.e. `SUM(${alias}.amount) > ?`. */
+  bindings: readonly any[];
+  /** Used to mark system-added conditions (like `LATERAL JOIN` conditions), which can be ignored when pruning unused joins. */
+  pruneable: boolean;
+}
+/** An EXISTS or NOT EXISTS subquery condition. */
+interface ExistsCondition {
+  kind: "exists";
+  /** When true, renders as NOT EXISTS. */
+  negate: boolean;
+  /** The subquery: SELECT 1 FROM child WHERE correlation AND filter. */
+  subquery: ParsedFindQuery;
+  /** Outer aliases referenced by the correlation predicate, for join pruning. */
+  outerAliases: string[];
+}
+/** An ADT version of `ValueFilter`. */
+type ParsedValueFilter<V> = {
+  kind: "eq";
+  value: V;
+} | {
+  kind: "in";
+  value: readonly V[];
+} | {
+  kind: "nin";
+  value: readonly V[];
+} | {
+  kind: "gt";
+  value: V;
+} | {
+  kind: "gte";
+  value: V;
+} | {
+  kind: "ne";
+  value: V;
+} | {
+  kind: "is-null";
+} | {
+  kind: "not-null";
+} | {
+  kind: "lt";
+  value: V;
+} | {
+  kind: "lte";
+  value: V;
+} | {
+  kind: "like";
+  value: V;
+} | {
+  kind: "nlike";
+  value: V;
+} | {
+  kind: "ilike";
+  value: V;
+} | {
+  kind: "nilike";
+  value: V;
+} | {
+  kind: "regex";
+  value: V;
+} | {
+  kind: "nregex";
+  value: V;
+} | {
+  kind: "iregex";
+  value: V;
+} | {
+  kind: "niregex";
+  value: V;
+} | {
+  kind: "contains";
+  value: readonly V[];
+} | {
+  kind: "ncontains";
+  value: readonly V[];
+} | {
+  kind: "overlaps";
+  value: readonly V[];
+} | {
+  kind: "noverlaps";
+  value: readonly V[];
+} | {
+  kind: "containedBy";
+  value: readonly V[];
+} | {
+  kind: "between";
+  value: [V, V];
+} | {
+  kind: "jsonPathExists";
+  value: string;
+} | {
+  kind: "jsonPathPredicate";
+  value: string;
+};
+/** Pulls out a flat list of all `ColumnCondition`s from a `ParsedExpressionFilter` tree. */
+declare function deepFindConditions(condition: ParsedExpressionFilter | undefined, filterPruneable: boolean): (ColumnCondition | RawCondition | ExistsCondition)[];
+//#endregion
+export { ColumnCondition, ExistsCondition, ParsedExpressionCondition, ParsedExpressionFilter, ParsedValueFilter, RawCondition, deepFindConditions };
+//# sourceMappingURL=parsedConditions.d.mts.map

package/build/queries/parsedConditions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsedConditions.d.mts","names":[],"sources":["../../src/queries/parsedConditions.ts"],"mappings":";;;UAIiB;EACf;EACA;EACA,YAAY;;;KAIF,4BAA4B,yBAAyB,kBAAkB,eAAe;UAEjF;EACf;EACA;EACA;EACA;EACA,MAAM;;;;;EAKN;;;UAIe;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf;;EAEA;;EAEA,UAAU;;EAEV;;;KAIU,kBAAkB;EACxB;EAAY,OAAO;;EACnB;EAAY,gBAAgB;;EAC5B;EAAa,gBAAgB;;EAC7B;EAAY,OAAO;;EACnB;EAAa,OAAO;;EACpB;EAAY,OAAO;;EACnB;;EACA;;EACA;EAAY,OAAO;;EACnB;EAAa,OAAO;;EACpB;EAAc,OAAO;;EACrB;EAAe,OAAO;;EACtB;EAAe,OAAO;;EACtB;EAAgB,OAAO;;EACvB;EAAe,OAAO;;EACtB;EAAgB,OAAO;;EACvB;EAAgB,OAAO;;EACvB;EAAiB,OAAO;;EACxB;EAAkB,gBAAgB;;EAClC;EAAmB,gBAAgB;;EACnC;EAAkB,gBAAgB;;EAClC;EAAmB,gBAAgB;;EACnC;EAAqB,gBAAgB;;EACrC;EAAiB,QAAQ,GAAG;;EAC5B;EAAwB;;EACxB;EAA2B;;;iBAGjB,mBACd,WAAW,oCACX,4BACE,kBAAkB,eAAe"}