joist-orm 1.50.5 → 1.51.0

package/build/src/EntityFilter.d.ts

@@ -0,0 +1,45 @@
+import { FilterOf, OrderOf } from "./EntityManager";
+/**
+ * Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings.
+ */
+export type FilterAndSettings<T> = {
+    where: FilterOf<T>;
+    orderBy?: OrderOf<T>;
+    limit?: number;
+    offset?: number;
+};
+export type OrderBy = "ASC" | "DESC";
+/**
+ * A filter for an entity of type `T`.
+ *
+ * @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.
+ */
+export type EntityFilter<T, I, F, N> = T | T[] | I | I[] | F | N | {
+    ne: T | I | N;
+};
+export type BooleanFilter<N> = true | false | N;
+export type ValueFilter<V, N> = V | V[] | N | {
+    eq: V | N;
+} | {
+    in: V[];
+} | {
+    gt: V;
+} | {
+    gte: V;
+} | {
+    ne: V | N;
+} | {
+    lt: V;
+} | {
+    lte: V;
+} | {
+    like: V;
+} | {
+    ilike: V;
+} | {
+    gte: V;
+    lte: V;
+};

package/build/src/EntityFilter.js

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

package/build/src/EntityFilter.js.map

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

package/build/src/EntityGraphQLFilter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This essentially matches the ValueFilter but with looser types to placate GraphQL.
+ */
+export type ValueGraphQLFilter<V> = {
+    eq?: V | null;
+    in?: V[] | null;
+    gt?: V | null;
+    gte?: V | null;
+    ne?: V | null;
+    lt?: V | null;
+    lte?: V | null;
+    like?: V | null;
+    ilike?: V | null;
+    between?: V[] | null;
+} | {
+    op: Operator;
+    value: Primitive;
+} | V | V[] | null;
+export type BooleanGraphQLFilter = true | false | null;
+export type Primitive = string | boolean | Date | number;
+export declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "ilike", "in", "between"];
+export type Operator = typeof operators[number];
+export declare const opToFn: Record<Exclude<Operator, "in" | "between">, string>;
+export type EnumGraphQLFilter<V> = V[] | null | undefined;
+/** A GraphQL version of EntityFilter. */
+export type EntityGraphQLFilter<T, I, F, N> = T | I | I[] | F | {
+    ne: T | I | N;
+} | null | undefined;

package/build/src/EntityGraphQLFilter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opToFn = exports.operators = void 0;
+exports.operators = ["eq", "gt", "gte", "ne", "lt", "lte", "like", "ilike", "in", "between"];
+exports.opToFn = {
+    eq: "=",
+    gt: ">",
+    gte: ">=",
+    ne: "!=",
+    lt: "<",
+    lte: "<=",
+    like: "LIKE",
+    ilike: "ILIKE",
+};
+//# sourceMappingURL=EntityGraphQLFilter.js.map

package/build/src/EntityGraphQLFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityGraphQLFilter.js","sourceRoot":"","sources":["../../src/EntityGraphQLFilter.ts"],"names":[],"mappings":";;;AAyBa,QAAA,SAAS,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,CAAU,CAAC;AAI9F,QAAA,MAAM,GAAwD;IACzE,EAAE,EAAE,GAAG;IACP,EAAE,EAAE,GAAG;IACP,GAAG,EAAE,IAAI;IACT,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,GAAG;IACP,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;CACf,CAAC"}

package/build/src/QueryBuilder.d.ts

@@ -1,118 +1,7 @@
 import { Knex } from "knex";
 import { Entity } from "./Entity";
-import { EntityConstructor, FilterOf, OrderOf } from "./EntityManager";
-import { EntityMetadata } from "./EntityMetadata";
-export type OrderBy = "ASC" | "DESC";
-export type BooleanFilter<N> = true | false | N;
-export type ValueFilter<V, N> = V | V[] | N | {
-    eq: V | N;
-} | {
-    in: V[];
-} | {
-    gt: V;
-} | {
-    gte: V;
-} | {
-    ne: V | N;
-} | {
-    lt: V;
-} | {
-    lte: V;
-} | {
-    like: V;
-} | {
-    ilike: V;
-} | {
-    gte: V;
-    lte: V;
-};
-/**
- * An ADT version of `ValueFilter`.
- *
- * The ValueFilter is a
- */
-export type ParsedValueFilter<V> = {
-    kind: "eq";
-    value: V | null;
-} | {
-    kind: "in";
-    value: V[];
-} | {
-    kind: "gt";
-    value: V;
-} | {
-    kind: "gte";
-    value: V;
-} | {
-    kind: "ne";
-    value: V | null;
-} | {
-    kind: "lt";
-    value: V;
-} | {
-    kind: "lte";
-    value: V;
-} | {
-    kind: "like";
-    value: V;
-} | {
-    kind: "ilike";
-    value: V;
-} | {
-    kind: "pass";
-} | {
-    kind: "between";
-    value: [V, V];
-};
-export declare function parseValueFilter<V>(filter: ValueFilter<V, any>): ParsedValueFilter<V>;
-export type EntityFilter<T, I, F, N> = T | T[] | I | I[] | F | N | {
-    ne: T | I | N;
-};
-export type ParsedEntityFilter = {
-    kind: "eq";
-    id: number | null;
-} | {
-    kind: "ne";
-    id: number | null;
-} | {
-    kind: "in";
-    ids: number[];
-} | {
-    kind: "join";
-    subFilter: any;
-};
-export declare function parseEntityFilter(meta: EntityMetadata<any>, filter: any): ParsedEntityFilter;
-export type BooleanGraphQLFilter = true | false | null;
-export type Primitive = string | boolean | Date | number;
-/** This essentially matches the ValueFilter but with looser types to placate GraphQL. */
-export type ValueGraphQLFilter<V> = {
-    eq?: V | null;
-    in?: V[] | null;
-    gt?: V | null;
-    gte?: V | null;
-    ne?: V | null;
-    lt?: V | null;
-    lte?: V | null;
-    like?: V | null;
-    ilike?: V | null;
-    between?: V[] | null;
-} | {
-    op: Operator;
-    value: Primitive;
-} | V | V[] | null;
-export type EnumGraphQLFilter<V> = V[] | null | undefined;
-/** A GraphQL version of EntityFilter. */
-export type EntityGraphQLFilter<T, I, F, N> = T | I | I[] | F | {
-    ne: T | I | N;
-} | null | undefined;
-declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "ilike", "in", "between"];
-export type Operator = typeof operators[number];
-export type FilterAndSettings<T> = {
-    where: FilterOf<T>;
-    orderBy?: OrderOf<T>;
-    limit?: number;
-    offset?: number;
-};
+import { FilterAndSettings } from "./EntityFilter";
+import { EntityConstructor } from "./EntityManager";
 /**
  * Builds the SQL/knex queries for `EntityManager.find` calls.
  *
@@ -122,4 +11,3 @@ export type FilterAndSettings<T> = {
  */
 export declare function buildQuery<T extends Entity>(knex: Knex, type: EntityConstructor<T>, filter: FilterAndSettings<T>): Knex.QueryBuilder<{}, unknown[]>;
 export declare function abbreviation(tableName: string): string;
-export {};

package/build/src/QueryBuilder.js

@@ -1,111 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.abbreviation = exports.buildQuery = exports.parseEntityFilter = exports.parseValueFilter = void 0;
-const joist_utils_1 = require("joist-utils");
-const Entity_1 = require("./Entity");
+exports.abbreviation = exports.buildQuery = void 0;
+const EntityGraphQLFilter_1 = require("./EntityGraphQLFilter");
 const EntityManager_1 = require("./EntityManager");
 const EntityMetadata_1 = require("./EntityMetadata");
 const index_1 = require("./index");
-const keys_1 = require("./keys");
 const utils_1 = require("./utils");
-function parseValueFilter(filter) {
-    if (filter === null) {
-        return { kind: "eq", value: filter };
-    }
-    else if (filter === undefined) {
-        return { kind: "pass" };
-    }
-    else if (Array.isArray(filter)) {
-        return { kind: "in", value: filter };
-    }
-    else if (typeof filter === "object") {
-        const keys = Object.keys(filter);
-        if (keys.length === 0) {
-            return { kind: "pass" };
-        }
-        else if (keys.length === 1) {
-            const key = keys[0];
-            switch (key) {
-                case "eq":
-                    return { kind: "eq", value: filter[key] ?? null };
-                case "ne":
-                    return { kind: "ne", value: filter[key] ?? null };
-                case "in":
-                    return { kind: "in", value: filter[key] };
-                case "gt":
-                case "gte":
-                case "lt":
-                case "lte":
-                case "like":
-                case "ilike":
-                    return { kind: key, value: filter[key] };
-            }
-        }
-        else if (keys.length === 2 && "op" in filter && "value" in filter) {
-            // Probe for `findGql` op & value
-            const { op, value } = filter;
-            return { kind: op, value: value ?? null };
-        }
-        else if (keys.length === 2 && "gte" in filter && "lte" in filter) {
-            const { gte, lte } = filter;
-            return { kind: "between", value: [gte, lte] };
-        }
-        throw new Error("unsupported value filter");
-    }
-    else {
-        // This is a primitive like a string, number
-        return { kind: "eq", value: filter ?? null };
-    }
-}
-exports.parseValueFilter = parseValueFilter;
-function parseEntityFilter(meta, filter) {
-    if (filter === null || filter === undefined) {
-        return { kind: "eq", id: null };
-    }
-    else if (typeof filter === "string" || typeof filter === "number") {
-        return { kind: "eq", id: (0, keys_1.keyToNumber)(meta, filter) };
-    }
-    else if (Array.isArray(filter)) {
-        return { kind: "in", ids: filter.map((id) => (0, keys_1.keyToNumber)(meta, id)) };
-    }
-    else if ((0, Entity_1.isEntity)(filter)) {
-        return { kind: "eq", id: (0, keys_1.keyToNumber)(meta, filter.id || -1) };
-    }
-    else if (typeof filter === "object") {
-        const keys = Object.keys(filter);
-        if (keys.length === 1 && keys[0] === "ne") {
-            const value = filter["ne"];
-            if (value === null || value === undefined) {
-                return { kind: "ne", id: null };
-            }
-            else if (typeof value === "string" || typeof value === "number") {
-                return { kind: "ne", id: (0, keys_1.keyToNumber)(meta, value) };
-            }
-            else if ((0, Entity_1.isEntity)(value)) {
-                return { kind: "ne", id: (0, keys_1.keyToNumber)(meta, value.id || -1) };
-            }
-            else {
-                throw new Error(`Unsupported "ne" value ${value}`);
-            }
-        }
-        return { kind: "join", subFilter: filter };
-    }
-    else {
-        throw new Error(`Unrecognized filter ${filter}`);
-    }
-}
-exports.parseEntityFilter = parseEntityFilter;
-const operators = ["eq", "gt", "gte", "ne", "lt", "lte", "like", "ilike", "in", "between"];
-const opToFn = {
-    eq: "=",
-    gt: ">",
-    gte: ">=",
-    ne: "!=",
-    lt: "<",
-    lte: "<=",
-    like: "LIKE",
-    ilike: "ILIKE",
-};
 /**
  * Builds the SQL/knex queries for `EntityManager.find` calls.
  *
@@ -116,115 +16,36 @@ const opToFn = {
 function buildQuery(knex, type, filter) {
     const meta = (0, EntityMetadata_1.getMetadata)(type);
     const { where, orderBy, limit, offset } = filter;
-    const aliases = {};
-    function getAlias(tableName) {
-        const abbrev = abbreviation(tableName);
-        const i = aliases[abbrev] || 0;
-        aliases[abbrev] = i + 1;
-        return i === 0 ? abbrev : `${abbrev}${i}`;
-    }
-    const alias = getAlias(meta.tableName);
-    let query = knex.select(`${alias}.*`).from(`${meta.tableName} AS ${alias}`);
-    // Define a function for recursively adding joins & filters
-    function addClauses(meta, alias, where, orderBy) {
-        // Combine the where and orderBy keys so that we can add them to aliases as that same time
-        // Filter out undefined values as they should be ignored (for now?)
-        const keys = [
-            ...(where ? Object.keys(where).filter((key) => where[key] !== undefined) : []),
-            ...(orderBy ? Object.keys(orderBy).filter((key) => orderBy[key] !== undefined) : []),
-        ];
-        keys.forEach((key) => {
-            const field = meta.allFields[key] ?? (0, utils_1.fail)(`${key} not found`);
-            // We may/may not have a where clause or orderBy for this key, but we should have at least one of them.
-            const clause = where && where[key];
-            const hasClause = where && key in where;
-            const order = orderBy && orderBy[key];
-            const hasOrder = !!order;
-            if (field.kind === "poly") {
-                if (Array.isArray(clause)) {
-                    const ids = clause.map((e) => (0, index_1.maybeResolveReferenceToId)(e));
-                    const idsByConstructor = (0, joist_utils_1.groupBy)(ids, (id) => (0, index_1.getConstructorFromTaggedId)(id).name);
-                    query = query.where((query) => field.serde.columns.reduce((query, { columnName, otherMetadata, mapToDb }) => {
-                        const ids = idsByConstructor[otherMetadata().cstr.name];
-                        return ids && ids.length > 0 ? query.orWhereIn(`${alias}.${columnName}`, ids.map(mapToDb)) : query;
-                    }, query));
-                }
-                else if ((0, Entity_1.isEntity)(clause) || typeof clause === "string") {
-                    query = addPolyClause(query, alias, field, meta, clause);
-                }
-                else if (clause === null) {
-                    query = field.components.reduce((query, component) => addPolyClause(query, alias, field, meta, 
-                    // Not really sure if this is safe, being lazy for now...
-                    (0, index_1.asConcreteCstr)(component.otherMetadata().cstr), clause), query);
-                }
-                else if (typeof clause === "object" && Object.keys(clause).length === 1 && "ne" in clause) {
-                    const { ne: value } = clause;
-                    if ((0, Entity_1.isEntity)(value) || typeof value === "string") {
-                        const column = polyColumnFor(meta, field, value);
-                        query = query.where((query) => query
-                            .whereNot(`${alias}.${column.columnName}`, column.mapToDb(value))
-                            // for some reason whereNot excludes null values, so explicitly include them here
-                            .orWhereNull(`${alias}.${column.columnName}`));
-                    }
-                    else if (value === null) {
-                        query = query.where((b) => field.components.reduce((b, { columnName }) => b.orWhereNotNull(`${alias}.${columnName}`), b));
-                    }
-                }
-            }
-            else if (field.kind === "o2o") {
-                // Add `otherTable.column = ...` clause, unless `key` is not in `where`, i.e. there is only an orderBy for this fk
-                const otherMeta = field.otherMetadata();
-                const otherAlias = getAlias(otherMeta.tableName);
-                const otherColumn = otherMeta.fields[field.otherFieldName];
-                query = query.leftJoin(`${otherMeta.tableName} AS ${otherAlias}`, `${otherAlias}.${otherColumn.serde.columns[0].columnName}`, `${alias}.id`);
-                const [shouldAddClauses, _query] = hasClause
-                    ? addForeignKeyClause(query, otherAlias, otherMeta.fields["id"].serde.columns[0], clause)
-                    : [false, query];
-                query = _query;
-                if (shouldAddClauses || hasOrder) {
-                    addClauses(otherMeta, otherAlias, shouldAddClauses ? clause : undefined, hasOrder ? order : undefined);
-                }
-            }
-            else if (field.kind === "m2o") {
-                const serde = (meta.fields[key] ?? (0, utils_1.fail)(`${key} not found`)).serde;
-                // TODO Currently hardcoded to single-column support; poly is handled above this
-                const column = serde.columns[0];
-                // Add `otherTable.column = ...` clause, unless `key` is not in `where`, i.e. there is only an orderBy for this fk
-                const [whereNeedsJoin, _query] = hasClause ? addForeignKeyClause(query, alias, column, clause) : [false, query];
-                query = _query;
-                if (whereNeedsJoin || hasOrder) {
-                    // Add a join for this column
-                    const otherMeta = field.otherMetadata();
-                    const otherAlias = getAlias(otherMeta.tableName);
-                    query = query.innerJoin(`${otherMeta.tableName} AS ${otherAlias}`, `${alias}.${column.columnName}`, `${otherAlias}.id`);
-                    // Then recurse to add its conditions to the query
-                    addClauses(otherMeta, otherAlias, whereNeedsJoin ? clause : undefined, hasOrder ? order : undefined);
-                }
-            }
-            else {
-                const field = meta.allFields[key] ?? (0, utils_1.fail)(`${key} not found`);
-                const serde = field.serde;
-                // TODO Currently hardcoded to single-column support; poly is handled above this
-                const column = serde.columns[0];
-                // TODO Currently we only support base-type WHEREs if the sub-type is the main `em.find`
-                // const maybeBaseAlias = field.alias;
-                query = hasClause ? addPrimitiveClause(query, alias, column, clause) : query;
-                // This is not a foreign key column, so it'll have the primitive filters/order bys
-                if (order) {
-                    query = query.orderBy(`${alias}.${column.columnName}`, order);
-                }
-            }
+    const parsed = (0, index_1.parseFindQuery)(meta, filter.where, filter.orderBy);
+    const primary = parsed.tables.find((t) => t.join === "primary");
+    let query = knex.from(`${primary.table} AS ${primary.alias}`);
+    parsed.selects.forEach((s) => {
+        query.select(knex.raw(s));
+    });
+    parsed.tables.forEach((t) => {
+        if (t.join === "left") {
+            query.leftOuterJoin(`${t.table} AS ${t.alias}`, t.col1, t.col2);
+        }
+        else if (t.join !== "primary") {
+            query.join(`${t.table} AS ${t.alias}`, t.col1, t.col2);
+        }
+    });
+    parsed.conditions.forEach((c) => {
+        addColumnCondition(query, c);
+    });
+    parsed.complexConditions &&
+        parsed.complexConditions.forEach((c) => {
+            addComplexCondition(query, c);
+        });
+    parsed.orderBys &&
+        parsed.orderBys.forEach(({ alias, column, order }) => {
+            query.orderBy(`${alias}.${column}`, order);
         });
-    }
-    addClauses(meta, alias, where, orderBy);
-    if ((0, index_1.needsClassPerTableJoins)(meta)) {
-        (0, index_1.addTablePerClassJoinsAndClassTag)(knex, meta, query, alias);
-    }
     // Even if they already added orders, add id as the last one to get deterministic output
-    query = query.orderBy(`${alias}.id`);
-    query = query.limit(limit || EntityManager_1.entityLimit);
+    query.orderBy(`${primary.alias}.id`);
+    query.limit(limit || EntityManager_1.entityLimit);
     if (offset) {
-        query = query.offset(offset);
+        query.offset(offset);
     }
     return query;
 }
@@ -236,122 +57,55 @@ function abbreviation(tableName) {
         .join("");
 }
 exports.abbreviation = abbreviation;
-function polyColumnFor(meta, field, value) {
-    const cstr = typeof value === "function" ? value : (0, index_1.maybeGetConstructorFromReference)(value);
-    return (field.serde.columns.find((c) => c.otherMetadata().cstr === cstr) ??
-        (0, utils_1.fail)(`${cstr.name} cannot be used as a filter on ${field.fieldName}`));
-}
-function addPolyClause(query, alias, field, meta, value, clause) {
-    clause = clause === undefined ? value : clause;
-    const column = polyColumnFor(meta, field, value);
-    const [, result] = addForeignKeyClause(query, alias, column, clause);
-    return result;
-}
-function addForeignKeyClause(query, alias, column, clause) {
-    // I.e. this could be { authorFk: authorEntity | null | id | { ...recurse... } }
-    const clauseKeys = typeof clause === "object" && clause !== null
-        ? Object.keys(clause).filter((key) => clause[key] !== undefined)
-        : [];
-    if ((0, Entity_1.isEntity)(clause) || typeof clause === "string" || Array.isArray(clause)) {
-        // I.e. { authorFk: authorEntity | id | id[] }
-        if ((0, Entity_1.isEntity)(clause) && clause.id === undefined) {
-            // The user is filtering on an unsaved entity, which will just never have any rows, so throw in -1
-            return [false, query.where(`${alias}.${column.columnName}`, -1)];
-        }
-        else if (Array.isArray(clause)) {
-            return [
-                false,
-                query.whereIn(`${alias}.${column.columnName}`, clause.map((id) => column.mapToDb(id))),
-            ];
-        }
-        else {
-            return [false, query.where(`${alias}.${column.columnName}`, column.mapToDb(clause))];
-        }
-    }
-    else if (clause === null) {
-        // I.e. { authorFk: null | undefined }
-        return [false, query.whereNull(`${alias}.${column.columnName}`)];
-    }
-    else if (clauseKeys.length === 1 && clauseKeys[0] === "id") {
-        // I.e. { authorFk: { id: string } } || { authorFk: { id: string[] } }
-        // If only querying on the id, we can skip the join
-        return [false, addPrimitiveClause(query, alias, column, clause["id"])];
-    }
-    else if (clauseKeys.length === 1 && clauseKeys[0] === "ne") {
-        // I.e. { authorFk: { ne: string | null | undefined } }
-        const value = clause["ne"];
-        if (value === null || value === undefined) {
-            return [false, query.whereNotNull(`${alias}.${column.columnName}`)];
-        }
-        else if (typeof value === "string") {
-            return [false, query.whereNot(`${alias}.${column.columnName}`, column.mapToDb(value))];
-        }
-        else {
-            throw new Error("Not implemented");
-        }
-    }
-    else {
-        // I.e. { authorFk: { ...authorFilter... } }
-        return [clause !== undefined, query];
-    }
-}
-function addPrimitiveClause(query, alias, column, clause) {
-    if (clause && typeof clause === "object" && operators.find((op) => Object.keys(clause).includes(op))) {
-        // I.e. `{ primitiveField: { gt: value } }`
-        return Object.entries(clause).reduce((query, [op, value]) => addPrimitiveOperator(query, alias, column, op, value), query);
-    }
-    else if (clause && typeof clause === "object" && "op" in clause) {
-        // I.e. { primitiveField: { op: "gt", value: 1 } }`
-        return addPrimitiveOperator(query, alias, column, clause.op, clause.value);
-    }
-    else if (Array.isArray(clause)) {
-        // I.e. `{ primitiveField: value[] }`
-        if (column.isArray) {
-            return query.where(`${alias}.${column.columnName}`, "@>", column.mapToDb(clause));
-        }
-        else {
-            return query.whereIn(`${alias}.${column.columnName}`, clause.map((v) => column.mapToDb(v)));
-        }
-    }
-    else if (clause === null) {
-        // I.e. `{ primitiveField: null }`
-        return query.whereNull(`${alias}.${column.columnName}`);
-    }
-    else if (clause === undefined) {
-        // I.e. `{ primitiveField: undefined }`
-        // Currently we treat this like a partial filter, i.e. don't include it. Seems odd
-        // unless this is opt-in, i.e. maybe only do this for `findGql`?
-        return query;
-    }
-    else {
-        // I.e. `{ primitiveField: value }`
-        // TODO In theory could add a addToQuery method to Serde to generalize this to multi-columns fields.
-        return query.where(`${alias}.${column.columnName}`, column.mapToDb(clause));
-    }
+function addComplexCondition(query, complex) {
+    query.where((q) => {
+        const op = complex.op === "and" ? "andWhere" : "orWhere";
+        complex.conditions.forEach((c) => {
+            if ("op" in c) {
+                throw new Error("Not implemented");
+            }
+            else {
+                q[op]((q) => addColumnCondition(q, c));
+            }
+        });
+    });
 }
-function addPrimitiveOperator(query, alias, column, op, value) {
-    const columnName = `${alias}.${column.columnName}`;
-    if (value === null || value === undefined) {
-        if (op === "ne") {
-            return query.whereNotNull(columnName);
-        }
-        else if (op === "eq") {
-            return query.whereNull(columnName);
-        }
-        else {
-            throw new Error("Only ne is supported when the value is undefined or null");
-        }
-    }
-    else if (op === "in") {
-        return query.whereIn(columnName, value.map((v) => column.mapToDb(v)));
-    }
-    else if (op === "between") {
-        const values = value.map((v) => column.mapToDb(v));
-        return query.where(columnName, ">=", values[0]).where(columnName, "<=", values[1]);
-    }
-    else {
-        const fn = opToFn[op] ?? (0, utils_1.fail)(`Invalid operator ${op}`);
-        return query.where(columnName, fn, column.mapToDb(value));
+function addColumnCondition(query, cc) {
+    const { alias, column, cond } = cc;
+    const columnName = `${alias}.${column}`;
+    switch (cond.kind) {
+        case "eq":
+        case "ne":
+        case "gte":
+        case "gt":
+        case "lte":
+        case "lt":
+        case "like":
+        case "ilike":
+            const fn = EntityGraphQLFilter_1.opToFn[cond.kind] ?? (0, utils_1.fail)(`Invalid operator ${cond.kind}`);
+            query.where(columnName, fn, cond.value);
+            break;
+        case "is-null":
+            query.whereNull(columnName);
+            break;
+        case "not-null":
+            query.whereNotNull(columnName);
+            break;
+        case "in":
+            query.whereIn(columnName, cond.value);
+            break;
+        case "@>":
+            query.where(columnName, "@>", cond.value);
+            break;
+        case "between":
+            const [min, max] = cond.value;
+            query.where(columnName, ">=", min);
+            query.where(columnName, "<=", max);
+            break;
+        case "pass":
+            break;
+        default:
+            (0, utils_1.assertNever)(cond);
     }
 }
 //# sourceMappingURL=QueryBuilder.js.map