@loomcore/api 0.1.99 → 0.1.101

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

@@ -1,6 +1,5 @@
 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 { toSnakeCase } from "./convert-keys.util.js";
 function convertFieldToSnakeCase(field) {
     if (field.startsWith("_")) {
@@ -20,20 +19,11 @@ function resolveLocalField(localField, mainTableName) {
 export function buildJoinClauses(operations, mainTableName) {
     let joinClause = "";
     for (const operation of operations) {
-        if (operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany) {
+        if (operation instanceof LeftJoin || operation instanceof InnerJoin) {
             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/build-select-clause.js

@@ -1,6 +1,22 @@
 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 { toSnakeCase } from './convert-keys.util.js';
+function convertFieldToSnakeCase(field) {
+    if (field.startsWith('_')) {
+        return field;
+    }
+    return toSnakeCase(field);
+}
+function resolveLocalRef(localField, mainTableName) {
+    if (!localField.includes('.')) {
+        const snake = convertFieldToSnakeCase(localField);
+        return `"${mainTableName}"."${snake}"`;
+    }
+    const [alias, field] = localField.split('.');
+    const snake = convertFieldToSnakeCase(field);
+    return `${alias}."${snake}"`;
+}
 async function getTableColumns(client, tableName) {
     const result = await client.query(`
             SELECT column_name
@@ -40,7 +56,13 @@ export async function buildSelectClause(client, mainTableName, mainTableAlias, o
         if (enrichment) {
             continue;
         }
-        joinSelects.push(`${joinMany.as}.aggregated AS "${joinMany.as}"`);
+        const manyColumns = await getTableColumns(client, joinMany.from);
+        const foreignSnake = convertFieldToSnakeCase(joinMany.foreignField);
+        const localRef = resolveLocalRef(joinMany.localField, mainTableName);
+        const subAlias = `_sub_${joinMany.as}`;
+        const objParts = manyColumns.map(c => `'${c.replace(/'/g, "''")}', ${subAlias}."${c}"`).join(', ');
+        const subquery = `(SELECT COALESCE(jsonb_agg(jsonb_build_object(${objParts})), '[]'::jsonb) FROM "${joinMany.from}" AS ${subAlias} WHERE ${subAlias}."${foreignSnake}" = ${localRef})`;
+        joinSelects.push(`${subquery} AS "${joinMany.as}"`);
     }
     const allSelects = [...mainSelects, ...joinSelects];
     return allSelects.join(', ');

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