joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/Entity.d.cts

@@ -0,0 +1,42 @@
+import { EntityManager, TaggedId } from "./EntityManager.cjs";
+//#region src/Entity.d.ts
+declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
+/** All the types we support for entity `id` fields. */
+type IdType = number | string;
+/** A marker/base interface for all of our entity types. */
+interface Entity {
+  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */
+  id: IdType;
+  idMaybe: IdType | undefined;
+  /** The entity id that is always tagged, regardless of the idType config. */
+  idTagged: TaggedId;
+  idTaggedMaybe: TaggedId | undefined;
+  readonly em: EntityManager;
+  readonly isNewEntity: boolean;
+  readonly isDeletedEntity: boolean;
+  readonly isDirtyEntity: boolean;
+  readonly transientFields: Record<string, unknown>;
+  set(opts: unknown): void;
+  setPartial(opts: unknown): void;
+  setDeepPartial(opts: unknown): Promise<void>;
+  /**
+   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.
+   *
+   * Once an entity is persisted, we'll return `Author#1:1` to denote "the previously-new author #1
+   * is now authors row id=1 in the database".
+   *
+   * This is meant to be used for developer-facing logging and debugging, and not a user-facing
+   * name / display name.
+   */
+  toString(): string;
+  /**
+   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.
+   *
+   * This is meant to be used for developer-facing logging and debugging, and not a user-facing
+   * name / display name.
+   */
+  toTaggedString(): string;
+}
+//#endregion
+export { Entity, IdType, isEntity };
+//# sourceMappingURL=Entity.d.cts.map

package/build/Entity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.d.cts","names":[],"sources":["../src/Entity.ts"],"mappings":";;iBAGgB,SAAS,uBAAuB,eAAe;;KAKnD;;UAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}

package/build/Entity.d.mts

@@ -0,0 +1,42 @@
+import { EntityManager, TaggedId } from "./EntityManager.mjs";
+//#region src/Entity.d.ts
+declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
+/** All the types we support for entity `id` fields. */
+type IdType = number | string;
+/** A marker/base interface for all of our entity types. */
+interface Entity {
+  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */
+  id: IdType;
+  idMaybe: IdType | undefined;
+  /** The entity id that is always tagged, regardless of the idType config. */
+  idTagged: TaggedId;
+  idTaggedMaybe: TaggedId | undefined;
+  readonly em: EntityManager;
+  readonly isNewEntity: boolean;
+  readonly isDeletedEntity: boolean;
+  readonly isDirtyEntity: boolean;
+  readonly transientFields: Record<string, unknown>;
+  set(opts: unknown): void;
+  setPartial(opts: unknown): void;
+  setDeepPartial(opts: unknown): Promise<void>;
+  /**
+   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.
+   *
+   * Once an entity is persisted, we'll return `Author#1:1` to denote "the previously-new author #1
+   * is now authors row id=1 in the database".
+   *
+   * This is meant to be used for developer-facing logging and debugging, and not a user-facing
+   * name / display name.
+   */
+  toString(): string;
+  /**
+   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.
+   *
+   * This is meant to be used for developer-facing logging and debugging, and not a user-facing
+   * name / display name.
+   */
+  toTaggedString(): string;
+}
+//#endregion
+export { Entity, IdType, isEntity };
+//# sourceMappingURL=Entity.d.mts.map

package/build/Entity.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.d.mts","names":[],"sources":["../src/Entity.ts"],"mappings":";;iBAGgB,SAAS,uBAAuB,eAAe;;KAKnD;;UAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}

package/build/Entity.js

@@ -1,8 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEntity = isEntity;
-const index_1 = require("./index");
+import "./index.js";
+import "./EntityManager.js";
+import { BaseEntity } from "./BaseEntity.js";
+//#region src/Entity.ts
 function isEntity(maybeEntity) {
-    return maybeEntity instanceof index_1.BaseEntity;
+	return maybeEntity instanceof BaseEntity;
 }
+//#endregion
+export { isEntity };
+
 //# sourceMappingURL=Entity.js.map

package/build/Entity.js.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.js","sourceRoot":"","sources":["../src/Entity.ts"],"names":[],"mappings":";;AAGA,4BAEC;AAJD,mCAAqC;AAErC,SAAgB,QAAQ,CAAC,WAAoB;IAC3C,OAAO,WAAW,YAAY,kBAAU,CAAC;AAC3C,CAAC"}
+{"version":3,"file":"Entity.js","names":[],"sources":["../src/Entity.ts"],"sourcesContent":["import { type EntityManager, type TaggedId } from \"./EntityManager.ts\";\nimport { BaseEntity } from \"./index.ts\";\n\nexport function isEntity(maybeEntity: unknown): maybeEntity is Entity {\n  return maybeEntity instanceof BaseEntity;\n}\n\n/** All the types we support for entity `id` fields. */\nexport type IdType = number | string;\n\n/** A marker/base interface for all of our entity types. */\nexport interface Entity {\n  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */\n  id: IdType;\n  idMaybe: IdType | undefined;\n  /** The entity id that is always tagged, regardless of the idType config. */\n  idTagged: TaggedId;\n  idTaggedMaybe: TaggedId | undefined;\n  readonly em: EntityManager;\n  readonly isNewEntity: boolean;\n  readonly isDeletedEntity: boolean;\n  readonly isDirtyEntity: boolean;\n  readonly transientFields: Record<string, unknown>;\n  set(opts: unknown): void;\n  setPartial(opts: unknown): void;\n  setDeepPartial(opts: unknown): Promise<void>;\n  /**\n   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.\n   *\n   * Once an entity is persisted, we'll return `Author#1:1` to denote \"the previously-new author #1\n   * is now authors row id=1 in the database\".\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toString(): string;\n  /**\n   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toTaggedString(): string;\n}\n"],"mappings":";;;;AAGA,SAAgB,SAAS,aAA6C;CACpE,OAAO,uBAAuB;AAChC"}

package/build/EntityFields.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/build/EntityFields.d.cts

@@ -0,0 +1,36 @@
+//#region src/EntityFields.d.ts
+/** All the fields for an entity in the `FieldsOf` / `EntityField` format. */
+type EntityFields<T> = { [K in keyof T]: EntityField; };
+type EntityField = {
+  kind: "primitive";
+  type: unknown;
+  unique: boolean;
+  nullable: never | undefined;
+  derived: boolean;
+} | {
+  kind: "enum";
+  type: unknown;
+  nullable: never | unknown;
+} | {
+  kind: "m2o";
+  type: unknown;
+  nullable: never | unknown;
+  derived: boolean;
+} | {
+  kind: "poly";
+  type: unknown;
+  nullable: never | unknown;
+};
+/** The subset of primitive, enum, and m2o fields from the `F` that are settable, i.e. not derived. */
+type SettableFields<F> = { [K in keyof F]: F[K] extends {
+  kind: "primitive";
+  derived: false;
+} ? F[K] : F[K] extends {
+  kind: "enum";
+} ? F[K] : F[K] extends {
+  kind: "m2o";
+  derived: false;
+} ? F[K] : never; };
+//#endregion
+export { EntityField, EntityFields, SettableFields };
+//# sourceMappingURL=EntityFields.d.cts.map

package/build/EntityFields.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFields.d.cts","names":[],"sources":["../src/EntityFields.ts"],"mappings":";;KACY,aAAa,QACtB,WAAW,IAAI;KAGN;EACN;EAAmB;EAAe;EAAiB;EAA6B;;EAChF;EAAc;EAAe;;EAC7B;EAAa;EAAe;EAA2B;;EACvD;EAAc;EAAe;;;KAGvB,eAAe,QACxB,WAAW,IAAI,EAAE;EAAa;EAAmB;IAC9C,EAAE,KACF,EAAE;EAAa;IACb,EAAE,KACF,EAAE;EAAa;EAAa;IAC1B,EAAE"}

package/build/EntityFields.d.mts

@@ -0,0 +1,36 @@
+//#region src/EntityFields.d.ts
+/** All the fields for an entity in the `FieldsOf` / `EntityField` format. */
+type EntityFields<T> = { [K in keyof T]: EntityField; };
+type EntityField = {
+  kind: "primitive";
+  type: unknown;
+  unique: boolean;
+  nullable: never | undefined;
+  derived: boolean;
+} | {
+  kind: "enum";
+  type: unknown;
+  nullable: never | unknown;
+} | {
+  kind: "m2o";
+  type: unknown;
+  nullable: never | unknown;
+  derived: boolean;
+} | {
+  kind: "poly";
+  type: unknown;
+  nullable: never | unknown;
+};
+/** The subset of primitive, enum, and m2o fields from the `F` that are settable, i.e. not derived. */
+type SettableFields<F> = { [K in keyof F]: F[K] extends {
+  kind: "primitive";
+  derived: false;
+} ? F[K] : F[K] extends {
+  kind: "enum";
+} ? F[K] : F[K] extends {
+  kind: "m2o";
+  derived: false;
+} ? F[K] : never; };
+//#endregion
+export { EntityField, EntityFields, SettableFields };
+//# sourceMappingURL=EntityFields.d.mts.map

package/build/EntityFields.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFields.d.mts","names":[],"sources":["../src/EntityFields.ts"],"mappings":";;KACY,aAAa,QACtB,WAAW,IAAI;KAGN;EACN;EAAmB;EAAe;EAAiB;EAA6B;;EAChF;EAAc;EAAe;;EAC7B;EAAa;EAAe;EAA2B;;EACvD;EAAc;EAAe;;;KAGvB,eAAe,QACxB,WAAW,IAAI,EAAE;EAAa;EAAmB;IAC9C,EAAE,KACF,EAAE;EAAa;IACb,EAAE,KACF,EAAE;EAAa;EAAa;IAC1B,EAAE"}

package/build/EntityFields.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=EntityFields.js.map
+export {};

package/build/EntityFilter.cjs

@@ -0,0 +1,32 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_scopes = require("./scopes.cjs");
+require("./typeMap.cjs");
+require("./EntityManager.cjs");
+require("./Entity.cjs");
+require("./Aliases.cjs");
+require("./QueryParser.cjs");
+//#region src/EntityFilter.ts
+/** Merges root-scope find settings with caller options, letting caller options win. */
+function mergeFindOptions(where, options) {
+	if (!require_scopes.isScope(where)) return {
+		where,
+		options
+	};
+	const resolved = require_scopes.resolveScope(where);
+	const scopeOptions = {};
+	if (resolved.orderBys.length > 0) scopeOptions.orderBy = resolved.orderBys;
+	if (resolved.limit !== void 0) scopeOptions.limit = resolved.limit;
+	if (resolved.offset !== void 0) scopeOptions.offset = resolved.offset;
+	if (resolved.softDeletes !== void 0) scopeOptions.softDeletes = resolved.softDeletes;
+	return {
+		where,
+		options: {
+			...scopeOptions,
+			...options
+		}
+	};
+}
+//#endregion
+exports.mergeFindOptions = mergeFindOptions;
+
+//# sourceMappingURL=EntityFilter.cjs.map

package/build/EntityFilter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFilter.cjs","names":["isScope","resolveScope"],"sources":["../src/EntityFilter.ts"],"sourcesContent":["import { type Alias } from \"./Aliases.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type FindFilterOptions, type IdOf } from \"./EntityManager.ts\";\nimport { type ColumnCondition, type RawCondition } from \"./QueryParser.ts\";\nimport { type Scope, isScope, resolveScope } from \"./scopes.ts\";\nimport { type FieldsOf, type FilterOf, type OrderOf } from \"./typeMap.ts\";\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type FilterAndSettings<T extends Entity> = {\n  // Either a `{ ... }` EntityFilter or a Scope like `Adult.parent`\n  where: FindFilter<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T> | OrderOf<T>[];\n  limit?: number | undefined;\n  offset?: number | undefined;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\nexport type OrderBy = \"ASC\" | \"DESC\";\n\n/**\n * A filter for an entity of type `T` for `em.find` inline conditions.\n *\n * An entity filter can either filter by \"an exact entity\" (i.e. the book with id 2)\n * or its own set of filters (i.e. all books with a title that starts with \"The\").\n *\n * @typeparam T The entity type, i.e. `Author`\n * @typeparam I The ID type of the entity, i.e. `AuthorId`\n * @typeparam F The filter type for the entity, i.e. `AuthorFilter`\n * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.\n */\nexport type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> =\n  | T\n  | readonly T[]\n  | I\n  | readonly I[]\n  | Scope<T>\n  // Note that this is a weak type (all optional keys) but TS still enforces at least one overlap\n  | EntityFilterObject<T, I, F, N>\n  // Always allow `undefined` for condition pruning\n  | undefined\n  // But only allow `null` for `nullable` relations\n  | N\n  | { ne: T | I | N | undefined }\n  // Allow setting `true` for `is not null` or `false` for `is null`\n  | boolean\n  | Alias<T>;\n\n/** A nested object filter, including logical composition at the current entity alias. */\nexport type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {\n  as?: Alias<T>;\n  and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];\n  or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];\n} & F;\n\nexport type BooleanFilter<N> = true | false | N;\n\n/**\n * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.\n *\n * Intentionally a thin alias rather than the source of truth: `as`/`and`/`or` are defined once on\n * `EntityFilterObject<T, I, F, N>` so the parameterized nested-relation arm of `EntityFilter` and this\n * root can't drift. That arm needs the `F`/`N` params — GraphQL filter shapes (`F`) and relation\n * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't\n * supply, so the shape lives on `EntityFilterObject` and this just specializes it.\n */\nexport type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;\n\n/** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */\nexport type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;\n\nexport type UniqueFilter<T extends Entity> = {\n  [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends { unique: true } ? K : never]?: FilterOf<T>[K];\n};\n\n/**\n * Filters against a specific field's values within `em.find` inline conditions.\n *\n * We always allow `undefined` to support condition pruning, but only conditionally\n * allow `null` if the column is actually nullable.\n */\nexport type ValueFilter<V, N> =\n  | V\n  | readonly V[]\n  | N\n  | undefined\n  // Both eq and in are redundant with `V` and `V[]` above but are convenient for matching GQL filter APIs\n  | { eq: V | N | undefined }\n  | { ne: V | N | undefined }\n  | { in: readonly (V | N | null)[] | undefined }\n  | { nin: readonly (V | N)[] | undefined }\n  | { gt: V | undefined }\n  | { gte: V | undefined }\n  | { lt: V | undefined }\n  | { lte: V | undefined }\n  | { like: V | undefined }\n  | { nlike: V | undefined }\n  | { ilike: V | undefined }\n  | { nilike: V | undefined }\n  | { regex?: V | undefined }\n  | { iregex?: V | undefined }\n  | { nregex?: V | undefined }\n  | { niregex?: V | undefined }\n  | { search: V | undefined }\n  // should put these in a dedicated ArrayFilter\n  | { contains: V | undefined }\n  | { overlaps: V | undefined }\n  | { containedBy: V | undefined }\n  // should put these in a dedicated JsonbFilter\n  | { pathExists: string | undefined }\n  | { pathIsTrue: string | undefined }\n  // this is between\n  | { gte: V | undefined; lte: V | undefined }\n  | { between: [V, V] | undefined };\n\n/**\n * Filters against complex expressions of filters.\n *\n * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.\n */\nexport type ExpressionFilter = (\n  | { and: Array<ExpressionCondition | undefined>; or?: never }\n  | { or: Array<ExpressionCondition | undefined>; and?: never }\n) & { pruneIfUndefined?: \"any\" | \"all\" };\n\n/** A user-facing filter for maybe-nested/maybe-simple conditions. */\nexport type ExpressionCondition = ExpressionFilter | ColumnCondition | RawCondition;\n\n/** Merges root-scope find settings with caller options, letting caller options win. */\nexport function mergeFindOptions<T extends Entity>(\n  where: FindFilter<T>,\n  options: FindFilterOptions<T>,\n): { where: FindFilter<T>; options: FindFilterOptions<T> } {\n  if (!isScope<T>(where)) return { where, options };\n\n  const resolved = resolveScope(where);\n  const scopeOptions: FindFilterOptions<T> = {};\n  if (resolved.orderBys.length > 0) scopeOptions.orderBy = resolved.orderBys;\n  if (resolved.limit !== undefined) scopeOptions.limit = resolved.limit;\n  if (resolved.offset !== undefined) scopeOptions.offset = resolved.offset;\n  if (resolved.softDeletes !== undefined) scopeOptions.softDeletes = resolved.softDeletes;\n  return { where, options: { ...scopeOptions, ...options } };\n}\n"],"mappings":";;;;;;;;;AAmIA,SAAgB,iBACd,OACA,SACyD;CACzD,IAAI,CAACA,eAAAA,QAAW,KAAK,GAAG,OAAO;EAAE;EAAO;CAAQ;CAEhD,MAAM,WAAWC,eAAAA,aAAa,KAAK;CACnC,MAAM,eAAqC,CAAC;CAC5C,IAAI,SAAS,SAAS,SAAS,GAAG,aAAa,UAAU,SAAS;CAClE,IAAI,SAAS,UAAU,KAAA,GAAW,aAAa,QAAQ,SAAS;CAChE,IAAI,SAAS,WAAW,KAAA,GAAW,aAAa,SAAS,SAAS;CAClE,IAAI,SAAS,gBAAgB,KAAA,GAAW,aAAa,cAAc,SAAS;CAC5E,OAAO;EAAE;EAAO,SAAS;GAAE,GAAG;GAAc,GAAG;EAAQ;CAAE;AAC3D"}

package/build/EntityFilter.d.cts

@@ -0,0 +1,135 @@
+import { FieldsOf, FilterOf, OrderOf } from "./typeMap.cjs";
+import { Scope } from "./scopes.cjs";
+import { FindFilterOptions, IdOf } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+import { Alias } from "./Aliases.cjs";
+import { ColumnCondition, RawCondition } from "./QueryParser.cjs";
+//#region src/EntityFilter.d.ts
+/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
+type FilterAndSettings<T extends Entity> = {
+  where: FindFilter<T>;
+  conditions?: ExpressionFilter;
+  orderBy?: OrderOf<T> | OrderOf<T>[];
+  limit?: number | undefined;
+  offset?: number | undefined;
+  softDeletes?: "exclude" | "include";
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
+};
+type OrderBy = "ASC" | "DESC";
+/**
+ * A filter for an entity of type `T` for `em.find` inline conditions.
+ *
+ * An entity filter can either filter by "an exact entity" (i.e. the book with id 2)
+ * or its own set of filters (i.e. all books with a title that starts with "The").
+ *
+ * @typeparam T The entity type, i.e. `Author`
+ * @typeparam I The ID type of the entity, i.e. `AuthorId`
+ * @typeparam F The filter type for the entity, i.e. `AuthorFilter`
+ * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.
+ */
+type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = T | readonly T[] | I | readonly I[] | Scope<T> | EntityFilterObject<T, I, F, N> | undefined | N | {
+  ne: T | I | N | undefined;
+} | boolean | Alias<T>;
+/** A nested object filter, including logical composition at the current entity alias. */
+type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {
+  as?: Alias<T>;
+  and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
+  or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
+} & F;
+type BooleanFilter<N> = true | false | N;
+/**
+ * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.
+ *
+ * Intentionally a thin alias rather than the source of truth: `as`/`and`/`or` are defined once on
+ * `EntityFilterObject<T, I, F, N>` so the parameterized nested-relation arm of `EntityFilter` and this
+ * root can't drift. That arm needs the `F`/`N` params — GraphQL filter shapes (`F`) and relation
+ * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't
+ * supply, so the shape lives on `EntityFilterObject` and this just specializes it.
+ */
+type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;
+/** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */
+type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;
+type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends {
+  unique: true;
+} ? K : never]?: FilterOf<T>[K]; };
+/**
+ * Filters against a specific field's values within `em.find` inline conditions.
+ *
+ * We always allow `undefined` to support condition pruning, but only conditionally
+ * allow `null` if the column is actually nullable.
+ */
+type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
+  eq: V | N | undefined;
+} | {
+  ne: V | N | undefined;
+} | {
+  in: readonly (V | N | null)[] | undefined;
+} | {
+  nin: readonly (V | N)[] | undefined;
+} | {
+  gt: V | undefined;
+} | {
+  gte: V | undefined;
+} | {
+  lt: V | undefined;
+} | {
+  lte: V | undefined;
+} | {
+  like: V | undefined;
+} | {
+  nlike: V | undefined;
+} | {
+  ilike: V | undefined;
+} | {
+  nilike: V | undefined;
+} | {
+  regex?: V | undefined;
+} | {
+  iregex?: V | undefined;
+} | {
+  nregex?: V | undefined;
+} | {
+  niregex?: V | undefined;
+} | {
+  search: V | undefined;
+} | {
+  contains: V | undefined;
+} | {
+  overlaps: V | undefined;
+} | {
+  containedBy: V | undefined;
+} | {
+  pathExists: string | undefined;
+} | {
+  pathIsTrue: string | undefined;
+} | {
+  gte: V | undefined;
+  lte: V | undefined;
+} | {
+  between: [V, V] | undefined;
+};
+/**
+ * Filters against complex expressions of filters.
+ *
+ * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.
+ */
+type ExpressionFilter = ({
+  and: Array<ExpressionCondition | undefined>;
+  or?: never;
+} | {
+  or: Array<ExpressionCondition | undefined>;
+  and?: never;
+}) & {
+  pruneIfUndefined?: "any" | "all";
+};
+/** A user-facing filter for maybe-nested/maybe-simple conditions. */
+type ExpressionCondition = ExpressionFilter | ColumnCondition | RawCondition;
+/** Merges root-scope find settings with caller options, letting caller options win. */
+declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>, options: FindFilterOptions<T>): {
+  where: FindFilter<T>;
+  options: FindFilterOptions<T>;
+};
+//#endregion
+export { BooleanFilter, EntityFilter, EntityFilterObject, ExpressionCondition, ExpressionFilter, FilterAndSettings, FilterWithAlias, FindFilter, OrderBy, UniqueFilter, ValueFilter, mergeFindOptions };
+//# sourceMappingURL=EntityFilter.d.cts.map

package/build/EntityFilter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFilter.d.cts","names":[],"sources":["../src/EntityFilter.ts"],"mappings":";;;;;;;;KAQY,kBAAkB,UAAU;EAEtC,OAAO,WAAW;EAClB,aAAa;EACb,UAAU,QAAQ,KAAK,QAAQ;EAC/B;EACA;EACA;EACA;EACA;;KAGU;;;;;;;;;;;;KAaA,aAAa,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,aACrE,aACS,MACT,aACS,MACT,MAAM,KAEN,mBAAmB,GAAG,GAAG,GAAG,iBAI5B;EACE,IAAI,IAAI,IAAI;cAGd,MAAM;;KAGE,mBAAmB,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI;EAC7E,KAAK,MAAM;EACX,MAAM,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;EAChE,KAAK,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;IAC7D;KAEQ,cAAc,oBAAoB;;;;;;;;;;KAWlC,gBAAgB,UAAU,UAAU,mBAAmB;;KAGvD,WAAW,UAAU,UAAU,gBAAgB,KAAK,MAAM;KAE1D,aAAa,UAAU,aAChC,WAAW,SAAS,WAAW,SAAS,MAAM,SAAS,GAAG;EAAa;IAAiB,aAAa,SAAS,GAAG;;;;;;;KASxG,YAAY,GAAG,KACvB,aACS,MACT;EAGE,IAAI,IAAI;;EACR,IAAI,IAAI;;EACR,cAAc,IAAI;;EAClB,eAAe,IAAI;;EACnB,IAAI;;EACJ,KAAK;;EACL,IAAI;;EACJ,KAAK;;EACL,MAAM;;EACN,OAAO;;EACP,OAAO;;EACP,QAAQ;;EACR,QAAQ;;EACR,SAAS;;EACT,SAAS;;EACT,UAAU;;EACV,QAAQ;;EAER,UAAU;;EACV,UAAU;;EACV,aAAa;;EAEb;;EACA;;EAEA,KAAK;EAAe,KAAK;;EACzB,UAAU,GAAG;;;;;;;KAOP;EACN,KAAK,MAAM;EAAkC;;EAC7C,IAAI,MAAM;EAAkC;;EAC5C;;;KAGM,sBAAsB,mBAAmB,kBAAkB;;iBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}

package/build/EntityFilter.d.mts

@@ -0,0 +1,135 @@
+import { FieldsOf, FilterOf, OrderOf } from "./typeMap.mjs";
+import { Scope } from "./scopes.mjs";
+import { FindFilterOptions, IdOf } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+import { Alias } from "./Aliases.mjs";
+import { ColumnCondition, RawCondition } from "./QueryParser.mjs";
+//#region src/EntityFilter.d.ts
+/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
+type FilterAndSettings<T extends Entity> = {
+  where: FindFilter<T>;
+  conditions?: ExpressionFilter;
+  orderBy?: OrderOf<T> | OrderOf<T>[];
+  limit?: number | undefined;
+  offset?: number | undefined;
+  softDeletes?: "exclude" | "include";
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
+};
+type OrderBy = "ASC" | "DESC";
+/**
+ * A filter for an entity of type `T` for `em.find` inline conditions.
+ *
+ * An entity filter can either filter by "an exact entity" (i.e. the book with id 2)
+ * or its own set of filters (i.e. all books with a title that starts with "The").
+ *
+ * @typeparam T The entity type, i.e. `Author`
+ * @typeparam I The ID type of the entity, i.e. `AuthorId`
+ * @typeparam F The filter type for the entity, i.e. `AuthorFilter`
+ * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.
+ */
+type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = T | readonly T[] | I | readonly I[] | Scope<T> | EntityFilterObject<T, I, F, N> | undefined | N | {
+  ne: T | I | N | undefined;
+} | boolean | Alias<T>;
+/** A nested object filter, including logical composition at the current entity alias. */
+type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {
+  as?: Alias<T>;
+  and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
+  or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
+} & F;
+type BooleanFilter<N> = true | false | N;
+/**
+ * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.
+ *
+ * Intentionally a thin alias rather than the source of truth: `as`/`and`/`or` are defined once on
+ * `EntityFilterObject<T, I, F, N>` so the parameterized nested-relation arm of `EntityFilter` and this
+ * root can't drift. That arm needs the `F`/`N` params — GraphQL filter shapes (`F`) and relation
+ * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't
+ * supply, so the shape lives on `EntityFilterObject` and this just specializes it.
+ */
+type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;
+/** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */
+type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;
+type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends {
+  unique: true;
+} ? K : never]?: FilterOf<T>[K]; };
+/**
+ * Filters against a specific field's values within `em.find` inline conditions.
+ *
+ * We always allow `undefined` to support condition pruning, but only conditionally
+ * allow `null` if the column is actually nullable.
+ */
+type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
+  eq: V | N | undefined;
+} | {
+  ne: V | N | undefined;
+} | {
+  in: readonly (V | N | null)[] | undefined;
+} | {
+  nin: readonly (V | N)[] | undefined;
+} | {
+  gt: V | undefined;
+} | {
+  gte: V | undefined;
+} | {
+  lt: V | undefined;
+} | {
+  lte: V | undefined;
+} | {
+  like: V | undefined;
+} | {
+  nlike: V | undefined;
+} | {
+  ilike: V | undefined;
+} | {
+  nilike: V | undefined;
+} | {
+  regex?: V | undefined;
+} | {
+  iregex?: V | undefined;
+} | {
+  nregex?: V | undefined;
+} | {
+  niregex?: V | undefined;
+} | {
+  search: V | undefined;
+} | {
+  contains: V | undefined;
+} | {
+  overlaps: V | undefined;
+} | {
+  containedBy: V | undefined;
+} | {
+  pathExists: string | undefined;
+} | {
+  pathIsTrue: string | undefined;
+} | {
+  gte: V | undefined;
+  lte: V | undefined;
+} | {
+  between: [V, V] | undefined;
+};
+/**
+ * Filters against complex expressions of filters.
+ *
+ * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.
+ */
+type ExpressionFilter = ({
+  and: Array<ExpressionCondition | undefined>;
+  or?: never;
+} | {
+  or: Array<ExpressionCondition | undefined>;
+  and?: never;
+}) & {
+  pruneIfUndefined?: "any" | "all";
+};
+/** A user-facing filter for maybe-nested/maybe-simple conditions. */
+type ExpressionCondition = ExpressionFilter | ColumnCondition | RawCondition;
+/** Merges root-scope find settings with caller options, letting caller options win. */
+declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>, options: FindFilterOptions<T>): {
+  where: FindFilter<T>;
+  options: FindFilterOptions<T>;
+};
+//#endregion
+export { BooleanFilter, EntityFilter, EntityFilterObject, ExpressionCondition, ExpressionFilter, FilterAndSettings, FilterWithAlias, FindFilter, OrderBy, UniqueFilter, ValueFilter, mergeFindOptions };
+//# sourceMappingURL=EntityFilter.d.mts.map

package/build/EntityFilter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFilter.d.mts","names":[],"sources":["../src/EntityFilter.ts"],"mappings":";;;;;;;;KAQY,kBAAkB,UAAU;EAEtC,OAAO,WAAW;EAClB,aAAa;EACb,UAAU,QAAQ,KAAK,QAAQ;EAC/B;EACA;EACA;EACA;EACA;;KAGU;;;;;;;;;;;;KAaA,aAAa,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,aACrE,aACS,MACT,aACS,MACT,MAAM,KAEN,mBAAmB,GAAG,GAAG,GAAG,iBAI5B;EACE,IAAI,IAAI,IAAI;cAGd,MAAM;;KAGE,mBAAmB,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI;EAC7E,KAAK,MAAM;EACX,MAAM,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;EAChE,KAAK,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;IAC7D;KAEQ,cAAc,oBAAoB;;;;;;;;;;KAWlC,gBAAgB,UAAU,UAAU,mBAAmB;;KAGvD,WAAW,UAAU,UAAU,gBAAgB,KAAK,MAAM;KAE1D,aAAa,UAAU,aAChC,WAAW,SAAS,WAAW,SAAS,MAAM,SAAS,GAAG;EAAa;IAAiB,aAAa,SAAS,GAAG;;;;;;;KASxG,YAAY,GAAG,KACvB,aACS,MACT;EAGE,IAAI,IAAI;;EACR,IAAI,IAAI;;EACR,cAAc,IAAI;;EAClB,eAAe,IAAI;;EACnB,IAAI;;EACJ,KAAK;;EACL,IAAI;;EACJ,KAAK;;EACL,MAAM;;EACN,OAAO;;EACP,OAAO;;EACP,QAAQ;;EACR,QAAQ;;EACR,SAAS;;EACT,SAAS;;EACT,UAAU;;EACV,QAAQ;;EAER,UAAU;;EACV,UAAU;;EACV,aAAa;;EAEb;;EACA;;EAEA,KAAK;EAAe,KAAK;;EACzB,UAAU,GAAG;;;;;;;KAOP;EACN,KAAK,MAAM;EAAkC;;EAC7C,IAAI,MAAM;EAAkC;;EAC5C;;;KAGM,sBAAsB,mBAAmB,kBAAkB;;iBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}

package/build/EntityFilter.js

@@ -1,21 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeFindOptions = mergeFindOptions;
-const scopes_1 = require("./scopes");
+import { isScope, resolveScope } from "./scopes.js";
+import "./typeMap.js";
+import "./EntityManager.js";
+import "./Entity.js";
+import "./Aliases.js";
+import "./QueryParser.js";
+//#region src/EntityFilter.ts
 /** Merges root-scope find settings with caller options, letting caller options win. */
 function mergeFindOptions(where, options) {
-    if (!(0, scopes_1.isScope)(where))
-        return { where, options };
-    const resolved = (0, scopes_1.resolveScope)(where);
-    const scopeOptions = {};
-    if (resolved.orderBys.length > 0)
-        scopeOptions.orderBy = resolved.orderBys;
-    if (resolved.limit !== undefined)
-        scopeOptions.limit = resolved.limit;
-    if (resolved.offset !== undefined)
-        scopeOptions.offset = resolved.offset;
-    if (resolved.softDeletes !== undefined)
-        scopeOptions.softDeletes = resolved.softDeletes;
-    return { where, options: { ...scopeOptions, ...options } };
+	if (!isScope(where)) return {
+		where,
+		options
+	};
+	const resolved = resolveScope(where);
+	const scopeOptions = {};
+	if (resolved.orderBys.length > 0) scopeOptions.orderBy = resolved.orderBys;
+	if (resolved.limit !== void 0) scopeOptions.limit = resolved.limit;
+	if (resolved.offset !== void 0) scopeOptions.offset = resolved.offset;
+	if (resolved.softDeletes !== void 0) scopeOptions.softDeletes = resolved.softDeletes;
+	return {
+		where,
+		options: {
+			...scopeOptions,
+			...options
+		}
+	};
 }
+//#endregion
+export { mergeFindOptions };
+
 //# sourceMappingURL=EntityFilter.js.map

package/build/EntityFilter.js.map

@@ -1 +1 @@
-{"version":3,"file":"EntityFilter.js","sourceRoot":"","sources":["../src/EntityFilter.ts"],"names":[],"mappings":";;AAmIA,4CAaC;AA5ID,qCAA6D;AA8H7D,uFAAuF;AACvF,SAAgB,gBAAgB,CAC9B,KAAoB,EACpB,OAA6B;IAE7B,IAAI,CAAC,IAAA,gBAAO,EAAI,KAAK,CAAC;QAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAElD,MAAM,QAAQ,GAAG,IAAA,qBAAY,EAAC,KAAK,CAAC,CAAC;IACrC,MAAM,YAAY,GAAyB,EAAE,CAAC;IAC9C,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,YAAY,CAAC,OAAO,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAC3E,IAAI,QAAQ,CAAC,KAAK,KAAK,SAAS;QAAE,YAAY,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;IACtE,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS;QAAE,YAAY,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;IACzE,IAAI,QAAQ,CAAC,WAAW,KAAK,SAAS;QAAE,YAAY,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;IACxF,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,YAAY,EAAE,GAAG,OAAO,EAAE,EAAE,CAAC;AAC7D,CAAC"}
+{"version":3,"file":"EntityFilter.js","names":[],"sources":["../src/EntityFilter.ts"],"sourcesContent":["import { type Alias } from \"./Aliases.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type FindFilterOptions, type IdOf } from \"./EntityManager.ts\";\nimport { type ColumnCondition, type RawCondition } from \"./QueryParser.ts\";\nimport { type Scope, isScope, resolveScope } from \"./scopes.ts\";\nimport { type FieldsOf, type FilterOf, type OrderOf } from \"./typeMap.ts\";\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type FilterAndSettings<T extends Entity> = {\n  // Either a `{ ... }` EntityFilter or a Scope like `Adult.parent`\n  where: FindFilter<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T> | OrderOf<T>[];\n  limit?: number | undefined;\n  offset?: number | undefined;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\nexport type OrderBy = \"ASC\" | \"DESC\";\n\n/**\n * A filter for an entity of type `T` for `em.find` inline conditions.\n *\n * An entity filter can either filter by \"an exact entity\" (i.e. the book with id 2)\n * or its own set of filters (i.e. all books with a title that starts with \"The\").\n *\n * @typeparam T The entity type, i.e. `Author`\n * @typeparam I The ID type of the entity, i.e. `AuthorId`\n * @typeparam F The filter type for the entity, i.e. `AuthorFilter`\n * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.\n */\nexport type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> =\n  | T\n  | readonly T[]\n  | I\n  | readonly I[]\n  | Scope<T>\n  // Note that this is a weak type (all optional keys) but TS still enforces at least one overlap\n  | EntityFilterObject<T, I, F, N>\n  // Always allow `undefined` for condition pruning\n  | undefined\n  // But only allow `null` for `nullable` relations\n  | N\n  | { ne: T | I | N | undefined }\n  // Allow setting `true` for `is not null` or `false` for `is null`\n  | boolean\n  | Alias<T>;\n\n/** A nested object filter, including logical composition at the current entity alias. */\nexport type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {\n  as?: Alias<T>;\n  and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];\n  or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];\n} & F;\n\nexport type BooleanFilter<N> = true | false | N;\n\n/**\n * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.\n *\n * Intentionally a thin alias rather than the source of truth: `as`/`and`/`or` are defined once on\n * `EntityFilterObject<T, I, F, N>` so the parameterized nested-relation arm of `EntityFilter` and this\n * root can't drift. That arm needs the `F`/`N` params — GraphQL filter shapes (`F`) and relation\n * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't\n * supply, so the shape lives on `EntityFilterObject` and this just specializes it.\n */\nexport type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;\n\n/** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */\nexport type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;\n\nexport type UniqueFilter<T extends Entity> = {\n  [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends { unique: true } ? K : never]?: FilterOf<T>[K];\n};\n\n/**\n * Filters against a specific field's values within `em.find` inline conditions.\n *\n * We always allow `undefined` to support condition pruning, but only conditionally\n * allow `null` if the column is actually nullable.\n */\nexport type ValueFilter<V, N> =\n  | V\n  | readonly V[]\n  | N\n  | undefined\n  // Both eq and in are redundant with `V` and `V[]` above but are convenient for matching GQL filter APIs\n  | { eq: V | N | undefined }\n  | { ne: V | N | undefined }\n  | { in: readonly (V | N | null)[] | undefined }\n  | { nin: readonly (V | N)[] | undefined }\n  | { gt: V | undefined }\n  | { gte: V | undefined }\n  | { lt: V | undefined }\n  | { lte: V | undefined }\n  | { like: V | undefined }\n  | { nlike: V | undefined }\n  | { ilike: V | undefined }\n  | { nilike: V | undefined }\n  | { regex?: V | undefined }\n  | { iregex?: V | undefined }\n  | { nregex?: V | undefined }\n  | { niregex?: V | undefined }\n  | { search: V | undefined }\n  // should put these in a dedicated ArrayFilter\n  | { contains: V | undefined }\n  | { overlaps: V | undefined }\n  | { containedBy: V | undefined }\n  // should put these in a dedicated JsonbFilter\n  | { pathExists: string | undefined }\n  | { pathIsTrue: string | undefined }\n  // this is between\n  | { gte: V | undefined; lte: V | undefined }\n  | { between: [V, V] | undefined };\n\n/**\n * Filters against complex expressions of filters.\n *\n * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.\n */\nexport type ExpressionFilter = (\n  | { and: Array<ExpressionCondition | undefined>; or?: never }\n  | { or: Array<ExpressionCondition | undefined>; and?: never }\n) & { pruneIfUndefined?: \"any\" | \"all\" };\n\n/** A user-facing filter for maybe-nested/maybe-simple conditions. */\nexport type ExpressionCondition = ExpressionFilter | ColumnCondition | RawCondition;\n\n/** Merges root-scope find settings with caller options, letting caller options win. */\nexport function mergeFindOptions<T extends Entity>(\n  where: FindFilter<T>,\n  options: FindFilterOptions<T>,\n): { where: FindFilter<T>; options: FindFilterOptions<T> } {\n  if (!isScope<T>(where)) return { where, options };\n\n  const resolved = resolveScope(where);\n  const scopeOptions: FindFilterOptions<T> = {};\n  if (resolved.orderBys.length > 0) scopeOptions.orderBy = resolved.orderBys;\n  if (resolved.limit !== undefined) scopeOptions.limit = resolved.limit;\n  if (resolved.offset !== undefined) scopeOptions.offset = resolved.offset;\n  if (resolved.softDeletes !== undefined) scopeOptions.softDeletes = resolved.softDeletes;\n  return { where, options: { ...scopeOptions, ...options } };\n}\n"],"mappings":";;;;;;;;AAmIA,SAAgB,iBACd,OACA,SACyD;CACzD,IAAI,CAAC,QAAW,KAAK,GAAG,OAAO;EAAE;EAAO;CAAQ;CAEhD,MAAM,WAAW,aAAa,KAAK;CACnC,MAAM,eAAqC,CAAC;CAC5C,IAAI,SAAS,SAAS,SAAS,GAAG,aAAa,UAAU,SAAS;CAClE,IAAI,SAAS,UAAU,KAAA,GAAW,aAAa,QAAQ,SAAS;CAChE,IAAI,SAAS,WAAW,KAAA,GAAW,aAAa,SAAS,SAAS;CAClE,IAAI,SAAS,gBAAgB,KAAA,GAAW,aAAa,cAAc,SAAS;CAC5E,OAAO;EAAE;EAAO,SAAS;GAAE,GAAG;GAAc,GAAG;EAAQ;CAAE;AAC3D"}