@loomcore/api 0.1.111 → 0.1.113

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

@@ -44,7 +44,7 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
         queryObject.filters._id = { in: entityIds };
         const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);
         const selectClause = hasJoins
-            ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+            ? await buildSelectClause(client, pluralResourceName, operations)
             : '*';
         const selectQuery = `
             SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}

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

@@ -8,7 +8,7 @@ export async function getAll(client, operations, pluralResourceName) {
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
     const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
     const selectClause = hasJoins
-        ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+        ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
     const query = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}`;
     const result = await client.query(query);

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

@@ -12,7 +12,7 @@ export async function getById(client, operations, queryObject, id, pluralResourc
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
     const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
     const selectClause = hasJoins
-        ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+        ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
     queryObject.filters || (queryObject.filters = {});
     queryObject.filters._id = { eq: id };

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

@@ -15,7 +15,7 @@ export async function get(client, operations, queryOptions, pluralResourceName)
     const paginationClause = buildPaginationClause(queryOptions);
     const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
     const selectClause = hasJoins
-        ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
+        ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
     const tablePrefix = hasJoins ? pluralResourceName : undefined;
     const { whereClause, values } = buildWhereClause(queryOptions, [], tablePrefix);

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

@@ -1,2 +1,2 @@
 import { Operation } from "../../operations/operation.js";
-export declare function buildJoinClauses(operations: Operation[], mainTableName: string): string;
+export declare function buildJoinClauses(operations: Operation[], mainTableName?: string): string;

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

@@ -7,24 +7,17 @@ function convertFieldToSnakeCase(field) {
     }
     return toSnakeCase(field);
 }
-function resolveLocalField(localField, mainTableName) {
-    if (!localField.includes(".")) {
-        const snake = convertFieldToSnakeCase(localField);
-        return `"${mainTableName}"."${snake}"`;
-    }
-    const [alias, field] = localField.split(".");
-    const snake = convertFieldToSnakeCase(field);
-    return `${alias}."${snake}"`;
-}
 export function buildJoinClauses(operations, mainTableName) {
-    let joinClause = "";
+    let joinClauses = [];
     for (const operation of operations) {
         if (operation instanceof LeftJoin || operation instanceof InnerJoin) {
-            const localRef = resolveLocalField(operation.localField, mainTableName);
+            const localRef = convertFieldToSnakeCase(operation.localField);
             const foreignSnake = convertFieldToSnakeCase(operation.foreignField);
             const joinType = operation instanceof InnerJoin ? "INNER JOIN" : "LEFT JOIN";
-            joinClause = `${joinClause} ${joinType} "${operation.from}" AS ${operation.as} ON ${localRef} = ${operation.as}."${foreignSnake}"`;
+            const joinTable = `"${operation.from}" AS "${operation.as}"`;
+            const leftSide = mainTableName ? `"${mainTableName}"."${localRef}"` : localRef;
+            joinClauses.push(`${joinType} ${joinTable} ON ${leftSide} = ${operation.as}."${foreignSnake}"`);
         }
     }
-    return joinClause;
+    return joinClauses.join('\n');
 }

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

@@ -1,3 +1,3 @@
 import { Client } from 'pg';
 import { Operation } from '../../operations/operation.js';
-export declare function buildSelectClause(client: Client, mainTableName: string, mainTableAlias: string, operations: Operation[]): Promise<string>;
+export declare function buildSelectClause(client: Client, mainTableName: string, operations: Operation[]): Promise<string>;

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

@@ -1,29 +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';
-import { toSnakeCase } from './convert-keys.util.js';
-function convertFieldToSnakeCase(field) {
-    if (field.startsWith('_')) {
-        return field;
-    }
-    return toSnakeCase(field);
-}
-function resolveLocalRef(localField, mainTableName, operations, currentIndex) {
-    if (!localField.includes('.')) {
-        const snake = convertFieldToSnakeCase(localField);
-        return `"${mainTableName}"."${snake}"`;
-    }
-    const [alias, field] = localField.split('.');
-    const snake = convertFieldToSnakeCase(field);
-    const priorOps = operations.slice(0, currentIndex);
-    const leftJoinMany = priorOps.find((op) => op instanceof LeftJoinMany && op.as === alias);
-    if (leftJoinMany) {
-        const castType = field === '_id' || snake === '_id' ? '::int' : '::text';
-        const elemAlias = `_elem_${alias}`;
-        return `(SELECT (${elemAlias}->>'${snake}')${castType} FROM jsonb_array_elements("${alias}") AS ${elemAlias})`;
-    }
-    return `${alias}."${snake}"`;
-}
 async function getTableColumns(client, tableName) {
     const result = await client.query(`
             SELECT column_name
@@ -45,62 +22,19 @@ function findEnrichmentTarget(operation, operations) {
     }
     return null;
 }
-export async function buildSelectClause(client, mainTableName, mainTableAlias, operations) {
+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 mainTableColumns = await getTableColumns(client, mainTableName);
     const mainSelects = mainTableColumns.map(col => `"${mainTableName}"."${col}" AS "${col}"`);
     const joinSelects = [];
-    for (const join of [...leftJoinOperations, ...innerJoinOperations]) {
+    for (const join of [...leftJoinOperations, ...leftJoinManyOperations, ...innerJoinOperations]) {
         const joinColumns = await getTableColumns(client, join.from);
         for (const col of joinColumns) {
             joinSelects.push(`${join.as}."${col}" AS "${join.as}__${col}"`);
         }
     }
-    for (let i = 0; i < leftJoinManyOperations.length; i++) {
-        const joinMany = leftJoinManyOperations[i];
-        const manyColumns = await getTableColumns(client, joinMany.from);
-        const foreignSnake = convertFieldToSnakeCase(joinMany.foreignField);
-        const currentOpIndex = operations.indexOf(joinMany);
-        const localRef = resolveLocalRef(joinMany.localField, mainTableName, operations, currentOpIndex);
-        const subAlias = `_sub_${joinMany.as}`;
-        const objParts = manyColumns.map(c => `'${c.replace(/'/g, "''")}', ${subAlias}."${c}"`).join(', ');
-        const priorOps = operations.slice(0, currentOpIndex);
-        const referencedLeftJoinMany = joinMany.localField.includes('.')
-            ? priorOps.find((op) => op instanceof LeftJoinMany && op.as === joinMany.localField.split('.')[0])
-            : null;
-        let whereClause;
-        if (referencedLeftJoinMany) {
-            const [prevAlias, fieldName] = joinMany.localField.split('.');
-            const prevFieldSnake = convertFieldToSnakeCase(fieldName);
-            const buildNestedInQuery = (refOp, extractField) => {
-                const extractFieldSnake = convertFieldToSnakeCase(extractField);
-                const refForeignSnake = convertFieldToSnakeCase(refOp.foreignField);
-                if (!refOp.localField.includes('.')) {
-                    const refLocalSnake = convertFieldToSnakeCase(refOp.localField);
-                    return `(SELECT "${extractFieldSnake}" FROM "${refOp.from}" WHERE "${refOp.from}"."${refForeignSnake}" = "${mainTableName}"."${refLocalSnake}")`;
-                }
-                const [parentAlias, parentField] = refOp.localField.split('.');
-                const parentOpIndex = operations.indexOf(refOp);
-                const parentOp = operations.slice(0, parentOpIndex).find((op) => op instanceof LeftJoinMany && op.as === parentAlias);
-                if (parentOp) {
-                    const parentFieldSnake = convertFieldToSnakeCase(parentField);
-                    const nestedQuery = buildNestedInQuery(parentOp, parentFieldSnake);
-                    return `(SELECT "${extractFieldSnake}" FROM "${refOp.from}" WHERE "${refOp.from}"."${refForeignSnake}" IN ${nestedQuery})`;
-                }
-                const parentFieldSnake = convertFieldToSnakeCase(parentField);
-                return `(SELECT "${extractFieldSnake}" FROM "${refOp.from}" WHERE "${refOp.from}"."${refForeignSnake}" = ${parentAlias}."${parentFieldSnake}")`;
-            };
-            const nestedQuery = buildNestedInQuery(referencedLeftJoinMany, prevFieldSnake);
-            whereClause = `${subAlias}."${foreignSnake}" IN ${nestedQuery}`;
-        }
-        else {
-            whereClause = `${subAlias}."${foreignSnake}" = ${localRef}`;
-        }
-        const subquery = `(SELECT COALESCE(jsonb_agg(jsonb_build_object(${objParts})), '[]'::jsonb) FROM "${joinMany.from}" AS ${subAlias} WHERE ${whereClause})`;
-        joinSelects.push(`${subquery} AS "${joinMany.as}"`);
-    }
     const allSelects = [...mainSelects, ...joinSelects];
-    return allSelects.join(', ');
+    return allSelects.join(',\n');
 }

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: Record<string, unknown>[], operations: Operation[]): T[];
+export declare function transformJoinResults<T>(rows: any[], operations: Operation[]): T[];

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

@@ -1,6 +1,30 @@
 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;
@@ -15,88 +39,90 @@ function parseJsonValue(value) {
     }
     return value;
 }
-function getJoinAliasesAndParents(operations) {
-    const aliases = new Set();
-    const parentByAlias = new Map();
-    for (const op of operations) {
-        if (op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany) {
-            aliases.add(op.as);
-            const parent = op.localField.includes('.') ? op.localField.split('.')[0] : null;
-            parentByAlias.set(op.as, parent);
-        }
-    }
-    return { aliases, parentByAlias };
-}
-const PREFIX_SEP = '__';
-function setJoinValue(joinData, alias, value, parentByAlias, operations) {
-    const parent = parentByAlias.get(alias) ?? null;
-    if (parent) {
-        const parentValue = joinData[parent];
-        const parentOp = operations.find(op => (op instanceof LeftJoinMany || op instanceof LeftJoin || op instanceof InnerJoin) && op.as === parent);
-        const isParentArray = parentOp instanceof LeftJoinMany;
-        if (isParentArray && Array.isArray(parentValue)) {
-            joinData[alias] = value;
-        }
-        else {
-            let parentObj = parentValue;
-            if (parentObj == null || typeof parentObj !== 'object' || Array.isArray(parentObj)) {
-                parentObj = {};
-                joinData[parent] = parentObj;
-            }
-            parentObj[alias] = value;
-        }
-    }
-    else {
-        joinData[alias] = value;
-    }
-}
 export function transformJoinResults(rows, operations) {
-    const { aliases: joinAliases, parentByAlias } = getJoinAliasesAndParents(operations);
-    if (joinAliases.size === 0) {
+    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, ...leftJoinManyOperations];
+    if (allJoinOperations.length === 0) {
         return rows;
     }
-    return rows.map((row) => {
+    const allJoinAliases = allJoinOperations.map(j => j.as);
+    return rows.map(row => {
         const transformed = {};
-        const flatJoinValues = {};
-        const prefixedByAlias = {};
+        const joinData = {};
         for (const key of Object.keys(row)) {
-            if (joinAliases.has(key)) {
-                flatJoinValues[key] = parseJsonValue(row[key]);
+            const hasJoinPrefix = allJoinOperations.some(join => key.startsWith(`${join.as}__`));
+            const isJoinAlias = allJoinAliases.includes(key);
+            if (!hasJoinPrefix && !isJoinAlias) {
+                transformed[key] = row[key];
             }
-            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];
+        }
+        for (const operation of operations) {
+            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 {
-                    transformed[key] = row[key];
+                    joinData[operation.as] = hasAnyData ? joinedData : null;
                 }
             }
-            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 flatJoinValues)) {
-                flatJoinValues[alias] = hasAny ? obj : null;
+            else if (operation instanceof LeftJoinMany) {
+                const jsonValue = parseJsonValue(row[operation.as]);
+                let parsedValue = Array.isArray(jsonValue) ? jsonValue : (jsonValue ? [jsonValue] : []);
+                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;
+                }
             }
         }
-        const joinData = {};
-        for (const op of operations) {
-            if (!(op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany))
-                continue;
-            const alias = op.as;
-            const value = flatJoinValues[alias];
-            if (value === undefined)
-                continue;
-            setJoinValue(joinData, alias, value, parentByAlias, operations);
-        }
         if (Object.keys(joinData).length > 0) {
             transformed._joinData = joinData;
         }

package/package.json

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