joist-core 2.3.0 → 2.4.0-next.2

package/build/newTestInstance.d.ts

@@ -1,208 +0,0 @@
-import { Entity } from "./Entity";
-import { EntityConstructor, EntityManager, IdOf, MaybeAbstractEntityConstructor } from "./EntityManager";
-import { DeepNew, FactoryExtrasOf } from "./index";
-import { ActualFactoryOpts, OptsOf } from "./typeMap";
-/**
- * A proxy that allows accessing factory-created entities by their factory id.
- *
- * For example, after creating entities with `as` keys:
- *
- * ```ts
- * newAuthor(em, { books: [{ is: "b#1" }, { is: "b#2", prequel: "b#1" }] });
- * const { b1, b2 } = factories;
- * ```
- *
- * The proxy parses property names like `b1` into `b#1` and looks up the entity
- * in the most recently used EntityManager.
- */
-export declare const factories: Record<string, any>;
-/**
- * DeepPartial-esque type specific to our `newTestInstance` factory.
- *
- * Specifically (vs using DeepPartial directly) this:
- *
- * 1. Adds a `use` tag of `Entity | Entity[]` that will be checked for existing
- * entities before creating new ones (i.e. "if `newTestInstance` needs a `Book`,
- * use the one in `use` instead of making a new one).
- *
- * 2. Works specifically against the constructor/entity opts fields.
- */
-export type FactoryOpts<T extends Entity> = DeepPartialOpts<T> & {
-    is?: string;
-    use?: Entity | Entity[];
-    useFactoryDefaults?: boolean | "none";
-    useExistingCheck?: boolean;
-    useLogging?: boolean;
-} & {
-    [K in keyof FactoryExtrasOf<T>]?: FactoryExtrasOf<T>[K];
-};
-export declare const testDate: Date;
-export declare const testPlainDate: import("temporal-spec").Temporal.PlainDate | undefined;
-export declare const testPlainDateTime: import("temporal-spec").Temporal.PlainDateTime | undefined;
-export declare const testZonedDateTime: import("temporal-spec").Temporal.ZonedDateTime | undefined;
-/**
- * Creates a test instance of `T`.
- *
- * If the factory code passes factoryOpts.useExisting, they can "intercept" the `em.create`
- * to try and resolve "already created" / singleton instances. The `useExisting` callback is
- * useful b/c the `opts` will be the "resolved-to-entity" opts, and not the raw "maybe object
- * literal, maybe object instance" opts that tests pass into the factory.
- */
-export declare function newTestInstance<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, 
-/** The test's test-specific override opts. */
-testOpts?: FactoryOpts<T>, 
-/** The factory file's default opts. */
-factoryOpts?: FactoryOpts<T> & {
-    useExisting?: (opts: OptsOf<T>, existing: DeepNew<T>) => boolean;
-}): DeepNew<T>;
-/**
- * A marker value for later replacement with the test instance's "unique-ish" index.
- *
- * This is meant to just be a helpful identifier in fields like entity names/descriptions for
- * debugging purposes.
- */
-export declare const testIndex: number;
-/**
- * A marker value for the default `newTestInstance` behavior.
- *
- * Useful for passing arguments to `newTestInstance` where you sometimes want to
- * provide a specific value, and other times ask for the "pick a default" behavior
- * (i.e. you don't want to pass `undefined` b/c that means explicitly "leave this
- * key unset").
- *
- * Note that this is a function so that we can infer the return type as basically
- * `any` without really using `any` (which would disable type-checking in the rest
- * of the expression).
- */
-export declare function defaultValue<T>(): T;
-/**
- * A marker value to never set a field, even if it's required.
- *
- * The factories treat `{ author: undefined }` as "still set the author", because of how easy
- * it is for destructuring/restructuring opts to implicitly set `undefined` values.
- *
- * If you want to force a field to not be set, you can use `{ author: noValue() }`.
- */
-export declare function noValue<T>(): T;
-/**
- * A marker value to accept values only if explicitly created-or-passed within the current,
- * unique "branch" of a factory call.
- *
- * This is useful for "diamond-shape" entity models like:
- *
- * ```
- *  ParentGroup <-- ParentItem
- *      |              |
- *   ChildGroup  <-- ChildItem
- * ```
- *
- * Where it's important that the `ChildItem -> ParentItem -> ParentGroup` path matches
- * the `ChildItem -> ChildGroup -> ParentGroup` path.
- *
- * This can be hard to achieve in normal factory behavior, i.e. for a call like:
- *
- * ```ts
- * const c = newChild(em, {
- *   groups: [
- *     { childItems: [{}, {}] },
- *     { childItems: [{}, {}] },
- *   ],
- * });
- * ```
- *
- * The first `ChildGroup` will create a new `ParentGroup` that is used by everything, which
- * is not our intent, as both `ChildGroup`s, and all four `ParentItem`s, will live in a single
- * `ParentGroup`.
- *
- * An initial idea is to pass `parentGroup: {}` in the factories, because that turns off "reusing
- * existing instances", but for this problem the `{}` approach is "too good" at creating new
- * instances, b/c the above diamond pattern will be disconnected.
- *
- * So `branchValue` provides a middle ground, where _usually_ it will be a new entity, unless
- * it was explicitly created within the same "branch" of a factory call.
- */
-export declare function maybeBranchValue<T>(opts?: ActualFactoryOpts<T>): T;
-/**
- * Allows a factory to declare that an optional relation should be filled in with an
- * "obvious default", or a new entity if one doesn't exist.
- *
- * This "obvious default or new entity" is what Joist already does for _required_ relations,
- * and so `maybeNew` lets the factory tell Joist to apply the same behavior to an optional
- * field.
- *
- * I.e.:
- *
- * ```typescript
- * export function newAuthor(em: Entity, opts: FactoryOpts<Author>) {
- *   return newTestInstance(em, Author, {
- *     // this always make a new publisher, unless explicitly overridden by the test,
- *     // i.e. when each author really needs "their own" publisher.
- *     publisher: {},
- *     // this will make a new publisher but first looks for "good defaults" in the
- *     // test, i.e. an already-created publisher. This is the default behavior of
- *     // required fields ("look for a good default"), and `maybeNew` lets you tell
- *     // Joist to invoke that same "maybe new" behavior for an optional field.
- *     publisher: maybeNew<Publisher>({}),
- *     ...opts,
- *   });
- * }
- * ```
- */
-export declare function maybeNew<T extends Entity>(opts?: ActualFactoryOpts<T>): FactoryEntityOpt<T>;
-/**
- * Similar to `maybeNew` in behaviour/use but with enhancements to support polymorphic fields:
- * 1) Allows you to specify which entity type to create, if it is found a new one is needed
- * 2) Allows you to prioritize which existing entities to select
- *
- * For example below, we are specifying that an Author should be created if needed (and optionally it's default opts
- * in the `ifNewOpts` field), and also that the priority order for choosing existing entities is Author, Book, and then Publisher.
- * Note since BookReview is excluded from `existingSearchOrder`, an existing BookReview will never be chosen.
- *
- * ```typescript
- * export function newComment(em: EntityManager, opts: FactoryOpts<Comment> = {}): New<Comment> {
- *   return newTestInstance(em, Comment, {
- *     parent: maybeNewPoly<CommentParent, Author>(
- *       Author, {
- *         ifNewOpts: { firstName: "optional"},
- *         existingSearchOrder: [Author, Book, Publisher]
- *       }),
- *     ...opts,
- *   });
- * }
- * ```
- */
-export declare function maybeNewPoly<T extends Entity, NewT extends T = T>(ifNewCstr: EntityConstructor<NewT>, opts?: {
-    ifNewOpts?: ActualFactoryOpts<NewT>;
-    existingSearchOrder?: MaybeAbstractEntityConstructor<T>[];
-}): FactoryEntityOpt<NewT>;
-/**
- * Returns a unique-ish test index for putting in `name` fields.
- *
- * Note that `testIndex` is easier to just include in a string, because it doesn't require passing
- * the `EntityManger` and `type`. But if a factory really wants the test index as a number, they can
- * call this method.
- *
- * Despite the name, these are 1-based, i.e. the first `Author` is `a1`.
- */
-export declare function getTestIndex<T extends Entity>(em: EntityManager, type: MaybeAbstractEntityConstructor<T>): number;
-type DefinedOr<T> = T | undefined | null;
-type DeepPartialOpts<T extends Entity> = AllowRelationsOrPartials<OptsOf<T>>;
-/** What a factory can accept for a given entity. */
-export type FactoryEntityOpt<T extends Entity> = T | IdOf<T> | (ActualFactoryOpts<T> & {
-    useFactoryDefaults?: boolean | "none";
-});
-type AllowRelationsOrPartials<T> = {
-    [P in keyof T]?: T[P] extends DefinedOr<infer U> ? U extends Array<infer V> ? V extends Entity ? Array<FactoryEntityOpt<V>> : T[P] : U extends Entity ? FactoryEntityOpt<U> : T[P] : T[P];
-};
-export type UseMapSource = "testOpts" | "useOpt" | "sameBranch" | "diffBranch";
-/** Enables factory logging for all factories. */
-export declare function setFactoryLogging(enabled: boolean): void;
-/** Marker for tests setting derived values during test setup. */
-export declare class FactoryInitialValue {
-    readonly value: any;
-    constructor(value: any);
-}
-export declare function isFactoryCreation(entity: Entity): boolean;
-export declare function resetFactoryCreated(): void;
-export {};
-//# sourceMappingURL=newTestInstance.d.ts.map

package/build/newTestInstance.d.ts.map

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

package/build/normalizeHints.d.ts

@@ -1,23 +0,0 @@
-import { Entity } from "./Entity";
-import { LoadHint } from "./loadHints";
-import { ReactiveHint } from "./reactiveHints";
-/** Normalizes a `key | key[] | { key: nested }` hint into `{ key: nested }`. */
-export type NormalizeHint<H> = H extends string ? Record<DropSuffix<H>, {}> : H extends ReadonlyArray<any> ? Record<DropSuffix<H[number]>, {}> : {
-    [K in keyof H as DropSuffix<K>]: H[K];
-};
-/** The separator between field names and the modified; we allow `_` for keys in hashes. */
-export type SuffixSeperator = ":" | "_";
-export type DropSuffix<K> = K extends `${infer key}${SuffixSeperator}ro` ? key : K;
-export declare const suffixRe: RegExp;
-/** Normalizes a `key | key[] | { key: nested }` hint into `{ key: nested }`. */
-export declare function normalizeHint<T extends Entity>(hint: LoadHint<T> | ReactiveHint<T>): object;
-/**
- * Returns a JSON key for batching by hint, cached to avoid repeated `JSON.stringify(hint)` calls.
- *
- * Benchmark TLDR, 5m repeated calls: strings are unchanged, array hints were ~8x faster,
- * nested object hints were ~26-38x faster.
- */
-export declare function hintKey<T extends Entity>(hint: LoadHint<T> | ReactiveHint<T> | undefined): string;
-/** Normalizes a `key | key[] | { key: nested }` hint into `{ key: nested }`. */
-export declare function deepNormalizeHint<T extends Entity>(hint: LoadHint<T> | ReactiveHint<T>): object;
-//# sourceMappingURL=normalizeHints.d.ts.map

package/build/normalizeHints.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalizeHints.d.ts","sourceRoot":"","sources":["../src/normalizeHints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,gFAAgF;AAChF,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC3C,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GACzB,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,GAC1B,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,GACjC;KAAG,CAAC,IAAI,MAAM,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEhD,2FAA2F;AAC3F,MAAM,MAAM,eAAe,GAAG,GAAG,GAAG,GAAG,CAAC;AAExC,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,MAAM,GAAG,GAAG,eAAe,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;AAEnF,eAAO,MAAM,QAAQ,QAAa,CAAC;AAMnC,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CAQ3F;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,MAAM,CAUjG;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CAQ/F"}

package/build/plugins/ImmutableEntitiesPlugin.d.ts

@@ -1,9 +0,0 @@
-import { Entity } from "../Entity";
-import { Plugin } from "../PluginManager";
-export declare class ImmutableEntitiesPlugin extends Plugin {
-    readonly entities: Set<Entity>;
-    beforeSetField(entity: Entity, field: string, newValue: any): void;
-    addEntity(entity: Entity): void;
-    removeEntity(entity: Entity): void;
-}
-//# sourceMappingURL=ImmutableEntitiesPlugin.d.ts.map

package/build/plugins/ImmutableEntitiesPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ImmutableEntitiesPlugin.d.ts","sourceRoot":"","sources":["../../src/plugins/ImmutableEntitiesPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,qBAAa,uBAAwB,SAAQ,MAAM;IACjD,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAE3C,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI;IAMlE,SAAS,CAAC,MAAM,EAAE,MAAM;IAIxB,YAAY,CAAC,MAAM,EAAE,MAAM;CAG5B"}

package/build/plugins/PreloadPlugin.d.ts

@@ -1,69 +0,0 @@
-import { Entity } from "../Entity";
-import { EntityMetadata } from "../EntityMetadata";
-import { EntityOrId, HintNode } from "../HintTree";
-import { LoadHint, NestedLoadHint } from "../loadHints";
-import { LateralJoinTable, ParsedFindQuery } from "../QueryParser";
-/**
- * This is a plugin API dedicated to preloading data for subtrees of entities.
- *
- * I.e. when evaluating `em.load(Author, "a:1", { books: "reviews" })`, loading both the
- * Author `a:1` plus all the author's books, and all the author's books' reviews, in a single
- * SQL call.
- *
- * Implementations of this API should execute the SQL queries necessary to load the data, and
- * then store the preloaded data in the `EntityManager.preloadedRelations` cache, which the
- * `OneToManyCollection`, `ManyToOneReference`, etc. relation implementations check before
- * issuing their own `.load()` SQL calls.
- */
-export interface PreloadPlugin {
-    /**
-     * Given a single load hint, partitions it into the sql-able and non-sql-able parts.
-     *
-     * The sql-able hints will later be passed to `preloadPopulate` to fetch as a single
-     * SQL call.
-     */
-    partitionHint(meta: EntityMetadata | undefined, hint: LoadHint<any>): [NestedLoadHint<any> | undefined, NestedLoadHint<any> | undefined];
-    /**
-     * Given an existing `ParsedFindQuery`, adds extra selects & joins directly
-     * to the `query` that will preload any child data requested in `tree`.
-     *
-     * The caller is still responsible for executing `query`, and then also
-     * calling the `PreloadHydrator` with the database results for the preload
-     * plugin to instantiate & populate the EM's preload cache.
-     *
-     * Note that the actual relations themselves won't be loaded, just the preload
-     * cache populated to make the relation `.preload()` / `.load()` fast.
-     */
-    addPreloading<T extends Entity>(meta: EntityMetadata, tree: HintNode<EntityOrId>, query: ParsedFindQuery): PreloadHydrator | undefined;
-    /**
-     * Given an anticipated `ParsedFindQuery`, returns lower-level `JoinResult` that
-     * are the fragments of SELECTs and JOINs that the caller can work into their custom
-     * query.
-     *
-     * This is primarily for callers who aren't going to call `driver.executeFind`, but instead
-     * are crafting their own SQL query for `driver.executeQuery` (basically this is `em.findAll`
-     * because it uses a complicated CTE + join strategy to do batching).
-     */
-    getPreloadJoins<T extends Entity>(meta: EntityMetadata, tree: HintNode<EntityOrId>, query: ParsedFindQuery): JoinResult[];
-}
-/**
- * Given a list of `rows`, and the already-hydrated `entities` for each row, reads the preload-specific
- * columns out of the `rows` result set, and pushes them into the EM preload cache, hydrating
- * the child entities in the process, but not marking any relations as loaded.
- *
- * The order of `rows` and `entities` must match.
- */
-export type PreloadHydrator = (rows: any[], entities: any[]) => void;
-/** A preload-loadable join for a given child, with potentially grand-child joins contained within it. */
-export type JoinResult = {
-    /** The select clause(s) for this join, i.e. `b._ as _b` or `c._ as _c`. */
-    selects: {
-        value: string;
-        as: string;
-    }[];
-    /** The SQL for this child's lateral join, which itself might have recursive lateral joins. */
-    join: LateralJoinTable;
-    /** The processor for this child's lateral join, which itself might recursively processor subjoins. */
-    hydrator: PreloadHydrator;
-};
-//# sourceMappingURL=PreloadPlugin.d.ts.map

package/build/plugins/PreloadPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PreloadPlugin.d.ts","sourceRoot":"","sources":["../../src/plugins/PreloadPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,aAAa,CACX,IAAI,EAAE,cAAc,GAAG,SAAS,EAChC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,GAClB,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC;IAEtE;;;;;;;;;;OAUG;IACH,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5B,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC1B,KAAK,EAAE,eAAe,GACrB,eAAe,GAAG,SAAS,CAAC;IAE/B;;;;;;;;OAQG;IACH,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9B,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC1B,KAAK,EAAE,eAAe,GACrB,UAAU,EAAE,CAAC;CACjB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAErE,yGAAyG;AACzG,MAAM,MAAM,UAAU,GAAG;IACvB,2EAA2E;IAC3E,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACzC,8FAA8F;IAC9F,IAAI,EAAE,gBAAgB,CAAC;IACvB,sGAAsG;IACtG,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC"}

package/build/plugins/PreloadPlugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PreloadPlugin.js","sourceRoot":"","sources":["../../src/plugins/PreloadPlugin.ts"],"names":[],"mappings":""}

package/build/preloading/JsonAggregatePreloader.d.ts

@@ -1,16 +0,0 @@
-import { Entity } from "../Entity";
-import { EntityMetadata } from "../EntityMetadata";
-import { HintNode } from "../HintTree";
-import { LoadHint, NestedLoadHint } from "../loadHints";
-import { JoinResult, PreloadHydrator, PreloadPlugin } from "../plugins/PreloadPlugin";
-import { ParsedFindQuery } from "../QueryParser";
-/**
- * A PreloadPlugin implementation that uses `CROSS LATERAL JOIN` and `json_aggregate`
- * to preload/reduce a subtree of data while still being a single row of data.
- */
-export declare class JsonAggregatePreloader implements PreloadPlugin {
-    partitionHint(meta: EntityMetadata | undefined, hint: LoadHint<any>): [NestedLoadHint<any> | undefined, NestedLoadHint<any> | undefined];
-    addPreloading<T extends Entity>(meta: EntityMetadata, root: HintNode<T>, query: ParsedFindQuery): PreloadHydrator | undefined;
-    getPreloadJoins<T extends Entity>(meta: EntityMetadata, root: HintNode<T>, query: ParsedFindQuery): JoinResult[];
-}
-//# sourceMappingURL=JsonAggregatePreloader.d.ts.map

package/build/preloading/JsonAggregatePreloader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JsonAggregatePreloader.d.ts","sourceRoot":"","sources":["../../src/preloading/JsonAggregatePreloader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAyD,MAAM,mBAAmB,CAAC;AAC1G,OAAO,EAAc,QAAQ,EAAE,MAAM,aAAa,CAAC;AAInD,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACtF,OAAO,EAA0C,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIzF;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,aAAa,CACX,IAAI,EAAE,cAAc,GAAG,SAAS,EAChC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,GAClB,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAIrE,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5B,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,KAAK,EAAE,eAAe,GACrB,eAAe,GAAG,SAAS;IA6B9B,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,EAAE;CAsBjH"}

package/build/preloading/canPreload.d.ts

@@ -1,3 +0,0 @@
-import { EntityMetadata, Field, ManyToManyEnumField, ManyToManyField, ManyToOneField, OneToManyField, OneToOneField } from "../EntityMetadata";
-export declare function canPreload(meta: EntityMetadata, field: Field): field is OneToManyField | ManyToOneField | ManyToManyField | ManyToManyEnumField | OneToOneField;
-//# sourceMappingURL=canPreload.d.ts.map

package/build/preloading/canPreload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canPreload.d.ts","sourceRoot":"","sources":["../../src/preloading/canPreload.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,EACL,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,cAAc,EACd,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B,wBAAgB,UAAU,CACxB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,KAAK,GACX,KAAK,IAAI,cAAc,GAAG,cAAc,GAAG,eAAe,GAAG,mBAAmB,GAAG,aAAa,CAelG"}

package/build/preloading/partitionHint.d.ts

@@ -1,5 +0,0 @@
-import { EntityMetadata } from "../EntityMetadata";
-import { LoadHint, NestedLoadHint } from "../loadHints";
-/** Partitions a hint into SQL-able and non-SQL-able hints. */
-export declare function partitionHint(meta: EntityMetadata | undefined, hint: LoadHint<any>): [NestedLoadHint<any> | undefined, NestedLoadHint<any> | undefined];
-//# sourceMappingURL=partitionHint.d.ts.map

package/build/preloading/partitionHint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"partitionHint.d.ts","sourceRoot":"","sources":["../../src/preloading/partitionHint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAKxD,8DAA8D;AAC9D,wBAAgB,aAAa,CAC3B,IAAI,EAAE,cAAc,GAAG,SAAS,EAChC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,GAClB,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,CA0CpE"}

package/build/reactiveHints.d.ts

@@ -1,146 +0,0 @@
-import { Entity } from "./Entity";
-import { MaybeAbstractEntityConstructor } from "./EntityManager";
-import { EntityMetadata } from "./EntityMetadata";
-import { Changes } from "./changes";
-import { Loadable, Loaded, LoadHint } from "./loadHints";
-import { NormalizeHint, SuffixSeperator } from "./normalizeHints";
-import { Collection, EnumCollection, LoadedCollection, LoadedEnumCollection, LoadedProperty, LoadedReadOnlyCollection, LoadedReference, OneToOneReference, PolymorphicReference, Property, ReactiveGetter, ReadOnlyCollection, Reference } from "./relations";
-import { LoadedOneToOneReference } from "./relations/OneToOneReference";
-import { FieldsOf, RelationsOf } from "./typeMap";
-/** The keys in `T` that rules & hooks can react to. */
-export type Reactable<T extends Entity> = FieldsOf<T> & Loadable<T> & Gettable<T> & SuffixedFieldsOf<T> & SuffixedLoadable<T> & SuffixedGettable<T>;
-/** Finds `hasReactiveGetters` which are not "loadable" b/c they're always loaded. */
-export type Gettable<T extends Entity> = {
-    -readonly [K in keyof T as GettableValue<T[K]> extends never ? never : K]: GettableValue<T[K]>;
-};
-type GettableValue<V> = V extends ReactiveGetter<any, infer P> ? P : never;
-/** The fields of `T` suffixed with `:ro` or `_ro`. */
-type SuffixedFieldsOf<T extends Entity> = {
-    [K in keyof FieldsOf<T> & string as `${K}${SuffixSeperator}ro`]: FieldsOf<T>[K];
-};
-type SuffixedLoadable<T extends Entity> = {
-    [K in keyof Loadable<T> & string as `${K}${SuffixSeperator}ro`]: Loadable<T>[K];
-};
-type SuffixedGettable<T extends Entity> = {
-    [K in keyof Gettable<T> & string as `${K}${SuffixSeperator}ro`]: Gettable<T>[K];
-};
-/**
- * A reactive hint of a single key, multiple keys, or nested keys and sub-hints.
- *
- * Reactive hints are different from load hints in that reactive hints include specific
- * fields to react against, while load hints contain only relations, collections, and async
- * properties to preload.
- */
-export type ReactiveHint<T extends Entity> = (keyof Reactable<T> & string) | ReadonlyArray<keyof Reactable<T> & string> | NestedReactiveHint<T>;
-export type NestedReactiveHint<T extends Entity> = {
-    [K in keyof Reactable<T>]?: Reactable<T>[K] extends infer U extends Entity ? ReactiveHint<U> : {};
-};
-/** Given an entity `T` that is being reacted with hint `H`, mark only the `H` attributes visible & populated. */
-export type Reacted<T extends Entity, H> = Entity & {
-    [K in keyof NormalizeHint<H> & keyof T]: T[K] extends OneToOneReference<any, infer U> ? LoadedOneToOneReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends PolymorphicReference<any, infer U, infer N> ? PolymorphicReference<T, U, N> & LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends Reference<any, infer U, infer N> ? LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends EnumCollection<any, infer E> ? LoadedEnumCollection<T, E> : T[K] extends Collection<any, infer U> ? LoadedCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends ReadOnlyCollection<any, infer U> ? LoadedReadOnlyCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends Property<any, infer V> ? LoadedProperty<any, V> : T[K];
-} & {
-    /**
-     * Gives reactive rules & fields a way to get the full entity if they really need it.
-     *
-     * This should be used carefully b/c it will side-step the reactive system, and instead
-     * reactive rules & fields should explicitly declare access to the fields they need, which
-     * will then allow accessing the field via the `Reacted<Author, ...>` type.
-     */
-    fullNonReactiveAccess: Loaded<T, H>;
-    /** Allow detecting if a reactive change is due to nuances like `hasUpdated` or `hasChanged`. */
-    changes: Changes<T, keyof (FieldsOf<T> & RelationsOf<T>), keyof NormalizeHint<H>>;
-} & MaybeTransientFields<T>;
-/** Allow returning reacted entities from `hasReactiveReference`. */
-export type MaybeReactedEntity<V> = V extends Entity ? {
-    fullNonReactiveAccess: V;
-} : V;
-/**
- * Allow returning reacted entities from `hasReactiveProperty`.
- *
- * The `MaybeReactedEntity` is used by `hasReactiveReference` which already has `undefined | never`
- * broken out as a separate generic; `hasReactiveProperty` does not, and so this type conditionally
- * pulls `undefined` out first, and then defers to `MaybeReactedEntity`.
- */
-export type MaybeReactedPropertyEntity<V> = V extends (infer V1 extends Entity) | undefined ? MaybeReactedEntity<V1> | undefined : MaybeReactedEntity<V>;
-/**
- * A reactive hint that only allows fields immediately on the entity, i.e. no nested hints.
- *
- * This is used by `ReactiveGetter`s to guarantee that their lambda functions will
- * always be `.get`-able and hence not need loading.
- */
-export type ShallowReactiveHint<T extends Entity> = (keyof FieldsOf<T> & string) | ReadonlyArray<keyof FieldsOf<T> & string>;
-/** If the domain model has transient fields, allow reactive behavior to see it, i.e. don't run validation rules for special operations. */
-export type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
-    transientFields: T["transientFields"];
-} : {};
-/**
- * Takes a reactive hint and returns the `ReactiveTarget`s that, should they change, need to
- * walk back to this watching reactable.
- *
- * @param rootType The original type that contained the reactive rule/field, used for helpful error messages
- * @param entityType The current entity of the step we're walking
- * @param hint The current hint we're walking
- * @param reactForOtherSide the name of our FK column, if the previous collection needs to react to our FK changing
- * @param isFirst
- */
-export declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEntityConstructor<T>, entityType: MaybeAbstractEntityConstructor<T>, hint: ReactiveHint<T>, reactForOtherSide?: string, reactForOtherSideIsReadOnly?: "field-read-only" | "hint-read-only" | false, isFirst?: boolean): ReactiveTarget[];
-/**
- * Walks `reverseHint` for every entity in `entities`.
- *
- * I.e. given `[book1, book2]` and `["author", 'publisher"]`, will return all the books' authors' publishers.
- *
- * Note that for references (and only references), we walk both through "the current value"
- * and prior values remembered in `referenceHistory`. This is fundamentally because references are the true "owner"
- * of the relation, while collections are derived.
- *
- * For example, with reversals walking through collections:
- *
- * - Given a hint `book: { author: firstName }`
- * - Which reverses to `author[firstName] -> books`
- * - When we walk through `a1.books`, we use only the current value, which might have only `[b2]` in it.
- * - We don't need to worry about "the old a1.books" value, which might have previously had `[b1]` in it,
- *   because the `b1.author` changing authors (from `a1` to `a2`) will trigger its own reactivity.
- *
- * Contrast with reversals walking through references:
- *
- * - Given a hint `author: { books: "title" }`
- * - Which reverses to `book[title] -> author`
- * - When we traverse through `b1.author`, we use both the current value and remembered values, so that both
- *   "our prior authors" and "our new author" see their latest `author.books` collection values.
- *
- * Delete cleanup runs before reverse hints are walked, so the current relation value may already be unset by the
- * time we get here. For persisted entities, `cleanupOnEntityDeleted` clears the owning FK via `setField`, which
- * remembers the prior FK in `referenceHistory`; this lets us still find the old owner. For collection reversals
- * this is enough because collections are derived from the owning FK: removing `b1` from `a1.books` is represented
- * by `b1.author` changing, not by an independent "old books" snapshot.
- *
- * References can also have transient values during a unit of work, i.e. a ReactiveField might observe `b1.author=a2`
- * before the final flush changes it to `a3`. `setField` remembers both original and transient reference values
- * separately from `originalData`, and we walk them in addition to the current value.
- */
-export declare function followReverseHint(reactionName: string, entities: Entity[], reverseHint: string[]): Promise<Entity[]>;
-/** Converts a normalized reactive `hint` into a load hint. */
-export declare function convertToLoadHint<T extends Entity>(meta: EntityMetadata, hint: ReactiveHint<T>, allowCustomKeys?: boolean): LoadHint<T>;
-/** An entity that, when `fields` change, should trigger the reactive rule/field pointed to by `path`. */
-export interface ReactiveTarget {
-    kind: "read-only" | "update";
-    /** The entity that contains a field our reactive rule/field accesses. */
-    entity: MaybeAbstractEntityConstructor<any>;
-    /** The field(s) that our reactive rule/field accesses, plus any implicit fields like FKs. */
-    fields: string[];
-    /** The path from this `entity` back to the source reactive rule/field. */
-    path: string[];
-}
-/** Returns true if `entity` is exactly `typeName` or a subtype of `typeName`.
- *
- * Used to honor poly/type filters like `@Publisher` during reverse-hint walks:
- * a `SmallPublisher` entity should pass an `@Publisher` filter because it is
- * a Publisher via inheritance.
- */
-export declare function isTypeOrSubType(entity: Entity, typeName: string): boolean;
-export declare function isPolyHint(key: string): boolean;
-export declare function splitPolyHintToKeyAndType(key: string): [string, string];
-/** If this hint is a poly like `author@Book`, return the type, otherwise return undefined. */
-export declare function getRelationFromMaybePolyKey(entity: Entity, key: string): any;
-export {};
-//# sourceMappingURL=reactiveHints.d.ts.map

package/build/reactiveHints.d.ts.map

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