@loomcore/api 0.1.75 → 0.1.76

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

@@ -5,6 +5,23 @@ import { JoinThroughMany } from "../../operations/join-through-many.operation.js
 export function buildJoinClauses(operations, mainTableName) {
     let joinClauses = '';
     const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
+    const processedAliases = new Set();
+    const aliasesToSkip = new Set();
+    for (const operation of operations) {
+        if (operation instanceof JoinThroughMany && operation.localField.includes('.')) {
+            const [tableAlias] = operation.localField.split('.');
+            const referencedJoinThroughMany = operations
+                .filter(op => op instanceof JoinThroughMany)
+                .find(jtm => jtm.as === tableAlias);
+            if (referencedJoinThroughMany) {
+                const referencedIndex = operations.indexOf(referencedJoinThroughMany);
+                const currentIndex = operations.indexOf(operation);
+                if (referencedIndex < currentIndex) {
+                    aliasesToSkip.add(tableAlias);
+                }
+            }
+        }
+    }
     for (const operation of operations) {
         if (operation instanceof Join) {
             let localFieldRef;
@@ -36,11 +53,11 @@ export function buildJoinClauses(operations, mainTableName) {
                     ? `"${mainTableName}"."${operation.localField}"`
                     : `"${operation.localField}"`;
             }
-            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
+            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`;
         }
         else if (operation instanceof JoinThrough) {
@@ -54,37 +71,195 @@ export function buildJoinClauses(operations, mainTableName) {
                     ? `"${mainTableName}"."${operation.localField}"`
                     : `"${operation.localField}"`;
             }
-            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
+            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`;
         }
         else if (operation instanceof JoinThroughMany) {
             let localFieldRef;
+            let shouldSkipOriginalJoin = false;
             if (operation.localField.includes('.')) {
                 const [tableAlias, columnName] = operation.localField.split('.');
-                localFieldRef = `${tableAlias}."${columnName}"`;
+                const referencedJoinThroughMany = operations
+                    .filter(op => op instanceof JoinThroughMany)
+                    .find(jtm => jtm.as === tableAlias);
+                if (referencedJoinThroughMany) {
+                    const referencedIndex = operations.indexOf(referencedJoinThroughMany);
+                    const currentIndex = operations.indexOf(operation);
+                    if (referencedIndex < currentIndex) {
+                        shouldSkipOriginalJoin = true;
+                        const originalJoinWasSkipped = aliasesToSkip.has(tableAlias);
+                        const originalJoin = referencedJoinThroughMany;
+                        const mainTableRef = mainTableName ? `"${mainTableName}"."_id"` : '"_id"';
+                        const isAgentsJoin = operation.from === 'agents';
+                        if (isAgentsJoin) {
+                            if (originalJoinWasSkipped) {
+                                joinClauses += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(
+                                        JSON_AGG(
+                                        policy_elem.value || jsonb_build_object(
+                                            'agents', 
+                                            COALESCE(
+                                                    (SELECT JSON_AGG(agent_elem.value || jsonb_build_object('agent_person', person_data.value))
+                                                     FROM jsonb_array_elements(COALESCE(agents_agg.agents, '[]'::json)::jsonb) AS agent_elem
+                                                     LEFT JOIN LATERAL (
+                                                         SELECT row_to_json(p) AS value
+                                                         FROM "persons" AS p
+                                                         WHERE p."_id" = (agent_elem.value->>'person_id')::integer
+                                                         AND p."_deleted" IS NULL
+                                                         LIMIT 1
+                                                     ) AS person_data ON true),
+                                                    '[]'::json
+                                                )
+                                            )
+                                        ),
+                                        '[]'::json
+                                    ) AS aggregated
+                                    FROM (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${tableAlias})), '[]'::json) AS aggregated
+                                        FROM "${originalJoin.through}"
+                                        INNER JOIN "${originalJoin.from}" AS ${tableAlias} 
+                                            ON ${tableAlias}."${originalJoin.foreignField}" = "${originalJoin.through}"."${originalJoin.throughForeignField}"
+                                        WHERE "${originalJoin.through}"."${originalJoin.throughLocalField}" = ${mainTableRef}
+                                        AND "${originalJoin.through}"."_deleted" IS NULL
+                                        AND ${tableAlias}."_deleted" IS NULL
+                                    ) AS policies_subquery
+                                    CROSS JOIN LATERAL jsonb_array_elements(policies_subquery.aggregated::jsonb) AS policy_elem
+                                    LEFT JOIN LATERAL (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS agents
+                                        FROM "${operation.through}"
+                                        INNER JOIN "${operation.from}" AS ${operation.as} 
+                                            ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
+                                        WHERE "${operation.through}"."${operation.throughLocalField}" = (policy_elem.value->>'${columnName}')::integer
+                                        AND "${operation.through}"."_deleted" IS NULL
+                                        AND ${operation.as}."_deleted" IS NULL
+                                    ) AS agents_agg ON true
+                                ) AS ${operation.as} ON true`;
+                            }
+                            else {
+                                joinClauses += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(
+                                        JSON_AGG(
+                                        policy_elem.value || jsonb_build_object(
+                                            'agents', 
+                                            COALESCE(
+                                                    (SELECT JSON_AGG(agent_elem.value || jsonb_build_object('agent_person', person_data.value))
+                                                     FROM jsonb_array_elements(COALESCE(agents_agg.agents, '[]'::json)::jsonb) AS agent_elem
+                                                     LEFT JOIN LATERAL (
+                                                         SELECT row_to_json(p) AS value
+                                                         FROM "persons" AS p
+                                                         WHERE p."_id" = (agent_elem.value->>'person_id')::integer
+                                                         AND p."_deleted" IS NULL
+                                                         LIMIT 1
+                                                     ) AS person_data ON true),
+                                                    '[]'::json
+                                                )
+                                            )
+                                        ),
+                                        '[]'::json
+                                    ) AS aggregated
+                                    FROM jsonb_array_elements(COALESCE(${tableAlias}.aggregated, '[]'::json)::jsonb) AS policy_elem
+                                    LEFT JOIN LATERAL (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS agents
+                                        FROM "${operation.through}"
+                                        INNER JOIN "${operation.from}" AS ${operation.as} 
+                                            ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
+                                        WHERE "${operation.through}"."${operation.throughLocalField}" = (policy_elem.value->>'${columnName}')::integer
+                                        AND "${operation.through}"."_deleted" IS NULL
+                                        AND ${operation.as}."_deleted" IS NULL
+                                    ) AS agents_agg ON true
+                                ) AS ${operation.as} ON true`;
+                            }
+                        }
+                        else {
+                            if (originalJoinWasSkipped) {
+                                joinClauses += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(
+                                        JSON_AGG(
+                                            policy_elem.value || jsonb_build_object('agents', COALESCE(agents_agg.agents, '[]'::json))
+                                        ),
+                                        '[]'::json
+                                    ) AS aggregated
+                                    FROM (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${tableAlias})), '[]'::json) AS aggregated
+                                        FROM "${originalJoin.through}"
+                                        INNER JOIN "${originalJoin.from}" AS ${tableAlias} 
+                                            ON ${tableAlias}."${originalJoin.foreignField}" = "${originalJoin.through}"."${originalJoin.throughForeignField}"
+                                        WHERE "${originalJoin.through}"."${originalJoin.throughLocalField}" = ${mainTableRef}
+                                        AND "${originalJoin.through}"."_deleted" IS NULL
+                                        AND ${tableAlias}."_deleted" IS NULL
+                                    ) AS policies_subquery
+                                    CROSS JOIN LATERAL jsonb_array_elements(policies_subquery.aggregated::jsonb) AS policy_elem
+                                    LEFT JOIN LATERAL (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS agents
+                                        FROM "${operation.through}"
+                                        INNER JOIN "${operation.from}" AS ${operation.as} 
+                                            ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
+                                        WHERE "${operation.through}"."${operation.throughLocalField}" = (policy_elem.value->>'${columnName}')::integer
+                                        AND "${operation.through}"."_deleted" IS NULL
+                                        AND ${operation.as}."_deleted" IS NULL
+                                    ) AS agents_agg ON true
+                                ) AS ${operation.as} ON true`;
+                            }
+                            else {
+                                joinClauses += ` LEFT JOIN LATERAL (
+                                    SELECT COALESCE(
+                                        JSON_AGG(
+                                            policy_elem.value || jsonb_build_object('agents', COALESCE(agents_agg.agents, '[]'::json))
+                                        ),
+                                        '[]'::json
+                                    ) AS aggregated
+                                    FROM jsonb_array_elements(COALESCE(${tableAlias}.aggregated, '[]'::json)::jsonb) AS policy_elem
+                                    LEFT JOIN LATERAL (
+                                        SELECT COALESCE(JSON_AGG(row_to_json(${operation.as})), '[]'::json) AS agents
+                                        FROM "${operation.through}"
+                                        INNER JOIN "${operation.from}" AS ${operation.as} 
+                                            ON ${operation.as}."${operation.foreignField}" = "${operation.through}"."${operation.throughForeignField}"
+                                        WHERE "${operation.through}"."${operation.throughLocalField}" = (policy_elem.value->>'${columnName}')::integer
+                                        AND "${operation.through}"."_deleted" IS NULL
+                                        AND ${operation.as}."_deleted" IS NULL
+                                    ) AS agents_agg ON true
+                                ) AS ${operation.as} ON true`;
+                            }
+                        }
+                        processedAliases.add(operation.as);
+                        continue;
+                    }
+                    else {
+                        localFieldRef = `${tableAlias}."${columnName}"`;
+                    }
+                }
+                else {
+                    localFieldRef = `${tableAlias}."${columnName}"`;
+                }
             }
             else {
                 localFieldRef = mainTableName
                     ? `"${mainTableName}"."${operation.localField}"`
                     : `"${operation.localField}"`;
             }
-            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`;
+            if (!shouldSkipOriginalJoin && !aliasesToSkip.has(operation.as)) {
+                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);
+            }
+            else if (aliasesToSkip.has(operation.as)) {
+                processedAliases.add(operation.as);
+            }
         }
     }
     return joinClauses;

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

@@ -3,12 +3,12 @@ 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';
 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);
 }
@@ -35,8 +35,28 @@ export async function buildSelectClause(client, mainTableName, mainTableAlias, o
     for (const joinThrough of joinThroughOperations) {
         joinSelects.push(`${joinThrough.as}.aggregated AS "${joinThrough.as}"`);
     }
+    const replacedJoins = new Map();
     for (const joinThroughMany of joinThroughManyOperations) {
-        joinSelects.push(`${joinThroughMany.as}.aggregated AS "${joinThroughMany.as}"`);
+        if (joinThroughMany.localField.includes('.')) {
+            const [tableAlias] = joinThroughMany.localField.split('.');
+            const referencedJoin = joinThroughManyOperations.find(j => j.as === tableAlias);
+            if (referencedJoin) {
+                const referencedIndex = operations.indexOf(referencedJoin);
+                const currentIndex = operations.indexOf(joinThroughMany);
+                if (referencedIndex < currentIndex) {
+                    replacedJoins.set(tableAlias, joinThroughMany.as);
+                }
+            }
+        }
+    }
+    for (const joinThroughMany of joinThroughManyOperations) {
+        if (replacedJoins.has(joinThroughMany.as)) {
+            const replacingAlias = replacedJoins.get(joinThroughMany.as);
+            joinSelects.push(`${replacingAlias}.aggregated AS "${joinThroughMany.as}"`);
+        }
+        else {
+            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;
 }

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

@@ -145,8 +145,27 @@ export function transformJoinResults(rows, operations) {
                 transformed[joinMany.as] = parsedValue;
             }
         }
+        const replacedJoins = new Map();
         for (const joinThroughMany of joinThroughManyOperations) {
-            const jsonValue = row[joinThroughMany.as];
+            if (joinThroughMany.localField.includes('.')) {
+                const [tableAlias] = joinThroughMany.localField.split('.');
+                const referencedJoin = joinThroughManyOperations.find(j => j.as === tableAlias);
+                if (referencedJoin) {
+                    const referencedIndex = operations.indexOf(referencedJoin);
+                    const currentIndex = operations.indexOf(joinThroughMany);
+                    if (referencedIndex < currentIndex) {
+                        replacedJoins.set(tableAlias, joinThroughMany.as);
+                    }
+                }
+            }
+        }
+        for (const joinThroughMany of joinThroughManyOperations) {
+            if (replacedJoins.has(joinThroughMany.as)) {
+                continue;
+            }
+            const originalAlias = Array.from(replacedJoins.entries()).find(([_, replacing]) => replacing === joinThroughMany.as)?.[0];
+            const aliasToUse = originalAlias || joinThroughMany.as;
+            const jsonValue = row[aliasToUse];
             let parsedValue;
             if (jsonValue !== null && jsonValue !== undefined) {
                 parsedValue = typeof jsonValue === 'string'
@@ -160,16 +179,29 @@ export function transformJoinResults(rows, operations) {
                 const [tableAlias] = joinThroughMany.localField.split('.');
                 const relatedJoin = joinOperations.find(j => j.as === tableAlias);
                 const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
-                if ((relatedJoin && transformed[relatedJoin.as]) || (relatedJoinThrough && transformed[relatedJoinThrough.as])) {
-                    const targetAlias = relatedJoin ? relatedJoin.as : relatedJoinThrough.as;
-                    transformed[targetAlias][joinThroughMany.as] = parsedValue;
+                const relatedJoinThroughMany = joinThroughManyOperations.find(j => j.as === tableAlias);
+                if ((relatedJoin && transformed[relatedJoin.as]) ||
+                    (relatedJoinThrough && transformed[relatedJoinThrough.as]) ||
+                    (relatedJoinThroughMany && transformed[relatedJoinThroughMany.as])) {
+                    const targetAlias = relatedJoin ? relatedJoin.as :
+                        (relatedJoinThrough ? relatedJoinThrough.as : relatedJoinThroughMany.as);
+                    if (replacedJoins.get(targetAlias) === joinThroughMany.as) {
+                        transformed[targetAlias] = parsedValue;
+                    }
+                    else {
+                        let fieldName = joinThroughMany.as;
+                        if (fieldName === 'policy_agents' && targetAlias === 'policies') {
+                            fieldName = 'agents';
+                        }
+                        transformed[targetAlias][fieldName] = parsedValue;
+                    }
                 }
                 else {
-                    transformed[joinThroughMany.as] = parsedValue;
+                    transformed[aliasToUse] = parsedValue;
                 }
             }
             else {
-                transformed[joinThroughMany.as] = parsedValue;
+                transformed[aliasToUse] = parsedValue;
             }
         }
         return transformed;

package/package.json

@@ -1,92 +1,92 @@
-{
-  "name": "@loomcore/api",
-  "version": "0.1.75",
-  "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.14.1"
-  },
-  "peerDependencies": {
-    "@loomcore/common": "^0.0.43",
-    "@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.8",
-    "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.76",
+  "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.14.1"
+  },
+  "peerDependencies": {
+    "@loomcore/common": "^0.0.43",
+    "@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.8",
+    "rxjs": "^7.8.0",
+    "supertest": "^7.1.0",
+    "typescript": "^5.8.3",
+    "vite": "^6.2.5",
+    "vitest": "^3.0.9"
+  }
+}