@loomcore/api 0.1.118 → 0.1.120

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

@@ -3,14 +3,18 @@ import { InnerJoin } from "../../operations/inner-join.operation.js";
 import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildSelectClause } from '../utils/build-select-clause.js';
-import { transformJoinResults } from '../utils/transform-join-results.js';
 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 joinClauses = hasJoins
+        ? buildJoinClauses(operations, pluralResourceName, { oneToOneOnly: true })
+        : buildJoinClauses(operations, pluralResourceName);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
     const query = `SELECT ${selectClause} FROM "${pluralResourceName}" ${joinClauses}`;
     const result = await client.query(query);
-    return transformJoinResults(result.rows, operations);
+    if (hasJoins) {
+        return result.rows.map(r => r.entity);
+    }
+    return result.rows;
 }

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

@@ -3,14 +3,15 @@ import { InnerJoin } from "../../operations/inner-join.operation.js";
 import { LeftJoinMany } from "../../operations/left-join-many.operation.js";
 import { buildJoinClauses } from "../utils/build-join-clauses.js";
 import { buildSelectClause } from "../utils/build-select-clause.js";
-import { transformJoinResults } from "../utils/transform-join-results.js";
 import { BadRequestError } from '../../../errors/index.js';
 import { buildWhereClause } from '../utils/build-where-clause.js';
 export async function getById(client, operations, queryObject, id, pluralResourceName) {
     if (!id)
         throw new BadRequestError('id is required');
-    const joinClauses = buildJoinClauses(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 selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
@@ -23,6 +24,8 @@ export async function getById(client, operations, queryObject, id, pluralResourc
     if (result.rows.length === 0) {
         return null;
     }
-    const transformed = transformJoinResults([result.rows[0]], operations);
-    return transformed[0] || null;
+    if (hasJoins) {
+        return result.rows[0].entity;
+    }
+    return result.rows[0];
 }

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

@@ -5,15 +5,16 @@ 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";
 import { buildSelectClause } from "../utils/build-select-clause.js";
-import { transformJoinResults } from "../utils/transform-join-results.js";
 import { executeCountQuery } from "../utils/build-count-query.js";
 import { apiUtils } from "../../../utils/api.utils.js";
 import { buildPaginationClause } from '../utils/build-pagination-clause.js';
 export async function get(client, operations, queryOptions, pluralResourceName) {
-    const joinClauses = buildJoinClauses(operations, pluralResourceName);
-    const orderByClause = buildOrderByClause(queryOptions);
-    const paginationClause = buildPaginationClause(queryOptions);
     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 paginationClause = buildPaginationClause(queryOptions);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, operations)
         : '*';
@@ -23,6 +24,8 @@ export async function get(client, operations, queryOptions, pluralResourceName)
     const total = await executeCountQuery(client, pluralResourceName, queryOptions);
     const dataQuery = `${baseQuery} ${orderByClause} ${paginationClause}`.trim();
     const dataResult = await client.query(dataQuery, values);
-    const entities = transformJoinResults(dataResult.rows, operations);
+    const entities = hasJoins
+        ? dataResult.rows.map(r => r.entity)
+        : dataResult.rows;
     return apiUtils.getPagedResult(entities, total, queryOptions);
 }

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

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

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

@@ -1,11 +1,42 @@
 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";
-export function buildJoinClauses(operations, mainTableName) {
+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]);
+        }
+    }
+    return through;
+}
+export function buildJoinClauses(operations, mainTableName, options) {
+    const oneToOneOnly = options?.oneToOneOnly ?? false;
+    const throughTableAliases = oneToOneOnly ? getThroughTableAliases(operations) : new Set();
     const joinClauses = [];
+    const oneToOneAliasesInScope = new Set();
     for (const operation of operations) {
+        if (operation instanceof LeftJoinMany) {
+            if (oneToOneOnly)
+                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);
+            }
+        }
         if (operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany) {
-            const joinType = operation instanceof InnerJoin ? "INNER JOIN" : "LEFT JOIN";
+            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(".");

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

@@ -1,2 +1,5 @@
 import { IQueryOptions } from "@loomcore/common/models";
-export declare function buildOrderByClause(queryObject: IQueryOptions): string;
+export interface BuildOrderByClauseOptions {
+    tablePrefix?: string;
+}
+export declare function buildOrderByClause(queryObject: IQueryOptions, options?: BuildOrderByClauseOptions): string;

package/dist/databases/postgres/utils/build-order-by-clause.js

@@ -1,8 +1,9 @@
-export function buildOrderByClause(queryObject) {
+export function buildOrderByClause(queryObject, options) {
     if (!queryObject.orderBy) {
         return '';
     }
     const orderBy = queryObject.orderBy;
     const sortDirection = queryObject.sortDirection || 'asc';
-    return `ORDER BY ${orderBy} ${sortDirection}`;
+    const qualified = options?.tablePrefix ? `"${options.tablePrefix}"."${orderBy}"` : orderBy;
+    return `ORDER BY ${qualified} ${sortDirection}`;
 }

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

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

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

@@ -1,7 +1,8 @@
 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';
-async function getTableColumns(client, tableName) {
+const PK = '_id';
+export async function getTableColumns(client, tableName) {
     const result = await client.query(`
             SELECT column_name
             FROM information_schema.columns
@@ -11,19 +12,176 @@ async function getTableColumns(client, tableName) {
         `, [tableName]);
     return result.rows.map(row => row.column_name);
 }
+function getParentAlias(localField) {
+    if (!localField.includes('.'))
+        return null;
+    return localField.split('.')[0];
+}
+function getChildOperations(operations, parentAlias) {
+    return operations.filter(op => {
+        const p = getParentAlias(op.localField);
+        return p === parentAlias;
+    });
+}
+function getTopLevelOperations(operations, mainTableName) {
+    return operations.filter(op => {
+        const p = getParentAlias(op.localField);
+        return p === null || p === mainTableName;
+    });
+}
+function sqlQuote(s) {
+    return "'" + s.replace(/'/g, "''") + "'";
+}
+function jsonbBuildObject(entries) {
+    if (entries.length === 0)
+        return "''{}''::jsonb";
+    const parts = entries.flatMap(({ key, expr }) => [sqlQuote(key), expr]);
+    return `jsonb_build_object(${parts.join(', ')})`;
+}
+function buildParentRef(localField, mainTableName) {
+    if (!localField.includes('.')) {
+        return `"${mainTableName}"."${localField}"`;
+    }
+    const [alias, column] = localField.split('.');
+    return `"${alias}"."${column}"`;
+}
+async function buildOneToOneValue(client, op, operations, mainTableName, inScopeAliases) {
+    const alias = op.as;
+    const columns = await getTableColumns(client, op.from);
+    const childOps = getChildOperations(operations, alias);
+    const entries = columns.map(col => ({
+        key: col,
+        expr: `"${alias}"."${col}"`
+    }));
+    for (const child of childOps) {
+        if (child instanceof LeftJoin || child instanceof InnerJoin) {
+            const childVal = await buildOneToOneValue(client, child, operations, mainTableName, inScopeAliases);
+            entries.push({ key: child.as, expr: childVal });
+        }
+        else if (child instanceof LeftJoinMany) {
+            const childVal = await buildManyValue(client, child, operations, mainTableName, alias, inScopeAliases);
+            entries.push({ key: child.as, expr: childVal });
+        }
+    }
+    const obj = jsonbBuildObject(entries);
+    return `CASE WHEN "${alias}"."${PK}" IS NOT NULL THEN ${obj} ELSE NULL END`;
+}
+function getThroughJoin(operations, localField) {
+    if (!localField.includes('.'))
+        return null;
+    const throughAlias = localField.split('.')[0];
+    const throughOp = operations.find(o => o instanceof InnerJoin && o.as === throughAlias);
+    return throughOp ?? null;
+}
+function getThroughAliasesUsedBySiblings(childOps) {
+    const throughAliases = new Set();
+    for (const op of childOps) {
+        if (op instanceof LeftJoinMany && op.localField.includes('.')) {
+            throughAliases.add(op.localField.split('.')[0]);
+        }
+    }
+    return throughAliases;
+}
+async function buildManyValue(client, op, operations, mainTableName, parentAlias, inScopeAliases) {
+    const alias = op.as;
+    const columns = await getTableColumns(client, op.from);
+    const childOps = getChildOperations(operations, alias);
+    const throughJoin = getThroughJoin(operations, op.localField);
+    const parentRef = buildParentRef(op.localField, mainTableName);
+    let fromClause;
+    let whereClause;
+    if (throughJoin) {
+        const throughAlias = throughJoin.as;
+        const linkColumn = op.localField.split('.')[1];
+        fromClause = `"${throughJoin.from}" AS "${throughAlias}" INNER JOIN "${op.from}" AS "${alias}" ON "${throughAlias}"."${linkColumn}" = "${alias}"."${op.foreignField}"`;
+        const throughParentRef = buildParentRef(throughJoin.localField, mainTableName);
+        whereClause = `"${throughAlias}"."${throughJoin.foreignField}" = ${throughParentRef}`;
+    }
+    else {
+        fromClause = `"${op.from}" AS "${alias}"`;
+        whereClause = `"${alias}"."${op.foreignField}" = ${parentRef}`;
+    }
+    const throughAliasesUsedBySiblings = getThroughAliasesUsedBySiblings(childOps);
+    const oneToOneChildren = childOps.filter(c => c instanceof LeftJoin || c instanceof InnerJoin);
+    for (const child of oneToOneChildren) {
+        const leftCol = child.localField.includes('.') ? child.localField.split('.')[1] : child.localField;
+        fromClause += ` LEFT JOIN "${child.from}" AS "${child.as}" ON "${alias}"."${leftCol}" = "${child.as}"."${child.foreignField}"`;
+    }
+    const itemEntries = columns.map(col => ({
+        key: col,
+        expr: `"${alias}"."${col}"`
+    }));
+    for (const child of childOps) {
+        if (child instanceof LeftJoin || child instanceof InnerJoin) {
+            const childColumns = await getTableColumns(client, child.from);
+            const nestedChildOps = getChildOperations(operations, child.as);
+            const nestedEntries = childColumns.map(c => ({
+                key: c,
+                expr: `"${child.as}"."${c}"`
+            }));
+            for (const n of nestedChildOps) {
+                if (n instanceof LeftJoin || n instanceof InnerJoin) {
+                    const grandCols = await getTableColumns(client, n.from);
+                    nestedEntries.push(...grandCols.map(c => ({ key: c, expr: `"${n.as}"."${c}"` })));
+                }
+                else if (n instanceof LeftJoinMany) {
+                    const sub = await buildManyValue(client, n, operations, mainTableName, child.as, inScopeAliases);
+                    nestedEntries.push({ key: n.as, expr: sub });
+                }
+            }
+            const nestedObj = jsonbBuildObject(nestedEntries);
+            itemEntries.push({
+                key: child.as,
+                expr: `CASE WHEN "${child.as}"."${PK}" IS NOT NULL THEN ${nestedObj} ELSE NULL END`
+            });
+        }
+        else if (child instanceof LeftJoinMany) {
+            const sub = await buildManyValue(client, child, operations, mainTableName, alias, inScopeAliases);
+            itemEntries.push({ key: child.as, expr: sub });
+        }
+    }
+    const itemExpr = jsonbBuildObject(itemEntries);
+    if (throughAliasesUsedBySiblings.size > 0) {
+        const orderByPk = `"${alias}"."${PK}"`;
+        const innerSelect = `SELECT DISTINCT ON (${orderByPk}) ${itemExpr} AS item FROM ${fromClause} WHERE ${whereClause} ORDER BY ${orderByPk}`;
+        return `(SELECT COALESCE(jsonb_agg(sub.item), '[]'::jsonb) FROM (${innerSelect}) sub)`;
+    }
+    return `(SELECT COALESCE(jsonb_agg(${itemExpr}), '[]'::jsonb) FROM ${fromClause} WHERE ${whereClause})`;
+}
+async function buildJoinDataObject(client, operations, mainTableName) {
+    const topLevel = getTopLevelOperations(operations, mainTableName);
+    const oneToOneAliases = new Set(operations.filter(o => o instanceof LeftJoin || o instanceof InnerJoin).map(o => o.as));
+    const entries = [];
+    for (const op of topLevel) {
+        if (op instanceof LeftJoin || op instanceof InnerJoin) {
+            const val = await buildOneToOneValue(client, op, operations, mainTableName, oneToOneAliases);
+            entries.push({ key: op.as, expr: val });
+        }
+        else if (op instanceof LeftJoinMany) {
+            const parentRef = buildParentRef(op.localField, mainTableName);
+            const val = await buildManyValue(client, op, operations, mainTableName, mainTableName, oneToOneAliases);
+            entries.push({ key: op.as, expr: val });
+        }
+    }
+    if (entries.length === 0)
+        return "''{}''::jsonb";
+    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 mainTableColumns = await getTableColumns(client, mainTableName);
-    const mainSelects = mainTableColumns.map(col => `"${mainTableName}"."${col}" AS "${col}"`);
-    const joinSelects = [];
-    for (const join of [...leftJoinOperations, ...innerJoinOperations, ...leftJoinManyOperations]) {
-        const joinColumns = await getTableColumns(client, join.from);
-        for (const col of joinColumns) {
-            joinSelects.push(`"${join.as}"."${col}" AS "${join.as}__${col}"`);
-        }
+    const hasJoins = leftJoinOperations.length > 0 || innerJoinOperations.length > 0 || leftJoinManyOperations.length > 0;
+    if (!hasJoins) {
+        return '*';
     }
-    const allSelects = [...mainSelects, ...joinSelects];
-    return allSelects.join(', ');
+    const mainColumns = await getTableColumns(client, mainTableName);
+    const mainEntries = mainColumns.map(col => ({
+        key: col,
+        expr: `"${mainTableName}"."${col}"`
+    }));
+    const joinDataExpr = await buildJoinDataObject(client, operations, mainTableName);
+    mainEntries.push({ key: '_joinData', expr: joinDataExpr });
+    const entityExpr = jsonbBuildObject(mainEntries);
+    return `${entityExpr} AS entity`;
 }

package/dist/middleware/error-handler.js

@@ -47,7 +47,7 @@ export const errorHandler = (err, req, res, next) => {
     }
     else {
         apiUtils.apiResponse(res, 500, {
-            errors: [{ message: 'Server Error' }]
+            errors: [{ message: err.message }]
         });
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.118",
+  "version": "0.1.120",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -58,7 +58,7 @@
     "qs": "^6.15.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.52",
+    "@loomcore/common": "^0.0.54",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",