@loomcore/api 0.1.74 → 0.1.76

package/dist/__tests__/common-test.utils.js

@@ -27,7 +27,7 @@ const newUser1Email = 'one@test.com';
 const newUser1Password = 'testone';
 const constDeviceIdCookie = crypto.randomBytes(16).toString('hex');
 function initialize(database) {
-    authService = new AuthService(database, new TestEmailClient());
+    authService = new AuthService(database);
     organizationService = new OrganizationService(database);
     deviceIdCookie = constDeviceIdCookie;
 }
@@ -210,6 +210,9 @@ export function setupTestConfig(isMultiTenant = true, dbType) {
             fromAddress: 'test@test.com',
             systemEmailAddress: 'system@test.com'
         },
+        thirdPartyClients: {
+            emailClient: new TestEmailClient()
+        },
         multiTenant: isMultiTenant ? {
             metaOrgName: 'Test Meta Organization',
             metaOrgCode: 'TEST_META_ORG'

package/dist/__tests__/postgres-test-migrations/postgres-test-schema.js

@@ -146,7 +146,30 @@ export const getPostgresTestSchema = (config) => {
         }
     });
     migrations.push({
-        name: '00000000000105_6_schema-clients',
+        name: '00000000000105_6_schema-policies',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "policies" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "amount" NUMERIC NOT NULL,
+          "frequency" VARCHAR NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "policies"');
+        }
+    });
+    migrations.push({
+        name: '00000000000105_7_schema-clients',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
             await pool.query(`
@@ -171,6 +194,58 @@ export const getPostgresTestSchema = (config) => {
             await pool.query('DROP TABLE IF EXISTS "clients"');
         }
     });
+    migrations.push({
+        name: '00000000000105_8_schema-clients-policies',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS clients_policies (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "client_id" INTEGER NOT NULL,
+          "policy_id" INTEGER NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_clients_policies_client_id FOREIGN KEY ("client_id") REFERENCES clients("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_clients_policies_policy_id FOREIGN KEY ("policy_id") REFERENCES policies("_id") ON DELETE CASCADE,
+          CONSTRAINT uk_clients_policies_client_policy UNIQUE ("client_id", "policy_id")
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "clients_policies"');
+        }
+    });
+    migrations.push({
+        name: '00000000000105_8_schema-agents-policies',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS agents_policies (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "policy_id" INTEGER NOT NULL,
+          "agent_id" INTEGER NOT NULL,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_agents_policies_policy_id FOREIGN KEY ("policy_id") REFERENCES policies("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_agents_policies_agent_id FOREIGN KEY ("agent_id") REFERENCES agents("_id") ON DELETE CASCADE,
+          CONSTRAINT uk_agents_policies_policy_agent UNIQUE ("policy_id", "agent_id")
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "agents_policies"');
+        }
+    });
     migrations.push({
         name: '00000000000106_schema-email-addresses',
         up: async ({ context: pool }) => {

package/dist/controllers/auth.controller.d.ts

@@ -1,10 +1,9 @@
 import { Application, Request, Response, NextFunction } from 'express';
 import { AuthService } from '../services/index.js';
 import { IDatabase } from '../databases/models/index.js';
-import { IEmailClient } from '../models/email-client.interface.js';
 export declare class AuthController {
     authService: AuthService;
-    constructor(app: Application, database: IDatabase, emailClient: IEmailClient);
+    constructor(app: Application, database: IDatabase);
     mapRoutes(app: Application): void;
     login(req: Request, res: Response, next: NextFunction): Promise<void>;
     registerUser(req: Request, res: Response): Promise<void>;

package/dist/controllers/auth.controller.js

@@ -6,8 +6,8 @@ import { AuthService } from '../services/index.js';
 import { isAuthorized } from '../middleware/index.js';
 export class AuthController {
     authService;
-    constructor(app, database, emailClient) {
-        this.authService = new AuthService(database, emailClient);
+    constructor(app, database) {
+        this.authService = new AuthService(database);
         this.mapRoutes(app);
     }
     mapRoutes(app) {

package/dist/databases/migrations/migration-runner.d.ts

@@ -1,5 +1,4 @@
 import { IBaseApiConfig } from '../../models/base-api-config.interface.js';
-import { IEmailClient } from '../../models/email-client.interface.js';
 export declare class MigrationRunner {
     private config;
     private dbType;
@@ -7,8 +6,7 @@ export declare class MigrationRunner {
     private migrationsDir;
     private primaryTimezone;
     private dbConnection;
-    private emailClient?;
-    constructor(config: IBaseApiConfig, emailClient?: IEmailClient);
+    constructor(config: IBaseApiConfig);
     private getTimestamp;
     private parseSql;
     private getMigrator;

package/dist/databases/migrations/migration-runner.js

@@ -15,15 +15,13 @@ export class MigrationRunner {
     migrationsDir;
     primaryTimezone;
     dbConnection;
-    emailClient;
-    constructor(config, emailClient) {
+    constructor(config) {
         setBaseApiConfig(config);
         this.config = config;
         this.dbType = config.app.dbType;
         this.dbUrl = this.dbType === 'postgres' ? buildPostgresUrl(config) : buildMongoUrl(config);
         this.migrationsDir = path.join(process.cwd(), 'database', 'migrations');
         this.primaryTimezone = config.app.primaryTimezone || 'UTC';
-        this.emailClient = emailClient;
     }
     getTimestamp() {
         const now = new Date();
@@ -66,7 +64,7 @@ export class MigrationRunner {
             this.dbConnection = pool;
             return new Umzug({
                 migrations: async () => {
-                    const initialSchema = getPostgresInitialSchema(this.config, this.emailClient).map(m => ({
+                    const initialSchema = getPostgresInitialSchema(this.config).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);
@@ -105,7 +103,7 @@ export class MigrationRunner {
             console.log(`🔎 Looking for migrations in: ${globPattern}`);
             return new Umzug({
                 migrations: async () => {
-                    const initialSchema = getMongoInitialSchema(this.config, this.emailClient).map(m => ({
+                    const initialSchema = getMongoInitialSchema(this.config).map(m => ({
                         name: m.name,
                         up: async () => {
                             console.log(`   Running [LIBRARY] ${m.name}...`);

package/dist/databases/mongo-db/migrations/mongo-initial-schema.d.ts

@@ -1,6 +1,5 @@
 import { Db } from 'mongodb';
 import { IBaseApiConfig } from '../../../models/base-api-config.interface.js';
-import { IEmailClient } from '../../../models/email-client.interface.js';
 export interface ISyntheticMigration {
     name: string;
     up: (context: {
@@ -10,4 +9,4 @@ export interface ISyntheticMigration {
         context: Db;
     }) => Promise<void>;
 }
-export declare const getMongoInitialSchema: (config: IBaseApiConfig, emailClient?: IEmailClient) => ISyntheticMigration[];
+export declare const getMongoInitialSchema: (config: IBaseApiConfig) => ISyntheticMigration[];

package/dist/databases/mongo-db/migrations/mongo-initial-schema.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
 import { MongoDBDatabase } from '../mongo-db.database.js';
 import { AuthService, OrganizationService } from '../../../services/index.js';
-export const getMongoInitialSchema = (config, emailClient) => {
+export const getMongoInitialSchema = (config) => {
     const migrations = [];
     const isMultiTenant = config.app.isMultiTenant;
     if (isMultiTenant && !config.multiTenant) {
@@ -12,7 +12,7 @@ export const getMongoInitialSchema = (config, emailClient) => {
     if (isAuthEnabled && !config.auth) {
         throw new Error('Auth enabled without auth configuration');
     }
-    if (isAuthEnabled && (!emailClient || !config.email)) {
+    if (isAuthEnabled && (!config.thirdPartyClients?.emailClient || !config.email)) {
         throw new Error('Auth enabled without email client or email configuration');
     }
     if (isMultiTenant)
@@ -166,7 +166,7 @@ export const getMongoInitialSchema = (config, emailClient) => {
             name: '00000000000009_data-admin-user',
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
-                const authService = new AuthService(database, emailClient);
+                const authService = new AuthService(database);
                 if (!isSystemUserContextInitialized()) {
                     const errorMessage = isMultiTenant
                         ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000008_data-meta-org) should have run before this migration. ' +
@@ -201,7 +201,7 @@ export const getMongoInitialSchema = (config, emailClient) => {
             up: async ({ context: db }) => {
                 const database = new MongoDBDatabase(db);
                 const organizationService = new OrganizationService(database);
-                const authService = new AuthService(database, emailClient);
+                const authService = new AuthService(database);
                 const metaOrg = await organizationService.getMetaOrg(EmptyUserContext);
                 if (!metaOrg) {
                     throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');

package/dist/databases/operations/__tests__/models/client-report.model.d.ts

@@ -1,9 +1,11 @@
 import { IPersonModel } from "./person.model.js";
 import { IAgentModel } from "./agent.model.js";
+import { IPolicyModel } from "./policy.model.js";
 import type { IAuditable, IEntity } from "@loomcore/common/models";
 export interface IClientReportsModel extends IEntity, IAuditable {
     client_person: IPersonModel;
     agent?: IAgentModel;
+    policies?: IPolicyModel[];
 }
 export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
     client_person: import("@sinclair/typebox").TObject<{
@@ -39,5 +41,27 @@ export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
             }>>;
         }>>;
     }>>;
+    policies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        amount: import("@sinclair/typebox").TNumber;
+        frequency: import("@sinclair/typebox").TString;
+        agents: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            person_id: import("@sinclair/typebox").TNumber;
+            agent_person: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                first_name: import("@sinclair/typebox").TString;
+                middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+                last_name: import("@sinclair/typebox").TString;
+                phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    phone_number: import("@sinclair/typebox").TString;
+                    phone_number_type: import("@sinclair/typebox").TString;
+                    is_default: import("@sinclair/typebox").TBoolean;
+                }>>;
+                email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    person_id: import("@sinclair/typebox").TNumber;
+                    email_address: import("@sinclair/typebox").TString;
+                    is_default: import("@sinclair/typebox").TBoolean;
+                }>>;
+            }>>;
+        }>>>;
+    }>>>;
 }>;
 export declare const clientReportsModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/client-report.model.js

@@ -1,9 +1,11 @@
 import { personSchema } from "./person.model.js";
 import { agentSchema } from "./agent.model.js";
+import { policySchema } from "./policy.model.js";
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
 export const clientReportsSchema = Type.Object({
     client_person: personSchema,
-    agent: Type.Optional(agentSchema)
+    agent: Type.Optional(agentSchema),
+    policies: Type.Optional(Type.Array(policySchema))
 });
 export const clientReportsModelSpec = entityUtils.getModelSpec(clientReportsSchema, { isAuditable: true });

package/dist/databases/operations/__tests__/models/policy.model.d.ts

@@ -0,0 +1,30 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+import { IAgentModel } from "./agent.model.js";
+export interface IPolicyModel extends IEntity, IAuditable {
+    amount: number;
+    frequency: string;
+    agents?: IAgentModel[];
+}
+export declare const policySchema: import("@sinclair/typebox").TObject<{
+    amount: import("@sinclair/typebox").TNumber;
+    frequency: import("@sinclair/typebox").TString;
+    agents: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        person_id: import("@sinclair/typebox").TNumber;
+        agent_person: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+            first_name: import("@sinclair/typebox").TString;
+            middle_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            last_name: import("@sinclair/typebox").TString;
+            phone_numbers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                phone_number: import("@sinclair/typebox").TString;
+                phone_number_type: import("@sinclair/typebox").TString;
+                is_default: import("@sinclair/typebox").TBoolean;
+            }>>;
+            email_addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                person_id: import("@sinclair/typebox").TNumber;
+                email_address: import("@sinclair/typebox").TString;
+                is_default: import("@sinclair/typebox").TBoolean;
+            }>>;
+        }>>;
+    }>>>;
+}>;
+export declare const policyModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/databases/operations/__tests__/models/policy.model.js

@@ -0,0 +1,9 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { agentSchema } from "./agent.model.js";
+export const policySchema = Type.Object({
+    amount: Type.Number(),
+    frequency: Type.String(),
+    agents: Type.Optional(Type.Array(agentSchema))
+});
+export const policyModelSpec = entityUtils.getModelSpec(policySchema, { isAuditable: true });

package/dist/databases/postgres/migrations/__tests__/test-migration-helper.js

@@ -1,9 +1,8 @@
 import { Umzug } from 'umzug';
 import { getPostgresInitialSchema } from '../postgres-initial-schema.js';
 import { getPostgresTestSchema } from '../../../../__tests__/postgres-test-migrations/postgres-test-schema.js';
-import { TestEmailClient } from '../../../../__tests__/test-email-client.js';
 export async function runInitialSchemaMigrations(pool, config) {
-    const initialSchema = getPostgresInitialSchema(config, new TestEmailClient());
+    const initialSchema = getPostgresInitialSchema(config);
     const umzug = new Umzug({
         migrations: async () => {
             return initialSchema.map(m => ({

package/dist/databases/postgres/migrations/postgres-initial-schema.d.ts

@@ -1,6 +1,5 @@
 import { Pool } from 'pg';
 import { IBaseApiConfig } from '../../../models/base-api-config.interface.js';
-import { IEmailClient } from '../../../models/email-client.interface.js';
 export interface SyntheticMigration {
     name: string;
     up: (context: {
@@ -10,4 +9,4 @@ export interface SyntheticMigration {
         context: Pool;
     }) => Promise<void>;
 }
-export declare const getPostgresInitialSchema: (config: IBaseApiConfig, emailClient?: IEmailClient) => SyntheticMigration[];
+export declare const getPostgresInitialSchema: (config: IBaseApiConfig) => SyntheticMigration[];

package/dist/databases/postgres/migrations/postgres-initial-schema.js

@@ -1,7 +1,7 @@
 import { initializeSystemUserContext, EmptyUserContext, getSystemUserContext, isSystemUserContextInitialized } from '@loomcore/common/models';
 import { PostgresDatabase } from '../postgres.database.js';
 import { AuthService, OrganizationService } from '../../../services/index.js';
-export const getPostgresInitialSchema = (config, emailClient) => {
+export const getPostgresInitialSchema = (config) => {
     const migrations = [];
     const isMultiTenant = config.app.isMultiTenant;
     if (isMultiTenant && !config.multiTenant) {
@@ -11,7 +11,7 @@ export const getPostgresInitialSchema = (config, emailClient) => {
     if (isAuthEnabled && !config.auth) {
         throw new Error('Auth enabled without auth configuration');
     }
-    if (isAuthEnabled && (!emailClient || !config.email)) {
+    if (isAuthEnabled && (!config.thirdPartyClients?.emailClient || !config.email)) {
         throw new Error('Auth enabled without email client or email configuration');
     }
     if (isMultiTenant) {
@@ -259,7 +259,7 @@ export const getPostgresInitialSchema = (config, emailClient) => {
                 const client = await pool.connect();
                 try {
                     const database = new PostgresDatabase(client);
-                    const authService = new AuthService(database, emailClient);
+                    const authService = new AuthService(database);
                     if (!isSystemUserContextInitialized()) {
                         const errorMessage = isMultiTenant
                             ? 'SystemUserContext has not been initialized. The meta-org migration (00000000000009_data-meta-org) should have run before this migration. ' +
@@ -301,7 +301,7 @@ export const getPostgresInitialSchema = (config, emailClient) => {
                 try {
                     const database = new PostgresDatabase(client);
                     const organizationService = new OrganizationService(database);
-                    const authService = new AuthService(database, emailClient);
+                    const authService = new AuthService(database);
                     const metaOrg = isMultiTenant ? await organizationService.getMetaOrg(EmptyUserContext) : undefined;
                     if (isMultiTenant && !metaOrg) {
                         throw new Error('Meta organization not found. Ensure meta-org migration ran successfully.');

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;
@@ -67,24 +84,182 @@ export function buildJoinClauses(operations, mainTableName) {
         }
         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

@@ -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/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/dist/models/base-api-config.interface.d.ts

@@ -1,6 +1,7 @@
 import { DbType } from "../databases/db-type.type.js";
 import { IAuthConfig } from "./auth-config.interface.js";
 import { IEmailConfig } from "./email-config.interface.js";
+import { IEmailClient } from "./email-client.interface.js";
 import { IMultiTenantConfig } from "./multi-tenant-config.interface.js";
 export interface IBaseApiConfig {
     app: {
@@ -30,4 +31,7 @@ export interface IBaseApiConfig {
         hostName: string;
         internalPort?: number;
     };
+    thirdPartyClients?: {
+        emailClient?: IEmailClient;
+    };
 }

package/dist/services/auth.service.d.ts

@@ -5,14 +5,13 @@ import { MultiTenantApiService } from './multi-tenant-api.service.js';
 import { UpdateResult } from '../databases/models/update-result.js';
 import { IRefreshToken } from '../models/refresh-token.model.js';
 import { IDatabase } from '../databases/models/index.js';
-import { IEmailClient } from '../models/email-client.interface.js';
 export declare class AuthService extends MultiTenantApiService<IUser> {
     private refreshTokenService;
     private passwordResetTokenService;
     private emailService;
     private organizationService;
     private authConfig;
-    constructor(database: IDatabase, emailClient: IEmailClient);
+    constructor(database: IDatabase);
     attemptLogin(req: Request, res: Response, email: string, password: string): Promise<ILoginResponse | null>;
     logUserIn(userContext: IUserContext, deviceId: string): Promise<{
         tokens: {

package/dist/services/auth.service.js

@@ -18,11 +18,11 @@ export class AuthService extends MultiTenantApiService {
     emailService;
     organizationService;
     authConfig;
-    constructor(database, emailClient) {
+    constructor(database) {
         super(database, 'users', 'user', UserSpec);
         this.refreshTokenService = new GenericApiService(database, 'refresh_tokens', 'refresh_token', refreshTokenModelSpec);
         this.passwordResetTokenService = new PasswordResetTokenService(database);
-        this.emailService = new EmailService(emailClient);
+        this.emailService = new EmailService();
         this.organizationService = new OrganizationService(database);
         if (!config.auth) {
             throw new ServerError('Auth configuration is not set');

package/dist/services/email.service.d.ts

@@ -1,7 +1,6 @@
-import { IEmailClient } from '../models/email-client.interface.js';
 export declare class EmailService {
     private emailConfig;
     private emailClient;
-    constructor(emailClient: IEmailClient);
+    constructor();
     sendHtmlEmail(emailAddress: string, subject: string, body: string): Promise<void>;
 }

package/dist/services/email.service.js

@@ -3,14 +3,19 @@ import { config } from '../config/index.js';
 export class EmailService {
     emailConfig;
     emailClient;
-    constructor(emailClient) {
+    constructor() {
         if (config.email) {
             this.emailConfig = config.email;
         }
         else {
             throw new ServerError('Email configuration is not available. Email API credentials are not set in the config.');
         }
-        this.emailClient = emailClient;
+        if (config.thirdPartyClients?.emailClient) {
+            this.emailClient = config.thirdPartyClients.emailClient;
+        }
+        else {
+            throw new ServerError('Email client is not available. Email client is not set in the config.');
+        }
     }
     async sendHtmlEmail(emailAddress, subject, body) {
         const messageData = {

package/package.json

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