@loomcore/api 0.2.69 → 0.2.70

package/dist/databases/models/classified-filter-key.d.ts

@@ -0,0 +1,8 @@
+export type ClassifiedFilterKey = {
+    type: 'root';
+} | {
+    type: 'join';
+    aliases: string[];
+    column: string;
+    crossesMany: boolean;
+};

package/dist/databases/models/classified-filter-key.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/models/index.d.ts

@@ -1,5 +1,7 @@
+export * from './classified-filter-key.js';
 export * from './constants.js';
 export * from './database.interface.js';
 export * from './database.js';
 export * from './delete-result.js';
 export * from './update-result.js';
+export * from './join-filter.interface.js';

package/dist/databases/models/index.js

@@ -1,5 +1,7 @@
+export * from './classified-filter-key.js';
 export * from './constants.js';
 export * from './database.interface.js';
 export * from './database.js';
 export * from './delete-result.js';
 export * from './update-result.js';
+export * from './join-filter.interface.js';

package/dist/databases/models/join-filter.interface.d.ts

@@ -0,0 +1,8 @@
+import type { Filter } from '@loomcore/common/models';
+export interface JoinFilter {
+    key: string;
+    filter: Filter;
+    aliases: string[];
+    column: string;
+    crossesMany: boolean;
+}

package/dist/databases/models/join-filter.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/mongo-db/queries/mongo-get-by-id.query.js

@@ -1,6 +1,8 @@
 import { entityUtils } from '@loomcore/common/utils';
 import { BadRequestError } from '../../../errors/index.js';
+import { splitFiltersByType } from '../../utils/resolve-join-filter.js';
 import NoSqlPipeline from '../models/no-sql-pipeline.js';
+import { buildJoinMatchStage } from '../utils/build-join-match.util.js';
 export async function getById(db, operations, queryObject, id, pluralResourceName) {
     if (!entityUtils.isValidObjectId(id)) {
         throw new BadRequestError('id is not a valid ObjectId');
@@ -8,10 +10,15 @@ export async function getById(db, operations, queryObject, id, pluralResourceNam
     const collection = db.collection(pluralResourceName);
     queryObject.filters || (queryObject.filters = {});
     queryObject.filters._id = { eq: id };
-    const pipeline = new NoSqlPipeline()
-        .addMatch(queryObject)
-        .addOperations(operations)
-        .build();
+    const { rootOptions, joinFilters } = splitFiltersByType(queryObject, operations, pluralResourceName);
+    const pipelineBuilder = new NoSqlPipeline()
+        .addMatch(rootOptions)
+        .addOperations(operations);
+    const joinMatch = buildJoinMatchStage(joinFilters, operations);
+    if (joinMatch) {
+        pipelineBuilder.addStage(joinMatch);
+    }
+    const pipeline = pipelineBuilder.build();
     const entity = await collection.aggregate(pipeline).next();
     return entity;
 }

package/dist/databases/mongo-db/queries/mongo-get.query.js

@@ -1,10 +1,18 @@
+import { splitFiltersByType } from '../../utils/resolve-join-filter.js';
 import NoSqlPipeline from '../models/no-sql-pipeline.js';
+import { buildJoinMatchStage } from '../utils/build-join-match.util.js';
 import { apiUtils } from '../../../utils/api.utils.js';
 export async function get(db, operations, queryOptions, modelSpec, pluralResourceName) {
     const collection = db.collection(pluralResourceName);
-    const pipeline = new NoSqlPipeline()
-        .addMatch(queryOptions, modelSpec)
-        .addOperations(operations)
+    const { rootOptions, joinFilters } = splitFiltersByType(queryOptions, operations, pluralResourceName);
+    const pipelineBuilder = new NoSqlPipeline()
+        .addMatch(rootOptions, modelSpec)
+        .addOperations(operations);
+    const joinMatch = buildJoinMatchStage(joinFilters, operations);
+    if (joinMatch) {
+        pipelineBuilder.addStage(joinMatch);
+    }
+    const pipeline = pipelineBuilder
         .addQueryOptions(queryOptions, true)
         .build();
     const cursor = collection.aggregate(pipeline);

package/dist/databases/mongo-db/utils/build-join-match.util.d.ts

@@ -0,0 +1,4 @@
+import { Document } from 'mongodb';
+import type { Operation } from '../../operations/operation.js';
+import { JoinFilter } from '../../models/join-filter.interface.js';
+export declare function buildJoinMatchStage(joinFilters: JoinFilter[], operations: Operation[]): Document | null;

package/dist/databases/mongo-db/utils/build-join-match.util.js

@@ -0,0 +1,192 @@
+import { entityUtils } from '@loomcore/common/utils';
+import { ObjectId } from 'mongodb';
+import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
+import { PROPERTIES_THAT_ARE_NOT_OBJECT_IDS } from '../../models/constants.js';
+import { findJoinOperation } from '../../utils/resolve-join-filter.js';
+function shouldConvertEqToObjectId(column) {
+    if (PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(column)) {
+        return false;
+    }
+    return column === '_id' || column.endsWith('Id');
+}
+function shouldConvertInToObjectIds(column) {
+    if (PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(column)) {
+        return false;
+    }
+    return column === '_id' || column.endsWith('Id') || column.endsWith('Ids');
+}
+function convertEqValue(column, value) {
+    if (shouldConvertEqToObjectId(column) && typeof value === 'string' && entityUtils.isValidObjectId(value)) {
+        return new ObjectId(value);
+    }
+    if (typeof value === 'string' && !isNaN(Number(value))) {
+        return Number(value);
+    }
+    return value;
+}
+function convertInValues(column, values) {
+    if (shouldConvertInToObjectIds(column)) {
+        const objectIds = values
+            .filter(val => typeof val === 'string' && entityUtils.isValidObjectId(val))
+            .map(val => new ObjectId(val));
+        if (objectIds.length === 0) {
+            return { values: [], dropped: true };
+        }
+        return { values: objectIds, dropped: false };
+    }
+    return {
+        values: values.map(val => typeof val === 'string' && !isNaN(Number(val)) ? Number(val) : val),
+        dropped: false,
+    };
+}
+function compareExpression(fieldExpr, column, filter) {
+    const parts = [];
+    if (filter.eq !== undefined) {
+        parts.push({ $eq: [fieldExpr, convertEqValue(column, filter.eq)] });
+    }
+    if (filter.ne !== undefined) {
+        parts.push({ $ne: [fieldExpr, convertEqValue(column, filter.ne)] });
+    }
+    if (filter.in !== undefined && Array.isArray(filter.in)) {
+        const converted = convertInValues(column, filter.in);
+        if (!converted.dropped) {
+            parts.push({ $in: [fieldExpr, converted.values] });
+        }
+    }
+    if (filter.gte !== undefined) {
+        parts.push({ $gte: [fieldExpr, filter.gte] });
+    }
+    if (filter.lte !== undefined) {
+        parts.push({ $lte: [fieldExpr, filter.lte] });
+    }
+    if (filter.gt !== undefined) {
+        parts.push({ $gt: [fieldExpr, filter.gt] });
+    }
+    if (filter.lt !== undefined) {
+        parts.push({ $lt: [fieldExpr, filter.lt] });
+    }
+    if (filter.contains !== undefined) {
+        parts.push({
+            $cond: [
+                { $eq: [{ $type: fieldExpr }, 'string'] },
+                { $regexMatch: { input: fieldExpr, regex: filter.contains, options: 'i' } },
+                false,
+            ],
+        });
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    return { $and: parts };
+}
+function scalarAssignment(column, filter) {
+    const ops = {};
+    if (filter.eq !== undefined) {
+        ops.$eq = convertEqValue(column, filter.eq);
+    }
+    if (filter.ne !== undefined) {
+        ops.$ne = convertEqValue(column, filter.ne);
+    }
+    if (filter.in !== undefined && Array.isArray(filter.in)) {
+        const converted = convertInValues(column, filter.in);
+        if (!converted.dropped) {
+            ops.$in = converted.values;
+        }
+    }
+    if (filter.gte !== undefined) {
+        ops.$gte = filter.gte;
+    }
+    if (filter.lte !== undefined) {
+        ops.$lte = filter.lte;
+    }
+    if (filter.gt !== undefined) {
+        ops.$gt = filter.gt;
+    }
+    if (filter.lt !== undefined) {
+        ops.$lt = filter.lt;
+    }
+    if (filter.contains !== undefined) {
+        ops.$regex = filter.contains;
+        ops.$options = 'i';
+    }
+    const keys = Object.keys(ops);
+    if (keys.length === 0) {
+        return undefined;
+    }
+    if (keys.length === 1 && keys[0] === '$eq') {
+        return ops.$eq;
+    }
+    return ops;
+}
+function anyMatchExpression(joinFilter, operations) {
+    const walk = (scope, index) => {
+        const alias = joinFilter.aliases[index];
+        const operation = findJoinOperation(operations, alias);
+        if (!operation) {
+            return null;
+        }
+        const here = scope ? `${scope}.${alias}` : `$_joinData.${alias}`;
+        const isLast = index === joinFilter.aliases.length - 1;
+        if (operation instanceof LeftJoinMany) {
+            const varName = `j${index}`;
+            const cond = isLast
+                ? compareExpression(`$$${varName}.${joinFilter.column}`, joinFilter.column, joinFilter.filter)
+                : walk(`$$${varName}`, index + 1);
+            if (!cond) {
+                return null;
+            }
+            return {
+                $gt: [
+                    {
+                        $size: {
+                            $filter: {
+                                input: { $ifNull: [here, []] },
+                                as: varName,
+                                cond,
+                            },
+                        },
+                    },
+                    0,
+                ],
+            };
+        }
+        if (isLast) {
+            return compareExpression(`${here}.${joinFilter.column}`, joinFilter.column, joinFilter.filter);
+        }
+        return walk(here, index + 1);
+    };
+    return walk('', 0);
+}
+export function buildJoinMatchStage(joinFilters, operations) {
+    const match = {};
+    const expressions = [];
+    for (const joinFilter of joinFilters) {
+        if (joinFilter.crossesMany) {
+            const expression = anyMatchExpression(joinFilter, operations);
+            if (expression) {
+                expressions.push(expression);
+            }
+            continue;
+        }
+        const assignment = scalarAssignment(joinFilter.column, joinFilter.filter);
+        if (assignment !== undefined) {
+            match[`_joinData.${joinFilter.aliases.join('.')}.${joinFilter.column}`] = assignment;
+        }
+        if (joinFilter.filter.ne !== undefined) {
+            match[`_joinData.${joinFilter.aliases.join('.')}`] = { $ne: null };
+        }
+    }
+    if (expressions.length === 1) {
+        match.$expr = expressions[0];
+    }
+    else if (expressions.length > 1) {
+        match.$expr = { $and: expressions };
+    }
+    if (Object.keys(match).length === 0) {
+        return null;
+    }
+    return { $match: match };
+}

package/dist/databases/mongo-db/utils/convert-operations-to-pipeline.util.js

@@ -13,17 +13,27 @@ function resolveLocalFieldPath(localField, processedOperations) {
     }
     return localField;
 }
+function innerJoinDropsDocument(operation, processedOperations) {
+    if (!(operation instanceof InnerJoin)) {
+        return false;
+    }
+    const dot = operation.localField.indexOf('.');
+    if (dot === -1) {
+        return true;
+    }
+    const parentAlias = operation.localField.slice(0, dot);
+    const parent = processedOperations.find(op => (op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany) && op.as === parentAlias);
+    return !(parent instanceof LeftJoinMany);
+}
 export function convertOperationsToPipeline(operations) {
     let pipeline = [];
     const processedOperations = [];
-    const joinAliases = operations
-        .filter(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany)
-        .map(op => op.as);
     operations.forEach(operation => {
         if (operation instanceof LeftJoin || operation instanceof InnerJoin) {
             const needsObjectIdConversion = operation.foreignField === '_id';
             const isNestedField = operation.localField.includes('.');
             const resolvedLocalField = resolveLocalFieldPath(operation.localField, processedOperations);
+            const preserveMissingMatch = !innerJoinDropsDocument(operation, processedOperations);
             if (needsObjectIdConversion) {
                 pipeline.push({
                     $lookup: {
@@ -51,7 +61,7 @@ export function convertOperationsToPipeline(operations) {
                 }, {
                     $unwind: {
                         path: `$${operation.as}Arr`,
-                        preserveNullAndEmptyArrays: true
+                        preserveNullAndEmptyArrays: preserveMissingMatch
                     }
                 }, {
                     $addFields: {
@@ -79,7 +89,7 @@ export function convertOperationsToPipeline(operations) {
                 }, {
                     $unwind: {
                         path: `$${operation.as}Arr`,
-                        preserveNullAndEmptyArrays: true
+                        preserveNullAndEmptyArrays: preserveMissingMatch
                     }
                 }, {
                     $addFields: {

package/dist/databases/operations/index.d.ts

@@ -1,4 +1,5 @@
 export * from './operation.js';
+export * from './join-operation.js';
 export * from './left-join.operation.js';
 export * from './inner-join.operation.js';
 export * from './left-join-many.operation.js';

package/dist/databases/operations/index.js

@@ -1,4 +1,5 @@
 export * from './operation.js';
+export * from './join-operation.js';
 export * from './left-join.operation.js';
 export * from './inner-join.operation.js';
 export * from './left-join-many.operation.js';

package/dist/databases/operations/join-operation.d.ts

@@ -0,0 +1,4 @@
+import { LeftJoin } from "./left-join.operation.js";
+import { InnerJoin } from "./inner-join.operation.js";
+import { LeftJoinMany } from "./left-join-many.operation.js";
+export type JoinOperation = LeftJoin | InnerJoin | LeftJoinMany;

package/dist/databases/operations/join-operation.js

@@ -0,0 +1 @@
+export {};

package/dist/databases/postgres/commands/postgres-batch-update.command.js

@@ -39,7 +39,7 @@ export async function batchUpdate(connection, entities, operations, queryObject,
             const { columns, values } = columnsAndValuesFromEntity(updateData);
             const setClause = columns.map((col, index) => `${col} = $${index + 1}`).join(', ');
             queryObject.filters._id = { eq: _id };
-            const { whereClause } = buildWhereClause(queryObject, values);
+            const { whereClause } = buildWhereClause(queryObject, pluralResourceName, values);
             const query = `
         UPDATE "${pluralResourceName}"
         SET ${setClause}
@@ -50,9 +50,8 @@ export async function batchUpdate(connection, entities, operations, queryObject,
         await session.query('COMMIT');
         const joinClauses = buildJoinClauses(operations, pluralResourceName);
         const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-        const tablePrefix = hasJoins ? pluralResourceName : undefined;
         queryObject.filters._id = { in: entityIds };
-        const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
+        const { whereClause, values } = buildWhereClause(queryObject, pluralResourceName);
         const selectClause = hasJoins
             ? await buildSelectClause(session, pluralResourceName, operations)
             : '*';

package/dist/databases/postgres/commands/postgres-delete-many.command.js

@@ -2,7 +2,7 @@ import { buildWhereClause } from '../utils/build-where-clause.js';
 import { DeleteResult } from '../../models/delete-result.js';
 export async function deleteMany(client, queryObject, pluralResourceName) {
     try {
-        const { whereClause, values } = buildWhereClause(queryObject);
+        const { whereClause, values } = buildWhereClause(queryObject, pluralResourceName);
         const query = `DELETE FROM "${pluralResourceName}" ${whereClause}`;
         const result = await client.query(query, values);
         return new DeleteResult(true, result.rowCount || 0);

package/dist/databases/postgres/commands/postgres-full-update-by-id.command.js

@@ -54,9 +54,7 @@ export async function fullUpdateById(client, operations, id, entity, pluralResou
             throw new IdNotFoundError();
         }
         const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-        const joinClauses = hasJoins
-            ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
-            : buildJoinClauses(operations, pluralResourceName);
+        const joinClauses = buildJoinClauses(operations, pluralResourceName);
         const selectClause = hasJoins
             ? await buildSelectClause(client, pluralResourceName, operations)
             : '*';

package/dist/databases/postgres/commands/postgres-partial-update-by-id.command.js

@@ -24,9 +24,7 @@ export async function partialUpdateById(client, operations, id, entity, pluralRe
             throw new IdNotFoundError();
         }
         const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-        const joinClauses = hasJoins
-            ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
-            : buildJoinClauses(operations, pluralResourceName);
+        const joinClauses = buildJoinClauses(operations, pluralResourceName);
         const selectClause = hasJoins
             ? await buildSelectClause(client, pluralResourceName, operations)
             : '*';

package/dist/databases/postgres/commands/postgres-update.command.js

@@ -9,7 +9,7 @@ import { buildSelectClause } from '../utils/build-select-clause.js';
 import { columnsAndValuesFromEntity } from '../utils/columns-and-values-from-entity.js';
 export async function update(client, queryObject, entity, operations, pluralResourceName) {
     try {
-        const { whereClause, values: whereValues } = buildWhereClause(queryObject);
+        const { whereClause, values: whereValues } = buildWhereClause(queryObject, pluralResourceName);
         const { columns, values: entityValues } = columnsAndValuesFromEntity(entity);
         const updateColumns = columns.filter(col => col !== '"_id"');
         const updateValues = entityValues.filter((_, index) => columns[index] !== '"_id"');
@@ -32,12 +32,9 @@ export async function update(client, queryObject, entity, operations, pluralReso
             throw new NotFoundError('No records found matching update query');
         }
         const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-        const joinClauses = hasJoins
-            ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
-            : buildJoinClauses(operations, pluralResourceName);
-        const orderByClause = buildOrderByClause(queryObject, hasJoins ? { tablePrefix: pluralResourceName } : undefined);
-        const tablePrefix = hasJoins ? pluralResourceName : undefined;
-        const { whereClause: selectWhereClause, values: selectWhereValues } = buildWhereClause(queryObject, [], tablePrefix);
+        const joinClauses = buildJoinClauses(operations, pluralResourceName);
+        const orderByClause = buildOrderByClause(queryObject, pluralResourceName);
+        const { whereClause: selectWhereClause, values: selectWhereValues } = buildWhereClause(queryObject, pluralResourceName);
         const selectClause = hasJoins
             ? await buildSelectClause(client, pluralResourceName, operations)
             : '*';

package/dist/databases/postgres/queries/postgres-find-one.query.js

@@ -1,8 +1,8 @@
 import { buildWhereClause } from '../utils/build-where-clause.js';
 import { buildOrderByClause } from '../utils/build-order-by-clause.js';
 export async function findOne(client, queryObject, pluralResourceName) {
-    const { whereClause, values } = buildWhereClause(queryObject);
-    const orderByClause = buildOrderByClause(queryObject);
+    const { whereClause, values } = buildWhereClause(queryObject, pluralResourceName);
+    const orderByClause = buildOrderByClause(queryObject, pluralResourceName);
     const query = `SELECT * FROM "${pluralResourceName}" ${whereClause} ${orderByClause} LIMIT 1`;
     const result = await client.query(query, values);
     if (result.rows.length === 0) {

package/dist/databases/postgres/queries/postgres-find.query.js

@@ -2,8 +2,8 @@ import { buildWhereClause } from '../utils/build-where-clause.js';
 import { buildOrderByClause } from '../utils/build-order-by-clause.js';
 import { buildPaginationClause } from '../utils/build-pagination-clause.js';
 export async function find(client, queryObject, pluralResourceName) {
-    const { whereClause, values } = buildWhereClause(queryObject);
-    const orderByClause = buildOrderByClause(queryObject);
+    const { whereClause, values } = buildWhereClause(queryObject, pluralResourceName);
+    const orderByClause = buildOrderByClause(queryObject, pluralResourceName);
     const paginationClause = buildPaginationClause(queryObject);
     const query = `SELECT * FROM "${pluralResourceName}" ${whereClause} ${orderByClause} ${paginationClause}`.trim();
     const result = await client.query(query, values);

package/dist/databases/postgres/queries/postgres-get-all.query.js

@@ -5,9 +5,7 @@ import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildSelectClause } from '../utils/build-select-clause.js';
 export async function getAll(client, operations, pluralResourceName) {
     const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-    const joinClauses = hasJoins
-        ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
-        : buildJoinClauses(operations, pluralResourceName);
+    const joinClauses = buildJoinClauses(operations, pluralResourceName);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';

package/dist/databases/postgres/queries/postgres-get-by-id.query.js

@@ -9,16 +9,13 @@ export async function getById(client, operations, queryObject, id, pluralResourc
     if (!id)
         throw new BadRequestError('id is required');
     const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-    const joinClauses = hasJoins
-        ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
-        : buildJoinClauses(operations, pluralResourceName);
+    const joinClauses = buildJoinClauses(operations, pluralResourceName);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
     queryObject.filters || (queryObject.filters = {});
     queryObject.filters._id = { eq: id };
-    const tablePrefix = hasJoins ? pluralResourceName : undefined;
-    const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
+    const { whereClause, values } = buildWhereClause(queryObject, pluralResourceName, [], operations);
     const query = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses} ${whereClause} LIMIT 1`;
     const result = await client.query(query, values);
     if (result.rows.length === 0) {

package/dist/databases/postgres/queries/postgres-get.query.js

@@ -1,6 +1,3 @@
-import { LeftJoin } from '../../operations/left-join.operation.js';
-import { InnerJoin } from '../../operations/inner-join.operation.js';
-import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
 import { buildWhereClause } from '../utils/build-where-clause.js';
 import { buildOrderByClause } from '../utils/build-order-by-clause.js';
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
@@ -8,20 +5,18 @@ import { buildSelectClause } from '../utils/build-select-clause.js';
 import { executeCountQuery } from '../utils/build-count-query.js';
 import { apiUtils } from '../../../utils/api.utils.js';
 import { buildPaginationClause } from '../utils/build-pagination-clause.js';
+import { isJoinOperation } from '../../utils/is-join-operation.util.js';
 export async function get(client, operations, queryOptions, pluralResourceName) {
-    const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
-    const joinClauses = hasJoins
-        ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
-        : buildJoinClauses(operations, pluralResourceName);
-    const orderByClause = buildOrderByClause(queryOptions, hasJoins ? { tablePrefix: pluralResourceName } : undefined);
+    const hasJoins = operations.some(isJoinOperation);
+    const joinClauses = buildJoinClauses(operations, pluralResourceName);
+    const orderByClause = buildOrderByClause(queryOptions, pluralResourceName);
     const paginationClause = buildPaginationClause(queryOptions);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
-    const tablePrefix = hasJoins ? pluralResourceName : undefined;
-    const { whereClause, values } = buildWhereClause(queryOptions, [], tablePrefix);
+    const { whereClause, values } = buildWhereClause(queryOptions, pluralResourceName, [], operations);
     const baseQuery = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses} ${whereClause}`;
-    const total = await executeCountQuery(client, pluralResourceName, queryOptions);
+    const total = await executeCountQuery(client, pluralResourceName, queryOptions, operations);
     const dataQuery = `${baseQuery} ${orderByClause} ${paginationClause}`.trim();
     const dataResult = await client.query(dataQuery, values);
     const entities = hasJoins

package/dist/databases/postgres/utils/build-count-query.d.ts

@@ -1,3 +1,8 @@
 import type { PostgresConnection } from '../postgres-connection.js';
 import { IQueryOptions } from '@loomcore/common/models';
-export declare function executeCountQuery(client: PostgresConnection, pluralResourceName: string, queryOptions?: IQueryOptions): Promise<number>;
+import type { Operation } from '../../operations/operation.js';
+export declare function buildCountQuerySql(pluralResourceName: string, queryOptions?: IQueryOptions, operations?: Operation[]): {
+    countQuery: string;
+    values: any[];
+};
+export declare function executeCountQuery(client: PostgresConnection, pluralResourceName: string, queryOptions?: IQueryOptions, operations?: Operation[]): Promise<number>;

package/dist/databases/postgres/utils/build-count-query.js

@@ -1,7 +1,15 @@
+import { buildJoinClauses } from './build-join-clauses.js';
 import { buildWhereClause } from './build-where-clause.js';
-export async function executeCountQuery(client, pluralResourceName, queryOptions = {}) {
-    const { whereClause, values } = buildWhereClause(queryOptions);
-    const countQuery = `SELECT COUNT(*) as total FROM "${pluralResourceName}" ${whereClause}`;
+export function buildCountQuerySql(pluralResourceName, queryOptions = {}, operations = []) {
+    const joinClauses = buildJoinClauses(operations, pluralResourceName);
+    const { whereClause, values } = buildWhereClause(queryOptions, pluralResourceName, [], operations);
+    const countQuery = ['SELECT COUNT(*) as total', `FROM "${pluralResourceName}"`, joinClauses, whereClause]
+        .filter(part => part.trim().length > 0)
+        .join(' ');
+    return { countQuery, values };
+}
+export async function executeCountQuery(client, pluralResourceName, queryOptions = {}, operations = []) {
+    const { countQuery, values } = buildCountQuerySql(pluralResourceName, queryOptions, operations);
     const countResult = await client.query(countQuery, values);
     return parseInt(countResult.rows[0].total, 10);
 }

package/dist/databases/postgres/utils/build-join-clauses.d.ts

@@ -1,5 +1,3 @@
 import { Operation } from '../../operations/operation.js';
-export interface BuildJoinClausesOptions {
-    oneToOneOnly?: boolean;
-}
-export declare function buildJoinClauses(operations: Operation[], mainTableName?: string, options?: BuildJoinClausesOptions): string;
+export declare function collectOuterOneToOneAliases(operations: Operation[], mainTableName: string): Set<string>;
+export declare function buildJoinClauses(operations: Operation[], mainTableName: string): string;

package/dist/databases/postgres/utils/build-join-clauses.js

@@ -1,54 +1,47 @@
 import { LeftJoin } from '../../operations/left-join.operation.js';
 import { InnerJoin } from '../../operations/inner-join.operation.js';
-import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
 import { toPostgresStoreName } from './convert-keys.util.js';
 function getParentAlias(localField) {
     if (!localField.includes('.'))
         return null;
     return localField.split('.')[0];
 }
-function getThroughTableAliases(operations) {
-    const through = new Set();
-    for (const op of operations) {
-        if (op instanceof LeftJoinMany && op.localField.includes('.')) {
-            through.add(op.localField.split('.')[0]);
+export function collectOuterOneToOneAliases(operations, mainTableName) {
+    const aliases = new Set();
+    for (const operation of operations) {
+        if (!(operation instanceof LeftJoin) && !(operation instanceof InnerJoin)) {
+            continue;
+        }
+        const parent = getParentAlias(operation.localField);
+        const parentInScope = parent === null || parent === mainTableName || aliases.has(parent);
+        if (!parentInScope) {
+            continue;
         }
+        aliases.add(operation.as);
     }
-    return through;
+    return aliases;
 }
-export function buildJoinClauses(operations, mainTableName, options) {
-    const oneToOneOnly = options?.oneToOneOnly ?? false;
-    const throughTableAliases = oneToOneOnly ? getThroughTableAliases(operations) : new Set();
+export function buildJoinClauses(operations, mainTableName) {
     const joinClauses = [];
-    const oneToOneAliasesInScope = new Set();
+    const oneToOneAliasesInScope = collectOuterOneToOneAliases(operations, mainTableName);
     for (const operation of operations) {
-        if (operation instanceof LeftJoinMany) {
-            if (oneToOneOnly)
-                continue;
+        if (!(operation instanceof LeftJoin) && !(operation instanceof InnerJoin)) {
+            continue;
+        }
+        if (!oneToOneAliasesInScope.has(operation.as)) {
+            continue;
         }
-        else if (operation instanceof LeftJoin || operation instanceof InnerJoin) {
-            if (oneToOneOnly) {
-                const parent = getParentAlias(operation.localField);
-                const parentInScope = parent === null || parent === mainTableName || oneToOneAliasesInScope.has(parent);
-                if (!parentInScope)
-                    continue;
-                oneToOneAliasesInScope.add(operation.as);
-            }
+        const joinType = operation instanceof LeftJoin ? 'LEFT JOIN' : 'INNER JOIN';
+        let leftSide;
+        if (operation.localField.includes('.')) {
+            const [alias, column] = operation.localField.split('.');
+            leftSide = `"${alias}"."${column}"`;
         }
-        if (operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany) {
-            const useLeftJoin = oneToOneOnly && operation instanceof InnerJoin && throughTableAliases.has(operation.as);
-            const joinType = useLeftJoin || operation instanceof LeftJoin || operation instanceof LeftJoinMany ? 'LEFT JOIN' : 'INNER JOIN';
-            let leftSide;
-            if (operation.localField.includes('.')) {
-                const [alias, column] = operation.localField.split('.');
-                leftSide = `"${alias}"."${column}"`;
-            }
-            else {
-                leftSide = mainTableName ? `"${mainTableName}"."${operation.localField}"` : `"${operation.localField}"`;
-            }
-            const fromTable = toPostgresStoreName(operation.from);
-            joinClauses.push(`${joinType} "${fromTable}" AS "${operation.as}" ON ${leftSide} = "${operation.as}"."${operation.foreignField}"`);
+        else {
+            leftSide = `"${mainTableName}"."${operation.localField}"`;
         }
+        const fromTable = toPostgresStoreName(operation.from);
+        joinClauses.push(`${joinType} "${fromTable}" AS "${operation.as}" ON ${leftSide} = "${operation.as}"."${operation.foreignField}"`);
     }
     return joinClauses.join(' ');
 }

package/dist/databases/postgres/utils/build-join-where.d.ts

@@ -0,0 +1,9 @@
+import type { Filter } from '@loomcore/common/models';
+import type { Operation } from '../../operations/operation.js';
+import { JoinFilter } from '../../models/join-filter.interface.js';
+export interface SqlParamIndex {
+    current: number;
+}
+export declare function toSqlColumnName(column: string): string;
+export declare function appendFilterConditions(qualifiedKey: string, value: Filter, conditions: string[], values: any[], paramIndex: SqlParamIndex): void;
+export declare function joinFilterSql(joinFilter: JoinFilter, operations: Operation[], mainTableName: string, values: any[], paramIndex: SqlParamIndex): string | null;

package/dist/databases/postgres/utils/build-join-where.js

@@ -0,0 +1,136 @@
+import { readFilterValue } from '../../utils/nullish-filter-value.js';
+import { findJoinOperation, parentAliasOf, } from '../../utils/resolve-join-filter.js';
+import { collectOuterOneToOneAliases } from './build-join-clauses.js';
+import { toPostgresStoreName, toSnakeCase } from './convert-keys.util.js';
+export function toSqlColumnName(column) {
+    if (column.startsWith('_')) {
+        return column;
+    }
+    if (column === 'id') {
+        return '_id';
+    }
+    return toSnakeCase(column);
+}
+function quoteIdent(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+export function appendFilterConditions(qualifiedKey, value, conditions, values, paramIndex) {
+    if (value.eq !== undefined) {
+        const comparison = readFilterValue(value.eq);
+        if (comparison.kind === 'value') {
+            conditions.push(`(${qualifiedKey} = $${paramIndex.current} OR (${qualifiedKey} IS NULL AND $${paramIndex.current} IS NULL))`);
+            values.push(comparison.value);
+            paramIndex.current++;
+        }
+        else {
+            conditions.push(`${qualifiedKey} IS NULL`);
+        }
+    }
+    if (value.ne !== undefined) {
+        const comparison = readFilterValue(value.ne);
+        if (comparison.kind === 'value') {
+            conditions.push(`(${qualifiedKey} != $${paramIndex.current} OR (${qualifiedKey} IS NOT NULL AND $${paramIndex.current} IS NULL) OR (${qualifiedKey} IS NULL AND $${paramIndex.current} IS NOT NULL))`);
+            values.push(comparison.value);
+            paramIndex.current++;
+        }
+        else {
+            conditions.push(`${qualifiedKey} IS NOT NULL`);
+        }
+    }
+    if (value.in !== undefined && Array.isArray(value.in)) {
+        const placeholders = value.in.map(() => `$${paramIndex.current++}`).join(', ');
+        conditions.push(`${qualifiedKey} IN (${placeholders})`);
+        values.push(...value.in);
+    }
+    if (value.gte !== undefined) {
+        conditions.push(`${qualifiedKey} >= $${paramIndex.current}`);
+        values.push(value.gte);
+        paramIndex.current++;
+    }
+    if (value.lte !== undefined) {
+        conditions.push(`${qualifiedKey} <= $${paramIndex.current}`);
+        values.push(value.lte);
+        paramIndex.current++;
+    }
+    if (value.gt !== undefined) {
+        conditions.push(`${qualifiedKey} > $${paramIndex.current}`);
+        values.push(value.gt);
+        paramIndex.current++;
+    }
+    if (value.lt !== undefined) {
+        conditions.push(`${qualifiedKey} < $${paramIndex.current}`);
+        values.push(value.lt);
+        paramIndex.current++;
+    }
+    if (value.contains !== undefined) {
+        conditions.push(`LOWER(${qualifiedKey}) LIKE LOWER($${paramIndex.current})`);
+        values.push(`%${value.contains}%`);
+        paramIndex.current++;
+    }
+}
+function qualifyLocalField(localField, mainTableName) {
+    const dot = localField.indexOf('.');
+    if (dot === -1) {
+        return mainTableName ? `${quoteIdent(mainTableName)}.${quoteIdent(localField)}` : quoteIdent(localField);
+    }
+    const alias = localField.slice(0, dot);
+    const column = localField.slice(dot + 1);
+    return `${quoteIdent(alias)}.${quoteIdent(column)}`;
+}
+function ancestorChain(target, operations, mainTableName, outerAliases) {
+    const chain = [target];
+    let current = target;
+    const seen = new Set([target.as]);
+    while (true) {
+        const parentAlias = parentAliasOf(current.localField);
+        if (parentAlias === null || parentAlias === mainTableName || outerAliases.has(parentAlias)) {
+            break;
+        }
+        if (seen.has(parentAlias)) {
+            break;
+        }
+        const parent = findJoinOperation(operations, parentAlias);
+        if (!parent) {
+            break;
+        }
+        seen.add(parent.as);
+        chain.unshift(parent);
+        current = parent;
+    }
+    return chain;
+}
+function existsSql(target, qualifiedColumn, filter, operations, mainTableName, outerAliases, values, paramIndex) {
+    const chain = ancestorChain(target, operations, mainTableName, outerAliases);
+    const first = chain[0];
+    let sql = `EXISTS (SELECT 1 FROM ${quoteIdent(toPostgresStoreName(first.from))} AS ${quoteIdent(first.as)}`;
+    for (let index = 1; index < chain.length; index++) {
+        const child = chain[index];
+        const fromTable = quoteIdent(toPostgresStoreName(child.from));
+        const childAlias = quoteIdent(child.as);
+        const onLeft = qualifyLocalField(child.localField, mainTableName);
+        sql += ` INNER JOIN ${fromTable} AS ${childAlias} ON ${onLeft} = ${childAlias}.${quoteIdent(child.foreignField)}`;
+    }
+    const conditions = [
+        `${qualifyLocalField(first.localField, mainTableName)} = ${quoteIdent(first.as)}.${quoteIdent(first.foreignField)}`,
+    ];
+    appendFilterConditions(qualifiedColumn, filter, conditions, values, paramIndex);
+    sql += ` WHERE ${conditions.join(' AND ')})`;
+    return sql;
+}
+export function joinFilterSql(joinFilter, operations, mainTableName, values, paramIndex) {
+    const target = findJoinOperation(operations, joinFilter.aliases[joinFilter.aliases.length - 1]);
+    if (!target) {
+        return null;
+    }
+    const outerAliases = collectOuterOneToOneAliases(operations, mainTableName);
+    const qualified = `${quoteIdent(target.as)}.${quoteIdent(toSqlColumnName(joinFilter.column))}`;
+    if (!joinFilter.crossesMany && outerAliases.has(target.as)) {
+        const conditions = [];
+        appendFilterConditions(qualified, joinFilter.filter, conditions, values, paramIndex);
+        if (joinFilter.filter.ne !== undefined) {
+            conditions.push(`${quoteIdent(target.as)}."_id" IS NOT NULL`);
+        }
+        return conditions.join(' AND ');
+    }
+    return existsSql(target, qualified, joinFilter.filter, operations, mainTableName, outerAliases, values, paramIndex);
+}

package/dist/databases/postgres/utils/build-order-by-clause.d.ts

@@ -1,5 +1,2 @@
 import { IQueryOptions } from '@loomcore/common/models';
-export interface BuildOrderByClauseOptions {
-    tablePrefix?: string;
-}
-export declare function buildOrderByClause(queryObject: IQueryOptions, options?: BuildOrderByClauseOptions): string;
+export declare function buildOrderByClause(queryObject: IQueryOptions, tablePrefix: string): string;

package/dist/databases/postgres/utils/build-order-by-clause.js

@@ -1,9 +1,8 @@
-export function buildOrderByClause(queryObject, options) {
+export function buildOrderByClause(queryObject, tablePrefix) {
     if (!queryObject.orderBy) {
         return '';
     }
     const orderBy = queryObject.orderBy;
     const sortDirection = queryObject.sortDirection || 'asc';
-    const qualified = options?.tablePrefix ? `"${options.tablePrefix}"."${orderBy}"` : orderBy;
-    return `ORDER BY ${qualified} ${sortDirection}`;
+    return `ORDER BY "${tablePrefix}"."${orderBy}" ${sortDirection}`;
 }

package/dist/databases/postgres/utils/build-select-clause.js

@@ -2,6 +2,7 @@ import { LeftJoin } from '../../operations/left-join.operation.js';
 import { InnerJoin } from '../../operations/inner-join.operation.js';
 import { LeftJoinMany } from '../../operations/left-join-many.operation.js';
 import { toPostgresStoreName } from './convert-keys.util.js';
+import { isJoinOperation } from '../../utils/is-join-operation.util.js';
 const PK = '_id';
 export async function getTableColumns(client, tableName) {
     const storeName = toPostgresStoreName(tableName);
@@ -172,10 +173,7 @@ async function buildJoinDataObject(client, operations, mainTableName) {
     return jsonbBuildObject(entries);
 }
 export async function buildSelectClause(client, mainTableName, operations) {
-    const leftJoinOperations = operations.filter(op => op instanceof LeftJoin);
-    const innerJoinOperations = operations.filter(op => op instanceof InnerJoin);
-    const leftJoinManyOperations = operations.filter(op => op instanceof LeftJoinMany);
-    const hasJoins = leftJoinOperations.length > 0 || innerJoinOperations.length > 0 || leftJoinManyOperations.length > 0;
+    const hasJoins = operations.some(isJoinOperation);
     if (!hasJoins) {
         return '*';
     }

package/dist/databases/postgres/utils/build-where-clause.d.ts

@@ -1,5 +1,6 @@
 import { IQueryOptions } from '@loomcore/common/models';
-export declare function buildWhereClause(queryObject: IQueryOptions, values?: any[], tablePrefix?: string): {
+import type { Operation } from '../../operations/operation.js';
+export declare function buildWhereClause(queryObject: IQueryOptions, tablePrefix: string, values?: any[], operations?: Operation[]): {
     whereClause: string;
     values: any[];
 };

package/dist/databases/postgres/utils/build-where-clause.js

@@ -1,76 +1,24 @@
-import { readFilterValue } from '../../utils/nullish-filter-value.js';
-import { toSnakeCase } from './convert-keys.util.js';
-export function buildWhereClause(queryObject, values = [], tablePrefix) {
-    const filters = queryObject.filters || {};
+import { splitFiltersByType } from '../../utils/resolve-join-filter.js';
+import { appendFilterConditions, joinFilterSql, toSqlColumnName } from './build-join-where.js';
+export function buildWhereClause(queryObject, tablePrefix, values = [], operations) {
+    const useJoinFilters = operations !== undefined && operations.length > 0;
+    const { rootOptions, joinFilters } = useJoinFilters
+        ? splitFiltersByType(queryObject, operations, tablePrefix)
+        : { rootOptions: queryObject, joinFilters: [] };
+    const filters = rootOptions.filters || {};
     const conditions = [];
-    let paramIndex = values.length + 1;
-    const qualifyColumn = (columnName) => {
-        return tablePrefix ? `"${tablePrefix}"."${columnName}"` : `"${columnName}"`;
-    };
+    const paramIndex = { current: values.length + 1 };
     for (const [key, value] of Object.entries(filters)) {
         if (value) {
-            let snakeKey;
-            if (key.startsWith('_')) {
-                snakeKey = key;
-            }
-            else if (key === 'id') {
-                snakeKey = '_id';
-            }
-            else {
-                snakeKey = toSnakeCase(key);
-            }
-            const qualifiedKey = qualifyColumn(snakeKey);
-            if (value.eq !== undefined) {
-                const comparison = readFilterValue(value.eq);
-                if (comparison.kind === 'value') {
-                    conditions.push(`(${qualifiedKey} = $${paramIndex} OR (${qualifiedKey} IS NULL AND $${paramIndex} IS NULL))`);
-                    values.push(comparison.value);
-                    paramIndex++;
-                }
-                else {
-                    conditions.push(`${qualifiedKey} IS NULL`);
-                }
-            }
-            if (value.ne !== undefined) {
-                const comparison = readFilterValue(value.ne);
-                if (comparison.kind === 'value') {
-                    conditions.push(`(${qualifiedKey} != $${paramIndex} OR (${qualifiedKey} IS NOT NULL AND $${paramIndex} IS NULL) OR (${qualifiedKey} IS NULL AND $${paramIndex} IS NOT NULL))`);
-                    values.push(comparison.value);
-                    paramIndex++;
-                }
-                else {
-                    conditions.push(`${qualifiedKey} IS NOT NULL`);
-                }
-            }
-            if (value.in !== undefined && Array.isArray(value.in)) {
-                const placeholders = value.in.map(() => `$${paramIndex++}`).join(', ');
-                conditions.push(`${qualifiedKey} IN (${placeholders})`);
-                values.push(...value.in);
-            }
-            if (value.gte !== undefined) {
-                conditions.push(`${qualifiedKey} >= $${paramIndex}`);
-                values.push(value.gte);
-                paramIndex++;
-            }
-            if (value.lte !== undefined) {
-                conditions.push(`${qualifiedKey} <= $${paramIndex}`);
-                values.push(value.lte);
-                paramIndex++;
-            }
-            if (value.gt !== undefined) {
-                conditions.push(`${qualifiedKey} > $${paramIndex}`);
-                values.push(value.gt);
-                paramIndex++;
-            }
-            if (value.lt !== undefined) {
-                conditions.push(`${qualifiedKey} < $${paramIndex}`);
-                values.push(value.lt);
-                paramIndex++;
-            }
-            if (value.contains !== undefined) {
-                conditions.push(`LOWER(${qualifiedKey}) LIKE LOWER($${paramIndex})`);
-                values.push(`%${value.contains}%`);
-                paramIndex++;
+            const qualifiedKey = `"${tablePrefix}"."${toSqlColumnName(key)}"`;
+            appendFilterConditions(qualifiedKey, value, conditions, values, paramIndex);
+        }
+    }
+    if (useJoinFilters) {
+        for (const joinFilter of joinFilters) {
+            const predicate = joinFilterSql(joinFilter, operations, tablePrefix, values, paramIndex);
+            if (predicate) {
+                conditions.push(predicate);
             }
         }
     }

package/dist/databases/utils/is-join-operation.util.d.ts

@@ -0,0 +1,3 @@
+import { type JoinOperation } from "../operations/join-operation.js";
+import { type Operation } from "../operations/operation.js";
+export declare function isJoinOperation(operation: Operation): operation is JoinOperation;

package/dist/databases/utils/is-join-operation.util.js

@@ -0,0 +1,6 @@
+import { InnerJoin } from "../operations/inner-join.operation.js";
+import { LeftJoin } from "../operations/left-join.operation.js";
+import { LeftJoinMany } from "../operations/left-join-many.operation.js";
+export function isJoinOperation(operation) {
+    return operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany;
+}

package/dist/databases/utils/resolve-join-filter.d.ts

@@ -0,0 +1,13 @@
+import type { IQueryOptions } from '@loomcore/common/models';
+import type { ClassifiedFilterKey } from '../models/classified-filter-key.js';
+import type { Operation } from '../operations/operation.js';
+import type { JoinOperation } from '../operations/join-operation.js';
+import { JoinFilter } from '../models/join-filter.interface.js';
+export declare function parentAliasOf(localField: string): string | null;
+export declare function findJoinOperation(operations: Operation[], alias: string): JoinOperation | undefined;
+export declare function logicalParentAlias(operation: JoinOperation, operations: Operation[], mainTableName: string): string | null;
+export declare function classifyFilterKey(key: string, operations: Operation[], mainTableName: string): ClassifiedFilterKey;
+export declare function splitFiltersByType(queryOptions: IQueryOptions, operations: Operation[], mainTableName: string): {
+    rootOptions: IQueryOptions;
+    joinFilters: JoinFilter[];
+};

package/dist/databases/utils/resolve-join-filter.js

@@ -0,0 +1,75 @@
+import { BadRequestError } from '../../errors/index.js';
+import { LeftJoinMany } from '../operations/left-join-many.operation.js';
+import { isJoinOperation } from './is-join-operation.util.js';
+export function parentAliasOf(localField) {
+    const dot = localField.indexOf('.');
+    if (dot === -1) {
+        return null;
+    }
+    return localField.slice(0, dot);
+}
+export function findJoinOperation(operations, alias) {
+    return operations.find((operation) => isJoinOperation(operation) && operation.as === alias);
+}
+export function logicalParentAlias(operation, operations, mainTableName) {
+    const rawParent = parentAliasOf(operation.localField);
+    if (rawParent === null || rawParent === mainTableName) {
+        return null;
+    }
+    const parent = findJoinOperation(operations, rawParent);
+    return parent ? parent.as : null;
+}
+export function classifyFilterKey(key, operations, mainTableName) {
+    if (!key.includes('.') || operations.length === 0) {
+        return { type: 'root' };
+    }
+    const parts = key.split('.');
+    if (parts.some(part => part.length === 0)) {
+        return { type: 'root' };
+    }
+    if (!findJoinOperation(operations, parts[0])) {
+        return { type: 'root' };
+    }
+    const column = parts[parts.length - 1];
+    const aliases = parts.slice(0, -1);
+    for (let index = 0; index < aliases.length; index++) {
+        const alias = aliases[index];
+        const operation = findJoinOperation(operations, alias);
+        if (!operation) {
+            throw new BadRequestError(`Invalid join filter "${key}": "${alias}" is not a joined table`);
+        }
+        const expectedParent = index === 0 ? null : aliases[index - 1];
+        const actualParent = logicalParentAlias(operation, operations, mainTableName);
+        if (actualParent !== expectedParent) {
+            const where = actualParent ? `"${actualParent}"` : 'the root collection';
+            throw new BadRequestError(`Invalid join filter "${key}": "${alias}" is nested under ${where}`);
+        }
+    }
+    const crossesMany = aliases.some(alias => findJoinOperation(operations, alias) instanceof LeftJoinMany);
+    return { type: 'join', aliases, column, crossesMany };
+}
+export function splitFiltersByType(queryOptions, operations, mainTableName) {
+    const rootFilters = {};
+    const joinFilters = [];
+    for (const [key, filter] of Object.entries(queryOptions.filters ?? {})) {
+        if (!filter) {
+            continue;
+        }
+        const classified = classifyFilterKey(key, operations, mainTableName);
+        if (classified.type === 'root') {
+            rootFilters[key] = filter;
+            continue;
+        }
+        joinFilters.push({
+            key,
+            filter,
+            aliases: classified.aliases,
+            column: classified.column,
+            crossesMany: classified.crossesMany,
+        });
+    }
+    return {
+        rootOptions: { ...queryOptions, filters: rootFilters },
+        joinFilters,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {