joist-core 2.3.0 → 2.4.0

package/build/rules.d.ts

@@ -1,123 +0,0 @@
-import { Changes } from "./changes";
-import { Entity } from "./Entity";
-import { ReactiveHint } from "./reactiveHints";
-import { FieldsOf } from "./typeMap";
-import { MaybePromise } from "./utils";
-export declare enum ValidationCode {
-    required = "required",
-    cannotBeUpdated = "not-updatable",
-    cannotBeChanged = "not-changeable",
-    numeric = "not-numeric",
-    minValue = "under-min",
-    maxValue = "over-max"
-}
-/**
- * The return type of `ValidationRule` lambdas.
- *
- * We're flexible and allow rules to return a variety of shapes, like just a string, string[], etc.
- *
- * Returning `undefined` means the rule passed.
- */
-export type ValidationRuleResult = string | string[] | GenericError | GenericError[] | undefined | void;
-/** An entity validation rule. */
-export type ValidationRule<T extends Entity> = (entity: T) => MaybePromise<ValidationRuleResult>;
-/** Internal metadata for an async/reactive validation rule. */
-export type ValidationRuleInternal<T extends Entity> = {
-    name: string;
-    hint: ReactiveHint<T> | undefined;
-    fn: ValidationRule<T>;
-};
-/** A generic error which contains a message, and optional field/codes. */
-export type GenericError = {
-    message: string;
-    field?: string;
-    code?: string;
-};
-/** Combines the GenericError with the `entity` that caused it. */
-export type ValidationError = {
-    entity: Entity;
-} & GenericError;
-export type ValidationRuleOptsFn<T extends Entity> = (entity: T) => MaybePromise<boolean>;
-export type ValidationRuleOpts<T extends Entity> = {
-    unless?: ValidationRuleOptsFn<T>;
-    if?: ValidationRuleOptsFn<T>;
-};
-export declare class ValidationErrors extends Error {
-    errors: Array<GenericError | ValidationError>;
-    readonly toJSON: () => string;
-    constructor(errors: ValidationError[]);
-    constructor(message: string);
-}
-/**
- * Creates a validation rule for required fields.
- *
- * This is added automatically by codegen to entities based on FK not-nulls.
- */
-export declare function newRequiredRule<T extends Entity>(key: keyof FieldsOf<T> & string, opts?: ValidationRuleOpts<T>): ValidationRule<T>;
-/**
- * Creates a validation rule that a field cannot be updated; it can only be set on creation.
- *
- * If the optional `unless` function returns true, then the update is allowed.
- */
-export declare function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(field: K, opts?: ValidationRuleOpts<T>): CannotBeUpdatedRule<T>;
-export declare function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(field: K, unless?: ValidationRuleOptsFn<T>): CannotBeUpdatedRule<T>;
-/**
- * Creates a validation rule that a field cannot be changed once set.
- *
- * If the optional `unless` function returns true, then the update is allowed.
- */
-export declare function cannotBeChanged<T extends Entity, K extends keyof Changes<T> & string>(field: K, opts?: ValidationRuleOpts<T>): ValidationRule<T>;
-type CannotBeUpdatedRule<T extends Entity> = ValidationRule<T> & {
-    field: string;
-    immutable: boolean;
-};
-export declare function isCannotBeUpdatedRule(rule: Function): rule is CannotBeUpdatedRule<any>;
-/** For STI, enforces subtype-specific relations/FKs at runtime. */
-export declare function mustBeSubType<T extends Entity, K extends keyof Changes<T> & string>(relationName: K, opts?: ValidationRuleOpts<T>): ValidationRule<T>;
-/**
- * Creates a validation rule that a field value cannot be smaller than a
- * certain value.
- *
- * @param field The field to validate
- * @param minValue The inclusive minimum value. e.g 0 range is [0, Infinity]
- * @param opts Optional validation rule options that control when the rule should run:
- *   - unless: Function that returns true to skip validation
- *   - if: Function that returns true to run validation
- *
- * @example
- * // Age cannot be smaller than 0
- * config.addRule(minValueRule("age", 0));
- */
-export declare function minValueRule<T extends Entity, K extends keyof T & string>(field: K, minValue: number, opts?: ValidationRuleOpts<T>): ValidationRule<T>;
-/**
- * Creates a validation rule that a field value cannot be greater than a
- * certain value.
- *
- * @param field The field to validate
- * @param maxValue The include maximum value. e.g 10 range is [-Infinity, 10]
- * @param opts Optional validation rule options that control when the rule should run:
- *   - unless: Function that returns true to skip validation
- *   - if: Function that returns true to run validation
- *
- * @example
- * // Age cannot be greater than 150
- * config.addRule(maxValueRule("age", 150));
- */
-export declare function maxValueRule<T extends Entity, K extends keyof T & string>(field: K, maxValue: number, opts?: ValidationRuleOpts<T>): ValidationRule<T>;
-/**
- * Creates a validation rule that a field value must be within a range of
- * certain values
- *
- * @param field The field to validate
- * @param minValue The inclusive minimum value. e.g  0 [0,   Infinity]
- * @param maxValue The include maximum value.   e.g 10 [-Infinity, 10]
- * @param opts Optional validation rule options that control when the rule should run:
- *   - unless: Function that returns true to skip validation
- *   - if: Function that returns true to run validation * @example
- *
- * // Age must be between 0 and 150
- * config.addRule(rangeValueRule("age", 0, 150));
- */
-export declare function rangeValueRule<T extends Entity, K extends keyof T & string>(field: K, minValue: number, maxValue: number, opts?: ValidationRuleOpts<T>): ValidationRule<T>;
-export {};
-//# sourceMappingURL=rules.d.ts.map

package/build/rules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../src/rules.ts"],"names":[],"mappings":"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"}

package/build/runtimeConfig.d.ts

@@ -1,17 +0,0 @@
-export declare function getRuntimeConfig(): RuntimeConfig;
-/**
- * Holds any `joist-config.json` values that we want to access at runtime.
- */
-export type RuntimeConfig = {
-    temporal: false | {
-        /** The application's default time zone, i.e. when we say "now", and store it as yyyy-MM-dd, what time zone should we use? */
-        timeZone: string;
-    };
-};
-/**
- * Called by the code-generated `metadata.ts` to pass along `joist-config.json` values.
- *
- * This avoids having to load/parse/ship the `joist-config.json` file at runtime.
- */
-export declare function setRuntimeConfig(config: RuntimeConfig): void;
-//# sourceMappingURL=runtimeConfig.d.ts.map

package/build/runtimeConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtimeConfig.d.ts","sourceRoot":"","sources":["../src/runtimeConfig.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EACJ,KAAK,GACL;QACE,6HAA6H;QAC7H,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACP,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,QAErD"}

package/build/scopes.d.ts

@@ -1,185 +0,0 @@
-import { type Alias } from "./Aliases";
-import type { Entity } from "./Entity";
-import type { ExpressionCondition, ExpressionFilter, FilterAndSettings, FilterWithAlias, FindFilter } from "./EntityFilter";
-import type { GraphQLFilterWithAlias } from "./EntityGraphQLFilter";
-import type { EntityManager, FindFilterOptions } from "./EntityManager";
-import type { Loaded, LoadHint } from "./loadHints";
-import type { OrderOf } from "./typeMap";
-/**
- * A scope fragment that introduces its own join aliases: a join tree plus conditions
- * that reference the aliases it binds.
- *
- * Lets a scope express predicates a plain nested filter can't, e.g. a top-level `OR`
- * spanning two different joined tables. Both halves are required — the `where` tree binds
- * the aliases (via `as:`) that `conditions` reference, so neither is meaningful alone.
- */
-export interface ScopeJoinFilter<T extends Entity> {
-    where: FilterWithAlias<T>;
-    conditions: ExpressionFilter;
-}
-/** A predicate expressed against a bound alias, i.e. `(a) => a.age.gte(18)`. */
-export type AliasFn<T extends Entity> = (a: Alias<T>) => ExpressionCondition | ExpressionCondition[] | ScopeJoinFilter<T>;
-/**
- * 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.
- */
-export declare function isScopeJoinFilter<T extends Entity>(result: ExpressionCondition | ExpressionCondition[] | ScopeJoinFilter<T>): result is ScopeJoinFilter<T>;
-/**
- * The fluent builder to either a) terminate/invoke or b) chain scope methods.
- *
- * I.e. `Author.adult` is a ScopeQuery that can either do `.find` or `.popular`.
- *
- * This `ScopeQuery` is just the terminal/invocation methods, the `.popular` methods
- * are chained on via the `Scope` mapped type below.
- */
-export interface ScopeQuery<T extends Entity> {
-    /**
-     * ANDs an ad-hoc filter onto the scope, i.e. `Author.adult.where({ firstName: "a1" })`.
-     *
-     * Accepts either a plain find filter (`{ field: value }`) or an alias callback
-     * (`(a) => a.field.eq(value)`) and appends it to the recorded ops — multiple
-     * `.where(...)` calls on the same field AND together rather than override.
-     */
-    where(where: FilterWithAlias<T>): this;
-    where(fn: AliasFn<T>): this;
-    /**
-     * Appends an `orderBy` to the scope, i.e. `Author.adult.orderBy({ age: "DESC" })`.
-     *
-     * Chained `.orderBy(...)` calls **accumulate** (the resulting query has every recorded
-     * orderBy in declaration order), unlike `.limit`/`.offset`/`.softDeletes` which are
-     * last-wins. To replace an existing scope's ordering, pass `orderBy` to the terminal
-     * `.find(em, { orderBy: ... })` instead — terminal options override the scope's.
-     */
-    orderBy(orderBy: OrderOf<T> | OrderOf<T>[]): this;
-    /**
-     * Sets the row limit on the scope, i.e. `Author.adult.limit(10)`.
-     *
-     * Chained `.limit(...)` calls are last-wins — only the most recent value survives compile.
-     */
-    limit(limit: number): this;
-    /**
-     * Sets the row offset on the scope, i.e. `Author.adult.offset(10)`.
-     *
-     * Chained `.offset(...)` calls are last-wins — only the most recent value survives compile.
-     */
-    offset(offset: number): this;
-    /**
-     * Overrides Joist's default soft-delete handling for this query, i.e.
-     * `Author.adult.softDeletes("include")` to see soft-deleted rows.
-     *
-     * Chained `.softDeletes(...)` calls are last-wins. The effective value also gates
-     * how `.where({ relation: ... })` filters that touch soft-delete-aware entities are
-     * composed at compile time.
-     */
-    softDeletes(softDeletes: "include" | "exclude"): this;
-    /**
-     * Runs the scope against `em`, returning all matching rows.
-     *
-     * Terminal options (`orderBy`, `limit`, `offset`, `softDeletes`) passed here
-     * **override** anything the scope recorded via `.orderBy(...)`, `.limit(...)`, etc.;
-     * `conditions` passed here are ANDed with the scope's compiled conditions rather than
-     * replacing them. To extend the scope's ordering instead of replacing it, chain
-     * `.orderBy(...)` before `.find(em)`.
-     */
-    find(em: EntityManager): Promise<T[]>;
-    find<const H extends LoadHint<T>>(em: EntityManager, opts?: FindFilterOptions<T> & {
-        populate?: H;
-    }): Promise<Loaded<T, H>[]>;
-    /** Like {@link find} but returns a single match or `undefined`. Same options precedence as `find`. */
-    findOne(em: EntityManager): Promise<T | undefined>;
-    findOne<const H extends LoadHint<T>>(em: EntityManager, opts?: FindFilterOptions<T> & {
-        populate?: H;
-    }): Promise<Loaded<T, H> | undefined>;
-    /** Like {@link findOne} but throws if no row matches. Same options precedence as `find`. */
-    findOneOrFail(em: EntityManager): Promise<T>;
-    findOneOrFail<const H extends LoadHint<T>>(em: EntityManager, opts?: FindFilterOptions<T> & {
-        populate?: H;
-    }): Promise<Loaded<T, H>>;
-    /**
-     * Returns the count of rows matching the scope.
-     *
-     * Recorded `orderBy`/`limit`/`offset` ops are dropped (they're meaningless for a count);
-     * `softDeletes` and conditions still apply.
-     */
-    findCount(em: EntityManager): Promise<number>;
-    /**
-     * Returns the tagged ids of rows matching the scope.
-     *
-     * Like {@link findCount}, recorded `orderBy`/`limit`/`offset` ops are dropped.
-     */
-    findIds(em: EntityManager): Promise<string[]>;
-    /**
-     * Compiles the scope into Joist's `FilterAndSettings` shape for passing to other APIs
-     * or for inspection in tests.
-     *
-     * Useful primarily for debugging — the returned shape captures whatever the terminal
-     * `find` methods would have sent to `em.find`, before terminal-options precedence is
-     * applied.
-     */
-    toFindArgs(): FilterAndSettings<T>;
-}
-/** A scope for entity `T`, with chainable named accessors supplied by `S`. */
-export type Scope<T extends Entity, S = {}> = ScopeQuery<T> & S;
-/**
- * A per-entity, pre-typed function for declaring scopes.
- *
- * I.e. this is the type of the `import { authorScope as scope }` that entity files
- * use to declare their scopes.
- *
- * Because of the `authorScope as scope` rename, we can bake into the API that this
- * is the Author entity, and so simplify its usage.
- */
-export interface ScopeFn<T extends Entity, R extends Scope<T>> {
-    /** Defines a scope based on a filter condition, i.e. `scope({ name: "John" })` or `scope(a => a.name.eq("John")`. */
-    (arg: FilterWithAlias<T> | AliasFn<T>): R;
-    /** Defines a parametrized filter, i.e. `scope(name => ({ name: { startsWith: name } }))`. */
-    fn<A extends unknown[]>(fn: (...args: A) => FilterWithAlias<T> | AliasFn<T>): (...args: A) => R;
-}
-/** A scope fragment that can be expanded against any current query alias. */
-export type ScopeFilterFragment<T extends Entity> = {
-    kind: "alias";
-    fn: AliasFn<T>;
-} | {
-    kind: "filter";
-    filter: FilterWithAlias<T>;
-};
-/**
- * Fully-expanded scope contents, with named refs resolved and settings collapsed.
- *
- * Deliberately *not* a `ParsedFindQuery`, even though they look adjacent: this is the pre-parse,
- * alias-free *input* we feed into `parseFindQuery`, not its alias-committed AST output. Two reasons
- * the distinction matters:
- * - `fragments` are un-parsed DSL — filter objects plus un-invoked `AliasFn` closures — so the same
- *   scope can be re-rooted onto the query's primary alias (`Author.adult.find(em)`) or onto a joined
- *   relation alias (`em.find(Book, { author: Author.adult })`). A `ParsedFindQuery` has already baked
- *   in concrete aliases like `a`/`b1` and could only be reused via alias-rewrite surgery.
- * - keeping `fragments` as a *list* (rather than one merged condition tree) preserves independent-EXISTS
- *   semantics: `.where({ books: ... }).where({ books: ... })` must stay two predicates — one EXISTS each —
- *   which a collapsed `ParsedFindQuery.condition` can no longer be split back into.
- */
-export interface ResolvedScope<T extends Entity> {
-    fragments: ScopeFilterFragment<T>[];
-    orderBys: OrderOf<T>[];
-    limit: number | undefined;
-    offset: number | undefined;
-    softDeletes: "include" | "exclude" | undefined;
-}
-/** Creates a per-entity, pre-typed scope function. */
-export declare function newScopeFn<T extends Entity, R extends Scope<T>>(entityType: string): ScopeFn<T, R>;
-/** Returns true if `value` is one of our scope proxies. */
-export declare function isScope<T extends Entity>(value: unknown): value is Scope<T>;
-/** Resolves a scope proxy into ordered filter fragments plus collapsed settings. */
-export declare function resolveScope<T extends Entity>(scope: Scope<T>): ResolvedScope<T>;
-/**
- * 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.
- */
-export declare function isSelectAllFilter<T extends Entity>(where: FindFilter<T> | GraphQLFilterWithAlias<T>, conditions: ExpressionFilter | undefined): boolean;
-//# sourceMappingURL=scopes.d.ts.map

package/build/scopes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"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"}

package/build/scopes.js

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isScopeJoinFilter = isScopeJoinFilter;
-exports.newScopeFn = newScopeFn;
-exports.isScope = isScope;
-exports.resolveScope = resolveScope;
-exports.isSelectAllFilter = isSelectAllFilter;
-const configure_1 = require("./configure");
-/**
- * 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);
-}
-// Use a symbol so stored scope fragments cannot collide with user-defined scope names.
-const kOps = Symbol("scopeOps");
-const kResolver = Symbol("scopeResolver");
-const kWithScopeOp = Symbol("scopeWithOp");
-// Symbol-keyed so it can't collide with a user's named scope (e.g. `Author.resolve`), which the
-// proxy would otherwise treat as a chained ref.
-const kResolve = Symbol("scopeResolve");
-/** Creates a per-entity, pre-typed scope function. */
-function newScopeFn(entityType) {
-    // We won't immediately have access to the EntityMetadata during static field assignment, so provide a lazy handle
-    const resolver = {
-        entityType,
-        maybeGet: () => (0, configure_1.maybeGetMetadataForType)(entityType)?.cstr,
-    };
-    // Create the scopeFn
-    function scopeFn(arg) {
-        return newScope(resolver, [toOp(arg)]);
-    }
-    // But then also add the `.fn(...)` for parameterized scopes
-    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) {
-    // A scope is a callable Proxy (so parameterized refs like `Author.adult.named("a")` work), so it's
-    // always `typeof === "function"`; that guard also keeps the `in` checks from throwing on primitives.
-    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 !== undefined)
-        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;
-            }
-            // `await scope` probes `.then`; returning undefined lets await resolve to the scope itself
-            // instead of treating the proxy as a thenable.
-            if (prop === "then")
-                return undefined;
-            return newScope(resolver, [...ops, { kind: "ref", name: prop }]);
-        },
-        apply(_target, _thisArg, args) {
-            // Invoked for chained parameterized refs, i.e. the `("a")` in `Author.adult.named("a")`.
-            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`.
- */
-class ScopeTerminals {
-    #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 {
-        // A scope is a valid `FindFilter` `where`, so `em.find` re-parses & expands its fragments.
-        where: newScope(resolver, resolved.fragments),
-        orderBy: resolved.orderBys.length ? resolved.orderBys : undefined,
-        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 = 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, new Set());
-    return { fragments, orderBys, limit, offset, softDeletes };
-}
-/** Resolves a recorded named-scope ref to its underlying ops. */
-function scopeOpsForRef(resolver, op) {
-    const cstr = resolveCstr(resolver);
-    const sibling = cstr[op.name];
-    if (op.args) {
-        // Scope proxies are also `typeof === "function"`, so explicitly reject them via `isScope`.
-        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 === undefined)
-        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 === undefined) {
-            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 === undefined)
-        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 };
-}
-//# sourceMappingURL=scopes.js.map