joist-core 2.3.0 → 2.4.0-next.10

package/build/queries/find/EntityFilter.d.mts

@@ -0,0 +1,127 @@
+import { FieldsOf, FilterOf, OrderOf } from "../../typeMap.mjs";
+import { AndCondition, DomainPredicate, OrCondition, UnbrandedPredicate } from "../conditions.mjs";
+import { Alias } from "./Aliases.mjs";
+import { Scope } from "./scopes.mjs";
+import { FindFilterOptions, IdOf } from "../../EntityManager.mjs";
+import { Entity } from "../../Entity.mjs";
+//#region src/queries/find/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 = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;
+/** A domain-alias predicate or nested group for em.find and scopes, not SQL table expressions. */
+type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;
+/** 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/queries/find/EntityFilter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFilter.d.mts","names":[],"sources":["../../../src/queries/find/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,mBAAmB,aAAa,uBAAuB,YAAY;;KAGnE,sBAAsB,mBAAmB,kBAAkB;;iBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}

package/build/queries/find/EntityFilter.js

@@ -0,0 +1,26 @@
+import { isScope, resolveScope } from "./scopes.js";
+//#region src/queries/find/EntityFilter.ts
+/** Merges root-scope find settings with caller options, letting caller options win. */
+function mergeFindOptions(where, 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/queries/find/EntityFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityFilter.js","names":[],"sources":["../../../src/queries/find/EntityFilter.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport type { FindFilterOptions, IdOf } from \"src/EntityManager.ts\";\nimport type { AndCondition, DomainPredicate, OrCondition, UnbrandedPredicate } from \"src/queries/conditions.ts\";\nimport type { Alias } from \"src/queries/find/Aliases.ts\";\nimport { type Scope, isScope, resolveScope } from \"src/queries/find/scopes.ts\";\nimport type { FieldsOf, FilterOf, OrderOf } from \"src/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 = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;\n\n/** A domain-alias predicate or nested group for em.find and scopes, not SQL table expressions. */\nexport type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;\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":";;;AAgIA,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"}

package/build/queries/find/EntityGraphQLFilter.cjs

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/queries/find/EntityGraphQLFilter.ts
+const operators = [
+	"eq",
+	"gt",
+	"gte",
+	"ne",
+	"lt",
+	"lte",
+	"like",
+	"nlike",
+	"ilike",
+	"nilike",
+	"regex",
+	"iregex",
+	"nregex",
+	"niregex",
+	"in",
+	"nin",
+	"between",
+	"contains",
+	"overlaps",
+	"containedBy",
+	"jsonPathExists",
+	"jsonPathPredicate"
+];
+const opToFn = {
+	eq: "=",
+	gt: ">",
+	gte: ">=",
+	ne: "!=",
+	lt: "<",
+	lte: "<=",
+	like: "LIKE",
+	nlike: "NOT LIKE",
+	ilike: "ILIKE",
+	nilike: "NOT ILIKE",
+	regex: "~",
+	iregex: "~*",
+	nregex: "!~",
+	niregex: "!~*",
+	contains: "@>",
+	containedBy: "<@",
+	overlaps: "&&",
+	jsonPathExists: "@?",
+	jsonPathPredicate: "@@"
+};
+//#endregion
+exports.opToFn = opToFn;
+exports.operators = operators;
+
+//# sourceMappingURL=EntityGraphQLFilter.cjs.map

package/build/queries/find/EntityGraphQLFilter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityGraphQLFilter.cjs","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport type { Alias } from \"src/queries/find/Aliases.ts\";\nimport type { EntityFilter, ExpressionFilter } from \"src/queries/find/EntityFilter.ts\";\nimport type { GraphQLFilterOf, OrderOf } from \"src/typeMap.ts\";\n\nexport type GraphQLFilterWithAlias<T extends Entity> = { as?: Alias<T> } & GraphQLFilterOf<T>;\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type GraphQLFilterAndSettings<T extends Entity> = {\n  where: GraphQLFilterWithAlias<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T>;\n  limit?: number | null;\n  offset?: number | null;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\n/**\n * This essentially matches the ValueFilter but with looser types to placate GraphQL.\n */\nexport type ValueGraphQLFilter<V> =\n  | {\n      eq?: V | null;\n      in?: readonly V[] | null;\n      nin?: readonly V[] | null;\n      gt?: V | null;\n      gte?: V | null;\n      ne?: V | null;\n      lt?: V | null;\n      lte?: V | null;\n      like?: V | null;\n      nlike?: V | null;\n      ilike?: V | null;\n      nilike?: V | null;\n      regex?: V | null;\n      iregex?: V | null;\n      nregex?: V | null;\n      niregex?: V | null;\n      search?: V | null;\n      between?: readonly V[] | null;\n      contains?: V | null;\n      overlaps?: V | null;\n      containedBy?: V | null;\n      pathExists?: string | null;\n      pathIsTrue?: string | null;\n    }\n  | { op: Operator; value: V | readonly V[] | undefined | null }\n  | V\n  | readonly V[]\n  | null;\n\nexport type BooleanGraphQLFilter = true | false | null;\n\nexport const operators = [\n  \"eq\",\n  \"gt\",\n  \"gte\",\n  \"ne\",\n  \"lt\",\n  \"lte\",\n  \"like\",\n  \"nlike\",\n  \"ilike\",\n  \"nilike\",\n  // Regular expression operators\n  \"regex\",\n  \"iregex\",\n  \"nregex\",\n  \"niregex\",\n  \"in\",\n  \"nin\",\n  \"between\",\n  \"contains\",\n  \"overlaps\",\n  \"containedBy\",\n  \"jsonPathExists\",\n  \"jsonPathPredicate\",\n] as const;\n\nexport type Operator = (typeof operators)[number];\n\nexport const opToFn: Record<Exclude<Operator, \"in\" | \"nin\" | \"between\">, string> = {\n  eq: \"=\",\n  gt: \">\",\n  gte: \">=\",\n  ne: \"!=\",\n  lt: \"<\",\n  lte: \"<=\",\n  like: \"LIKE\",\n  nlike: \"NOT LIKE\",\n  ilike: \"ILIKE\",\n  nilike: \"NOT ILIKE\",\n  // Regular expression operators\n  regex: \"~\",\n  iregex: \"~*\",\n  nregex: \"!~\",\n  niregex: \"!~*\",\n  // containsAll / hasAll\n  contains: \"@>\",\n  containedBy: \"<@\",\n  // containsSome / hasSome\n  overlaps: \"&&\",\n  jsonPathExists: \"@?\",\n  jsonPathPredicate: \"@@\",\n};\n\n/** A GraphQL version of EntityFilter. */\nexport type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;\n"],"mappings":";;AAuDA,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAIA,MAAa,SAAsE;CACjF,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CAER,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CAET,UAAU;CACV,aAAa;CAEb,UAAU;CACV,gBAAgB;CAChB,mBAAmB;AACrB"}

package/build/queries/find/EntityGraphQLFilter.d.cts

@@ -0,0 +1,59 @@
+import { GraphQLFilterOf, OrderOf } from "../../typeMap.cjs";
+import { Alias } from "./Aliases.cjs";
+import { EntityFilter, ExpressionFilter } from "./EntityFilter.cjs";
+import { Entity } from "../../Entity.cjs";
+//#region src/queries/find/EntityGraphQLFilter.d.ts
+type GraphQLFilterWithAlias<T extends Entity> = {
+  as?: Alias<T>;
+} & GraphQLFilterOf<T>;
+/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
+type GraphQLFilterAndSettings<T extends Entity> = {
+  where: GraphQLFilterWithAlias<T>;
+  conditions?: ExpressionFilter;
+  orderBy?: OrderOf<T>;
+  limit?: number | null;
+  offset?: number | null;
+  softDeletes?: "exclude" | "include";
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
+};
+/**
+ * This essentially matches the ValueFilter but with looser types to placate GraphQL.
+ */
+type ValueGraphQLFilter<V> = {
+  eq?: V | null;
+  in?: readonly V[] | null;
+  nin?: readonly V[] | null;
+  gt?: V | null;
+  gte?: V | null;
+  ne?: V | null;
+  lt?: V | null;
+  lte?: V | null;
+  like?: V | null;
+  nlike?: V | null;
+  ilike?: V | null;
+  nilike?: V | null;
+  regex?: V | null;
+  iregex?: V | null;
+  nregex?: V | null;
+  niregex?: V | null;
+  search?: V | null;
+  between?: readonly V[] | null;
+  contains?: V | null;
+  overlaps?: V | null;
+  containedBy?: V | null;
+  pathExists?: string | null;
+  pathIsTrue?: string | null;
+} | {
+  op: Operator;
+  value: V | readonly V[] | undefined | null;
+} | V | readonly V[] | null;
+type BooleanGraphQLFilter = true | false | null;
+declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "nlike", "ilike", "nilike", "regex", "iregex", "nregex", "niregex", "in", "nin", "between", "contains", "overlaps", "containedBy", "jsonPathExists", "jsonPathPredicate"];
+type Operator = (typeof operators)[number];
+declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
+/** A GraphQL version of EntityFilter. */
+type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
+//#endregion
+export { BooleanGraphQLFilter, EntityGraphQLFilter, GraphQLFilterAndSettings, GraphQLFilterWithAlias, Operator, ValueGraphQLFilter, opToFn, operators };
+//# sourceMappingURL=EntityGraphQLFilter.d.cts.map

package/build/queries/find/EntityGraphQLFilter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityGraphQLFilter.d.cts","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"mappings":";;;;;KAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;KAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;KAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;KAGD;cAEC;KA0BD,mBAAmB;cAElB,QAAQ,OAAO,QAAQ;;KA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}

package/build/queries/find/EntityGraphQLFilter.d.mts

@@ -0,0 +1,59 @@
+import { GraphQLFilterOf, OrderOf } from "../../typeMap.mjs";
+import { Alias } from "./Aliases.mjs";
+import { EntityFilter, ExpressionFilter } from "./EntityFilter.mjs";
+import { Entity } from "../../Entity.mjs";
+//#region src/queries/find/EntityGraphQLFilter.d.ts
+type GraphQLFilterWithAlias<T extends Entity> = {
+  as?: Alias<T>;
+} & GraphQLFilterOf<T>;
+/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
+type GraphQLFilterAndSettings<T extends Entity> = {
+  where: GraphQLFilterWithAlias<T>;
+  conditions?: ExpressionFilter;
+  orderBy?: OrderOf<T>;
+  limit?: number | null;
+  offset?: number | null;
+  softDeletes?: "exclude" | "include";
+  allowMultipleLeftJoins?: boolean;
+  optimizeJoinsToExists?: boolean;
+};
+/**
+ * This essentially matches the ValueFilter but with looser types to placate GraphQL.
+ */
+type ValueGraphQLFilter<V> = {
+  eq?: V | null;
+  in?: readonly V[] | null;
+  nin?: readonly V[] | null;
+  gt?: V | null;
+  gte?: V | null;
+  ne?: V | null;
+  lt?: V | null;
+  lte?: V | null;
+  like?: V | null;
+  nlike?: V | null;
+  ilike?: V | null;
+  nilike?: V | null;
+  regex?: V | null;
+  iregex?: V | null;
+  nregex?: V | null;
+  niregex?: V | null;
+  search?: V | null;
+  between?: readonly V[] | null;
+  contains?: V | null;
+  overlaps?: V | null;
+  containedBy?: V | null;
+  pathExists?: string | null;
+  pathIsTrue?: string | null;
+} | {
+  op: Operator;
+  value: V | readonly V[] | undefined | null;
+} | V | readonly V[] | null;
+type BooleanGraphQLFilter = true | false | null;
+declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "nlike", "ilike", "nilike", "regex", "iregex", "nregex", "niregex", "in", "nin", "between", "contains", "overlaps", "containedBy", "jsonPathExists", "jsonPathPredicate"];
+type Operator = (typeof operators)[number];
+declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
+/** A GraphQL version of EntityFilter. */
+type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
+//#endregion
+export { BooleanGraphQLFilter, EntityGraphQLFilter, GraphQLFilterAndSettings, GraphQLFilterWithAlias, Operator, ValueGraphQLFilter, opToFn, operators };
+//# sourceMappingURL=EntityGraphQLFilter.d.mts.map

package/build/queries/find/EntityGraphQLFilter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityGraphQLFilter.d.mts","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"mappings":";;;;;KAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;KAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;KAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;KAGD;cAEC;KA0BD,mBAAmB;cAElB,QAAQ,OAAO,QAAQ;;KA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}

package/build/queries/find/EntityGraphQLFilter.js

@@ -0,0 +1,50 @@
+//#region src/queries/find/EntityGraphQLFilter.ts
+const operators = [
+	"eq",
+	"gt",
+	"gte",
+	"ne",
+	"lt",
+	"lte",
+	"like",
+	"nlike",
+	"ilike",
+	"nilike",
+	"regex",
+	"iregex",
+	"nregex",
+	"niregex",
+	"in",
+	"nin",
+	"between",
+	"contains",
+	"overlaps",
+	"containedBy",
+	"jsonPathExists",
+	"jsonPathPredicate"
+];
+const opToFn = {
+	eq: "=",
+	gt: ">",
+	gte: ">=",
+	ne: "!=",
+	lt: "<",
+	lte: "<=",
+	like: "LIKE",
+	nlike: "NOT LIKE",
+	ilike: "ILIKE",
+	nilike: "NOT ILIKE",
+	regex: "~",
+	iregex: "~*",
+	nregex: "!~",
+	niregex: "!~*",
+	contains: "@>",
+	containedBy: "<@",
+	overlaps: "&&",
+	jsonPathExists: "@?",
+	jsonPathPredicate: "@@"
+};
+//#endregion
+export { opToFn, operators };
+
+//# sourceMappingURL=EntityGraphQLFilter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EntityGraphQLFilter.js","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport type { Alias } from \"src/queries/find/Aliases.ts\";\nimport type { EntityFilter, ExpressionFilter } from \"src/queries/find/EntityFilter.ts\";\nimport type { GraphQLFilterOf, OrderOf } from \"src/typeMap.ts\";\n\nexport type GraphQLFilterWithAlias<T extends Entity> = { as?: Alias<T> } & GraphQLFilterOf<T>;\n\n/** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */\nexport type GraphQLFilterAndSettings<T extends Entity> = {\n  where: GraphQLFilterWithAlias<T>;\n  conditions?: ExpressionFilter;\n  orderBy?: OrderOf<T>;\n  limit?: number | null;\n  offset?: number | null;\n  softDeletes?: \"exclude\" | \"include\";\n  allowMultipleLeftJoins?: boolean;\n  optimizeJoinsToExists?: boolean;\n};\n\n/**\n * This essentially matches the ValueFilter but with looser types to placate GraphQL.\n */\nexport type ValueGraphQLFilter<V> =\n  | {\n      eq?: V | null;\n      in?: readonly V[] | null;\n      nin?: readonly V[] | null;\n      gt?: V | null;\n      gte?: V | null;\n      ne?: V | null;\n      lt?: V | null;\n      lte?: V | null;\n      like?: V | null;\n      nlike?: V | null;\n      ilike?: V | null;\n      nilike?: V | null;\n      regex?: V | null;\n      iregex?: V | null;\n      nregex?: V | null;\n      niregex?: V | null;\n      search?: V | null;\n      between?: readonly V[] | null;\n      contains?: V | null;\n      overlaps?: V | null;\n      containedBy?: V | null;\n      pathExists?: string | null;\n      pathIsTrue?: string | null;\n    }\n  | { op: Operator; value: V | readonly V[] | undefined | null }\n  | V\n  | readonly V[]\n  | null;\n\nexport type BooleanGraphQLFilter = true | false | null;\n\nexport const operators = [\n  \"eq\",\n  \"gt\",\n  \"gte\",\n  \"ne\",\n  \"lt\",\n  \"lte\",\n  \"like\",\n  \"nlike\",\n  \"ilike\",\n  \"nilike\",\n  // Regular expression operators\n  \"regex\",\n  \"iregex\",\n  \"nregex\",\n  \"niregex\",\n  \"in\",\n  \"nin\",\n  \"between\",\n  \"contains\",\n  \"overlaps\",\n  \"containedBy\",\n  \"jsonPathExists\",\n  \"jsonPathPredicate\",\n] as const;\n\nexport type Operator = (typeof operators)[number];\n\nexport const opToFn: Record<Exclude<Operator, \"in\" | \"nin\" | \"between\">, string> = {\n  eq: \"=\",\n  gt: \">\",\n  gte: \">=\",\n  ne: \"!=\",\n  lt: \"<\",\n  lte: \"<=\",\n  like: \"LIKE\",\n  nlike: \"NOT LIKE\",\n  ilike: \"ILIKE\",\n  nilike: \"NOT ILIKE\",\n  // Regular expression operators\n  regex: \"~\",\n  iregex: \"~*\",\n  nregex: \"!~\",\n  niregex: \"!~*\",\n  // containsAll / hasAll\n  contains: \"@>\",\n  containedBy: \"<@\",\n  // containsSome / hasSome\n  overlaps: \"&&\",\n  jsonPathExists: \"@?\",\n  jsonPathPredicate: \"@@\",\n};\n\n/** A GraphQL version of EntityFilter. */\nexport type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;\n"],"mappings":";AAuDA,MAAa,YAAY;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAIA,MAAa,SAAsE;CACjF,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CAER,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CAET,UAAU;CACV,aAAa;CAEb,UAAU;CACV,gBAAgB;CAChB,mBAAmB;AACrB"}