@loomcore/api 0.2.68 → 0.2.70

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/build-no-sql-match.util.js

@@ -2,6 +2,7 @@ import { entityUtils } from '@loomcore/common/utils';
 import { ObjectId } from 'mongodb';
 import { PROPERTIES_THAT_ARE_NOT_OBJECT_IDS } from '../../models/constants.js';
 import { getPropertySchema } from '../../utils/get-property-schema.util.js';
+import { readFilterValue } from '../../utils/nullish-filter-value.js';
 function isExcludedFromObjectIdConversion(key) {
     return PROPERTIES_THAT_ARE_NOT_OBJECT_IDS.includes(key);
 }
@@ -36,16 +37,41 @@ export function buildNoSqlMatch(queryOptions, modelSpec) {
         if (value) {
             const propSchema = schema ? getPropertySchema(key, schema) : undefined;
             if (value.eq !== undefined) {
-                const valueToCompare = value.eq;
-                if (shouldConvertEqToObjectId(key, propSchema, hasSchema)
-                    && typeof valueToCompare === 'string' && entityUtils.isValidObjectId(valueToCompare)) {
-                    match[key] = new ObjectId(valueToCompare);
+                const comparison = readFilterValue(value.eq);
+                if (comparison.kind === 'null') {
+                    match[key] = { $type: 'null' };
                 }
-                else if (typeof valueToCompare === 'string' && !isNaN(Number(valueToCompare))) {
-                    match[key] = Number(valueToCompare);
+                else if (comparison.kind === 'undefined') {
+                    match[key] = { $exists: false };
+                }
+                else if (shouldConvertEqToObjectId(key, propSchema, hasSchema)
+                    && typeof comparison.value === 'string' && entityUtils.isValidObjectId(comparison.value)) {
+                    match[key] = new ObjectId(comparison.value);
+                }
+                else if (typeof comparison.value === 'string' && !isNaN(Number(comparison.value))) {
+                    match[key] = Number(comparison.value);
+                }
+                else {
+                    match[key] = comparison.value;
+                }
+            }
+            if (value.ne !== undefined) {
+                const comparison = readFilterValue(value.ne);
+                if (comparison.kind === 'null') {
+                    match[key] = { $not: { $type: 'null' } };
+                }
+                else if (comparison.kind === 'undefined') {
+                    match[key] = { $exists: true };
+                }
+                else if (shouldConvertEqToObjectId(key, propSchema, hasSchema)
+                    && typeof comparison.value === 'string' && entityUtils.isValidObjectId(comparison.value)) {
+                    match[key] = { $ne: new ObjectId(comparison.value) };
+                }
+                else if (typeof comparison.value === 'string' && !isNaN(Number(comparison.value))) {
+                    match[key] = { $ne: Number(comparison.value) };
                 }
                 else {
-                    match[key] = valueToCompare;
+                    match[key] = { $ne: comparison.value };
                 }
             }
             if (value.in !== undefined && Array.isArray(value.in)) {

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;