@loomcore/api 0.1.97 → 0.1.99

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

@@ -1,7 +1,6 @@
-import { Join } from "../../operations/join.operation.js";
-import { JoinMany } from "../../operations/join-many.operation.js";
-import { JoinThrough } from "../../operations/join-through.operation.js";
-import { JoinThroughMany } from "../../operations/join-through-many.operation.js";
+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 { buildJoinClauses } from "../utils/build-join-clauses.js";
 import { buildSelectClause } from "../utils/build-select-clause.js";
 import { transformJoinResults } from "../utils/transform-join-results.js";
@@ -11,7 +10,7 @@ export async function getById(client, operations, queryObject, id, pluralResourc
     if (!id)
         throw new BadRequestError('id is required');
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
-    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany);
+    const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

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

@@ -1,7 +1,6 @@
-import { Join } from "../../operations/join.operation.js";
-import { JoinMany } from "../../operations/join-many.operation.js";
-import { JoinThrough } from "../../operations/join-through.operation.js";
-import { JoinThroughMany } from "../../operations/join-through-many.operation.js";
+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 { buildWhereClause } from "../utils/build-where-clause.js";
 import { buildOrderByClause } from "../utils/build-order-by-clause.js";
 import { buildJoinClauses } from "../utils/build-join-clauses.js";
@@ -14,7 +13,7 @@ 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 Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany);
+    const hasJoins = operations.some(op => op instanceof LeftJoin || op instanceof InnerJoin || op instanceof LeftJoinMany);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

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

@@ -1,374 +1,40 @@
-import { Join } from "../../operations/join.operation.js";
-import { JoinMany } from "../../operations/join-many.operation.js";
-import { JoinThrough } from "../../operations/join-through.operation.js";
-import { JoinThroughMany } from "../../operations/join-through-many.operation.js";
+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('_')) {
+    if (field.startsWith("_")) {
         return field;
     }
-    else if (field === 'id') {
-        return '_id';
-    }
-    else {
-        return toSnakeCase(field);
-    }
+    return toSnakeCase(field);
 }
-function resolveLocalField(localField, mainTableName, operations) {
-    if (!localField.includes('.')) {
-        const snakeField = convertFieldToSnakeCase(localField);
-        return mainTableName
-            ? `"${mainTableName}"."${snakeField}"`
-            : `"${snakeField}"`;
-    }
-    const [alias, field] = localField.split('.');
-    const objectJoin = operations.find(op => op instanceof JoinThrough && op.as === alias);
-    if (objectJoin) {
-        return `(${alias}.aggregated->>'${field}')::integer`;
-    }
-    const arrayJoin = operations.find(op => (op instanceof JoinMany || op instanceof JoinThroughMany) && op.as === alias);
-    if (arrayJoin) {
-        return `(${alias}.aggregated->>'${field}')::integer`;
-    }
-    const snakeField = convertFieldToSnakeCase(field);
-    return `${alias}."${snakeField}"`;
-}
-function findEnrichmentTarget(operation, operations) {
-    if (!operation.localField.includes('.')) {
-        return null;
-    }
-    const [alias, field] = operation.localField.split('.');
-    const target = operations.find(op => (op instanceof JoinMany || op instanceof JoinThroughMany) && op.as === alias);
-    if (target && operations.indexOf(target) < operations.indexOf(operation)) {
-        return { target, field };
-    }
-    return null;
+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 joinClauses = '';
-    const processedAliases = new Set();
-    const enrichedAliases = new Set();
-    const joinOperations = operations.filter(op => op instanceof Join);
-    const targetsToEnrich = new Set();
-    const enrichmentsByTarget = new Map();
+    let joinClause = "";
     for (const operation of operations) {
-        if (operation instanceof JoinMany || operation instanceof JoinThroughMany) {
-            const enrichment = findEnrichmentTarget(operation, operations);
-            if (enrichment) {
-                const { target } = enrichment;
-                targetsToEnrich.add(target.as);
-                if (!enrichmentsByTarget.has(target.as)) {
-                    enrichmentsByTarget.set(target.as, []);
-                }
-                enrichmentsByTarget.get(target.as).push({ operation, field: enrichment.field });
-            }
-        }
-    }
-    for (const [targetAlias, enrichments] of enrichmentsByTarget.entries()) {
-        enrichments.sort((a, b) => operations.indexOf(a.operation) - operations.indexOf(b.operation));
-    }
-    for (const operation of operations) {
-        if (processedAliases.has(operation.as)) {
-            continue;
-        }
-        const isEnrichmentOp = (operation instanceof JoinMany || operation instanceof JoinThroughMany) &&
-            findEnrichmentTarget(operation, operations) !== null;
-        if (targetsToEnrich.has(operation.as) && !isEnrichmentOp) {
-            continue;
-        }
-        if (operation instanceof Join) {
-            const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-            joinClauses += ` LEFT JOIN "${operation.from}" AS ${operation.as} ON ${localFieldRef} = "${operation.as}"."${operation.foreignField}"`;
-            processedAliases.add(operation.as);
-        }
-        else if (operation instanceof JoinMany) {
-            const enrichment = findEnrichmentTarget(operation, operations);
-            if (enrichment) {
-                const enrichments = enrichmentsByTarget.get(enrichment.target.as);
-                const isFirstEnrichment = enrichments[0].operation === operation;
-                if (isFirstEnrichment && !enrichedAliases.has(enrichment.target.as)) {
-                    const { target, field } = enrichment;
-                    const targetLocalFieldRef = target.localField.includes('.')
-                        ? resolveLocalField(target.localField, mainTableName, operations)
-                        : (() => {
-                            const snakeField = convertFieldToSnakeCase(target.localField);
-                            return mainTableName ? `"${mainTableName}"."${snakeField}"` : `"${snakeField}"`;
-                        })();
-                    let enrichmentJoins = '';
-                    let jsonBuildObjects = '';
-                    for (const enrich of enrichments) {
-                        const enrichField = enrich.field;
-                        const enrichOp = enrich.operation;
-                        const enrichAlias = `enrich_${enrichOp.as}`;
-                        const nestedJoin = joinOperations.find((j) => {
-                            if (!j.localField.includes('.'))
-                                return false;
-                            const [referencedAlias] = j.localField.split('.');
-                            const referencedJoin = operations.find(op => (op instanceof Join || op instanceof JoinMany || op instanceof JoinThroughMany) &&
-                                op.as === referencedAlias);
-                            if (referencedJoin instanceof Join && referencedJoin.from === enrichOp.from) {
-                                return true;
-                            }
-                            if (enrichOp instanceof JoinThroughMany && referencedJoin instanceof Join && referencedJoin.from === enrichOp.from) {
-                                return true;
-                            }
-                            return false;
-                        });
-                        if (nestedJoin) {
-                            const nestedField = nestedJoin.localField.split('.')[1];
-                            enrichmentJoins += ` LEFT JOIN LATERAL (
-                                SELECT COALESCE(
-                                    JSON_AGG(
-                                        enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
-                                    ),
-                                    '[]'::json
-                                ) AS enriched
-                                FROM (
-                                    SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                    FROM "${enrichOp.from}" AS enrich_table
-                                    WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                    AND enrich_table."_deleted" IS NULL
-                                ) AS enrich_data
-                                CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
-                                LEFT JOIN LATERAL (
-                                    SELECT row_to_json(nested_table) AS ${nestedJoin.as}
-                                    FROM "${nestedJoin.from}" AS nested_table
-                                    WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
-                                    AND nested_table."_deleted" IS NULL
-                                    LIMIT 1
-                                ) AS nested_join_data ON true
-                            ) AS ${enrichAlias} ON true`;
-                        }
-                        else {
-                            enrichmentJoins += ` LEFT JOIN LATERAL (
-                                SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                FROM "${enrichOp.from}" AS enrich_table
-                                WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                AND enrich_table."_deleted" IS NULL
-                            ) AS ${enrichAlias} ON true`;
-                        }
-                        jsonBuildObjects += ` || jsonb_build_object('${enrichOp.as}', COALESCE(${enrichAlias}.enriched, '[]'::json))`;
-                    }
-                    joinClauses += ` LEFT JOIN LATERAL (
-                        SELECT COALESCE(
-                            JSON_AGG(
-                                elem.value${jsonBuildObjects}
-                            ),
-                            '[]'::json
-                        ) AS aggregated
-                        FROM (
-                            SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
-                            FROM "${target.from}" AS target_table
-                            WHERE target_table."${target.foreignField}" = ${targetLocalFieldRef}
-                            AND target_table."_deleted" IS NULL
-                        ) AS original_data
-                        CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
-                    ) AS ${target.as} ON true`;
-                    enrichedAliases.add(target.as);
-                    processedAliases.add(target.as);
-                    for (const enrich of enrichments) {
-                        processedAliases.add(enrich.operation.as);
-                    }
-                }
-            }
-            else {
-                const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-                joinClauses += ` LEFT JOIN LATERAL (
-                    SELECT COALESCE(JSON_AGG(row_to_json("${operation.from}")), '[]'::json) AS aggregated
-                    FROM "${operation.from}"
-                    WHERE "${operation.from}"."${operation.foreignField}" = ${localFieldRef}
-                    AND "${operation.from}"."_deleted" IS NULL
-                ) AS ${operation.as} ON true`;
-                processedAliases.add(operation.as);
-            }
-        }
-        else if (operation instanceof JoinThrough) {
-            const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-            joinClauses += ` LEFT JOIN LATERAL (
-                SELECT row_to_json(${operation.as}) AS aggregated
-                FROM "${operation.through}"
-                INNER JOIN "${operation.from}" AS ${operation.as} 
-                    ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
-                WHERE "${operation.through}"."${operation.throughLocalField}" = ${localFieldRef}
-                AND "${operation.through}"."_deleted" IS NULL
-                AND ${operation.as}."_deleted" IS NULL
-                LIMIT 1
-            ) AS ${operation.as} ON true`;
-            processedAliases.add(operation.as);
-        }
-        else if (operation instanceof JoinThroughMany) {
-            const enrichment = findEnrichmentTarget(operation, operations);
-            if (enrichment) {
-                const enrichments = enrichmentsByTarget.get(enrichment.target.as);
-                const isFirstEnrichment = enrichments[0].operation === operation;
-                if (isFirstEnrichment && !enrichedAliases.has(enrichment.target.as)) {
-                    const { target, field } = enrichment;
-                    const targetLocalFieldRef = target.localField.includes('.')
-                        ? resolveLocalField(target.localField, mainTableName, operations)
-                        : (() => {
-                            const snakeField = convertFieldToSnakeCase(target.localField);
-                            return mainTableName ? `"${mainTableName}"."${snakeField}"` : `"${snakeField}"`;
-                        })();
-                    const isTargetJoinMany = target instanceof JoinMany;
-                    let enrichmentJoins = '';
-                    let jsonBuildObjects = '';
-                    for (const enrich of enrichments) {
-                        const enrichField = enrich.field;
-                        const enrichOp = enrich.operation;
-                        const enrichAlias = `enrich_${enrichOp.as}`;
-                        if (enrichOp instanceof JoinMany) {
-                            const nestedJoin = joinOperations.find(j => j.localField.includes('.') &&
-                                j.localField.startsWith(`${enrichOp.as}.`));
-                            if (nestedJoin) {
-                                const nestedField = nestedJoin.localField.split('.')[1];
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(
-                                        JSON_AGG(
-                                            enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
-                                        ),
-                                        '[]'::json
-                                    ) AS enriched
-                                    FROM (
-                                        SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                        FROM "${enrichOp.from}" AS enrich_table
-                                        WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                        AND enrich_table."_deleted" IS NULL
-                                    ) AS enrich_data
-                                    CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
-                                    LEFT JOIN LATERAL (
-                                        SELECT row_to_json(nested_table) AS ${nestedJoin.as}
-                                        FROM "${nestedJoin.from}" AS nested_table
-                                        WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
-                                        AND nested_table."_deleted" IS NULL
-                                        LIMIT 1
-                                    ) AS nested_join_data ON true
-                                ) AS ${enrichAlias} ON true`;
-                            }
-                            else {
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(JSON_AGG(row_to_json(enrich_table)), '[]'::json) AS enriched
-                                    FROM "${enrichOp.from}" AS enrich_table
-                                    WHERE enrich_table."${enrichOp.foreignField}" = (elem.value->>'${enrichField}')::integer
-                                    AND enrich_table."_deleted" IS NULL
-                                ) AS ${enrichAlias} ON true`;
-                            }
-                        }
-                        else {
-                            const nestedJoin = joinOperations.find((j) => {
-                                if (!j.localField.includes('.'))
-                                    return false;
-                                const [referencedAlias] = j.localField.split('.');
-                                const referencedJoin = operations.find(op => (op instanceof Join || op instanceof JoinMany || op instanceof JoinThroughMany) &&
-                                    op.as === referencedAlias);
-                                if (referencedJoin instanceof Join && referencedJoin.from === enrichOp.from) {
-                                    return true;
-                                }
-                                if (enrichOp instanceof JoinThroughMany && referencedJoin instanceof Join && referencedJoin.from === enrichOp.from) {
-                                    return true;
-                                }
-                                return false;
-                            });
-                            if (nestedJoin) {
-                                const nestedField = nestedJoin.localField.split('.')[1];
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(
-                                        JSON_AGG(
-                                            enrich_elem.value || jsonb_build_object('${nestedJoin.as}', nested_join_data.${nestedJoin.as})
-                                        ),
-                                        '[]'::json
-                                    ) AS enriched
-                                    FROM (
-                                        SELECT COALESCE(JSON_AGG(row_to_json(${enrichAlias}_table)), '[]'::json) AS enriched
-                                        FROM "${enrichOp.through}"
-                                        INNER JOIN "${enrichOp.from}" AS ${enrichAlias}_table 
-                                            ON ${enrichAlias}_table."${enrichOp.foreignField}" = "${enrichOp.through}"."${enrichOp.throughForeignField}"
-                                        WHERE "${enrichOp.through}"."${enrichOp.throughLocalField}" = (elem.value->>'${enrichField}')::integer
-                                        AND "${enrichOp.through}"."_deleted" IS NULL
-                                        AND ${enrichAlias}_table."_deleted" IS NULL
-                                    ) AS enrich_data
-                                    CROSS JOIN LATERAL jsonb_array_elements(enrich_data.enriched::jsonb) AS enrich_elem
-                                    LEFT JOIN LATERAL (
-                                        SELECT row_to_json(nested_table) AS ${nestedJoin.as}
-                                        FROM "${nestedJoin.from}" AS nested_table
-                                        WHERE nested_table."${nestedJoin.foreignField}" = (enrich_elem.value->>'${nestedField}')::integer
-                                        AND nested_table."_deleted" IS NULL
-                                        LIMIT 1
-                                    ) AS nested_join_data ON true
-                                ) AS ${enrichAlias} ON true`;
-                            }
-                            else {
-                                enrichmentJoins += ` LEFT JOIN LATERAL (
-                                    SELECT COALESCE(JSON_AGG(row_to_json(${enrichAlias}_table)), '[]'::json) AS enriched
-                                    FROM "${enrichOp.through}"
-                                    INNER JOIN "${enrichOp.from}" AS ${enrichAlias}_table 
-                                        ON ${enrichAlias}_table."${enrichOp.foreignField}" = "${enrichOp.through}"."${enrichOp.throughForeignField}"
-                                    WHERE "${enrichOp.through}"."${enrichOp.throughLocalField}" = (elem.value->>'${enrichField}')::integer
-                                    AND "${enrichOp.through}"."_deleted" IS NULL
-                                    AND ${enrichAlias}_table."_deleted" IS NULL
-                                ) AS ${enrichAlias} ON true`;
-                            }
-                        }
-                        jsonBuildObjects += ` || jsonb_build_object('${enrichOp.as}', COALESCE(${enrichAlias}.enriched, '[]'::json))`;
-                    }
-                    if (isTargetJoinMany) {
-                        joinClauses += ` LEFT JOIN LATERAL (
-                            SELECT COALESCE(
-                                JSON_AGG(
-                                    elem.value${jsonBuildObjects}
-                                ),
-                                '[]'::json
-                            ) AS aggregated
-                            FROM (
-                                SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
-                                FROM "${target.from}" AS target_table
-                                WHERE target_table."${target.foreignField}" = ${targetLocalFieldRef}
-                                AND target_table."_deleted" IS NULL
-                            ) AS original_data
-                            CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
-                        ) AS ${target.as} ON true`;
-                    }
-                    else {
-                        const targetThrough = target;
-                        joinClauses += ` LEFT JOIN LATERAL (
-                            SELECT COALESCE(
-                                JSON_AGG(
-                                    elem.value${jsonBuildObjects}
-                                ),
-                                '[]'::json
-                            ) AS aggregated
-                            FROM (
-                                SELECT COALESCE(JSON_AGG(row_to_json(target_table)), '[]'::json) AS aggregated
-                                FROM "${targetThrough.through}"
-                                INNER JOIN "${targetThrough.from}" AS target_table 
-                                    ON target_table."${targetThrough.foreignField}" = "${targetThrough.through}"."${targetThrough.throughForeignField}"
-                                WHERE "${targetThrough.through}"."${targetThrough.throughLocalField}" = ${targetLocalFieldRef}
-                                AND "${targetThrough.through}"."_deleted" IS NULL
-                                AND target_table."_deleted" IS NULL
-                            ) AS original_data
-                            CROSS JOIN LATERAL jsonb_array_elements(original_data.aggregated::jsonb) AS elem${enrichmentJoins}
-                        ) AS ${target.as} ON true`;
-                    }
-                    enrichedAliases.add(target.as);
-                    processedAliases.add(target.as);
-                    for (const enrich of enrichments) {
-                        processedAliases.add(enrich.operation.as);
-                    }
-                }
+        if (operation instanceof LeftJoin || operation instanceof InnerJoin || operation instanceof LeftJoinMany) {
+            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 {
-                const localFieldRef = resolveLocalField(operation.localField, mainTableName, operations);
-                joinClauses += ` LEFT JOIN LATERAL (
-                    SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS aggregated
-                    FROM "${operation.through}"
-                    INNER JOIN "${operation.from}" AS ${operation.as} 
-                        ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
-                    WHERE "${operation.through}"."${operation.throughLocalField}" = ${localFieldRef}
-                    AND "${operation.through}"."_deleted" IS NULL
-                    AND ${operation.as}."_deleted" IS NULL
-                ) AS ${operation.as} ON true`;
-                processedAliases.add(operation.as);
+                joinClause += ` ${joinType} "${operation.from}" AS ${operation.as} ON ${localRef} = ${operation.as}."${foreignSnake}"`;
             }
         }
     }
-    return joinClauses;
+    return joinClause;
 }

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

@@ -1,14 +1,13 @@
-import { Join } from '../../operations/join.operation.js';
-import { JoinMany } from '../../operations/join-many.operation.js';
-import { JoinThrough } from '../../operations/join-through.operation.js';
-import { JoinThroughMany } from '../../operations/join-through-many.operation.js';
+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 result = await client.query(`
-            SELECT column_name
-            FROM information_schema.columns
-            WHERE table_schema = current_schema()
-              AND table_name = $1
-            ORDER BY ordinal_position
+    const result = await client.query(`
+            SELECT column_name
+            FROM information_schema.columns
+            WHERE table_schema = current_schema()
+              AND table_name = $1
+            ORDER BY ordinal_position
         `, [tableName]);
     return result.rows.map(row => row.column_name);
 }
@@ -17,43 +16,32 @@ function findEnrichmentTarget(operation, operations) {
         return null;
     }
     const [alias] = operation.localField.split('.');
-    const target = operations.find(op => (op instanceof JoinMany || op instanceof JoinThroughMany) && op.as === alias);
+    const target = operations.find(op => op instanceof LeftJoinMany && op.as === alias);
     if (target && operations.indexOf(target) < operations.indexOf(operation)) {
         return { target, field: operation.localField.split('.')[1] };
     }
     return null;
 }
 export async function buildSelectClause(client, mainTableName, mainTableAlias, operations) {
-    const joinOperations = operations.filter(op => op instanceof Join);
-    const joinManyOperations = operations.filter(op => op instanceof JoinMany);
-    const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
-    const joinThroughManyOperations = operations.filter(op => op instanceof JoinThroughMany);
+    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 joinOperations) {
+    for (const join of [...leftJoinOperations, ...innerJoinOperations]) {
         const joinColumns = await getTableColumns(client, join.from);
         for (const col of joinColumns) {
             joinSelects.push(`${join.as}."${col}" AS "${join.as}__${col}"`);
         }
     }
-    for (const joinThrough of joinThroughOperations) {
-        joinSelects.push(`${joinThrough.as}.aggregated AS "${joinThrough.as}"`);
-    }
-    for (const joinMany of joinManyOperations) {
+    for (const joinMany of leftJoinManyOperations) {
         const enrichment = findEnrichmentTarget(joinMany, operations);
         if (enrichment) {
             continue;
         }
         joinSelects.push(`${joinMany.as}.aggregated AS "${joinMany.as}"`);
     }
-    for (const joinThroughMany of joinThroughManyOperations) {
-        const enrichment = findEnrichmentTarget(joinThroughMany, operations);
-        if (enrichment) {
-            continue;
-        }
-        joinSelects.push(`${joinThroughMany.as}.aggregated AS "${joinThroughMany.as}"`);
-    }
     const allSelects = [...mainSelects, ...joinSelects];
     return allSelects.join(', ');
 }

package/dist/databases/postgres/utils/does-table-exist.util.js

@@ -1,8 +1,8 @@
 export async function doesTableExist(client, tableName) {
-    const result = await client.query(`
-        SELECT EXISTS (
-            SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1
-        )
+    const result = await client.query(`
+        SELECT EXISTS (
+            SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1
+        )
     `, [tableName]);
     return result.rows[0].exists;
 }