@loomcore/api 0.1.95 → 0.1.98

package/dist/databases/postgres/utils/transform-join-results.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';
 function findNestedObject(obj, alias, path = []) {
     if (obj[alias] !== undefined && obj[alias] !== null) {
         return { obj: obj[alias], path: [...path, alias] };
@@ -45,7 +44,7 @@ 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;
     }
@@ -58,24 +57,20 @@ function mapEnrichmentFieldName(fieldName, targetAlias) {
     return fieldName;
 }
 export function transformJoinResults(rows, 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);
-    if (joinOperations.length === 0 &&
-        joinManyOperations.length === 0 &&
-        joinThroughOperations.length === 0 &&
-        joinThroughManyOperations.length === 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];
+    if (allJoinOperations.length === 0 &&
+        leftJoinManyOperations.length === 0) {
         return rows;
     }
     const allJoinAliases = [
-        ...joinOperations.map(j => j.as),
-        ...joinManyOperations.map(j => j.as),
-        ...joinThroughOperations.map(j => j.as),
-        ...joinThroughManyOperations.map(j => j.as)
+        ...allJoinOperations.map(j => j.as),
+        ...leftJoinManyOperations.map(j => j.as)
     ];
     const enrichmentMap = new Map();
-    for (const op of [...joinManyOperations, ...joinThroughManyOperations]) {
+    for (const op of leftJoinManyOperations) {
         const target = findEnrichmentTarget(op, operations);
         if (target) {
             enrichmentMap.set(op, target);
@@ -85,7 +80,7 @@ export function transformJoinResults(rows, operations) {
         const transformed = {};
         const joinData = {};
         for (const key of Object.keys(row)) {
-            const hasJoinPrefix = joinOperations.some(join => key.startsWith(`${join.as}__`));
+            const hasJoinPrefix = allJoinOperations.some(join => key.startsWith(`${join.as}__`));
             const isJoinAlias = allJoinAliases.includes(key);
             if (!hasJoinPrefix && !isJoinAlias) {
                 transformed[key] = row[key];
@@ -95,7 +90,7 @@ export function transformJoinResults(rows, operations) {
             if (enrichmentMap.has(operation)) {
                 continue;
             }
-            if (operation instanceof Join) {
+            if (operation instanceof LeftJoin || operation instanceof InnerJoin) {
                 const prefix = `${operation.as}__`;
                 const joinedData = {};
                 let hasAnyData = false;
@@ -111,15 +106,11 @@ export function transformJoinResults(rows, operations) {
                 }
                 if (operation.localField.includes('.')) {
                     const [tableAlias] = operation.localField.split('.');
-                    const relatedJoin = joinOperations.find(j => j.as === tableAlias);
-                    const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
+                    const relatedJoin = allJoinOperations.find(j => j.as === tableAlias);
                     let targetObject = null;
                     if (relatedJoin && joinData[relatedJoin.as]) {
                         targetObject = joinData[relatedJoin.as];
                     }
-                    else if (relatedJoinThrough && joinData[relatedJoinThrough.as]) {
-                        targetObject = joinData[relatedJoinThrough.as];
-                    }
                     else {
                         const found = findNestedObject(joinData, tableAlias);
                         if (found) {
@@ -137,88 +128,7 @@ export function transformJoinResults(rows, operations) {
                     joinData[operation.as] = hasAnyData ? joinedData : null;
                 }
             }
-            else if (operation instanceof JoinThrough) {
-                const jsonValue = parseJsonValue(row[operation.as]);
-                if (operation.localField.includes('.')) {
-                    const [tableAlias] = operation.localField.split('.');
-                    const relatedJoin = joinOperations.find(j => j.as === tableAlias);
-                    const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
-                    let targetObject = null;
-                    if (relatedJoin && joinData[relatedJoin.as]) {
-                        targetObject = joinData[relatedJoin.as];
-                    }
-                    else if (relatedJoinThrough) {
-                        const found = findNestedObject(joinData, relatedJoinThrough.as);
-                        if (found) {
-                            targetObject = found.obj;
-                        }
-                    }
-                    if (targetObject) {
-                        targetObject[operation.as] = jsonValue;
-                    }
-                    else {
-                        joinData[operation.as] = jsonValue;
-                    }
-                }
-                else {
-                    joinData[operation.as] = jsonValue;
-                }
-            }
-            else if (operation instanceof JoinMany) {
-                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 = joinOperations.find(j => j.as === tableAlias);
-                    const relatedJoinMany = joinManyOperations.find(j => j.as === tableAlias);
-                    const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
-                    const relatedJoinThroughMany = joinThroughManyOperations.find(j => j.as === tableAlias);
-                    let targetObject = null;
-                    if (relatedJoin && joinData[relatedJoin.as]) {
-                        targetObject = joinData[relatedJoin.as];
-                    }
-                    else if (relatedJoinThrough) {
-                        const found = findNestedObject(joinData, relatedJoinThrough.as);
-                        if (found) {
-                            targetObject = found.obj;
-                        }
-                    }
-                    else if (relatedJoinMany && joinData[relatedJoinMany.as]) {
-                        targetObject = joinData[relatedJoinMany.as];
-                    }
-                    else if (relatedJoinThroughMany && joinData[relatedJoinThroughMany.as]) {
-                        targetObject = joinData[relatedJoinThroughMany.as];
-                    }
-                    if (targetObject) {
-                        targetObject[operation.as] = parsedValue;
-                    }
-                    else {
-                        joinData[operation.as] = parsedValue;
-                    }
-                }
-                else {
-                    joinData[operation.as] = parsedValue;
-                }
-            }
-            else if (operation instanceof JoinThroughMany) {
+            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())
@@ -241,26 +151,15 @@ export function transformJoinResults(rows, operations) {
                 }
                 if (operation.localField.includes('.')) {
                     const [tableAlias] = operation.localField.split('.');
-                    const relatedJoin = joinOperations.find(j => j.as === tableAlias);
-                    const relatedJoinMany = joinManyOperations.find(j => j.as === tableAlias);
-                    const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
-                    const relatedJoinThroughMany = joinThroughManyOperations.find(j => j.as === tableAlias);
+                    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 (relatedJoinThrough) {
-                        const found = findNestedObject(joinData, relatedJoinThrough.as);
-                        if (found) {
-                            targetObject = found.obj;
-                        }
-                    }
                     else if (relatedJoinMany && joinData[relatedJoinMany.as]) {
                         targetObject = joinData[relatedJoinMany.as];
                     }
-                    else if (relatedJoinThroughMany && joinData[relatedJoinThroughMany.as]) {
-                        targetObject = joinData[relatedJoinThroughMany.as];
-                    }
                     if (targetObject) {
                         targetObject[operation.as] = parsedValue;
                     }

package/dist/models/initial-database-config.interface.d.ts

@@ -2,6 +2,7 @@ import { IAppConfig } from "./app-config.interface.js";
 import { IDatabaseConfig } from "./database-config.interface.js";
 import { IEmailConfig } from "./email-config.interface.js";
 export interface IInitialDbMigrationConfig {
+    env: string;
     app: IAppConfig;
     database: IDatabaseConfig;
     adminUser: {

package/package.json

@@ -1,92 +1,92 @@
-{
-  "name": "@loomcore/api",
-  "version": "0.1.95",
-  "private": false,
-  "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
-  "scripts": {
-    "clean": "rm -rf dist",
-    "tsc": "tsc --project tsconfig.prod.json",
-    "build": "npm-run-all -s clean tsc",
-    "add": "git add .",
-    "commit": "git commit -m \"Updates\"",
-    "patch": "npm version patch",
-    "push": "git push",
-    "publishMe": "npm publish --access public",
-    "pub": "npm-run-all -s add commit patch build push publishMe",
-    "update-lib-versions": "npx --yes npm-check-updates -u -f @loomcore/common",
-    "install-updated-libs": "npm i @loomcore/common",
-    "update-libs": "npm-run-all -s update-lib-versions install-updated-libs",
-    "typecheck": "tsc",
-    "test": "npm-run-all -s test:postgres test:mongodb",
-    "test:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run",
-    "test:postgres:real": "cross-env NODE_ENV=test TEST_DATABASE=postgres USE_REAL_POSTGRES=true vitest run",
-    "test:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run",
-    "test:ci": "npm-run-all -s test:ci:postgres test:ci:mongodb",
-    "test:ci:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --reporter=json --outputFile=test-results-postgres.json",
-    "test:ci:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run --reporter=json --outputFile=test-results-mongodb.json",
-    "test:watch": "cross-env NODE_ENV=test vitest",
-    "coverage": "npm-run-all -s coverage:postgres coverage:mongodb",
-    "coverage:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --coverage",
-    "coverage:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run --coverage",
-    "test:db:start": "docker-compose -f docker-compose.test.yml up -d",
-    "test:db:stop": "docker-compose -f docker-compose.test.yml down",
-    "test:db:logs": "docker-compose -f docker-compose.test.yml logs -f"
-  },
-  "author": "Tim Hardy",
-  "license": "Apache 2.0",
-  "main": "dist/index.js",
-  "type": "module",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist/**/*"
-  ],
-  "exports": {
-    "./__tests__": "./dist/__tests__/index.js",
-    "./config": "./dist/config/index.js",
-    "./controllers": "./dist/controllers/index.js",
-    "./databases": "./dist/databases/index.js",
-    "./errors": "./dist/errors/index.js",
-    "./middleware": "./dist/middleware/index.js",
-    "./models": "./dist/models/index.js",
-    "./services": "./dist/services/index.js",
-    "./utils": "./dist/utils/index.js"
-  },
-  "dependencies": {
-    "jsonwebtoken": "^9.0.2",
-    "node-mailjet": "^6.0.8",
-    "qs": "^6.15.0"
-  },
-  "peerDependencies": {
-    "@loomcore/common": "^0.0.51",
-    "@sinclair/typebox": "0.34.33",
-    "cookie-parser": "^1.4.6",
-    "cors": "^2.8.5",
-    "express": "^5.1.0",
-    "lodash": "^4.17.21",
-    "moment": "^2.30.1",
-    "mongodb": "^6.16.0",
-    "pg": "^8.15.6",
-    "rxjs": "^7.8.0",
-    "umzug": "^3.8.2"
-  },
-  "devDependencies": {
-    "@types/cookie-parser": "^1.4.7",
-    "@types/cors": "^2.8.18",
-    "@types/express": "^5.0.1",
-    "@types/jsonwebtoken": "^9.0.9",
-    "@types/lodash": "^4.17.13",
-    "@types/pg": "^8.15.6",
-    "@types/qs": "^6.14.0",
-    "@types/supertest": "^6.0.3",
-    "@vitest/coverage-v8": "^3.0.9",
-    "cross-env": "^7.0.3",
-    "mongodb-memory-server": "^9.3.0",
-    "npm-run-all": "^4.1.5",
-    "pg-mem": "^3.0.12",
-    "rxjs": "^7.8.0",
-    "supertest": "^7.1.0",
-    "typescript": "^5.8.3",
-    "vite": "^6.2.5",
-    "vitest": "^3.0.9"
-  }
-}
+{
+  "name": "@loomcore/api",
+  "version": "0.1.98",
+  "private": false,
+  "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "tsc": "tsc --project tsconfig.prod.json",
+    "build": "npm-run-all -s clean tsc",
+    "add": "git add .",
+    "commit": "git commit -m \"Updates\"",
+    "patch": "npm version patch",
+    "push": "git push",
+    "publishMe": "npm publish --access public",
+    "pub": "npm-run-all -s add commit patch build push publishMe",
+    "update-lib-versions": "npx --yes npm-check-updates -u -f @loomcore/common",
+    "install-updated-libs": "npm i @loomcore/common",
+    "update-libs": "npm-run-all -s update-lib-versions install-updated-libs",
+    "typecheck": "tsc",
+    "test": "npm-run-all -s test:postgres test:mongodb",
+    "test:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run",
+    "test:postgres:real": "cross-env NODE_ENV=test TEST_DATABASE=postgres USE_REAL_POSTGRES=true vitest run",
+    "test:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run",
+    "test:ci": "npm-run-all -s test:ci:postgres test:ci:mongodb",
+    "test:ci:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --reporter=json --outputFile=test-results-postgres.json",
+    "test:ci:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run --reporter=json --outputFile=test-results-mongodb.json",
+    "test:watch": "cross-env NODE_ENV=test vitest",
+    "coverage": "npm-run-all -s coverage:postgres coverage:mongodb",
+    "coverage:postgres": "cross-env NODE_ENV=test TEST_DATABASE=postgres vitest run --coverage",
+    "coverage:mongodb": "cross-env NODE_ENV=test TEST_DATABASE=mongodb vitest run --coverage",
+    "test:db:start": "docker-compose -f docker-compose.test.yml up -d",
+    "test:db:stop": "docker-compose -f docker-compose.test.yml down",
+    "test:db:logs": "docker-compose -f docker-compose.test.yml logs -f"
+  },
+  "author": "Tim Hardy",
+  "license": "Apache 2.0",
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "exports": {
+    "./__tests__": "./dist/__tests__/index.js",
+    "./config": "./dist/config/index.js",
+    "./controllers": "./dist/controllers/index.js",
+    "./databases": "./dist/databases/index.js",
+    "./errors": "./dist/errors/index.js",
+    "./middleware": "./dist/middleware/index.js",
+    "./models": "./dist/models/index.js",
+    "./services": "./dist/services/index.js",
+    "./utils": "./dist/utils/index.js"
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2",
+    "node-mailjet": "^6.0.8",
+    "qs": "^6.15.0"
+  },
+  "peerDependencies": {
+    "@loomcore/common": "^0.0.51",
+    "@sinclair/typebox": "0.34.33",
+    "cookie-parser": "^1.4.6",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "mongodb": "^6.16.0",
+    "pg": "^8.15.6",
+    "rxjs": "^7.8.0",
+    "umzug": "^3.8.2"
+  },
+  "devDependencies": {
+    "@types/cookie-parser": "^1.4.7",
+    "@types/cors": "^2.8.18",
+    "@types/express": "^5.0.1",
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/lodash": "^4.17.13",
+    "@types/pg": "^8.15.6",
+    "@types/qs": "^6.14.0",
+    "@types/supertest": "^6.0.3",
+    "@vitest/coverage-v8": "^3.0.9",
+    "cross-env": "^7.0.3",
+    "mongodb-memory-server": "^9.3.0",
+    "npm-run-all": "^4.1.5",
+    "pg-mem": "^3.0.12",
+    "rxjs": "^7.8.0",
+    "supertest": "^7.1.0",
+    "typescript": "^5.8.3",
+    "vite": "^6.2.5",
+    "vitest": "^3.0.9"
+  }
+}

package/dist/databases/operations/join-through-many.operation.d.ts

@@ -1,10 +0,0 @@
-export declare class JoinThroughMany {
-    from: string;
-    through: string;
-    localField: string;
-    throughLocalField: string;
-    throughForeignField: string;
-    foreignField: string;
-    as: string;
-    constructor(from: string, through: string, localField: string, throughLocalField: string, throughForeignField: string, foreignField: string, as: string);
-}

package/dist/databases/operations/join-through-many.operation.js

@@ -1,21 +0,0 @@
-export class JoinThroughMany {
-    from;
-    through;
-    localField;
-    throughLocalField;
-    throughForeignField;
-    foreignField;
-    as;
-    constructor(from, through, localField, throughLocalField, throughForeignField, foreignField, as) {
-        if (from === as) {
-            throw new Error(`JoinThroughMany alias "${as}" must be different from table name "${from}". The alias is used to identify the join result and must be unique.`);
-        }
-        this.from = from;
-        this.through = through;
-        this.localField = localField;
-        this.throughLocalField = throughLocalField;
-        this.throughForeignField = throughForeignField;
-        this.foreignField = foreignField;
-        this.as = as;
-    }
-}

package/dist/databases/operations/join-through.operation.d.ts

@@ -1,10 +0,0 @@
-export declare class JoinThrough {
-    from: string;
-    through: string;
-    localField: string;
-    throughLocalField: string;
-    throughForeignField: string;
-    foreignField: string;
-    as: string;
-    constructor(from: string, through: string, localField: string, throughLocalField: string, throughForeignField: string, foreignField: string, as: string);
-}

package/dist/databases/operations/join-through.operation.js

@@ -1,21 +0,0 @@
-export class JoinThrough {
-    from;
-    through;
-    localField;
-    throughLocalField;
-    throughForeignField;
-    foreignField;
-    as;
-    constructor(from, through, localField, throughLocalField, throughForeignField, foreignField, as) {
-        if (from === as) {
-            throw new Error(`JoinThrough alias "${as}" must be different from table name "${from}". The alias is used to identify the join result and must be unique.`);
-        }
-        this.from = from;
-        this.through = through;
-        this.localField = localField;
-        this.throughLocalField = throughLocalField;
-        this.throughForeignField = throughForeignField;
-        this.foreignField = foreignField;
-        this.as = as;
-    }
-}