@loomcore/api 0.2.68 → 0.2.70

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,63 +1,24 @@
-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) {
-                conditions.push(`(${qualifiedKey} = $${paramIndex} OR (${qualifiedKey} IS NULL AND $${paramIndex} IS NULL))`);
-                values.push(value.eq);
-                paramIndex++;
-            }
-            if (value.ne !== undefined) {
-                conditions.push(`(${qualifiedKey} != $${paramIndex} OR (${qualifiedKey} IS NOT NULL AND $${paramIndex} IS NULL) OR (${qualifiedKey} IS NULL AND $${paramIndex} IS NOT NULL))`);
-                values.push(value.ne);
-                paramIndex++;
-            }
-            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/nullish-filter-value.d.ts

@@ -0,0 +1,9 @@
+export type FilterComparison = {
+    kind: 'null';
+} | {
+    kind: 'undefined';
+} | {
+    kind: 'value';
+    value: unknown;
+};
+export declare function readFilterValue(raw: unknown): FilterComparison;

package/dist/databases/utils/nullish-filter-value.js

@@ -0,0 +1,15 @@
+export function readFilterValue(raw) {
+    if (typeof raw === 'string' && raw.startsWith('"') && raw.endsWith('"')) {
+        const inner = raw.slice(1, -1);
+        if (inner === 'null' || inner === 'undefined') {
+            return { kind: 'value', value: inner };
+        }
+    }
+    if (raw === null || raw === 'null') {
+        return { kind: 'null' };
+    }
+    if (raw === 'undefined') {
+        return { kind: 'undefined' };
+    }
+    return { kind: 'value', value: raw };
+}

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.68",
+  "version": "0.2.70",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {