@loomcore/api 0.1.70 → 0.1.73

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

@@ -123,7 +123,30 @@ export const getPostgresTestSchema = (config) => {
         }
     });
     migrations.push({
-        name: '00000000000104_schema-clients',
+        name: '00000000000105_5_schema-agents',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS "agents" (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "person_id" INTEGER NOT NULL UNIQUE,
+          "_created" TIMESTAMPTZ NOT NULL,
+          "_createdBy" INTEGER NOT NULL,
+          "_updated" TIMESTAMPTZ NOT NULL,
+          "_updatedBy" INTEGER NOT NULL,
+          "_deleted" TIMESTAMPTZ,
+          "_deletedBy" INTEGER,
+          CONSTRAINT fk_agents_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "agents"');
+        }
+    });
+    migrations.push({
+        name: '00000000000105_6_schema-clients',
         up: async ({ context: pool }) => {
             const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
             await pool.query(`
@@ -132,13 +155,15 @@ export const getPostgresTestSchema = (config) => {
           ${orgColumnDef}
           "external_id" VARCHAR UNIQUE,
           "person_id" INTEGER NOT NULL UNIQUE,
+          "agent_id" INTEGER,
           "_created" TIMESTAMPTZ NOT NULL,
           "_createdBy" INTEGER NOT NULL,
           "_updated" TIMESTAMPTZ NOT NULL,
           "_updatedBy" INTEGER NOT NULL,
           "_deleted" TIMESTAMPTZ,
           "_deletedBy" INTEGER,
-          CONSTRAINT fk_clients_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE
+          CONSTRAINT fk_clients_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_clients_agent_id FOREIGN KEY ("agent_id") REFERENCES agents("_id") ON DELETE SET NULL
         )
       `);
         },
@@ -279,5 +304,101 @@ export const getPostgresTestSchema = (config) => {
             await pool.query('DROP TABLE IF EXISTS "persons_phone_numbers"');
         }
     });
+    migrations.push({
+        name: '00000000000111_schema-states',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS states (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" 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 "states"');
+        }
+    });
+    migrations.push({
+        name: '00000000000112_schema-districts',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS districts (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR NOT NULL,
+          "state_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_districts_state_id FOREIGN KEY ("state_id") REFERENCES states("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "districts"');
+        }
+    });
+    migrations.push({
+        name: '00000000000113_schema-schools',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS schools (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "name" VARCHAR NOT NULL,
+          "district_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_schools_district_id FOREIGN KEY ("district_id") REFERENCES districts("_id") ON DELETE CASCADE
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "schools"');
+        }
+    });
+    migrations.push({
+        name: '00000000000114_schema-person-schools',
+        up: async ({ context: pool }) => {
+            const orgColumnDef = isMultiTenant ? '"_orgId" INTEGER,' : '';
+            await pool.query(`
+        CREATE TABLE IF NOT EXISTS persons_schools (
+          "_id" INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+          ${orgColumnDef}
+          "person_id" INTEGER NOT NULL,
+          "school_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_persons_schools_person_id FOREIGN KEY ("person_id") REFERENCES persons("_id") ON DELETE CASCADE,
+          CONSTRAINT fk_persons_schools_school_id FOREIGN KEY ("school_id") REFERENCES schools("_id") ON DELETE CASCADE,
+          CONSTRAINT uk_persons_schools_person_school UNIQUE ("person_id", "school_id")
+        )
+      `);
+        },
+        down: async ({ context: pool }) => {
+            await pool.query('DROP TABLE IF EXISTS "persons_schools"');
+        }
+    });
     return migrations;
 };

package/dist/databases/mongo-db/utils/convert-operations-to-pipeline.util.js

@@ -1,6 +1,7 @@
 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';
 export function convertOperationsToPipeline(operations) {
     let pipeline = [];
     const processedOperations = [];
@@ -124,6 +125,193 @@ export function convertOperationsToPipeline(operations) {
             }
         }
         else if (operation instanceof JoinThrough) {
+            const needsObjectIdConversion = operation.foreignField === '_id';
+            const isNestedField = operation.localField.includes('.');
+            if (needsObjectIdConversion || isNestedField) {
+                pipeline.push({
+                    $lookup: {
+                        from: operation.through,
+                        let: { localId: { $cond: [
+                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
+                                    { $toObjectId: `$${operation.localField}` },
+                                    `$${operation.localField}`
+                                ] } },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [
+                                            {
+                                                $cond: [
+                                                    { $eq: [{ $type: `$${operation.throughLocalField}` }, 'string'] },
+                                                    { $toObjectId: `$${operation.throughLocalField}` },
+                                                    `$${operation.throughLocalField}`
+                                                ]
+                                            },
+                                            '$$localId'
+                                        ]
+                                    }
+                                }
+                            },
+                            { $limit: 1 }
+                        ],
+                        as: `${operation.as}_through`
+                    }
+                }, {
+                    $unwind: {
+                        path: `$${operation.as}_through`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                }, {
+                    $lookup: {
+                        from: operation.from,
+                        let: { foreignId: { $cond: [
+                                    { $eq: [{ $type: `$${operation.as}_through.${operation.throughForeignField}` }, 'string'] },
+                                    { $toObjectId: `$${operation.as}_through.${operation.throughForeignField}` },
+                                    `$${operation.as}_through.${operation.throughForeignField}`
+                                ] } },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $expr: {
+                                        $eq: [
+                                            {
+                                                $cond: [
+                                                    { $eq: [{ $type: `$${operation.foreignField}` }, 'string'] },
+                                                    { $toObjectId: `$${operation.foreignField}` },
+                                                    `$${operation.foreignField}`
+                                                ]
+                                            },
+                                            '$$foreignId'
+                                        ]
+                                    }
+                                }
+                            }
+                        ],
+                        as: `${operation.as}_temp`
+                    }
+                }, {
+                    $unwind: {
+                        path: `$${operation.as}_temp`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                }, {
+                    $addFields: {
+                        [operation.as]: `$${operation.as}_temp`
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}_through`]: 0,
+                        [`${operation.as}_temp`]: 0
+                    }
+                });
+                if (isNestedField) {
+                    const [parentAlias] = operation.localField.split('.');
+                    const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinThrough) && op.as === parentAlias);
+                    if (parentJoin) {
+                        pipeline.push({
+                            $set: {
+                                [parentAlias]: {
+                                    $mergeObjects: [
+                                        { $ifNull: [`$${parentAlias}`, {}] },
+                                        { [operation.as]: `$${operation.as}` }
+                                    ]
+                                }
+                            }
+                        });
+                        pipeline.push({
+                            $unset: operation.as
+                        });
+                    }
+                }
+            }
+            else {
+                const isNestedFieldElse = operation.localField.includes('.');
+                if (isNestedFieldElse) {
+                    pipeline.push({
+                        $lookup: {
+                            from: operation.through,
+                            let: { localId: `$${operation.localField}` },
+                            pipeline: [
+                                {
+                                    $match: {
+                                        $expr: {
+                                            $eq: [`$${operation.throughLocalField}`, '$$localId']
+                                        }
+                                    }
+                                },
+                                { $limit: 1 }
+                            ],
+                            as: `${operation.as}_through`
+                        }
+                    }, {
+                        $unwind: {
+                            path: `$${operation.as}_through`,
+                            preserveNullAndEmptyArrays: true
+                        }
+                    });
+                }
+                else {
+                    pipeline.push({
+                        $lookup: {
+                            from: operation.through,
+                            localField: operation.localField,
+                            foreignField: operation.throughLocalField,
+                            as: `${operation.as}_through`
+                        }
+                    }, {
+                        $unwind: {
+                            path: `$${operation.as}_through`,
+                            preserveNullAndEmptyArrays: true
+                        }
+                    });
+                }
+                pipeline.push({
+                    $lookup: {
+                        from: operation.from,
+                        localField: `${operation.as}_through.${operation.throughForeignField}`,
+                        foreignField: operation.foreignField,
+                        as: `${operation.as}_temp`
+                    }
+                }, {
+                    $unwind: {
+                        path: `$${operation.as}_temp`,
+                        preserveNullAndEmptyArrays: true
+                    }
+                }, {
+                    $addFields: {
+                        [operation.as]: `$${operation.as}_temp`
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}_through`]: 0,
+                        [`${operation.as}_temp`]: 0
+                    }
+                });
+                if (isNestedFieldElse) {
+                    const [parentAlias] = operation.localField.split('.');
+                    const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinThrough) && op.as === parentAlias);
+                    if (parentJoin) {
+                        pipeline.push({
+                            $addFields: {
+                                [parentAlias]: {
+                                    $mergeObjects: [
+                                        `$${parentAlias}`,
+                                        { [operation.as]: `$${operation.as}` }
+                                    ]
+                                }
+                            }
+                        });
+                        pipeline.push({
+                            $project: {
+                                [operation.as]: 0
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        else if (operation instanceof JoinThroughMany) {
             const needsObjectIdConversion = operation.foreignField === '_id';
             const isNestedField = operation.localField.includes('.');
             if (needsObjectIdConversion || isNestedField) {
@@ -208,7 +396,7 @@ export function convertOperationsToPipeline(operations) {
                 });
                 if (isNestedField) {
                     const [parentAlias] = operation.localField.split('.');
-                    const parentJoin = processedOperations.find(op => op instanceof Join && op.as === parentAlias);
+                    const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinThrough) && op.as === parentAlias);
                     if (parentJoin) {
                         pipeline.push({
                             $set: {
@@ -293,7 +481,7 @@ export function convertOperationsToPipeline(operations) {
                 });
                 if (isNestedFieldElse) {
                     const [parentAlias] = operation.localField.split('.');
-                    const parentJoin = processedOperations.find(op => op instanceof Join && op.as === parentAlias);
+                    const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinThrough) && op.as === parentAlias);
                     if (parentJoin) {
                         pipeline.push({
                             $addFields: {

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

@@ -0,0 +1,25 @@
+import { IAuditable, IEntity } from "@loomcore/common/models";
+import { IPersonModel } from "./person.model.js";
+export interface IAgentModel extends IEntity, IAuditable {
+    person_id: number;
+    agent_person?: IPersonModel;
+}
+export declare const agentSchema: 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 agentModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

@@ -0,0 +1,8 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { personSchema } from "./person.model.js";
+export const agentSchema = Type.Object({
+    person_id: Type.Number(),
+    agent_person: Type.Optional(personSchema),
+});
+export const agentModelSpec = entityUtils.getModelSpec(agentSchema, { isAuditable: true });

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

@@ -1,10 +1,12 @@
 import { IPersonModel } from "./person.model.js";
+import { IAgentModel } from "./agent.model.js";
 import type { IAuditable, IEntity } from "@loomcore/common/models";
 export interface IClientReportsModel extends IEntity, IAuditable {
-    person: IPersonModel;
+    client_person: IPersonModel;
+    agent?: IAgentModel;
 }
 export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
-    person: import("@sinclair/typebox").TObject<{
+    client_person: 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;
@@ -19,5 +21,23 @@ export declare const clientReportsSchema: import("@sinclair/typebox").TObject<{
             is_default: import("@sinclair/typebox").TBoolean;
         }>>;
     }>;
+    agent: import("@sinclair/typebox").TOptional<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,7 +1,9 @@
 import { personSchema } from "./person.model.js";
+import { agentSchema } from "./agent.model.js";
 import { entityUtils } from "@loomcore/common/utils";
 import { Type } from "@sinclair/typebox";
 export const clientReportsSchema = Type.Object({
-    person: personSchema
+    client_person: personSchema,
+    agent: Type.Optional(agentSchema)
 });
 export const clientReportsModelSpec = entityUtils.getModelSpec(clientReportsSchema, { isAuditable: true });

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

@@ -0,0 +1,12 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+import { IStateModel } from "./state.model.js";
+export interface IDistrictModel extends IEntity, IAuditable {
+    name: string;
+    state_id: number;
+    state?: IStateModel;
+}
+export declare const districtSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    state_id: import("@sinclair/typebox").TNumber;
+}>;
+export declare const districtModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

@@ -0,0 +1,7 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const districtSchema = Type.Object({
+    name: Type.String(),
+    state_id: Type.Number(),
+});
+export const districtModelSpec = entityUtils.getModelSpec(districtSchema, { isAuditable: true });

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

@@ -1,12 +1,14 @@
 import type { IAuditable, IEntity } from "@loomcore/common/models";
 import { IEmailAddressModel } from "./email-address.model.js";
 import { IPhoneNumberModel } from "./phone-number.model.js";
+import { ISchoolModel } from "./school.model.js";
 export interface IPersonModel extends IEntity, IAuditable {
     first_name: string;
     middle_name: string | null;
     last_name: string;
     email_addresses: IEmailAddressModel[];
     phone_numbers: IPhoneNumberModel[];
+    school?: ISchoolModel;
 }
 export declare const personSchema: import("@sinclair/typebox").TObject<{
     first_name: import("@sinclair/typebox").TString;

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

@@ -0,0 +1,12 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+import { IDistrictModel } from "./district.model.js";
+export interface ISchoolModel extends IEntity, IAuditable {
+    name: string;
+    district_id: number;
+    district?: IDistrictModel;
+}
+export declare const schoolSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    district_id: import("@sinclair/typebox").TNumber;
+}>;
+export declare const schoolModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

@@ -0,0 +1,7 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const schoolSchema = Type.Object({
+    name: Type.String(),
+    district_id: Type.Number(),
+});
+export const schoolModelSpec = entityUtils.getModelSpec(schoolSchema, { isAuditable: true });

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

@@ -0,0 +1,8 @@
+import type { IAuditable, IEntity } from "@loomcore/common/models";
+export interface IStateModel extends IEntity, IAuditable {
+    name: string;
+}
+export declare const stateSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>;
+export declare const stateModelSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

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

@@ -0,0 +1,6 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+export const stateSchema = Type.Object({
+    name: Type.String(),
+});
+export const stateModelSpec = entityUtils.getModelSpec(stateSchema, { isAuditable: true });

package/dist/databases/operations/index.d.ts

@@ -2,3 +2,4 @@ export * from './operation.js';
 export * from './join.operation.js';
 export * from './join-many.operation.js';
 export * from './join-through.operation.js';
+export * from './join-through-many.operation.js';

package/dist/databases/operations/index.js

@@ -2,3 +2,4 @@ export * from './operation.js';
 export * from './join.operation.js';
 export * from './join-many.operation.js';
 export * from './join-through.operation.js';
+export * from './join-through-many.operation.js';

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,18 @@
+export class JoinThroughMany {
+    from;
+    through;
+    localField;
+    throughLocalField;
+    throughForeignField;
+    foreignField;
+    as;
+    constructor(from, through, localField, throughLocalField, throughForeignField, foreignField, as) {
+        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/operation.d.ts

@@ -1,4 +1,5 @@
 import { Join } from "./join.operation.js";
 import { JoinMany } from "./join-many.operation.js";
 import { JoinThrough } from "./join-through.operation.js";
-export type Operation = Join | JoinMany | JoinThrough;
+import { JoinThroughMany } from "./join-through-many.operation.js";
+export type Operation = Join | JoinMany | JoinThrough | JoinThroughMany;

package/dist/databases/postgres/commands/postgres-batch-update.command.js

@@ -1,6 +1,7 @@
 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 { BadRequestError } from "../../../errors/index.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildSelectClause } from '../utils/build-select-clause.js';
@@ -39,7 +40,7 @@ export async function batchUpdate(client, entities, operations, queryObject, plu
         }
         await client.query('COMMIT');
         const joinClauses = buildJoinClauses(operations, pluralResourceName);
-        const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
+        const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany);
         const tablePrefix = hasJoins ? pluralResourceName : undefined;
         queryObject.filters._id = { in: entityIds };
         const { whereClause, values } = buildWhereClause(queryObject, [], tablePrefix);

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

@@ -1,12 +1,13 @@
 import { Join } from "../../operations/join.operation.js";
 import { JoinMany } from "../../operations/join-many.operation.js";
 import { JoinThrough } from "../../operations/join-through.operation.js";
+import { JoinThroughMany } from "../../operations/join-through-many.operation.js";
 import { buildJoinClauses } from '../utils/build-join-clauses.js';
 import { buildSelectClause } from '../utils/build-select-clause.js';
 import { transformJoinResults } from '../utils/transform-join-results.js';
 export async function getAll(client, operations, pluralResourceName) {
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
-    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
+    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

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

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

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

@@ -1,6 +1,7 @@
 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 { buildWhereClause } from "../utils/build-where-clause.js";
 import { buildOrderByClause } from "../utils/build-order-by-clause.js";
 import { buildJoinClauses } from "../utils/build-join-clauses.js";
@@ -13,7 +14,7 @@ export async function get(client, operations, queryOptions, pluralResourceName)
     const joinClauses = buildJoinClauses(operations, pluralResourceName);
     const orderByClause = buildOrderByClause(queryOptions);
     const paginationClause = buildPaginationClause(queryOptions);
-    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough);
+    const hasJoins = operations.some(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany);
     const selectClause = hasJoins
         ? await buildSelectClause(client, pluralResourceName, pluralResourceName, operations)
         : '*';

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

@@ -1,55 +1,91 @@
 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";
 export function buildJoinClauses(operations, mainTableName) {
     let joinClauses = '';
-    const joinOperations = operations.filter(op => op instanceof Join);
-    const joinManyOperations = operations.filter(op => op instanceof JoinMany);
     const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
-    for (const operation of joinOperations) {
-        const localFieldRef = mainTableName
-            ? `"${mainTableName}"."${operation.localField}"`
-            : `"${operation.localField}"`;
-        joinClauses += ` LEFT JOIN "${operation.from}" AS ${operation.as} ON ${localFieldRef} = "${operation.as}"."${operation.foreignField}"`;
-    }
-    for (const joinMany of joinManyOperations) {
-        let localFieldRef;
-        if (joinMany.localField.includes('.')) {
-            const [tableAlias, columnName] = joinMany.localField.split('.');
-            localFieldRef = `${tableAlias}."${columnName}"`;
+    for (const operation of operations) {
+        if (operation instanceof Join) {
+            let localFieldRef;
+            if (operation.localField.includes('.')) {
+                const [tableAlias, columnName] = operation.localField.split('.');
+                const referencedJoinThrough = joinThroughOperations.find(jt => jt.as === tableAlias);
+                if (referencedJoinThrough) {
+                    localFieldRef = `(${tableAlias}.aggregated->>'${columnName}')::integer`;
+                }
+                else {
+                    localFieldRef = `${tableAlias}."${columnName}"`;
+                }
+            }
+            else {
+                localFieldRef = mainTableName
+                    ? `"${mainTableName}"."${operation.localField}"`
+                    : `"${operation.localField}"`;
+            }
+            joinClauses += ` LEFT JOIN "${operation.from}" AS ${operation.as} ON ${localFieldRef} = "${operation.as}"."${operation.foreignField}"`;
         }
-        else {
-            localFieldRef = mainTableName
-                ? `"${mainTableName}"."${joinMany.localField}"`
-                : `"${joinMany.localField}"`;
+        else if (operation instanceof JoinMany) {
+            let localFieldRef;
+            if (operation.localField.includes('.')) {
+                const [tableAlias, columnName] = operation.localField.split('.');
+                localFieldRef = `${tableAlias}."${columnName}"`;
+            }
+            else {
+                localFieldRef = 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
+            ) AS ${operation.as} ON true`;
         }
-        joinClauses += ` LEFT JOIN LATERAL (
-            SELECT COALESCE(JSON_AGG(row_to_json("${joinMany.from}")), '[]'::json) AS aggregated
-            FROM "${joinMany.from}"
-            WHERE "${joinMany.from}"."${joinMany.foreignField}" = ${localFieldRef}
-            AND "${joinMany.from}"."_deleted" IS NULL
-        ) AS ${joinMany.as} ON true`;
-    }
-    for (const joinThrough of joinThroughOperations) {
-        let localFieldRef;
-        if (joinThrough.localField.includes('.')) {
-            const [tableAlias, columnName] = joinThrough.localField.split('.');
-            localFieldRef = `${tableAlias}."${columnName}"`;
+        else if (operation instanceof JoinThrough) {
+            let localFieldRef;
+            if (operation.localField.includes('.')) {
+                const [tableAlias, columnName] = operation.localField.split('.');
+                localFieldRef = `${tableAlias}."${columnName}"`;
+            }
+            else {
+                localFieldRef = 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
+            ) AS ${operation.as} ON true`;
         }
-        else {
-            localFieldRef = mainTableName
-                ? `"${mainTableName}"."${joinThrough.localField}"`
-                : `"${joinThrough.localField}"`;
+        else if (operation instanceof JoinThroughMany) {
+            let localFieldRef;
+            if (operation.localField.includes('.')) {
+                const [tableAlias, columnName] = operation.localField.split('.');
+                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`;
         }
-        joinClauses += ` LEFT JOIN LATERAL (
-            SELECT COALESCE(JSON_AGG(row_to_json(${joinThrough.as})), '[]'::json) AS aggregated
-            FROM "${joinThrough.through}"
-            INNER JOIN "${joinThrough.from}" AS ${joinThrough.as} 
-                ON ${joinThrough.as}."${joinThrough.foreignField}" = "${joinThrough.through}"."${joinThrough.throughForeignField}"
-            WHERE "${joinThrough.through}"."${joinThrough.throughLocalField}" = ${localFieldRef}
-            AND "${joinThrough.through}"."_deleted" IS NULL
-            AND ${joinThrough.as}."_deleted" IS NULL
-        ) AS ${joinThrough.as} ON true`;
     }
     return joinClauses;
 }

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

@@ -1,6 +1,7 @@
 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';
 async function getTableColumns(client, tableName) {
     const result = await client.query(`
             SELECT column_name
@@ -15,6 +16,7 @@ export async function buildSelectClause(client, mainTableName, mainTableAlias, o
     const joinOperations = operations.filter(op => op instanceof Join);
     const joinManyOperations = operations.filter(op => op instanceof JoinMany);
     const joinThroughOperations = operations.filter(op => op instanceof JoinThrough);
+    const joinThroughManyOperations = operations.filter(op => op instanceof JoinThroughMany);
     const mainTableColumns = await getTableColumns(client, mainTableName);
     const mainSelects = mainTableColumns.map(col => `"${mainTableName}"."${col}" AS "${col}"`);
     const joinSelects = [];
@@ -33,6 +35,9 @@ export async function buildSelectClause(client, mainTableName, mainTableAlias, o
     for (const joinThrough of joinThroughOperations) {
         joinSelects.push(`${joinThrough.as}.aggregated AS "${joinThrough.as}"`);
     }
+    for (const joinThroughMany of joinThroughManyOperations) {
+        joinSelects.push(`${joinThroughMany.as}.aggregated AS "${joinThroughMany.as}"`);
+    }
     const allSelects = [...mainSelects, ...joinSelects];
     return allSelects.join(', ');
 }

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

@@ -1,11 +1,13 @@
 import { Join } from '../../operations/join.operation.js';
 import { JoinMany } from '../../operations/join-many.operation.js';
 import { JoinThrough } from '../../operations/join-through.operation.js';
+import { JoinThroughMany } from '../../operations/join-through-many.operation.js';
 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);
-    if (joinOperations.length === 0 && joinManyOperations.length === 0 && joinThroughOperations.length === 0) {
+    const joinThroughManyOperations = operations.filter(op => op instanceof JoinThroughMany);
+    if (joinOperations.length === 0 && joinManyOperations.length === 0 && joinThroughOperations.length === 0 && joinThroughManyOperations.length === 0) {
         return rows;
     }
     return rows.map(row => {
@@ -13,7 +15,8 @@ export function transformJoinResults(rows, operations) {
         const allJoinAliases = [
             ...joinOperations.map(j => j.as),
             ...joinManyOperations.map(j => j.as),
-            ...joinThroughOperations.map(j => j.as)
+            ...joinThroughOperations.map(j => j.as),
+            ...joinThroughManyOperations.map(j => j.as)
         ];
         for (const key of Object.keys(row)) {
             const hasJoinPrefix = joinOperations.some(join => key.startsWith(`${join.as}__`));
@@ -22,21 +25,100 @@ export function transformJoinResults(rows, operations) {
                 transformed[key] = row[key];
             }
         }
-        for (const join of joinOperations) {
-            const prefix = `${join.as}__`;
-            const joinedData = {};
-            let hasAnyData = false;
-            for (const key of Object.keys(row)) {
-                if (key.startsWith(prefix)) {
-                    const columnName = key.substring(prefix.length);
-                    const value = row[key];
-                    joinedData[columnName] = value;
-                    if (value !== null && value !== undefined) {
-                        hasAnyData = true;
+        for (const operation of operations) {
+            if (operation instanceof JoinThrough) {
+                const jsonValue = row[operation.as];
+                let parsedValue;
+                if (jsonValue !== null && jsonValue !== undefined) {
+                    parsedValue = typeof jsonValue === 'string'
+                        ? JSON.parse(jsonValue)
+                        : jsonValue;
+                }
+                else {
+                    parsedValue = null;
+                }
+                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);
+                    if ((relatedJoin && transformed[relatedJoin.as]) || (relatedJoinThrough && transformed[relatedJoinThrough.as])) {
+                        const targetAlias = relatedJoin ? relatedJoin.as : relatedJoinThrough.as;
+                        transformed[targetAlias][operation.as] = parsedValue;
+                    }
+                    else {
+                        transformed[operation.as] = parsedValue;
                     }
                 }
+                else {
+                    transformed[operation.as] = parsedValue;
+                }
+            }
+            else if (operation instanceof Join) {
+                const prefix = `${operation.as}__`;
+                const joinedData = {};
+                let hasAnyData = false;
+                for (const key of Object.keys(row)) {
+                    if (key.startsWith(prefix)) {
+                        const columnName = key.substring(prefix.length);
+                        const value = row[key];
+                        joinedData[columnName] = value;
+                        if (value !== null && value !== undefined) {
+                            hasAnyData = true;
+                        }
+                    }
+                }
+                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 findNestedObject = (obj, alias, path = []) => {
+                        if (obj[alias] !== undefined && obj[alias] !== null) {
+                            return { obj: obj[alias], path: [...path, alias] };
+                        }
+                        for (const key in obj) {
+                            if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+                                const found = findNestedObject(obj[key], alias, [...path, key]);
+                                if (found !== null) {
+                                    return found;
+                                }
+                            }
+                        }
+                        return null;
+                    };
+                    let targetObject = null;
+                    if (relatedJoin) {
+                        if (transformed[relatedJoin.as] !== undefined && transformed[relatedJoin.as] !== null) {
+                            targetObject = transformed[relatedJoin.as];
+                        }
+                        else {
+                            const found = findNestedObject(transformed, relatedJoin.as);
+                            if (found !== null && found.obj !== undefined && found.obj !== null) {
+                                targetObject = found.obj;
+                            }
+                        }
+                    }
+                    else if (relatedJoinThrough) {
+                        const found = findNestedObject(transformed, relatedJoinThrough.as);
+                        if (found !== null && found.obj !== undefined && found.obj !== null) {
+                            targetObject = found.obj;
+                        }
+                    }
+                    if (targetObject) {
+                        if (hasAnyData) {
+                            targetObject[operation.as] = joinedData;
+                        }
+                        else {
+                            targetObject[operation.as] = null;
+                        }
+                    }
+                    else {
+                        transformed[operation.as] = hasAnyData ? joinedData : null;
+                    }
+                }
+                else {
+                    transformed[operation.as] = hasAnyData ? joinedData : null;
+                }
             }
-            transformed[join.as] = hasAnyData ? joinedData : null;
         }
         for (const joinMany of joinManyOperations) {
             const jsonValue = row[joinMany.as];
@@ -63,8 +145,8 @@ export function transformJoinResults(rows, operations) {
                 transformed[joinMany.as] = parsedValue;
             }
         }
-        for (const joinThrough of joinThroughOperations) {
-            const jsonValue = row[joinThrough.as];
+        for (const joinThroughMany of joinThroughManyOperations) {
+            const jsonValue = row[joinThroughMany.as];
             let parsedValue;
             if (jsonValue !== null && jsonValue !== undefined) {
                 parsedValue = typeof jsonValue === 'string'
@@ -74,18 +156,20 @@ export function transformJoinResults(rows, operations) {
             else {
                 parsedValue = [];
             }
-            if (joinThrough.localField.includes('.')) {
-                const [tableAlias] = joinThrough.localField.split('.');
+            if (joinThroughMany.localField.includes('.')) {
+                const [tableAlias] = joinThroughMany.localField.split('.');
                 const relatedJoin = joinOperations.find(j => j.as === tableAlias);
-                if (relatedJoin && transformed[relatedJoin.as]) {
-                    transformed[relatedJoin.as][joinThrough.as] = parsedValue;
+                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;
                 }
                 else {
-                    transformed[joinThrough.as] = parsedValue;
+                    transformed[joinThroughMany.as] = parsedValue;
                 }
             }
             else {
-                transformed[joinThrough.as] = parsedValue;
+                transformed[joinThroughMany.as] = parsedValue;
             }
         }
         return transformed;

package/package.json

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