@loomcore/api 0.1.90 → 0.1.91

package/dist/__tests__/common-test.utils.d.ts

@@ -1,4 +1,4 @@
-import { Application } from 'express';
+import { Request, Response, Application, NextFunction } from 'express';
 import { IUserContext, IQueryOptions, IUser } from '@loomcore/common/models';
 import { ApiController } from '../controllers/api.controller.js';
 import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
@@ -31,16 +31,13 @@ export declare class CategoryController extends ApiController<ICategory> {
 }
 export declare function setupTestConfig(isMultiTenant: boolean | undefined, dbType: DbType): void;
 export declare class ProductService extends GenericApiService<IProduct> {
-    private db;
     constructor(database: IDatabase);
-    prepareQuery(userContext: IUserContext, queryObject: IQueryOptions, operations: Operation[]): {
-        queryObject: IQueryOptions;
-        operations: Operation[];
-    };
-    postProcessEntity(userContext: IUserContext, single: any): any;
 }
 export declare class ProductsController extends ApiController<IProduct> {
     constructor(app: Application, database: IDatabase);
+    get(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getAll(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getById(req: Request, res: Response, next: NextFunction): Promise<void>;
 }
 export declare class MultiTenantProductService extends MultiTenantApiService<IProduct> {
     private db;

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

@@ -2,6 +2,7 @@ import crypto from 'crypto';
 import jwt from 'jsonwebtoken';
 import { EmptyUserContext } from '@loomcore/common/models';
 import { Type } from '@sinclair/typebox';
+import { Value } from '@sinclair/typebox/value';
 import { JwtService } from '../services/jwt.service.js';
 import { ApiController } from '../controllers/api.controller.js';
 import { MultiTenantApiService } from '../services/multi-tenant-api.service.js';
@@ -15,11 +16,13 @@ import * as testObjectsModule from './test-objects.js';
 const { getTestMetaOrg, getTestOrg, getTestMetaOrgUser, getTestMetaOrgUserContext, getTestOrgUserContext, setTestOrgId, setTestMetaOrgId, setTestMetaOrgUserId, setTestOrgUserId } = testObjectsModule;
 import { CategorySpec } from './models/category.model.js';
 import { ProductSpec } from './models/product.model.js';
+import { ProductWithCategoryPublicSpec, ProductWithCategorySpec } from './models/product-with-category.model.js';
 import { setBaseApiConfig, config } from '../config/index.js';
 import { entityUtils } from '@loomcore/common/utils';
 import { getTestMetaOrgUserPerson, getTestOrgUser, getTestOrgUserPerson, setTestMetaOrgUserPersonId, setTestOrgUserPersonId } from './test-objects.js';
 import { TestEmailClient } from './test-email-client.js';
 import { PersonService } from '../services/person.service.js';
+import { apiUtils } from '../utils/index.js';
 let deviceIdCookie;
 let authService;
 let organizationService;
@@ -234,39 +237,70 @@ export function setupTestConfig(isMultiTenant = true, dbType) {
         },
     });
 }
+const prepareQueryCustom = (userContext, queryObject, operations) => {
+    return {
+        queryObject: queryObject,
+        operations: [
+            ...operations,
+            new Join('categories', 'categoryId', '_id', 'category')
+        ]
+    };
+};
+const postProcessEntityCustom = (userContext, entity) => {
+    return {
+        ...entity,
+        category: entity._joinData?.category
+    };
+};
 export class ProductService extends GenericApiService {
-    db;
     constructor(database) {
         super(database, 'products', 'product', ProductSpec);
-        this.db = database;
-    }
-    prepareQuery(userContext, queryObject, operations) {
-        const newOperations = [
-            ...operations,
-            new Join('categories', 'categoryId', '_id', 'category')
-        ];
-        return super.prepareQuery(userContext, queryObject, newOperations);
-    }
-    postProcessEntity(userContext, single) {
-        if (single && single.category) {
-            const categoryService = new CategoryService(this.db);
-            single.category = categoryService.postProcessEntity(userContext, single.category);
-        }
-        return super.postProcessEntity(userContext, single);
     }
 }
 export class ProductsController extends ApiController {
     constructor(app, database) {
         const productService = new ProductService(database);
-        const AggregatedProductSchema = Type.Intersect([
-            ProductSpec.fullSchema,
-            Type.Partial(Type.Object({
-                category: CategorySpec.fullSchema
-            }))
-        ]);
-        const PublicAggregatedProductSchema = Type.Omit(AggregatedProductSchema, ['internalNumber']);
-        const PublicAggregatedProductSpec = entityUtils.getModelSpec(PublicAggregatedProductSchema);
-        super('products', app, productService, 'product', ProductSpec, PublicAggregatedProductSpec);
+        super('products', app, productService, 'product', ProductSpec);
+    }
+    async get(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const userContext = req.userContext;
+        if (!userContext) {
+            throw new Error('User context not found');
+        }
+        const queryOptions = apiUtils.getQueryOptionsFromRequest(req);
+        const pagedResult = await this.service.get(userContext, queryOptions, prepareQueryCustom, postProcessEntityCustom);
+        apiUtils.apiResponse(res, 200, { data: pagedResult }, ProductWithCategorySpec, ProductWithCategoryPublicSpec);
+    }
+    async getAll(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const userContext = req.userContext;
+        if (!userContext) {
+            throw new Error('User context not found');
+        }
+        const entities = await this.service.getAll(userContext, prepareQueryCustom, postProcessEntityCustom);
+        apiUtils.apiResponse(res, 200, { data: entities }, ProductWithCategorySpec, ProductWithCategoryPublicSpec);
+    }
+    async getById(req, res, next) {
+        res.set('Content-Type', 'application/json');
+        const userContext = req.userContext;
+        if (!userContext) {
+            throw new Error('User context not found');
+        }
+        const idParam = req.params?.id;
+        if (!idParam) {
+            throw new Error('ID parameter is required');
+        }
+        try {
+            const id = Value.Convert(this.idSchema, idParam);
+            console.log('got to Id response');
+            const entity = await this.service.getById(userContext, id, prepareQueryCustom, postProcessEntityCustom);
+            console.log('got to Id response 2');
+            apiUtils.apiResponse(res, 200, { data: entity }, ProductWithCategorySpec, ProductWithCategoryPublicSpec);
+        }
+        catch (error) {
+            throw new Error(`Invalid ID format: ${error.message || error}`);
+        }
     }
 }
 export class MultiTenantProductService extends MultiTenantApiService {

package/dist/__tests__/models/product-with-category.model.d.ts

@@ -0,0 +1,21 @@
+import { ICategory } from "./category.model.js";
+import { IAuditable, IEntity } from "@loomcore/common/models";
+export interface IProductWithCategory extends IEntity, IAuditable {
+    name: string;
+    description?: string;
+    internalNumber?: string;
+    category: ICategory;
+}
+export declare const ProductWithCategorySchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    internalNumber: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    category: import("@sinclair/typebox").TSchema;
+}>;
+export declare const ProductWithCategorySpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;
+export declare const PublicProductWithCategorySchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    category: import("@sinclair/typebox").TSchema;
+}>;
+export declare const ProductWithCategoryPublicSpec: import("@loomcore/common/models").IModelSpec<import("@sinclair/typebox").TSchema>;

package/dist/__tests__/models/product-with-category.model.js

@@ -0,0 +1,12 @@
+import { entityUtils } from "@loomcore/common/utils";
+import { Type } from "@sinclair/typebox";
+import { CategorySpec } from "./category.model.js";
+export const ProductWithCategorySchema = Type.Object({
+    name: Type.String(),
+    description: Type.Optional(Type.String()),
+    internalNumber: Type.Optional(Type.String()),
+    category: CategorySpec.fullSchema,
+});
+export const ProductWithCategorySpec = entityUtils.getModelSpec(ProductWithCategorySchema, { isAuditable: true });
+export const PublicProductWithCategorySchema = Type.Omit(ProductWithCategorySchema, ['internalNumber']);
+export const ProductWithCategoryPublicSpec = entityUtils.getModelSpec(PublicProductWithCategorySchema);

package/dist/__tests__/models/product.model.d.ts

@@ -1,12 +1,10 @@
 import { IAuditable, IEntity } from "@loomcore/common/models";
-import { ICategory } from "./category.model.js";
 import { AppIdType } from "@loomcore/common/types";
 export interface IProduct extends IEntity, IAuditable {
     name: string;
     description?: string;
     internalNumber?: string;
     categoryId: AppIdType;
-    category?: ICategory;
 }
 export declare const ProductSchema: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;

package/dist/controllers/index.d.ts

@@ -8,3 +8,4 @@ export * from './roles.controller.js';
 export * from './authorizations.controller.js';
 export * from './features.controller.js';
 export * from './persons.controller.js';
+export * from './types.js';

package/dist/controllers/index.js

@@ -8,3 +8,4 @@ export * from './roles.controller.js';
 export * from './authorizations.controller.js';
 export * from './features.controller.js';
 export * from './persons.controller.js';
+export * from './types.js';

package/dist/controllers/types.d.ts

@@ -0,0 +1,7 @@
+import { IEntity, IQueryOptions, IUserContext } from "@loomcore/common/models";
+import { Operation } from "../databases/index.js";
+export type PrepareQueryCustomFunction = (userContext: IUserContext | undefined, queryObject: IQueryOptions, operations: Operation[]) => {
+    queryObject: IQueryOptions;
+    operations: Operation[];
+};
+export type PostProcessEntityCustomFunction<TIn extends IEntity, TOut extends IEntity> = (userContext: IUserContext, entity: TIn) => TOut;

package/dist/controllers/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -2,21 +2,49 @@ 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';
+function resolveLocalFieldPath(localField, processedOperations) {
+    if (!localField.includes('.')) {
+        return localField;
+    }
+    const [parentAlias] = localField.split('.');
+    const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany) &&
+        op.as === parentAlias);
+    if (parentJoin) {
+        return `_joinData.${localField}`;
+    }
+    return localField;
+}
 export function convertOperationsToPipeline(operations) {
     let pipeline = [];
     const processedOperations = [];
+    const joinAliases = operations
+        .filter(op => op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany)
+        .map(op => op.as);
+    if (joinAliases.length > 0) {
+        pipeline.push({
+            $set: {
+                _joinData: {}
+            }
+        });
+    }
     operations.forEach(operation => {
         if (operation instanceof Join) {
             const needsObjectIdConversion = operation.foreignField === '_id';
+            const isNestedField = operation.localField.includes('.');
+            const resolvedLocalField = resolveLocalFieldPath(operation.localField, processedOperations);
             if (needsObjectIdConversion) {
                 pipeline.push({
                     $lookup: {
                         from: operation.from,
-                        let: { localId: { $cond: [
-                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
-                                    { $toObjectId: `$${operation.localField}` },
-                                    `$${operation.localField}`
-                                ] } },
+                        let: {
+                            localId: {
+                                $cond: [
+                                    { $eq: [{ $type: `$${resolvedLocalField}` }, 'string'] },
+                                    { $toObjectId: `$${resolvedLocalField}` },
+                                    `$${resolvedLocalField}`
+                                ]
+                            }
+                        },
                         pipeline: [
                             {
                                 $match: {
@@ -35,7 +63,7 @@ export function convertOperationsToPipeline(operations) {
                     }
                 }, {
                     $addFields: {
-                        [operation.as]: `$${operation.as}Arr`
+                        [`_joinData.${operation.as}`]: `$${operation.as}Arr`
                     }
                 }, {
                     $project: {
@@ -47,7 +75,7 @@ export function convertOperationsToPipeline(operations) {
                 pipeline.push({
                     $lookup: {
                         from: operation.from,
-                        localField: operation.localField,
+                        localField: resolvedLocalField,
                         foreignField: operation.foreignField,
                         as: `${operation.as}Arr`
                     }
@@ -58,7 +86,7 @@ export function convertOperationsToPipeline(operations) {
                     }
                 }, {
                     $addFields: {
-                        [operation.as]: `$${operation.as}Arr`
+                        [`_joinData.${operation.as}`]: `$${operation.as}Arr`
                     }
                 }, {
                     $project: {
@@ -66,19 +94,43 @@ export function convertOperationsToPipeline(operations) {
                     }
                 });
             }
+            if (isNestedField) {
+                const [parentAlias] = operation.localField.split('.');
+                const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany) && op.as === parentAlias);
+                if (parentJoin) {
+                    pipeline.push({
+                        $set: {
+                            [`_joinData.${parentAlias}`]: {
+                                $mergeObjects: [
+                                    { $ifNull: [`$_joinData.${parentAlias}`, {}] },
+                                    { [operation.as]: `$_joinData.${operation.as}` }
+                                ]
+                            }
+                        }
+                    });
+                    pipeline.push({
+                        $unset: `_joinData.${operation.as}`
+                    });
+                }
+            }
         }
         else if (operation instanceof JoinMany) {
             const needsObjectIdConversion = operation.foreignField === '_id';
             const isNestedField = operation.localField.includes('.');
+            const resolvedLocalField = resolveLocalFieldPath(operation.localField, processedOperations);
             if (needsObjectIdConversion || isNestedField) {
                 pipeline.push({
                     $lookup: {
                         from: operation.from,
-                        let: { localId: { $cond: [
-                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
-                                    { $toObjectId: `$${operation.localField}` },
-                                    `$${operation.localField}`
-                                ] } },
+                        let: {
+                            localId: {
+                                $cond: [
+                                    { $eq: [{ $type: `$${resolvedLocalField}` }, 'string'] },
+                                    { $toObjectId: `$${resolvedLocalField}` },
+                                    `$${resolvedLocalField}`
+                                ]
+                            }
+                        },
                         pipeline: [
                             {
                                 $match: {
@@ -88,27 +140,33 @@ export function convertOperationsToPipeline(operations) {
                                 }
                             }
                         ],
-                        as: operation.as
+                        as: `${operation.as}_temp`
+                    }
+                }, {
+                    $addFields: {
+                        [`_joinData.${operation.as}`]: `$${operation.as}_temp`
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}_temp`]: 0
                     }
                 });
                 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 JoinMany || op instanceof JoinThrough || op instanceof JoinThroughMany) && op.as === parentAlias);
                     if (parentJoin) {
                         pipeline.push({
-                            $addFields: {
-                                [parentAlias]: {
+                            $set: {
+                                [`_joinData.${parentAlias}`]: {
                                     $mergeObjects: [
-                                        `$${parentAlias}`,
-                                        { [operation.as]: `$${operation.as}` }
+                                        { $ifNull: [`$_joinData.${parentAlias}`, {}] },
+                                        { [operation.as]: `$_joinData.${operation.as}` }
                                     ]
                                 }
                             }
                         });
                         pipeline.push({
-                            $project: {
-                                [operation.as]: 0
-                            }
+                            $unset: `_joinData.${operation.as}`
                         });
                     }
                 }
@@ -117,9 +175,17 @@ export function convertOperationsToPipeline(operations) {
                 pipeline.push({
                     $lookup: {
                         from: operation.from,
-                        localField: operation.localField,
+                        localField: resolvedLocalField,
                         foreignField: operation.foreignField,
-                        as: operation.as
+                        as: `${operation.as}_temp`
+                    }
+                }, {
+                    $addFields: {
+                        [`_joinData.${operation.as}`]: `$${operation.as}_temp`
+                    }
+                }, {
+                    $project: {
+                        [`${operation.as}_temp`]: 0
                     }
                 });
             }
@@ -127,15 +193,20 @@ export function convertOperationsToPipeline(operations) {
         else if (operation instanceof JoinThrough) {
             const needsObjectIdConversion = operation.foreignField === '_id';
             const isNestedField = operation.localField.includes('.');
+            const resolvedLocalField = resolveLocalFieldPath(operation.localField, processedOperations);
             if (needsObjectIdConversion || isNestedField) {
                 pipeline.push({
                     $lookup: {
                         from: operation.through,
-                        let: { localId: { $cond: [
-                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
-                                    { $toObjectId: `$${operation.localField}` },
-                                    `$${operation.localField}`
-                                ] } },
+                        let: {
+                            localId: {
+                                $cond: [
+                                    { $eq: [{ $type: `$${resolvedLocalField}` }, 'string'] },
+                                    { $toObjectId: `$${resolvedLocalField}` },
+                                    `$${resolvedLocalField}`
+                                ]
+                            }
+                        },
                         pipeline: [
                             {
                                 $match: {
@@ -165,11 +236,15 @@ export function convertOperationsToPipeline(operations) {
                 }, {
                     $lookup: {
                         from: operation.from,
-                        let: { foreignId: { $cond: [
+                        let: {
+                            foreignId: {
+                                $cond: [
                                     { $eq: [{ $type: `$${operation.as}_through.${operation.throughForeignField}` }, 'string'] },
                                     { $toObjectId: `$${operation.as}_through.${operation.throughForeignField}` },
                                     `$${operation.as}_through.${operation.throughForeignField}`
-                                ] } },
+                                ]
+                            }
+                        },
                         pipeline: [
                             {
                                 $match: {
@@ -197,7 +272,7 @@ export function convertOperationsToPipeline(operations) {
                     }
                 }, {
                     $addFields: {
-                        [operation.as]: `$${operation.as}_temp`
+                        [`_joinData.${operation.as}`]: `$${operation.as}_temp`
                     }
                 }, {
                     $project: {
@@ -211,27 +286,28 @@ export function convertOperationsToPipeline(operations) {
                     if (parentJoin) {
                         pipeline.push({
                             $set: {
-                                [parentAlias]: {
+                                [`_joinData.${parentAlias}`]: {
                                     $mergeObjects: [
-                                        { $ifNull: [`$${parentAlias}`, {}] },
-                                        { [operation.as]: `$${operation.as}` }
+                                        { $ifNull: [`$_joinData.${parentAlias}`, {}] },
+                                        { [operation.as]: `$_joinData.${operation.as}` }
                                     ]
                                 }
                             }
                         });
                         pipeline.push({
-                            $unset: operation.as
+                            $unset: `_joinData.${operation.as}`
                         });
                     }
                 }
             }
             else {
                 const isNestedFieldElse = operation.localField.includes('.');
+                const resolvedLocalFieldElse = resolveLocalFieldPath(operation.localField, processedOperations);
                 if (isNestedFieldElse) {
                     pipeline.push({
                         $lookup: {
                             from: operation.through,
-                            let: { localId: `$${operation.localField}` },
+                            let: { localId: `$${resolvedLocalFieldElse}` },
                             pipeline: [
                                 {
                                     $match: {
@@ -255,7 +331,7 @@ export function convertOperationsToPipeline(operations) {
                     pipeline.push({
                         $lookup: {
                             from: operation.through,
-                            localField: operation.localField,
+                            localField: resolvedLocalFieldElse,
                             foreignField: operation.throughLocalField,
                             as: `${operation.as}_through`
                         }
@@ -280,7 +356,7 @@ export function convertOperationsToPipeline(operations) {
                     }
                 }, {
                     $addFields: {
-                        [operation.as]: `$${operation.as}_temp`
+                        [`_joinData.${operation.as}`]: `$${operation.as}_temp`
                     }
                 }, {
                     $project: {
@@ -293,19 +369,17 @@ export function convertOperationsToPipeline(operations) {
                     const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinThrough) && op.as === parentAlias);
                     if (parentJoin) {
                         pipeline.push({
-                            $addFields: {
-                                [parentAlias]: {
+                            $set: {
+                                [`_joinData.${parentAlias}`]: {
                                     $mergeObjects: [
-                                        `$${parentAlias}`,
-                                        { [operation.as]: `$${operation.as}` }
+                                        { $ifNull: [`$_joinData.${parentAlias}`, {}] },
+                                        { [operation.as]: `$_joinData.${operation.as}` }
                                     ]
                                 }
                             }
                         });
                         pipeline.push({
-                            $project: {
-                                [operation.as]: 0
-                            }
+                            $unset: `_joinData.${operation.as}`
                         });
                     }
                 }
@@ -314,15 +388,20 @@ export function convertOperationsToPipeline(operations) {
         else if (operation instanceof JoinThroughMany) {
             const needsObjectIdConversion = operation.foreignField === '_id';
             const isNestedField = operation.localField.includes('.');
+            const resolvedLocalField = resolveLocalFieldPath(operation.localField, processedOperations);
             if (needsObjectIdConversion || isNestedField) {
                 pipeline.push({
                     $lookup: {
                         from: operation.through,
-                        let: { localId: { $cond: [
-                                    { $eq: [{ $type: `$${operation.localField}` }, 'string'] },
-                                    { $toObjectId: `$${operation.localField}` },
-                                    `$${operation.localField}`
-                                ] } },
+                        let: {
+                            localId: {
+                                $cond: [
+                                    { $eq: [{ $type: `$${resolvedLocalField}` }, 'string'] },
+                                    { $toObjectId: `$${resolvedLocalField}` },
+                                    `$${resolvedLocalField}`
+                                ]
+                            }
+                        },
                         pipeline: [
                             {
                                 $match: {
@@ -351,11 +430,15 @@ export function convertOperationsToPipeline(operations) {
                 }, {
                     $lookup: {
                         from: operation.from,
-                        let: { foreignId: { $cond: [
+                        let: {
+                            foreignId: {
+                                $cond: [
                                     { $eq: [{ $type: `$${operation.as}_through.${operation.throughForeignField}` }, 'string'] },
                                     { $toObjectId: `$${operation.as}_through.${operation.throughForeignField}` },
                                     `$${operation.as}_through.${operation.throughForeignField}`
-                                ] } },
+                                ]
+                            }
+                        },
                         pipeline: [
                             {
                                 $match: {
@@ -380,18 +463,19 @@ export function convertOperationsToPipeline(operations) {
                     $group: {
                         _id: '$_id',
                         root: { $first: '$$ROOT' },
-                        [operation.as]: { $push: { $arrayElemAt: [`$${operation.as}_temp`, 0] } }
+                        [`${operation.as}_temp_grouped`]: { $push: { $arrayElemAt: [`$${operation.as}_temp`, 0] } }
                     }
                 }, {
                     $replaceRoot: {
                         newRoot: {
-                            $mergeObjects: ['$root', { [operation.as]: `$${operation.as}` }]
+                            $mergeObjects: ['$root', { [`_joinData.${operation.as}`]: `$${operation.as}_temp_grouped` }]
                         }
                     }
                 }, {
                     $project: {
                         [`${operation.as}_through`]: 0,
-                        [`${operation.as}_temp`]: 0
+                        [`${operation.as}_temp`]: 0,
+                        [`${operation.as}_temp_grouped`]: 0
                     }
                 });
                 if (isNestedField) {
@@ -400,27 +484,28 @@ export function convertOperationsToPipeline(operations) {
                     if (parentJoin) {
                         pipeline.push({
                             $set: {
-                                [parentAlias]: {
+                                [`_joinData.${parentAlias}`]: {
                                     $mergeObjects: [
-                                        { $ifNull: [`$${parentAlias}`, {}] },
-                                        { [operation.as]: `$${operation.as}` }
+                                        { $ifNull: [`$_joinData.${parentAlias}`, {}] },
+                                        { [operation.as]: `$_joinData.${operation.as}` }
                                     ]
                                 }
                             }
                         });
                         pipeline.push({
-                            $unset: operation.as
+                            $unset: `_joinData.${operation.as}`
                         });
                     }
                 }
             }
             else {
                 const isNestedFieldElse = operation.localField.includes('.');
+                const resolvedLocalFieldElse = resolveLocalFieldPath(operation.localField, processedOperations);
                 if (isNestedFieldElse) {
                     pipeline.push({
                         $lookup: {
                             from: operation.through,
-                            let: { localId: `$${operation.localField}` },
+                            let: { localId: `$${resolvedLocalFieldElse}` },
                             pipeline: [
                                 {
                                     $match: {
@@ -443,7 +528,7 @@ export function convertOperationsToPipeline(operations) {
                     pipeline.push({
                         $lookup: {
                             from: operation.through,
-                            localField: operation.localField,
+                            localField: resolvedLocalFieldElse,
                             foreignField: operation.throughLocalField,
                             as: `${operation.as}_through`
                         }
@@ -465,18 +550,19 @@ export function convertOperationsToPipeline(operations) {
                     $group: {
                         _id: '$_id',
                         root: { $first: '$$ROOT' },
-                        [operation.as]: { $push: { $arrayElemAt: [`$${operation.as}_temp`, 0] } }
+                        [`${operation.as}_temp_grouped`]: { $push: { $arrayElemAt: [`$${operation.as}_temp`, 0] } }
                     }
                 }, {
                     $replaceRoot: {
                         newRoot: {
-                            $mergeObjects: ['$root', { [operation.as]: `$${operation.as}` }]
+                            $mergeObjects: ['$root', { [`_joinData.${operation.as}`]: `$${operation.as}_temp_grouped` }]
                         }
                     }
                 }, {
                     $project: {
                         [`${operation.as}_through`]: 0,
-                        [`${operation.as}_temp`]: 0
+                        [`${operation.as}_temp`]: 0,
+                        [`${operation.as}_temp_grouped`]: 0
                     }
                 });
                 if (isNestedFieldElse) {
@@ -484,19 +570,17 @@ export function convertOperationsToPipeline(operations) {
                     const parentJoin = processedOperations.find(op => (op instanceof Join || op instanceof JoinThrough) && op.as === parentAlias);
                     if (parentJoin) {
                         pipeline.push({
-                            $addFields: {
-                                [parentAlias]: {
+                            $set: {
+                                [`_joinData.${parentAlias}`]: {
                                     $mergeObjects: [
-                                        `$${parentAlias}`,
-                                        { [operation.as]: `$${operation.as}` }
+                                        { $ifNull: [`$_joinData.${parentAlias}`, {}] },
+                                        { [operation.as]: `$_joinData.${operation.as}` }
                                     ]
                                 }
                             }
                         });
                         pipeline.push({
-                            $project: {
-                                [operation.as]: 0
-                            }
+                            $unset: `_joinData.${operation.as}`
                         });
                     }
                 }

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

@@ -83,6 +83,7 @@ export function transformJoinResults(rows, operations) {
     }
     return rows.map(row => {
         const transformed = {};
+        const joinData = {};
         for (const key of Object.keys(row)) {
             const hasJoinPrefix = joinOperations.some(join => key.startsWith(`${join.as}__`));
             const isJoinAlias = allJoinAliases.includes(key);
@@ -113,14 +114,14 @@ export function transformJoinResults(rows, operations) {
                     const relatedJoin = joinOperations.find(j => j.as === tableAlias);
                     const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
                     let targetObject = null;
-                    if (relatedJoin && transformed[relatedJoin.as]) {
-                        targetObject = transformed[relatedJoin.as];
+                    if (relatedJoin && joinData[relatedJoin.as]) {
+                        targetObject = joinData[relatedJoin.as];
                     }
-                    else if (relatedJoinThrough && transformed[relatedJoinThrough.as]) {
-                        targetObject = transformed[relatedJoinThrough.as];
+                    else if (relatedJoinThrough && joinData[relatedJoinThrough.as]) {
+                        targetObject = joinData[relatedJoinThrough.as];
                     }
                     else {
-                        const found = findNestedObject(transformed, tableAlias);
+                        const found = findNestedObject(joinData, tableAlias);
                         if (found) {
                             targetObject = found.obj;
                         }
@@ -129,11 +130,11 @@ export function transformJoinResults(rows, operations) {
                         targetObject[operation.as] = hasAnyData ? joinedData : null;
                     }
                     else {
-                        transformed[operation.as] = hasAnyData ? joinedData : null;
+                        joinData[operation.as] = hasAnyData ? joinedData : null;
                     }
                 }
                 else {
-                    transformed[operation.as] = hasAnyData ? joinedData : null;
+                    joinData[operation.as] = hasAnyData ? joinedData : null;
                 }
             }
             else if (operation instanceof JoinThrough) {
@@ -143,11 +144,11 @@ export function transformJoinResults(rows, operations) {
                     const relatedJoin = joinOperations.find(j => j.as === tableAlias);
                     const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
                     let targetObject = null;
-                    if (relatedJoin && transformed[relatedJoin.as]) {
-                        targetObject = transformed[relatedJoin.as];
+                    if (relatedJoin && joinData[relatedJoin.as]) {
+                        targetObject = joinData[relatedJoin.as];
                     }
                     else if (relatedJoinThrough) {
-                        const found = findNestedObject(transformed, relatedJoinThrough.as);
+                        const found = findNestedObject(joinData, relatedJoinThrough.as);
                         if (found) {
                             targetObject = found.obj;
                         }
@@ -156,11 +157,11 @@ export function transformJoinResults(rows, operations) {
                         targetObject[operation.as] = jsonValue;
                     }
                     else {
-                        transformed[operation.as] = jsonValue;
+                        joinData[operation.as] = jsonValue;
                     }
                 }
                 else {
-                    transformed[operation.as] = jsonValue;
+                    joinData[operation.as] = jsonValue;
                 }
             }
             else if (operation instanceof JoinMany) {
@@ -191,30 +192,30 @@ export function transformJoinResults(rows, operations) {
                     const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
                     const relatedJoinThroughMany = joinThroughManyOperations.find(j => j.as === tableAlias);
                     let targetObject = null;
-                    if (relatedJoin && transformed[relatedJoin.as]) {
-                        targetObject = transformed[relatedJoin.as];
+                    if (relatedJoin && joinData[relatedJoin.as]) {
+                        targetObject = joinData[relatedJoin.as];
                     }
                     else if (relatedJoinThrough) {
-                        const found = findNestedObject(transformed, relatedJoinThrough.as);
+                        const found = findNestedObject(joinData, relatedJoinThrough.as);
                         if (found) {
                             targetObject = found.obj;
                         }
                     }
-                    else if (relatedJoinMany && transformed[relatedJoinMany.as]) {
-                        targetObject = transformed[relatedJoinMany.as];
+                    else if (relatedJoinMany && joinData[relatedJoinMany.as]) {
+                        targetObject = joinData[relatedJoinMany.as];
                     }
-                    else if (relatedJoinThroughMany && transformed[relatedJoinThroughMany.as]) {
-                        targetObject = transformed[relatedJoinThroughMany.as];
+                    else if (relatedJoinThroughMany && joinData[relatedJoinThroughMany.as]) {
+                        targetObject = joinData[relatedJoinThroughMany.as];
                     }
                     if (targetObject) {
                         targetObject[operation.as] = parsedValue;
                     }
                     else {
-                        transformed[operation.as] = parsedValue;
+                        joinData[operation.as] = parsedValue;
                     }
                 }
                 else {
-                    transformed[operation.as] = parsedValue;
+                    joinData[operation.as] = parsedValue;
                 }
             }
             else if (operation instanceof JoinThroughMany) {
@@ -245,33 +246,36 @@ export function transformJoinResults(rows, operations) {
                     const relatedJoinThrough = joinThroughOperations.find(j => j.as === tableAlias);
                     const relatedJoinThroughMany = joinThroughManyOperations.find(j => j.as === tableAlias);
                     let targetObject = null;
-                    if (relatedJoin && transformed[relatedJoin.as]) {
-                        targetObject = transformed[relatedJoin.as];
+                    if (relatedJoin && joinData[relatedJoin.as]) {
+                        targetObject = joinData[relatedJoin.as];
                     }
                     else if (relatedJoinThrough) {
-                        const found = findNestedObject(transformed, relatedJoinThrough.as);
+                        const found = findNestedObject(joinData, relatedJoinThrough.as);
                         if (found) {
                             targetObject = found.obj;
                         }
                     }
-                    else if (relatedJoinMany && transformed[relatedJoinMany.as]) {
-                        targetObject = transformed[relatedJoinMany.as];
+                    else if (relatedJoinMany && joinData[relatedJoinMany.as]) {
+                        targetObject = joinData[relatedJoinMany.as];
                     }
-                    else if (relatedJoinThroughMany && transformed[relatedJoinThroughMany.as]) {
-                        targetObject = transformed[relatedJoinThroughMany.as];
+                    else if (relatedJoinThroughMany && joinData[relatedJoinThroughMany.as]) {
+                        targetObject = joinData[relatedJoinThroughMany.as];
                     }
                     if (targetObject) {
                         targetObject[operation.as] = parsedValue;
                     }
                     else {
-                        transformed[operation.as] = parsedValue;
+                        joinData[operation.as] = parsedValue;
                     }
                 }
                 else {
-                    transformed[operation.as] = parsedValue;
+                    joinData[operation.as] = parsedValue;
                 }
             }
         }
+        if (Object.keys(joinData).length > 0) {
+            transformed._joinData = joinData;
+        }
         return transformed;
     });
 }

package/dist/services/generic-api-service/generic-api-service.interface.d.ts

@@ -3,6 +3,7 @@ import { IUserContext, IEntity, IPagedResult, IQueryOptions } from '@loomcore/co
 import type { AppIdType } from '@loomcore/common/types';
 import { DeleteResult } from '../../databases/models/delete-result.js';
 import { Operation } from '../../databases/operations/operation.js';
+import { PostProcessEntityCustomFunction, PrepareQueryCustomFunction } from '../../controllers/types.js';
 export interface IGenericApiService<T extends IEntity> {
     validate(doc: any, isPartial?: boolean): ValueError[] | null;
     validateMany(docs: any[], isPartial?: boolean): ValueError[] | null;
@@ -13,8 +14,11 @@ export interface IGenericApiService<T extends IEntity> {
     preProcessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId: boolean): Promise<Partial<T>>;
     postProcessEntity(userContext: IUserContext, entity: T): T;
     getAll(userContext: IUserContext): Promise<T[]>;
-    get(userContext: IUserContext, queryOptions: IQueryOptions): Promise<IPagedResult<T>>;
+    getAll<TCustom extends IEntity>(userContext: IUserContext, prepareQueryCustom: PrepareQueryCustomFunction, postProcessEntityCustom: PostProcessEntityCustomFunction<T, TCustom>): Promise<TCustom[]>;
+    get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
+    get<TCustom extends IEntity>(userContext: IUserContext, queryOptions: IQueryOptions, prepareQueryCustom: PrepareQueryCustomFunction, postProcessEntityCustom: PostProcessEntityCustomFunction<T, TCustom>): Promise<IPagedResult<TCustom>>;
     getById(userContext: IUserContext, id: AppIdType): Promise<T>;
+    getById<TCustom extends IEntity>(userContext: IUserContext, id: AppIdType, prepareQueryCustom: PrepareQueryCustomFunction, postProcessEntityCustom: PostProcessEntityCustomFunction<T, TCustom>): Promise<TCustom>;
     getCount(userContext: IUserContext): Promise<number>;
     create(userContext: IUserContext, entity: Partial<T>): Promise<T | null>;
     createMany(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;

package/dist/services/generic-api-service/generic-api.service.d.ts

@@ -5,6 +5,7 @@ import { IGenericApiService } from './generic-api-service.interface.js';
 import { Operation } from '../../databases/operations/operation.js';
 import { DeleteResult } from '../../databases/models/delete-result.js';
 import { IDatabase } from '../../databases/models/index.js';
+import { PostProcessEntityCustomFunction, PrepareQueryCustomFunction } from '../../controllers/types.js';
 export declare class GenericApiService<T extends IEntity> implements IGenericApiService<T> {
     protected database: IDatabase;
     protected pluralResourceName: string;
@@ -12,6 +13,7 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     protected modelSpec: IModelSpec;
     constructor(database: IDatabase, pluralResourceName: string, singularResourceName: string, modelSpec: IModelSpec);
     getAll(userContext: IUserContext): Promise<T[]>;
+    getAll<TCustom extends IEntity>(userContext: IUserContext, prepareQueryCustom: PrepareQueryCustomFunction, postProcessEntityCustom: PostProcessEntityCustomFunction<T, TCustom>): Promise<TCustom[]>;
     prepareQuery(userContext: IUserContext | undefined, queryObject: IQueryOptions, operations: Operation[]): {
         queryObject: IQueryOptions;
         operations: Operation[];
@@ -21,8 +23,10 @@ export declare class GenericApiService<T extends IEntity> implements IGenericApi
     preProcessEntity(userContext: IUserContext, entity: Partial<T>, isCreate: boolean, allowId?: boolean): Promise<Partial<T>>;
     postProcessEntity(userContext: IUserContext, entity: T): T;
     get(userContext: IUserContext, queryOptions?: IQueryOptions): Promise<IPagedResult<T>>;
+    get<TCustom extends IEntity>(userContext: IUserContext, queryOptions: IQueryOptions, prepareQueryCustom: PrepareQueryCustomFunction, postProcessEntityCustom: PostProcessEntityCustomFunction<T, TCustom>): Promise<IPagedResult<TCustom>>;
     protected prepareQueryOptions(userContext: IUserContext | undefined, queryOptions: IQueryOptions): IQueryOptions;
     getById(userContext: IUserContext, id: AppIdType): Promise<T>;
+    getById<TCustom extends IEntity>(userContext: IUserContext, id: AppIdType, prepareQueryCustom: PrepareQueryCustomFunction, postProcessEntityCustom: PostProcessEntityCustomFunction<T, TCustom>): Promise<TCustom>;
     getCount(userContext: IUserContext): Promise<number>;
     create(userContext: IUserContext, entity: Partial<T>): Promise<T | null>;
     createMany(userContext: IUserContext, entities: Partial<T>[]): Promise<T[]>;

package/dist/services/generic-api-service/generic-api.service.js

@@ -16,10 +16,22 @@ export class GenericApiService {
         this.modelSpec = modelSpec;
         this.database = database;
     }
-    async getAll(userContext) {
-        const { operations } = this.prepareQuery(userContext, {}, []);
+    async getAll(userContext, prepareQueryCustom, postProcessEntityCustom) {
+        let operations = [];
+        if (prepareQueryCustom) {
+            operations = prepareQueryCustom(userContext, {}, []).operations;
+        }
+        else {
+            operations = this.prepareQuery(userContext, {}, []).operations;
+        }
         const entities = await this.database.getAll(operations, this.pluralResourceName);
-        return entities.map(entity => this.postProcessEntity(userContext, entity));
+        return entities.map(entity => {
+            const dbProcessed = this.postProcessEntity(userContext, entity);
+            if (postProcessEntityCustom) {
+                return postProcessEntityCustom(userContext, dbProcessed);
+            }
+            return dbProcessed;
+        });
     }
     prepareQuery(userContext, queryObject, operations) {
         return { queryObject, operations };
@@ -63,11 +75,23 @@ export class GenericApiService {
     postProcessEntity(userContext, entity) {
         return this.database.postProcessEntity(entity, this.modelSpec.fullSchema);
     }
-    async get(userContext, queryOptions = { ...DefaultQueryOptions }) {
+    async get(userContext, queryOptions = { ...DefaultQueryOptions }, prepareQueryCustom, postProcessEntityCustom) {
         const preparedOptions = this.prepareQueryOptions(userContext, queryOptions);
-        const { operations } = this.prepareQuery(userContext, {}, []);
+        let operations = [];
+        if (prepareQueryCustom) {
+            operations = prepareQueryCustom(userContext, {}, []).operations;
+        }
+        else {
+            operations = this.prepareQuery(userContext, {}, []).operations;
+        }
         const pagedResult = await this.database.get(operations, preparedOptions, this.modelSpec, this.pluralResourceName);
-        const transformedEntities = (pagedResult.entities || []).map(entity => this.postProcessEntity(userContext, entity));
+        const transformedEntities = (pagedResult.entities || []).map(entity => {
+            const transformedEntity = this.postProcessEntity(userContext, entity);
+            if (postProcessEntityCustom) {
+                return postProcessEntityCustom(userContext, transformedEntity);
+            }
+            return transformedEntity;
+        });
         return {
             ...pagedResult,
             entities: transformedEntities
@@ -76,13 +100,30 @@ export class GenericApiService {
     prepareQueryOptions(userContext, queryOptions) {
         return queryOptions;
     }
-    async getById(userContext, id) {
-        const { operations, queryObject } = this.prepareQuery(userContext, {}, []);
+    async getById(userContext, id, prepareQueryCustom, postProcessEntityCustom) {
+        let operations = [];
+        let queryObject = {};
+        if (prepareQueryCustom) {
+            const result = prepareQueryCustom(userContext, {}, []);
+            operations = result.operations;
+            queryObject = result.queryObject;
+        }
+        else {
+            const result = this.prepareQuery(userContext, {}, []);
+            operations = result.operations;
+            queryObject = result.queryObject;
+        }
         const entity = await this.database.getById(operations, queryObject, id, this.pluralResourceName);
         if (!entity) {
             throw new IdNotFoundError();
         }
-        return this.postProcessEntity(userContext, entity);
+        const transformedEntity = this.postProcessEntity(userContext, entity);
+        if (postProcessEntityCustom) {
+            return postProcessEntityCustom(userContext, transformedEntity);
+        }
+        else {
+            return transformedEntity;
+        }
     }
     async getCount(userContext) {
         this.prepareQuery(userContext, {}, []);

package/dist/utils/api.utils.js

@@ -5,14 +5,21 @@ function apiResponse(response, status, options = {}, modelSpec, publicSpec) {
     const specForEncoding = publicSpec ?? modelSpec;
     if (specForEncoding && options.data) {
         if (Array.isArray(options.data)) {
-            options.data = options.data.map((item) => specForEncoding.encode(item));
+            options.data = options.data.map((item) => {
+                delete item._joinData;
+                return specForEncoding.encode(item);
+            });
         }
         else if (typeof options.data === 'object' && options.data !== null && 'entities' in options.data && Array.isArray(options.data.entities)) {
             const pagedResult = options.data;
-            pagedResult.entities = pagedResult.entities.map((item) => specForEncoding.encode(item));
+            pagedResult.entities = pagedResult.entities.map((item) => {
+                delete item._joinData;
+                return specForEncoding?.encode(item);
+            });
             options.data = pagedResult;
         }
         else {
+            delete options.data._joinData;
             const encodedData = specForEncoding.encode(options.data);
             options.data = encodedData;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomcore/api",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "private": false,
   "description": "Loom Core Api - An opinionated Node.js api using Typescript, Express, and MongoDb or PostgreSQL",
   "scripts": {
@@ -57,7 +57,7 @@
     "qs": "^6.15.0"
   },
   "peerDependencies": {
-    "@loomcore/common": "^0.0.50",
+    "@loomcore/common": "^0.0.51",
     "@sinclair/typebox": "0.34.33",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",