@loomcore/api 0.1.99 → 0.1.100

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

@@ -24,16 +24,7 @@ export function buildJoinClauses(operations, mainTableName) {
             const localRef = resolveLocalField(operation.localField, mainTableName);
             const foreignSnake = convertFieldToSnakeCase(operation.foreignField);
             const joinType = operation instanceof InnerJoin ? "INNER JOIN" : "LEFT JOIN";
-            if (operation instanceof LeftJoinMany) {
-                joinClause += ` ${joinType} (
-                    SELECT "${foreignSnake}", json_agg(row_to_json(_many.*)) AS aggregated
-                    FROM "${operation.from}" _many
-                    GROUP BY "${foreignSnake}"
-                ) AS ${operation.as} ON ${localRef} = ${operation.as}."${foreignSnake}"`;
-            }
-            else {
-                joinClause += ` ${joinType} "${operation.from}" AS ${operation.as} ON ${localRef} = ${operation.as}."${foreignSnake}"`;
-            }
+            joinClause = `${joinClause} ${joinType} "${operation.from}" AS ${operation.as} ON ${localRef} = ${operation.as}."${foreignSnake}"`;
         }
     }
     return joinClause;

package/dist/databases/postgres/utils/transform-join-results.d.ts

@@ -1,2 +1,2 @@
 import { Operation } from '../../operations/operation.js';
-export declare function transformJoinResults<T>(rows: any[], operations: Operation[]): T[];
+export declare function transformJoinResults<T>(rows: Record<string, unknown>[], operations: Operation[]): T[];

package/dist/databases/postgres/utils/transform-join-results.js

@@ -1,30 +1,6 @@
 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';
-function findNestedObject(obj, alias, path = []) {
-    if (obj[alias] !== undefined && obj[alias] !== null) {
-        return { obj: obj[alias], path: [...path, alias] };
-    }
-    for (const key in obj) {
-        if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
-            const found = findNestedObject(obj[key], alias, [...path, key]);
-            if (found !== null) {
-                return found;
-            }
-        }
-        else if (Array.isArray(obj[key])) {
-            for (const item of obj[key]) {
-                if (item && typeof item === 'object') {
-                    const found = findNestedObject(item, alias, [...path, key]);
-                    if (found !== null) {
-                        return found;
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}
 function parseJsonValue(value) {
     if (value === null || value === undefined) {
         return null;
@@ -39,137 +15,51 @@ function parseJsonValue(value) {
     }
     return value;
 }
-function findEnrichmentTarget(operation, operations) {
-    if (!operation.localField.includes('.')) {
-        return null;
-    }
-    const [alias] = operation.localField.split('.');
-    const target = operations.find(op => op instanceof LeftJoinMany && op.as === alias);
-    if (target && operations.indexOf(target) < operations.indexOf(operation)) {
-        return target;
-    }
-    return null;
-}
-function mapEnrichmentFieldName(fieldName, targetAlias) {
-    if (fieldName === 'policy_agents' && (targetAlias === 'client_policies' || targetAlias === 'policies')) {
-        return 'agents';
+function getJoinAliases(operations) {
+    const aliases = new Set();
+    for (const op of operations) {
+        if (op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany) {
+            aliases.add(op.as);
+        }
     }
-    return fieldName;
+    return aliases;
 }
+const PREFIX_SEP = '__';
 export function transformJoinResults(rows, 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 allJoinOperations = [...leftJoinOperations, ...innerJoinOperations];
-    if (allJoinOperations.length === 0 &&
-        leftJoinManyOperations.length === 0) {
+    const joinAliases = getJoinAliases(operations);
+    if (joinAliases.size === 0) {
         return rows;
     }
-    const allJoinAliases = [
-        ...allJoinOperations.map(j => j.as),
-        ...leftJoinManyOperations.map(j => j.as)
-    ];
-    const enrichmentMap = new Map();
-    for (const op of leftJoinManyOperations) {
-        const target = findEnrichmentTarget(op, operations);
-        if (target) {
-            enrichmentMap.set(op, target);
-        }
-    }
-    return rows.map(row => {
+    return rows.map((row) => {
         const transformed = {};
         const joinData = {};
+        const prefixedByAlias = {};
         for (const key of Object.keys(row)) {
-            const hasJoinPrefix = allJoinOperations.some(join => key.startsWith(`${join.as}__`));
-            const isJoinAlias = allJoinAliases.includes(key);
-            if (!hasJoinPrefix && !isJoinAlias) {
-                transformed[key] = row[key];
+            if (joinAliases.has(key)) {
+                joinData[key] = parseJsonValue(row[key]);
             }
-        }
-        for (const operation of operations) {
-            if (enrichmentMap.has(operation)) {
-                continue;
-            }
-            if (operation instanceof LeftJoin || operation instanceof InnerJoin) {
-                const prefix = `${operation.as}__`;
-                const joinedData = {};
-                let hasAnyData = false;
-                for (const key of Object.keys(row)) {
-                    if (key.startsWith(prefix)) {
-                        const columnName = key.substring(prefix.length);
-                        const value = row[key];
-                        joinedData[columnName] = value;
-                        if (value !== null && value !== undefined) {
-                            hasAnyData = true;
-                        }
-                    }
-                }
-                if (operation.localField.includes('.')) {
-                    const [tableAlias] = operation.localField.split('.');
-                    const relatedJoin = allJoinOperations.find(j => j.as === tableAlias);
-                    let targetObject = null;
-                    if (relatedJoin && joinData[relatedJoin.as]) {
-                        targetObject = joinData[relatedJoin.as];
-                    }
-                    else {
-                        const found = findNestedObject(joinData, tableAlias);
-                        if (found) {
-                            targetObject = found.obj;
-                        }
-                    }
-                    if (targetObject) {
-                        targetObject[operation.as] = hasAnyData ? joinedData : null;
-                    }
-                    else {
-                        joinData[operation.as] = hasAnyData ? joinedData : null;
-                    }
+            else if (key.includes(PREFIX_SEP)) {
+                const i = key.indexOf(PREFIX_SEP);
+                const alias = key.slice(0, i);
+                const column = key.slice(i + PREFIX_SEP.length);
+                if (joinAliases.has(alias)) {
+                    if (!prefixedByAlias[alias])
+                        prefixedByAlias[alias] = {};
+                    prefixedByAlias[alias][column] = row[key];
                 }
                 else {
-                    joinData[operation.as] = hasAnyData ? joinedData : null;
+                    transformed[key] = row[key];
                 }
             }
-            else if (operation instanceof LeftJoinMany) {
-                const jsonValue = parseJsonValue(row[operation.as]);
-                let parsedValue = Array.isArray(jsonValue) ? jsonValue : (jsonValue ? [jsonValue] : []);
-                const enrichments = Array.from(enrichmentMap.entries())
-                    .filter(([_, target]) => target === operation)
-                    .map(([enrichOp]) => enrichOp);
-                if (enrichments.length > 0 && Array.isArray(parsedValue)) {
-                    for (const item of parsedValue) {
-                        if (item && typeof item === 'object') {
-                            for (const enrichment of enrichments) {
-                                if (item[enrichment.as] !== undefined) {
-                                    const mappedName = mapEnrichmentFieldName(enrichment.as, operation.as);
-                                    if (mappedName !== enrichment.as) {
-                                        item[mappedName] = item[enrichment.as];
-                                        delete item[enrichment.as];
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                if (operation.localField.includes('.')) {
-                    const [tableAlias] = operation.localField.split('.');
-                    const relatedJoin = allJoinOperations.find(j => j.as === tableAlias);
-                    const relatedJoinMany = leftJoinManyOperations.find(j => j.as === tableAlias);
-                    let targetObject = null;
-                    if (relatedJoin && joinData[relatedJoin.as]) {
-                        targetObject = joinData[relatedJoin.as];
-                    }
-                    else if (relatedJoinMany && joinData[relatedJoinMany.as]) {
-                        targetObject = joinData[relatedJoinMany.as];
-                    }
-                    if (targetObject) {
-                        targetObject[operation.as] = parsedValue;
-                    }
-                    else {
-                        joinData[operation.as] = parsedValue;
-                    }
-                }
-                else {
-                    joinData[operation.as] = parsedValue;
-                }
+            else {
+                transformed[key] = row[key];
+            }
+        }
+        for (const alias of Object.keys(prefixedByAlias)) {
+            const obj = prefixedByAlias[alias];
+            const hasAny = Object.values(obj).some(v => v !== null && v !== undefined);
+            if (!(alias in joinData)) {
+                joinData[alias] = hasAny ? obj : null;
             }
         }
         if (Object.keys(joinData).length > 0) {

package/package.json

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