@dav3/gql-of-power 1.4.0 → 1.6.0

package/README.md

@@ -293,6 +293,68 @@ Returns `null` when the FK column is null (LEFT JOIN).
 
 ---
 
+## Three Ways to Define an Entity
+
+There are three APIs for registering a GQL entity. They differ in **when** the generated types (FilterInput, PaginationInput, FieldsResolver, etc.) are registered — that difference matters for filter-type resolution (see [Troubleshooting](#troubleshooting)).
+
+### Quick comparison
+
+| API                 | When to use                                                                                              | Calls `buildResolvers()`?                                    | FilterInput registered   |
+| ------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------ |
+| `@GQLEntityClass`   | **Default.** No circular imports between entity files.                                                   | ✅ Automatically (at decoration time)                        | ✅ Yes                   |
+| `createGQLTypes()`  | Same as `@GQLEntityClass` but as a function call (can't decorate a class, or prefer the explicit style). | ✅ Automatically (internally)                                | ✅ Yes                   |
+| `createGQLEntity()` | **Circular imports** between entity definitions — you need to defer resolver registration.               | ❌ **Deferred** — you must call `.buildResolvers()` yourself | ❌ No, until you call it |
+
+### `@GQLEntityClass` — the default (recommended)
+
+The decorator registers the entity **and** its FilterInput/FieldsResolver immediately at decoration time. All generated statics (`FilterInput`, `PaginationInput`, `FieldsResolver`) are available on the class.
+
+```typescript
+@GQLEntityClass(Book, bookFields)
+export class BookGQL extends GQLEntityBase {}
+// BookGQL.FilterInput is ready. Done.
+```
+
+### `createGQLTypes()` — function-call equivalent
+
+Same behaviour as the decorator — it calls `createGQLEntity().buildResolvers()` internally (see `gql-entity.ts:1221-1222`). Use it when you can't or don't want to decorate a class.
+
+```typescript
+export const BookGQL = createGQLTypes(Book, bookFields);
+// BookGQL.FilterInput is ready. Done.
+```
+
+### `createGQLEntity()` — for circular imports (advanced)
+
+Returns the entity definition **without** registering the FilterInput or FieldsResolver. You must call `.buildResolvers()` yourself before `buildSchema()` runs. This split exists so two entity files can reference each other's `GQLEntity` type thunks without a circular-import deadlock at module-load time.
+
+```typescript
+// book.entity.ts
+export const BookEntity = createGQLEntity(Book, bookFields);
+//   ↑ FilterInput NOT registered yet
+
+// author.entity.ts — can import BookEntity for the thunk even if Book imports Author
+export const AuthorEntity = createGQLEntity(Author, authorFields, {
+	customFields: {/* ... uses () => BookEntity.GQLEntity ... */},
+});
+
+// schema/index.ts — YOU must call buildResolvers() on EVERY entity
+export const BookGQL = BookEntity.buildResolvers(); // ← registers BookFilterInput
+export const AuthorGQL = AuthorEntity.buildResolvers(); // ← registers AuthorFilterInput
+```
+
+> ⚠️ **If you forget a `.buildResolvers()` call**, any filter that references that entity (relationship fields, mapping custom-field filters, `_exists` filters) will throw at schema-build time:
+>
+> ```
+> gql-of-power: FilterInput for referenced entity "Book" (BookFilterInput) is not registered.
+> Make sure Book's buildResolvers() is called (or use createGQLTypes / @GQLEntityClass)
+> before building the schema.
+> ```
+>
+> The error names the missing entity so you know exactly which file to fix.
+
+---
+
 ## Filtering
 
 Filter at any nesting level:
@@ -318,19 +380,32 @@ filter: {
 
 ### Filter operations
 
-| Operation      | Meaning                                                |
-| -------------- | ------------------------------------------------------ |
-| `_eq`          | Equal                                                  |
-| `_ne`          | Not equal                                              |
-| `_in`          | In array                                               |
-| `_nin`         | Not in array                                           |
-| `_like`        | ILIKE (case-insensitive contains)                      |
-| `_gt` / `_gte` | Greater than / greater than or equal                   |
-| `_lt` / `_lte` | Less than / less than or equal                         |
-| `_and`         | Logical AND                                            |
-| `_or`          | Logical OR (generates UNION ALL)                       |
-| `_exists`      | Check related entities exist (AND-combined per key)    |
-| `_not_exists`  | Check no related entities exist (AND-combined per key) |
+| Operation      | Meaning                                                 |
+| -------------- | ------------------------------------------------------- |
+| `_eq`          | Equal                                                   |
+| `_ne`          | Not equal                                               |
+| `_in`          | In array                                                |
+| `_nin`         | Not in array                                            |
+| `_like`        | LIKE (case-sensitive contains)                          |
+| `_nlike`       | NOT LIKE                                                |
+| `_ilike`       | ILIKE (case-insensitive contains)                       |
+| `_nilike`      | NOT ILIKE                                               |
+| `_startsWith`  | LIKE prefix (case-sensitive)                            |
+| `_istartsWith` | ILIKE prefix (case-insensitive)                         |
+| `_endsWith`    | LIKE suffix (case-sensitive)                            |
+| `_iendsWith`   | ILIKE suffix (case-insensitive)                         |
+| `_re`          | Regex match (`~`)                                       |
+| `_nre`         | Regex non-match (`!~`)                                  |
+| `_gt` / `_gte` | Greater than / greater than or equal                    |
+| `_lt` / `_lte` | Less than / less than or equal                          |
+| `_between`     | BETWEEN low AND high                                    |
+| `_nbetween`    | NOT BETWEEN low AND high                                |
+| `_is_null`     | IS NULL (true) / IS NOT NULL (false)                    |
+| `_and`         | Logical AND                                             |
+| `_or`          | Logical OR (generates UNION ALL)                        |
+| `_not`         | Negates a conjunction of conditions (NOT (...) wrapper) |
+| `_exists`      | Check related entities exist (AND-combined per key)     |
+| `_not_exists`  | Check no related entities exist (AND-combined per key)  |
 
 ### Existence Filters (`_exists` / `_not_exists`)
 
@@ -363,6 +438,28 @@ filter: {
 
 `_exists` generates `EXISTS (SELECT 1 FROM ... WHERE ...)` subqueries. `_not_exists` generates `NOT EXISTS (...)`. Multiple keys within one `_exists`/`_not_exists` each produce a separate `EXISTS`/`NOT EXISTS` clause, AND-combined in the WHERE. OR across exists conditions is achieved via `_or`.
 
+### Negation Filter (`_not`)
+
+Negate a set of conditions. `_not` takes an array of filter objects, AND-combines them, and wraps the result in `NOT (...)`.
+
+```graphql
+# Persons whose name is NOT "Sauron" AND race is NOT "Maiar"
+filter: {
+  _not: [
+    { name: "Sauron" }
+    { race: "Maiar" }
+  ]
+}
+
+# Combine _not with other filters
+filter: {
+  age_gt: 50
+  _not: [{ race: "Orc" }]
+}
+```
+
+Generates `NOT (cond1 AND cond2)` in the WHERE clause. For simple field-level negation, the negated operators (`_ne`, `_nin`) are more direct — `_not` is for negating compound expressions. Note: nesting `_or` inside `_not` is not fully negated (the UNION ALL path is not invertible); use De Morgan's law (`_and` of negated conditions) instead.
+
 ---
 
 ## Count Fields
@@ -560,9 +657,90 @@ No `limit` or `offset` parameters are accepted — `LIMIT 1` is always applied.
 
 ---
 
+## Troubleshooting
+
+### `FilterInput for referenced entity "X" is not registered`
+
+This error fires at `buildSchema()` time when a relationship field, mapping custom-field filter, or `_exists` filter references an entity whose FilterInput was never registered.
+
+**Cause:** You used `createGQLEntity()` (the deferred API) for entity `X` but forgot to call `X.buildResolvers()` before building the schema. The entity's ObjectType is registered, but its FilterInput is not.
+
+**Fix:** Either switch the entity to `@GQLEntityClass` / `createGQLTypes()` (which call `buildResolvers()` automatically), or add the missing call:
+
+```typescript
+// schema/index.ts — collect ALL entities and call buildResolvers()
+const BookGQL = BookEntity.buildResolvers();
+const AuthorGQL = AuthorEntity.buildResolvers();
+```
+
+Before August 2026 this was a **silent wrong-type bug**: the missing FilterInput fell back to the parent entity's FilterInput, so `Author.books` would generate `AuthorFilterInput` instead of `BookFilterInput`. The library now throws with the message above.
+
+### Mapping custom-field filter is missing from the schema
+
+If a `customFields` entry with `mapping` doesn't produce its nested filter (e.g. `HomeRegion: { name_eq: '...' }` is absent), check whether `resolve` was **also** set on the same field:
+
+```typescript
+customFields: {
+	homeRegion: {
+		type: () => RegionGQL.GQLEntity,
+		mapping: { refEntity: Region, refFields: 'id', fields: 'homeRegionId' },
+		generateFilter: true,
+		resolve: (root) => ...,  // ← THIS makes the filter silently disappear
+	},
+},
+```
+
+`resolve` and `mapping` are **mutually exclusive** on the same custom field. When both are set, only the resolver registers — the mapping filter is skipped. TypeScript's `CustomFieldSettings<T>` union enforces this at the type level, but `as any` bypasses it. Remove `resolve` (and `resolveDecorators`/`requires`) from a mapping-strategy field.
+
+### Filter key is PascalCase, not camelCase
+
+Mapping custom-field filters appear in the FilterInput under a **capitalized** key:
+
+```graphql
+# ✅ Correct — PascalCase filter key
+persons(filter: { HomeRegion: { name_eq: 'Gondor' } }) { ... }
+
+# ❌ Wrong — camelCase doesn't exist on the FilterInput
+persons(filter: { homeRegion: { name_eq: 'Gondor' } })
+# Field "homeRegion" is not defined by type "PersonFilterInput". Did you mean "HomeRegion"?
+```
+
+The field **selection** in the query stays camelCase (`homeRegion { ... }`); only the filter key is capitalized. Count-field nested filters follow the same rule (`BookCount: { _gte: 2 }`).
+
+### Relationship-field filters aren't statically typed
+
+`GQLEntityFilterInputFieldType<T>` surfaces filter operators for scalar fields but does **not** statically include nested relationship sub-filters (they're generated at runtime). Cast the filter object `as any` when using relationship filters:
+
+```typescript
+queryManager.getQueryResultsForInfo(provider, PersonGQL, info, {
+	fellowship: { id_in: [1, 2] }, // works at runtime, not statically typed
+} as any);
+```
+
+This is the library's own test-suite pattern.
+
+### `mapNumericEnum` filter values silently fail inside nested/inline filters
+
+If a `mapNumericEnum` field filters correctly at the **top level** but silently returns no results (or the wrong rows) when placed inside an inline field-argument filter on a nested relation — e.g.:
+
+```graphql
+# Works: top-level filter → 'InProgress' converted to 1
+bearers(filter: { questState: InProgress }) { name }
+
+# Silently failed before August 2026: inline filter → 'InProgress' passed as a string
+rings { bearer(filter: { questState: InProgress }) { name } }
+```
+
+**Cause:** enum conversion (`convertFilterEnumValues`) was historically applied only to top-level filters in `GQLQueryManager`. Inline field-argument filters (`books(filter: {...})`), count-field filters (`bookCount(filter: {...})`), and multi-level nested filters entered the SQL mapper through a different code path that bypassed conversion entirely. The `mapNumericEnum` string key went straight to SQL as a string instead of being converted to the numeric DB value, so the `WHERE` clause silently matched nothing.
+
+**Fix (August 2026):** `handleFieldArguments` and `mapCountField` in the SQL mapper now call `convertFilterEnumValues` on inline filter args before SQL generation. The conversion resolves the target entity's `mapNumericEnum` fields through the parent entity's relation-field registry and recurses to arbitrary depth. This means filters now behave identically at the top level, inside `relation(filter:)`, inside nested `relation(filter: { nested: {...} })`, inside count subqueries, and inside `_or`/`_and` arrays at any level.
+
+**If you still see this pattern:** ensure the target entity is decorator-registered (`@GQLEntityClass` / `createGQLTypes`) so its `mapNumericEnum` fields appear in the `MapEnumFieldsMap` registry — conversion silently passes values through for unregistered entities.
+
+---
+
 ## Known Limitations
 
-- ⚠️ Class-level `_not` conditions not yet supported
 - ⚠️ Order by columns on related/joined tables not supported
 - ⚠️ ACL pending async refactoring
 

package/dist/entities/gql-entity.d.ts

@@ -29,6 +29,8 @@ export declare const clearMapEnumFields: () => void;
 export declare const getParseJsonFieldsFor: (name: string) => Set<string>;
 export declare const registerParseJsonField: (gqlEntityName: string, fieldName: string) => void;
 export declare const clearParseJsonFields: () => void;
+export declare const getRelationFieldsFor: (name: string) => Record<string, () => string>;
+export declare const clearRelationFields: () => void;
 export declare const getACLFor: (name: string) => AccessControlEntry<any, any>;
 export declare const getGQLEntityNameFor: (name: string) => string;
 export declare const getGQLEntityNameForClass: <T>(classType: new () => T) => string;

package/dist/entities/gql-entity.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGQLEntityFields = exports.GQLEntityBase = exports.getGQLEntityTypeFor = exports.getGQLEntityFieldResolverNameFor = exports.getGQLEntityFieldResolverName = exports.getGQLEntityNameForClass = exports.getGQLEntityNameFor = exports.getACLFor = exports.clearParseJsonFields = exports.registerParseJsonField = exports.getParseJsonFieldsFor = exports.clearMapEnumFields = exports.getMapEnumFieldsFor = exports.clearCountFields = exports.registerCountField = exports.getCountFieldsFor = exports.getCustomFieldsFor = exports.getFieldByAlias = exports.getFieldsOptionsFor = exports.setGlobalConfig = void 0;
+exports.createGQLEntityFields = exports.GQLEntityBase = exports.getGQLEntityTypeFor = exports.getGQLEntityFieldResolverNameFor = exports.getGQLEntityFieldResolverName = exports.getGQLEntityNameForClass = exports.getGQLEntityNameFor = exports.getACLFor = exports.clearRelationFields = exports.getRelationFieldsFor = exports.clearParseJsonFields = exports.registerParseJsonField = exports.getParseJsonFieldsFor = exports.clearMapEnumFields = exports.getMapEnumFieldsFor = exports.clearCountFields = exports.registerCountField = exports.getCountFieldsFor = exports.getCustomFieldsFor = exports.getFieldByAlias = exports.getFieldsOptionsFor = exports.setGlobalConfig = void 0;
 exports.getAutoResolvers = getAutoResolvers;
 exports.defineFields = defineFields;
 exports.GQLEntityClass = GQLEntityClass;
@@ -24,6 +24,14 @@ const CustomFieldsMap = {};
 const CountFieldsMap = {};
 const MapEnumFieldsMap = {};
 const ParseJsonFieldsMap = {};
+/**
+ * Relation fields declared via the plain `defineFields` pattern (not via
+ * `customFields`/`mapping`). Keyed by gqlEntityName → field name → target
+ * entity's ORM name (the raw string returned by `relatedEntityName()`). Used by
+ * `convertFilterEnumValues` to recurse into nested relation filters and apply
+ * the target entity's mapNumericEnum conversions.
+ */
+const RelationFieldsMap = {};
 const aclMap = {};
 /**
  * Shared field-metadata registration used by both the @GQLEntityClass decorator
@@ -167,6 +175,14 @@ const clearParseJsonFields = () => {
     }
 };
 exports.clearParseJsonFields = clearParseJsonFields;
+const getRelationFieldsFor = (name) => RelationFieldsMap[name] ?? {};
+exports.getRelationFieldsFor = getRelationFieldsFor;
+const clearRelationFields = () => {
+    for (const key of Object.keys(RelationFieldsMap)) {
+        delete RelationFieldsMap[key];
+    }
+};
+exports.clearRelationFields = clearRelationFields;
 const getACLFor = (name) => aclMap[name] ?? {};
 exports.getACLFor = getACLFor;
 const getGQLEntityNameFor = (name) => `${name}${gqlTypesSuffix || process.env['D3GOP_TYPES_SUFFIX'] || ''}`;
@@ -436,45 +452,6 @@ function _buildInputType(gqlEntityName, fields, opts, metadata, customFields) {
     return GQLEntityInput;
 }
 // ─── Shared resolver builder ─────────────────────────────────────────────────
-/** Phase 2: attach @FieldResolver methods for fields with `mapNumericEnum` (reverse-maps DB number → enum string). */
-function _registerMapNumericEnumResolvers(rawFields, FieldsResolver) {
-    for (const fieldName of Object.keys(rawFields)) {
-        const fieldOpts = rawFields[fieldName];
-        if (!fieldOpts?.mapNumericEnum)
-            continue;
-        const fieldNameToUse = fieldOpts.alias ?? fieldName;
-        const enumTypeThunk = fieldOpts.type;
-        const resolveFn = (root) => {
-            const value = root[fieldNameToUse];
-            if (value === null || value === undefined)
-                return null;
-            try {
-                const enumObj = enumTypeThunk();
-                const key = enumObj[value];
-                if (typeof key === 'string')
-                    return key;
-                for (const enumKey of Object.keys(enumObj)) {
-                    if (enumObj[enumKey] === value)
-                        return enumKey;
-                }
-                return value;
-            }
-            catch {
-                return value;
-            }
-        };
-        Object.defineProperty(FieldsResolver.prototype, fieldNameToUse, {
-            value: resolveFn,
-            writable: true,
-            configurable: true,
-        });
-        (0, type_graphql_1.FieldResolver)(enumTypeThunk, {
-            ...fieldOpts.options,
-            name: fieldNameToUse,
-        })(FieldsResolver.prototype, fieldNameToUse, Object.getOwnPropertyDescriptor(FieldsResolver.prototype, fieldNameToUse));
-        (0, type_graphql_1.Root)()(FieldsResolver.prototype, fieldNameToUse, 0);
-    }
-}
 /** Phase 3: process custom fields — alias registration, metadata, resolve/mapping/requiresRelations strategies. */
 function _processCustomFields(customFields, gqlEntityName, GQLEntity, GQLEntityFilterInput, FieldsResolver, opts, metadata) {
     CustomFieldsMap[gqlEntityName] = customFields;
@@ -597,7 +574,15 @@ function _registerMappingFieldFilter(fieldNameToUse, fieldOptions, GQLEntityFilt
         target: GQLEntityFilterInput,
         name: UppercasedFieldName,
         schemaName: UppercasedFieldName,
-        getType: () => TypeMap[refFilterTypeName] ?? GQLEntityFilterInput,
+        getType: () => {
+            const type = TypeMap[refFilterTypeName];
+            if (!type) {
+                throw new Error(`gql-of-power: FilterInput for referenced entity "${refGqlEntityName}" (${refFilterTypeName}) ` +
+                    `is not registered. Make sure ${refGqlEntityName}'s buildResolvers() is called ` +
+                    `(or use createGQLTypes / @GQLEntityClass) before building the schema.`);
+            }
+            return type;
+        },
         typeOptions: { nullable: true },
         complexity: undefined,
         description: `Filter by ${fieldNameToUse} fields`,
@@ -788,7 +773,15 @@ function _registerExistsFilters(gqlEntityName, fields, opts, metadata, GQLEntity
                 target: GQLEntityExistsFilterInput,
                 name: relFieldName,
                 schemaName: relFieldName,
-                getType: () => TypeMap[relFilterTypeName] ?? GQLEntityFilterInput,
+                getType: () => {
+                    const type = TypeMap[relFilterTypeName];
+                    if (!type) {
+                        throw new Error(`gql-of-power: FilterInput for related entity "${relGQLEntityName}" (${relFilterTypeName}) ` +
+                            `is not registered. Make sure ${relGQLEntityName}'s buildResolvers() is called ` +
+                            `(or use createGQLTypes / @GQLEntityClass) before building the schema.`);
+                    }
+                    return type;
+                },
                 typeOptions: { nullable: true },
                 complexity: undefined,
                 description: `Filter ${relFieldName} by their fields for existence check`,
@@ -850,10 +843,7 @@ function _buildResolversForEntity(GQLEntity, gqlEntityName, fields, opts, metada
     FieldsResolver = __decorate([
         (0, type_graphql_1.Resolver)(() => GQLEntity)
     ], FieldsResolver);
-    // ─── Phases 2-6: delegate to focused helpers ────────────────────────────
-    if (rawFields) {
-        _registerMapNumericEnumResolvers(rawFields, FieldsResolver);
-    }
+    // ─── Phases 3-6: delegate to focused helpers ────────────────────────────
     if (customFields) {
         _processCustomFields(customFields, gqlEntityName, GQLEntity, GQLEntityFilterInput, FieldsResolver, opts, metadata);
     }
@@ -1003,6 +993,16 @@ function createGQLEntityFilters(fieldOptions, fieldName, GQLEntity, metadata, GQ
             deprecationReason: undefined,
         };
         metadata.collectClassFieldMetadata(fieldFilter);
+        // Register relation fields for nested-filter enum conversion. The nested
+        // FilterInput is exposed under both the camelCased fieldName (above) and the
+        // UppercasedFieldName — record both so convertFilterEnumValues can resolve
+        // whichever key the caller uses.
+        if ('relatedEntityName' in fieldOptions && fieldOptions.relatedEntityName) {
+            RelationFieldsMap[gqlEntityName] = RelationFieldsMap[gqlEntityName] || {};
+            const relThunk = fieldOptions.relatedEntityName;
+            RelationFieldsMap[gqlEntityName][fieldName] = relThunk;
+            RelationFieldsMap[gqlEntityName][UppercasedFieldName] = relThunk;
+        }
         if ('array' in fieldOptions && 'relatedEntityName' in fieldOptions) {
             const relatedEntityName = (0, exports.getGQLEntityNameFor)(fieldOptions.relatedEntityName());
             metadata.collectHandlerParamMetadata({

package/dist/field-operations.d.ts

@@ -19,13 +19,22 @@ export declare abstract class FieldOperationsClass<T> {
     abstract _lt: T;
     abstract _lte: T;
     abstract _like: T;
-    abstract _re: T;
+    abstract _nlike: T;
     abstract _ilike: T;
+    abstract _nilike: T;
+    abstract _startsWith: T;
+    abstract _istartsWith: T;
+    abstract _endsWith: T;
+    abstract _iendsWith: T;
+    abstract _re: T;
+    abstract _nre: T;
     abstract _fulltext: T;
     abstract _overlap: T[];
     abstract _contains: T;
     abstract _contained: T;
     abstract _between: T[];
+    abstract _nbetween: T[];
+    abstract _is_null: T;
     abstract _exists: T;
 }
 type Scalar = string | number | boolean | bigint | null;
@@ -69,7 +78,7 @@ export declare const FieldOperations: {
         where: string;
         value: undefined;
     };
-    _re: ([l, r]: string[], []: Scalar[]) => {
+    _nlike: ([l, r]: string[], []: Scalar[]) => {
         where: string;
         value: undefined;
     };
@@ -77,6 +86,34 @@ export declare const FieldOperations: {
         where: string;
         value: undefined;
     };
+    _nilike: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _startsWith: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _istartsWith: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _endsWith: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _iendsWith: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _re: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _nre: ([l, r]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
     _fulltext: ([l, r]: string[], []: Scalar[]) => {
         where: string;
         value: undefined;
@@ -93,6 +130,14 @@ export declare const FieldOperations: {
         where: string;
         value: undefined;
     };
+    _nbetween: ([l, r1, r2]: string[], []: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
+    _is_null: ([l]: string[], [_l, rv]: Scalar[]) => {
+        where: string;
+        value: undefined;
+    };
     _exists: ([l]: string[], []: Scalar[]) => {
         where: string;
         value: undefined;

package/dist/field-operations.js

@@ -64,14 +64,42 @@ exports.FieldOperations = {
         where: `${l} like ${r}`,
         value: undefined,
     }),
-    _re: ([l, r], []) => ({
-        where: `${l} ~ ${r}`,
+    _nlike: ([l, r], []) => ({
+        where: `${l} not like ${r}`,
         value: undefined,
     }),
     _ilike: ([l, r], []) => ({
         where: `${l} ilike ${r}`,
         value: undefined,
     }),
+    _nilike: ([l, r], []) => ({
+        where: `${l} not ilike ${r}`,
+        value: undefined,
+    }),
+    _startsWith: ([l, r], []) => ({
+        where: `${l} like ${r} || '%'`,
+        value: undefined,
+    }),
+    _istartsWith: ([l, r], []) => ({
+        where: `${l} ilike ${r} || '%'`,
+        value: undefined,
+    }),
+    _endsWith: ([l, r], []) => ({
+        where: `${l} like '%' || ${r}`,
+        value: undefined,
+    }),
+    _iendsWith: ([l, r], []) => ({
+        where: `${l} ilike '%' || ${r}`,
+        value: undefined,
+    }),
+    _re: ([l, r], []) => ({
+        where: `${l} ~ ${r}`,
+        value: undefined,
+    }),
+    _nre: ([l, r], []) => ({
+        where: `${l} !~ ${r}`,
+        value: undefined,
+    }),
     _fulltext: ([l, r], []) => ({
         where: `${l}::tsvector @@ ${r}::tsquery`,
         value: undefined,
@@ -88,6 +116,14 @@ exports.FieldOperations = {
         where: `${l} between ${r1} and ${r2}`,
         value: undefined,
     }),
+    _nbetween: ([l, r1, r2], []) => ({
+        where: `${l} not between ${r1} and ${r2}`,
+        value: undefined,
+    }),
+    _is_null: ([l], [_l, rv]) => ({
+        where: rv ? `${l} is null` : `${l} is not null`,
+        value: undefined,
+    }),
     _exists: ([l], []) => ({
         where: `exists ${l}`,
         value: undefined,

package/dist/queries/enum-filter-converter.d.ts

@@ -0,0 +1,29 @@
+export declare function toDbValue(value: any, enumObj: any, isArray: boolean): any;
+export declare function findEnumFieldName(key: string, enumFields: Record<string, any>): string | null;
+/** Convert an operator-keyed object (e.g. { _eq: 'X', _in: [...] }) whose target is an enum field. */
+export declare function convertOperatorObject(operatorObject: Record<string, any>, enumObj: any): Record<string, any>;
+/** Recurse into a mapped custom-field nested filter using the referenced entity's enums. */
+export declare function convertMappedCustomField(key: string, value: any, mappedCustomFields: Record<string, {
+    mapping: {
+        refEntity: new () => any;
+    };
+}>): any;
+/**
+ * Recurse into a plain-`defineFields` relation nested filter using the target
+ * entity's enums. The relation field is looked up in `RelationFieldsMap`
+ * (registered by `createGQLEntityFilters`), which stores the target entity's
+ * ORM name thunk. Falls back to returning the value untouched if the key isn't
+ * a known relation field.
+ */
+export declare function convertRelationField(key: string, value: any, relationFields: Record<string, () => string>): any;
+export declare function convertFilterEnumValues(filter: any, enumFields: Record<string, any>, mappedCustomFields?: Record<string, {
+    mapping: {
+        refEntity: new () => any;
+    };
+}>, relationFields?: Record<string, () => string>): any;
+/** Resolve a single filter key/value to its enum-converted form. */
+export declare function convertFilterEntry(key: string, value: any, enumFields: Record<string, any>, mappedCustomFields?: Record<string, {
+    mapping: {
+        refEntity: new () => any;
+    };
+}>, relationFields?: Record<string, () => string>): any;