@airoom/nextmin-node 2.0.1 → 2.0.2

package/dist/api/apiRouter.d.ts

@@ -6,6 +6,10 @@ export interface APIRouterOptions {
     dbAdapter: DatabaseAdapter;
     server?: HttpServer;
     fileStorageAdapter?: FileStorageAdapter;
+    imageProxy?: {
+        originalBase?: string;
+        proxyBase?: string;
+    };
 }
 export declare class APIRouter {
     private router;
@@ -14,9 +18,10 @@ export declare class APIRouter {
     private jwtSecret;
     private trustedApiKey;
     private schemaLoader;
-    private isDevelopment;
+    private get isDevelopment();
     private findRoutesMounted;
     private searchRoutesMounted;
+    private batchRoutesMounted;
     private authRoutesInitialized;
     private schemasRouteRegistered;
     private registeredModels;
@@ -25,6 +30,7 @@ export declare class APIRouter {
     private fileStorage?;
     private realtimeService?;
     private fileRoutesMounted;
+    private aggregateService?;
     constructor(options: APIRouterOptions);
     getRouter(): express.Router;
     private wireSchemaHotReload;
@@ -37,6 +43,7 @@ export declare class APIRouter {
     private mountRoutes;
     private mountFindRoutes;
     private mountSearchRoutes;
+    private mountBatchRoutes;
     private mountFileRoutes;
     private createCtx;
     private getSchema;

package/dist/api/apiRouter.js

@@ -12,16 +12,23 @@ const SchemaLoader_1 = require("../utils/SchemaLoader");
 const DefaultDataInitializer_1 = require("../utils/DefaultDataInitializer");
 const RealtimeService_1 = require("../services/RealtimeService");
 const Events_1 = require("../utils/Events");
+const AggregateService_1 = require("../services/AggregateService");
 const setupFileRoutes_1 = require("./router/setupFileRoutes");
 const setupAuthRoutes_1 = require("./router/setupAuthRoutes");
 const mountCrudRoutes_1 = require("./router/mountCrudRoutes");
 const mountFindRoutes_1 = require("./router/mountFindRoutes");
 const mountSearchRoutes_1 = require("./router/mountSearchRoutes");
+const mountBatchRoutes_1 = require("./router/mountBatchRoutes");
 class APIRouter {
+    get isDevelopment() {
+        return (process.env.APP_MODE?.toLowerCase() !== 'production' &&
+            process.env.NODE_ENV?.toLowerCase() !== 'production');
+    }
     constructor(options) {
         this.models = {};
         this.findRoutesMounted = false;
         this.searchRoutesMounted = false;
+        this.batchRoutesMounted = false;
         this.authRoutesInitialized = false;
         this.schemasRouteRegistered = false;
         this.registeredModels = new Set();
@@ -182,7 +189,6 @@ class APIRouter {
             }
             return missing;
         };
-        this.isDevelopment = process.env.APP_MODE !== 'production';
         this.router = express_1.default.Router();
         this.fileStorage = options.fileStorageAdapter;
         this.dbAdapter = options.dbAdapter;
@@ -211,6 +217,7 @@ class APIRouter {
             this.mountRoutes(initialSchemas);
             this.mountFindRoutes();
             this.mountSearchRoutes();
+            this.mountBatchRoutes();
             this.mountFileRoutes();
             await this.syncAllIndexes(initialSchemas);
             const initializer = new DefaultDataInitializer_1.DefaultDataInitializer(this.dbAdapter, this.models);
@@ -224,6 +231,7 @@ class APIRouter {
                 Logger_1.default.error('APIRouter', 'Failed to initialize default data', err);
             }
             this.setupNotFoundMiddleware();
+            this.aggregateService = new AggregateService_1.AggregateService(this.createCtx());
             this.wireSchemaHotReload();
         };
         if (typeof this.dbAdapter.registerSchemas === 'function') {
@@ -384,6 +392,13 @@ class APIRouter {
         (0, mountSearchRoutes_1.mountSearchRoutes)(this.createCtx());
         this.ensureNotFoundLast();
     }
+    mountBatchRoutes() {
+        if (this.batchRoutesMounted)
+            return;
+        this.batchRoutesMounted = true;
+        (0, mountBatchRoutes_1.mountBatchRoutes)(this.createCtx());
+        this.ensureNotFoundLast();
+    }
     mountFileRoutes() {
         if (this.fileRoutesMounted)
             return;

package/dist/api/router/mountBatchRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { RouterCtx } from './ctx';
+export declare function mountBatchRoutes(ctx: RouterCtx): void;

package/dist/api/router/mountBatchRoutes.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountBatchRoutes = mountBatchRoutes;
+const authorize_1 = require("../../policy/authorize");
+const QueryEngine_1 = require("../../database/QueryEngine");
+const utils_1 = require("./utils");
+function mountBatchRoutes(ctx) {
+    const { router } = ctx;
+    router.post('/_batch', ctx.optionalAuthMiddleware, async (req, res) => {
+        try {
+            const batchRequest = req.body;
+            if (!batchRequest || typeof batchRequest !== 'object') {
+                return res.status(400).json({ error: true, message: 'Invalid batch request' });
+            }
+            const results = {};
+            for (const [key, config] of Object.entries(batchRequest)) {
+                try {
+                    const { path, query: queryParams } = config;
+                    if (!path) {
+                        results[key] = { error: true, message: 'Missing path' };
+                        continue;
+                    }
+                    // Path is usually something like "/doctors" or "/doctors?slug=... "
+                    // We need to extract the model name
+                    const modelMatch = path.match(/^\/([^/?]+)/);
+                    if (!modelMatch) {
+                        results[key] = { error: true, message: 'Invalid path' };
+                        continue;
+                    }
+                    const modelName = modelMatch[1].toLowerCase();
+                    const schema = ctx.getSchema(modelName);
+                    const model = ctx.getModel(modelName);
+                    // Prepare pseudo-request for parseQuery
+                    const pseudoReq = {
+                        query: queryParams || {},
+                        user: req.user,
+                    };
+                    const { limit, page, skip, sort, projection, sample, _populate } = (0, utils_1.parseQuery)(pseudoReq);
+                    const filter = QueryEngine_1.QueryEngine.parse(pseudoReq.query, schema);
+                    const roleStr = req.user?.role;
+                    const pctx = {
+                        isAuthenticated: !!req.user,
+                        role: typeof roleStr === 'string' ? roleStr.toLowerCase() : null,
+                        userId: req.user?.id || req.user?._id || null,
+                        isSuperadmin: roleStr?.toLowerCase() === 'superadmin',
+                        apiKeyOk: true,
+                    };
+                    const rdec = (0, authorize_1.authorize)(modelName, 'read', { allowedMethods: schema.allowedMethods, access: schema.access }, pctx);
+                    if (!rdec.allow) {
+                        results[key] = { error: true, message: 'Forbidden' };
+                        continue;
+                    }
+                    const finalFilter = { ...filter, ...(rdec.queryFilter || {}) };
+                    // Handle countBy if present in query
+                    const countBy = String(pseudoReq.query.countBy || '').trim();
+                    if (countBy && schema.attributes[countBy]) {
+                        const counts = await ctx.dbAdapter.countBy(schema.modelName, countBy, finalFilter, schema);
+                        results[key] = { success: true, counts };
+                        continue;
+                    }
+                    const totalRows = await model.count(finalFilter);
+                    const rows = await model.read(finalFilter, limit, skip, !!rdec.exposePrivate, {
+                        sort,
+                        projection,
+                        sample,
+                        _populate,
+                    });
+                    const data = rdec.exposePrivate
+                        ? (0, authorize_1.applyReadMaskMany)(rows, rdec.sensitiveMask)
+                        : (0, authorize_1.applyReadMaskMany)(rows, rdec.readMask);
+                    results[key] = {
+                        success: true,
+                        data,
+                        pagination: { totalRows, page, limit },
+                    };
+                }
+                catch (err) {
+                    results[key] = { error: true, message: err.message || 'Error' };
+                }
+            }
+            return res.status(200).json({
+                success: true,
+                results,
+            });
+        }
+        catch (err) {
+            return res.status(500).json({ error: true, message: err.message || 'Batch execution failed' });
+        }
+    });
+}

package/dist/api/router/mountCrudRoutes.js

@@ -296,6 +296,14 @@ function mountCrudRoutes(ctx, modelNameLC) {
                 return res.status(403).json({ error: true, message: 'forbidden' });
             }
             const finalFilter = (0, authorize_1.andFilter)(filter, rdec.queryFilter || {});
+            const countBy = String(req.query.countBy ?? '').trim();
+            if (countBy && schema.attributes[countBy]) {
+                const counts = await ctx.dbAdapter.countBy(schema.modelName, countBy, finalFilter, schema);
+                return res.status(200).json({
+                    success: true,
+                    counts,
+                });
+            }
             const isUsersModel = modelNameLC === 'user' ||
                 modelNameLC === 'users' ||
                 (schema?.modelName ?? '').toLowerCase() === 'users';
@@ -640,7 +648,7 @@ function mountCrudRoutes(ctx, modelNameLC) {
                 }
                 let updatedChild = before;
                 if (Object.keys(childUpd).length) {
-                    updatedChild = await model.update(req.params.id, childUpd);
+                    updatedChild = await model.update(req.params.id, childUpd, false, before);
                 }
                 if (targetBaseId && Object.keys(baseUpd).length) {
                     await baseModel.update(targetBaseId, baseUpd);
@@ -687,7 +695,7 @@ function mountCrudRoutes(ctx, modelNameLC) {
                     })),
                 });
             }
-            const updatedRecord = await model.update(req.params.id, upd);
+            const updatedRecord = await model.update(req.params.id, upd, false, before);
             let responseDoc = updatedRecord;
             if (udec.exposePrivate && updatedRecord?.id) {
                 const refetched = await model.read({ id: updatedRecord.id }, 1, 0, true);

package/dist/api/router/setupFileRoutes.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupFileRoutes = setupFileRoutes;
 const multer_1 = __importDefault(require("multer"));
+const Logger_1 = __importDefault(require("../../utils/Logger"));
 function setupFileRoutes(ctx) {
     if (!ctx.fileStorage)
         return;
@@ -53,6 +54,46 @@ function setupFileRoutes(ctx) {
                 .json({ error: true, message: err?.message ?? 'Upload failed' });
         }
     });
+    ctx.router.get('/files/:key(*)', async (req, res) => {
+        try {
+            let key = String(req.params.key || '');
+            if (!key) {
+                return res.status(400).json({ error: true, message: 'Key is required' });
+            }
+            // Ensure no leading slash for storage providers
+            key = key.replace(/^\/+/, '');
+            Logger_1.default.info('FileProxy', `Fetching file from storage: ${key}`);
+            const { body, contentType, size } = await ctx.fileStorage.download(key);
+            if (contentType)
+                res.setHeader('Content-Type', contentType);
+            if (size)
+                res.setHeader('Content-Length', size);
+            // Cache for 1 year if it's an image
+            if (contentType?.startsWith('image/')) {
+                res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+            }
+            else {
+                res.setHeader('Cache-Control', 'public, max-age=86400');
+            }
+            if (body && typeof body.pipe === 'function') {
+                body.pipe(res);
+            }
+            else if (body && typeof body.transformToByteArray === 'function') {
+                const data = await body.transformToByteArray();
+                res.send(Buffer.from(data));
+            }
+            else {
+                res.send(body);
+            }
+        }
+        catch (err) {
+            Logger_1.default.warn('FileProxy', `Failed to fetch file ${req.params.key}: ${err.message}`);
+            if (err.name === 'NoSuchKey' || err.code === 'NoSuchKey' || err.name === 'NotFound' || err.code === 'NotFound') {
+                return res.status(404).json({ error: true, message: 'File not found in storage' });
+            }
+            return res.status(500).json({ error: true, message: err?.message ?? 'Download failed' });
+        }
+    });
     ctx.router.post('/files', fileAuthMiddleware, upload.any(), async (req, res) => {
         try {
             const files = req.files ?? [];

package/dist/api/router/utils.d.ts

@@ -55,6 +55,8 @@ export type ParsedQuery = {
     skip: number;
     projection?: Record<string, 1>;
     sort: SortSpec;
+    sample?: number;
+    _populate?: Record<string, Record<string, 1>>;
 };
 export declare function parseQuery(req: Request, allowedKeys?: Set<string>): ParsedQuery;
 export declare function extractIds(val: unknown): string[];

package/dist/api/router/utils.js

@@ -287,7 +287,23 @@ function parseQuery(req, allowedKeys) {
     // NOTE: do NOT force a fallback like '-createdAt' here;
     // parseSort will apply { createdAt: -1 } only if no sort is provided.
     const sort = parseSort(req.query.sort, req.query.sortType, allowedKeys);
-    return { limit, page, skip, projection, sort };
+    const sampleRaw = req.query.sample;
+    const sample = sampleRaw ? Math.max(Number.parseInt(String(sampleRaw), 10) || 0, 0) : undefined;
+    const populateMap = {};
+    const populateRaw = String(req.query.populate ?? '').trim();
+    if (populateRaw) {
+        const parts = populateRaw.split(';');
+        for (const part of parts) {
+            const [field, subFieldsRaw] = part.split(':');
+            if (field && subFieldsRaw) {
+                const subFields = subFieldsRaw.split(',').map(s => s.trim()).filter(Boolean);
+                if (subFields.length > 0) {
+                    populateMap[field] = Object.fromEntries(subFields.map(f => [f, 1]));
+                }
+            }
+        }
+    }
+    return { limit, page, skip, projection, sort, sample, _populate: populateMap };
 }
 function extractIds(val) {
     if (val == null)

package/dist/database/DatabaseAdapter.d.ts

@@ -15,6 +15,7 @@ export interface DatabaseAdapter {
      * Returns a map ofparentId -> firstRelatedId
      */
     findFirstRelatedIds(collection: string, field: string, ids: string[]): Promise<Map<string, string>>;
+    countBy(collection: string, field: string, query: any, schema: Schema): Promise<Record<string, number>>;
     syncIndexes?(modelName: string, desired: FieldIndexSpec): Promise<void>;
     cleanupUnusedFields?(schemas: Record<string, Schema>): Promise<Record<string, string[]>>;
     isExclusiveProjection(projection: Record<string, 0 | 1> | undefined, schema: Schema | undefined): boolean;

package/dist/database/NMAdapter.d.ts

@@ -10,6 +10,7 @@ export declare class NMAdapter implements DatabaseAdapter {
     private repositories;
     private entitySchemas;
     private registeredSchemas;
+    private imageProxyOptions;
     constructor(options: any);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
@@ -22,12 +23,16 @@ export declare class NMAdapter implements DatabaseAdapter {
     private coercePayloadForStorage;
     read(collection: string, query: any, limit?: number, skip?: number, schemaDefinition?: NextMinSchema, includePrivateFields?: boolean, options?: ReadOptions): Promise<any[]>;
     private prepareResult;
+    private transformUrls;
     private idToString;
     private convertToObjectId;
+    private discoverInverseRelation;
+    private hydrateDynamicAggregates;
     private hydrateRelations;
     update(collection: string, targetId: any, data: any, schemaDefinition?: NextMinSchema): Promise<any>;
     delete(collection: string, targetId: any, schemaDefinition?: NextMinSchema): Promise<any>;
     count(collection: string, query: any, schemaDefinition?: NextMinSchema): Promise<number>;
+    countBy(collection: string, field: string, query: any, schema?: NextMinSchema): Promise<Record<string, number>>;
     findFirstRelatedIds(collection: string, field: string, ids: string[]): Promise<Map<string, string>>;
     /**
      * Centralized Nested Search Resolver

package/dist/database/NMAdapter.js

@@ -19,6 +19,38 @@ class NMAdapter {
         this.repositories = new Map();
         this.entitySchemas = new Map();
         this.registeredSchemas = {};
+        this.imageProxyOptions = {};
+        const isValidUrl = (url) => typeof url === 'string' && url.startsWith('http');
+        let imageProxy = options.imageProxy;
+        if (!imageProxy || Object.keys(imageProxy).length === 0) {
+            imageProxy = { proxyBase: '/images' };
+        }
+        if (imageProxy && imageProxy.proxyBase) {
+            this.imageProxyOptions = { ...imageProxy };
+            // Auto-detect originalBase if missing but s3/r2 config exists
+            if (!this.imageProxyOptions.originalBase) {
+                const s3 = options.s3 || {
+                    bucket: process.env.S3_BUCKET,
+                    region: process.env.S3_REGION,
+                    endpoint: process.env.S3_ENDPOINT,
+                    publicBaseUrl: process.env.S3_PUBLIC_BASE_URL
+                };
+                if (s3.publicBaseUrl) {
+                    this.imageProxyOptions.originalBase = s3.publicBaseUrl.replace(/\/+$/, '');
+                }
+                else if (s3.bucket) {
+                    if (isValidUrl(s3.endpoint)) {
+                        this.imageProxyOptions.originalBase = `${s3.endpoint.replace(/\/+$/, '')}/${s3.bucket}`;
+                    }
+                    else if (s3.region) {
+                        this.imageProxyOptions.originalBase = `https://${s3.bucket}.s3.${s3.region}.amazonaws.com`;
+                    }
+                }
+            }
+            if (this.imageProxyOptions.originalBase && this.imageProxyOptions.proxyBase) {
+                Logger_1.default.info('NMAdapter', `Image proxy enabled: ${this.imageProxyOptions.originalBase} -> ${this.imageProxyOptions.proxyBase}`);
+            }
+        }
         this.dataSource = new typeorm_1.DataSource({
             ...options,
             entities: [], // Will be populated dynamically
@@ -130,11 +162,13 @@ class NMAdapter {
             },
             createdAt: {
                 type: 'datetime',
+                createDate: true,
                 default: () => 'CURRENT_TIMESTAMP',
                 nullable: true,
             },
             updatedAt: {
                 type: 'datetime',
+                updateDate: true,
                 default: () => 'CURRENT_TIMESTAMP',
                 nullable: true,
             },
@@ -159,6 +193,9 @@ class NMAdapter {
                     continue; // Base model protects this field; skip column in child
                 }
             }
+            const head = Array.isArray(attr) ? attr[0] : attr;
+            if (head?.type === 'virtual')
+                continue;
             const typeORMType = this.mapType(attr);
             const isUnique = attr.unique === true;
             const isSparse = attr.sparse === true;
@@ -219,6 +256,12 @@ class NMAdapter {
     async create(collection, data, schemaDefinition) {
         const repo = this.getRepository(collection);
         const coerced = this.coercePayloadForStorage(data, schemaDefinition);
+        // Ensure timestamps are set if not provided (especially for MongoDB)
+        const now = new Date();
+        if (!coerced.createdAt)
+            coerced.createdAt = now;
+        if (!coerced.updatedAt)
+            coerced.updatedAt = now;
         const created = await repo.save(coerced);
         return this.prepareResult(created);
     }
@@ -260,7 +303,16 @@ class NMAdapter {
             const hasRootProj = this.isExclusiveProjection(options.projection, schemaDefinition);
             if (hasRootProj) {
                 const dbProjection = {};
+                // Always include ID for hydration purposes
+                if (isMongo)
+                    dbProjection._id = true;
+                else
+                    dbProjection.id = true;
                 for (const [key, value] of Object.entries(options.projection)) {
+                    // Skip dynamic aggregate fields like model[count] for the DB query
+                    if (key.includes('[') && key.endsWith(']')) {
+                        continue;
+                    }
                     if (key.includes('.') && schemaDefinition) {
                         const root = key.split('.')[0];
                         const attr = schemaDefinition.attributes[root];
@@ -288,7 +340,15 @@ class NMAdapter {
             }
         }
         let results;
-        if (isMongo && findOptions.projection) {
+        if (isMongo && options?.sample) {
+            const mongoRepo = repo.manager.getMongoRepository(repo.metadata.name);
+            const aggregation = [{ $match: where }];
+            aggregation.push({ $sample: { size: options.sample } });
+            if (findOptions.projection)
+                aggregation.push({ $project: findOptions.projection });
+            results = await mongoRepo.aggregate(aggregation).toArray();
+        }
+        else if (isMongo && findOptions.projection) {
             const mongoRepo = repo.manager.getMongoRepository(repo.metadata.name);
             const cursor = mongoRepo.createCursor(where);
             cursor.project(findOptions.projection);
@@ -301,11 +361,32 @@ class NMAdapter {
             results = await cursor.toArray();
         }
         else {
-            results = await repo.find(findOptions);
+            if (options?.sample && !isMongo) {
+                const qb = repo.createQueryBuilder('entity');
+                qb.where(where);
+                if (limit)
+                    qb.take(limit);
+                if (skip)
+                    qb.skip(skip);
+                const dbType = this.dataSource.options.type;
+                if (dbType === 'postgres' || dbType === 'sqlite') {
+                    qb.orderBy('RANDOM()');
+                }
+                else if (dbType === 'mysql' || dbType === 'mariadb') {
+                    qb.orderBy('RAND()');
+                }
+                else if (dbType === 'mssql') {
+                    qb.orderBy('NEWID()');
+                }
+                results = await qb.getMany();
+            }
+            else {
+                results = await repo.find(findOptions);
+            }
         }
         const mappedResults = results.map(r => this.prepareResult(r));
         if (schemaDefinition) {
-            await this.hydrateRelations(mappedResults, schemaDefinition, options?.depth ?? 0, options?.projection);
+            await this.hydrateRelations(mappedResults, schemaDefinition, options?.depth ?? 0, options);
         }
         return mappedResults;
     }
@@ -324,8 +405,40 @@ class NMAdapter {
             if (item.id != null)
                 item.id = String(item.id);
         }
+        // Apply image URL proxying/transformation if configured
+        if (this.imageProxyOptions.originalBase && this.imageProxyOptions.proxyBase) {
+            this.transformUrls(item);
+        }
         return item;
     }
+    transformUrls(obj) {
+        if (!obj || typeof obj !== 'object')
+            return;
+        const { originalBase, proxyBase } = this.imageProxyOptions;
+        if (!originalBase || !proxyBase)
+            return;
+        for (const key in obj) {
+            const val = obj[key];
+            if (typeof val === 'string') {
+                if (val.startsWith(originalBase)) {
+                    obj[key] = val.replace(originalBase, proxyBase);
+                }
+            }
+            else if (Array.isArray(val)) {
+                for (let i = 0; i < val.length; i++) {
+                    if (typeof val[i] === 'string' && val[i].startsWith(originalBase)) {
+                        val[i] = val[i].replace(originalBase, proxyBase);
+                    }
+                    else if (val[i] && typeof val[i] === 'object') {
+                        this.transformUrls(val[i]);
+                    }
+                }
+            }
+            else if (val && typeof val === 'object') {
+                this.transformUrls(val);
+            }
+        }
+    }
     idToString(val) {
         if (val == null)
             return '';
@@ -358,8 +471,15 @@ class NMAdapter {
                 return this.convertToObjectId(extractedId);
         }
         try {
-            if (typeof val === 'string' && val.length === 24 && /^[0-9a-fA-F]{24}$/.test(val)) {
-                return new mongodb_1.ObjectId(val);
+            if (this.dataSource.options.type === 'mongodb') {
+                if (typeof val === 'string' && val.length === 24 && /^[0-9a-fA-F]{24}$/.test(val)) {
+                    return new mongodb_1.ObjectId(val);
+                }
+            }
+            else {
+                const n = Number(val);
+                if (!isNaN(n) && String(val).trim() !== '')
+                    return n;
             }
             return val;
         }
@@ -367,9 +487,87 @@ class NMAdapter {
             return val;
         }
     }
-    async hydrateRelations(results, schema, depth = 0, projection) {
+    discoverInverseRelation(targetModelName, sourceModelHint) {
+        const targetLc = targetModelName.toLowerCase();
+        const sourceLc = sourceModelHint.toLowerCase();
+        // 1. Find a schema that matches sourceModelHint (plural or singular)
+        let sourceSchema;
+        // Try exact match first
+        sourceSchema = this.registeredSchemas[sourceLc];
+        // Try common plural/singular variations
+        if (!sourceSchema) {
+            const variations = [
+                sourceLc + 's',
+                sourceLc + 'es',
+                sourceLc.endsWith('y') ? sourceLc.slice(0, -1) + 'ies' : sourceLc,
+                sourceLc.endsWith('ies') ? sourceLc.slice(0, -3) + 'y' : sourceLc,
+                sourceLc.endsWith('s') ? sourceLc.slice(0, -1) : sourceLc
+            ];
+            for (const v of variations) {
+                if (this.registeredSchemas[v]) {
+                    sourceSchema = this.registeredSchemas[v];
+                    break;
+                }
+            }
+        }
+        if (!sourceSchema)
+            return null;
+        // 2. Find which field in sourceSchema points to targetModelName
+        for (const [field, attr] of Object.entries(sourceSchema.attributes)) {
+            const a = Array.isArray(attr) ? attr[0] : attr;
+            if (a.ref?.toLowerCase() === targetLc) {
+                return { sourceModel: sourceSchema.modelName, foreignField: field };
+            }
+        }
+        return null;
+    }
+    async hydrateDynamicAggregates(results, schema, projection) {
+        const promises = [];
+        const idsToFetch = results.map(r => r.id).filter(v => v != null);
+        if (idsToFetch.length === 0)
+            return;
+        for (const [projKey, projVal] of Object.entries(projection)) {
+            if (projVal !== 1)
+                continue;
+            if (!projKey.includes('[') || !projKey.endsWith(']'))
+                continue;
+            const parts = projKey.split('[');
+            const modelHint = parts[0];
+            const op = parts[1].slice(0, -1);
+            if (op !== 'count')
+                continue;
+            const relation = this.discoverInverseRelation(schema.modelName, modelHint);
+            if (!relation) {
+                Logger_1.default.warn('NMAdapter', `No inverse relation found for ${modelHint} pointing to ${schema.modelName}`);
+                continue;
+            }
+            promises.push((async () => {
+                try {
+                    const sourceSchema = this.registeredSchemas[relation.sourceModel.toLowerCase()];
+                    const counts = await this.countBy(relation.sourceModel, relation.foreignField, { [relation.foreignField]: { $in: idsToFetch } }, sourceSchema);
+                    const targetKey = `${modelHint}Count`;
+                    results.forEach(r => {
+                        const lid = this.idToString(r.id);
+                        r[targetKey] = counts[lid] || 0;
+                    });
+                }
+                catch (err) {
+                    Logger_1.default.warn('NMAdapter', `Failed to fetch dynamic aggregate ${projKey} for ${schema.modelName}: ${err}`);
+                }
+            })());
+        }
+        if (promises.length > 0) {
+            await Promise.all(promises);
+        }
+    }
+    async hydrateRelations(results, schema, depth = 0, options) {
         if (!results.length || depth > 2)
             return;
+        const projection = options?.projection;
+        // --- Dynamic Aggregates (e.g. model[count]) ---
+        if (projection) {
+            await this.hydrateDynamicAggregates(results, schema, projection);
+        }
         // 1) Handle inheritance: if schema extends another, fetch base records
         if (schema.extends) {
             const baseLc = schema.extends.toLowerCase();
@@ -436,6 +634,29 @@ class NMAdapter {
         }
         // 2) Handle standard ObjectId hydration & 3) json-group in parallel
         const hydrationPromises = [];
+        // --- Virtual fields (Inverse relationship counts) ---
+        const virtualFields = Object.entries(schema.attributes).filter(([key, attr]) => {
+            const a = Array.isArray(attr) ? attr[0] : attr;
+            return a?.type === 'virtual' && a?.op === 'count';
+        });
+        for (const [key, attr] of virtualFields) {
+            hydrationPromises.push((async () => {
+                const a = Array.isArray(attr) ? attr[0] : attr;
+                const refModel = a.ref;
+                const foreignField = a.foreignField;
+                const localField = a.localField || 'id';
+                if (!refModel || !foreignField)
+                    return;
+                const idsToFetch = results.map(r => r[localField]).filter(v => v != null);
+                if (idsToFetch.length === 0)
+                    return;
+                const counts = await this.countBy(refModel, foreignField, { [foreignField]: { $in: idsToFetch } });
+                results.forEach(r => {
+                    const lid = this.idToString(r[localField]);
+                    r[key] = counts[lid] || 0;
+                });
+            })());
+        }
         // --- Standard Relations ---
         const relFields = Object.entries(schema.attributes).filter(([key, attr]) => {
             if (key === 'baseId')
@@ -472,13 +693,16 @@ class NMAdapter {
                 }
                 if (idsToFetch.size === 0)
                     return;
-                let subProjection = undefined;
-                if (projection) {
+                let subProjection = options?._populate?.[key];
+                if (subProjection) {
+                    subProjection = { ...subProjection, id: 1 };
+                }
+                if (!subProjection && projection) {
                     const prefix = `${key}.`;
                     for (const [pk, pv] of Object.entries(projection)) {
                         if (pk.startsWith(prefix)) {
                             if (!subProjection)
-                                subProjection = {};
+                                subProjection = { id: 1 };
                             subProjection[pk.slice(prefix.length)] = pv;
                         }
                     }
@@ -554,6 +778,8 @@ class NMAdapter {
         const coerced = this.coercePayloadForStorage(data, schemaDefinition);
         // Strip ID fields from data to prevent primary key conflicts
         const { id: _unusedId, _id: _unusedRawId, ...updateData } = coerced;
+        const now = new Date();
+        updateData.updatedAt = now;
         if (isMongo) {
             // Using explicit getMongoRepository and updateOne prevents accidental bulk updates
             // that targetBy filter {} could cause in standard TypeORM .update()
@@ -572,6 +798,8 @@ class NMAdapter {
                     setObj[k] = updateData[k] !== undefined ? updateData[k] : v;
                 }
             }
+            // Always update the updatedAt field
+            setObj.updatedAt = now;
             const updatePayload = {};
             if (Object.keys(setObj).length > 0)
                 updatePayload.$set = setObj;
@@ -622,6 +850,42 @@ class NMAdapter {
         }
         return total;
     }
+    async countBy(collection, field, query, schema) {
+        const repo = this.getRepository(collection);
+        const where = this.transformQuery(query, schema);
+        const counts = {};
+        if (this.dataSource.options.type === 'mongodb') {
+            const mongoRepo = repo.manager.getMongoRepository(repo.metadata.name);
+            // Determine if field is an array from schema to use $unwind
+            const isArray = Array.isArray(schema?.attributes?.[field]);
+            const pipeline = [{ $match: where }];
+            if (isArray) {
+                pipeline.push({ $unwind: `$${field}` });
+            }
+            pipeline.push({ $group: { _id: `$${field}`, count: { $sum: 1 } } });
+            const results = await mongoRepo.aggregate(pipeline).toArray();
+            results.forEach((r) => {
+                if (r._id != null)
+                    counts[this.idToString(r._id)] = r.count;
+            });
+        }
+        else {
+            const results = await repo
+                .createQueryBuilder('entity')
+                .select(`entity.${field}`, 'key')
+                .addSelect('COUNT(*)', 'count')
+                .where(where)
+                .groupBy(`entity.${field}`)
+                .getRawMany();
+            results.forEach((r) => {
+                const k = r.key || r.KEY || r[`entity_${field}`];
+                if (k != null) {
+                    counts[this.idToString(k)] = parseInt(r.count || r.COUNT || 0, 10);
+                }
+            });
+        }
+        return counts;
+    }
     async findFirstRelatedIds(collection, field, ids) {
         const repo = this.getRepository(collection);
         const map = new Map();

package/dist/files/FileStorageAdapter.d.ts

@@ -28,6 +28,11 @@ export interface UploadResult {
 export interface FileStorageAdapter {
     readonly name: FileProvider;
     upload(input: UploadPayload): Promise<UploadResult>;
+    download(key: string): Promise<{
+        body: any;
+        contentType?: string;
+        size?: number;
+    }>;
     delete(key: string): Promise<{
         deleted: boolean;
     }>;

package/dist/files/LocalFileStorageAdapter.d.ts

@@ -9,6 +9,11 @@ export declare class LocalFileStorageAdapter implements FileStorageAdapter {
     private publicUrlPrefix;
     constructor(options: LocalFileStorageOptions);
     upload(input: UploadPayload): Promise<UploadResult>;
+    download(key: string): Promise<{
+        body: any;
+        contentType?: string;
+        size?: number;
+    }>;
     delete(key: string): Promise<{
         deleted: boolean;
     }>;

package/dist/files/LocalFileStorageAdapter.js

@@ -43,6 +43,20 @@ class LocalFileStorageAdapter {
             contentType: input.contentType,
         };
     }
+    async download(key) {
+        const filePath = path_1.default.join(this.uploadDir, key);
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new Error('File not found');
+        }
+        const stats = fs_1.default.statSync(filePath);
+        const body = fs_1.default.createReadStream(filePath);
+        return {
+            body,
+            size: stats.size,
+            // Note: Local storage doesn't store contentType natively in metadata here, 
+            // but we could infer it if needed.
+        };
+    }
     async delete(key) {
         const filePath = path_1.default.join(this.uploadDir, key);
         if (fs_1.default.existsSync(filePath)) {

package/dist/files/S3FileStorageAdapter.d.ts

@@ -22,6 +22,11 @@ export declare class S3FileStorageAdapter implements FileStorageAdapter {
     private readonly publicBaseUrl?;
     constructor(opts: S3AdapterOptions);
     upload(input: UploadPayload): Promise<UploadResult>;
+    download(key: string): Promise<{
+        body: any;
+        contentType?: string;
+        size?: number;
+    }>;
     delete(key: string): Promise<{
         deleted: boolean;
     }>;

package/dist/files/S3FileStorageAdapter.js

@@ -55,6 +55,20 @@ class S3FileStorageAdapter {
             metadata: input.metadata,
         };
     }
+    async download(key) {
+        try {
+            const res = await this.s3.send(new client_s3_1.GetObjectCommand({ Bucket: this.bucket, Key: key }));
+            return {
+                body: res.Body,
+                contentType: res.ContentType,
+                size: res.ContentLength,
+            };
+        }
+        catch (err) {
+            // Re-throw so the caller can log it with more context
+            throw err;
+        }
+    }
     async delete(key) {
         await this.s3.send(new client_s3_1.DeleteObjectCommand({ Bucket: this.bucket, Key: key }));
         return { deleted: true };

package/dist/models/BaseModel.d.ts

@@ -5,6 +5,8 @@ export type ReadOptions = {
     sort?: SortSpec;
     projection?: Record<string, 0 | 1>;
     depth?: number;
+    sample?: number;
+    _populate?: Record<string, Record<string, 1>>;
 };
 export interface Attributes {
     type: string;
@@ -21,6 +23,9 @@ export interface Attributes {
     rich?: boolean;
     searchBy?: string;
     show?: string;
+    op?: 'count' | 'sum' | 'avg' | 'min' | 'max';
+    foreignField?: string;
+    localField?: string;
 }
 export interface CustomAction {
     label: string;
@@ -47,15 +52,23 @@ export interface Schema {
     extends?: string;
     actions?: CustomAction[];
     access?: any;
+    aggregates?: AggregateSpec[];
+}
+export interface AggregateSpec {
+    sourceModel: string;
+    foreignField: string;
+    op: 'count' | 'avg' | 'sum' | 'min' | 'max';
+    field?: string;
+    targetField: string;
 }
 export declare class BaseModel {
-    private schema;
+    schema: Schema;
     private adapter;
     private collectionName;
     constructor(schema: Schema, adapter: DatabaseAdapter);
     create(data: any, includePrivateFields?: boolean): Promise<any>;
     read(query: any, limit?: number, skip?: number, includePrivateFields?: boolean, options?: ReadOptions): Promise<any[]>;
-    update(id: string, data: any, includePrivateFields?: boolean): Promise<any>;
+    update(id: string, data: any, includePrivateFields?: boolean, oldDoc?: any): Promise<any>;
     delete(id: string, includePrivateFields?: boolean): Promise<any>;
     count(query: any, includePrivateFields?: boolean): Promise<number>;
     findFirstRelatedIds(field: string, ids: string[]): Promise<Map<string, string>>;

package/dist/models/BaseModel.js

@@ -31,13 +31,13 @@ class BaseModel {
         Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'read', 'after'), { ...payload, result });
         return result;
     }
-    async update(id, data, includePrivateFields) {
-        const payload = { modelName: this.schema.modelName, id, data };
+    async update(id, data, includePrivateFields, oldDoc) {
+        const payload = { modelName: this.schema.modelName, id, data, oldDoc };
         Events_1.events.emitEvent(Events_1.Events.BEFORE_UPDATE, payload);
         Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'update', 'before'), payload);
         const result = await this.adapter.update(this.collectionName, id, data, this.schema, includePrivateFields);
-        Events_1.events.emitEvent(Events_1.Events.AFTER_UPDATE, { ...payload, result });
-        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'update', 'after'), { ...payload, result });
+        Events_1.events.emitEvent(Events_1.Events.AFTER_UPDATE, { ...payload, result, oldDoc });
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'update', 'after'), { ...payload, result, oldDoc });
         return result;
     }
     async delete(id, includePrivateFields) {

package/dist/services/AggregateService.d.ts

@@ -0,0 +1,8 @@
+import type { RouterCtx } from '../api/router/ctx';
+export declare class AggregateService {
+    private ctx;
+    constructor(ctx: RouterCtx);
+    private init;
+    private handleUpdate;
+    private recalculate;
+}

package/dist/services/AggregateService.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateService = void 0;
+const Events_1 = require("../utils/Events");
+const Logger_1 = __importDefault(require("../utils/Logger"));
+class AggregateService {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.init();
+    }
+    init() {
+        Events_1.events.on(Events_1.Events.AFTER_CREATE, (payload) => this.handleUpdate(payload.modelName, payload.result, 'create'));
+        Events_1.events.on(Events_1.Events.AFTER_UPDATE, (payload) => this.handleUpdate(payload.modelName, payload.result, 'update'));
+        Events_1.events.on(Events_1.Events.AFTER_DELETE, (payload) => this.handleUpdate(payload.modelName, payload.result, 'delete'));
+        Logger_1.default.info('AggregateService', 'Initialized and listening for CRUD events');
+    }
+    async handleUpdate(sourceModelName, doc, action) {
+        if (!doc)
+            return;
+        // Find SCHEMAS that have aggregates dependent on sourceModelName
+        const allSchemas = Object.values(this.ctx.liveSchemas);
+        for (const targetSchema of allSchemas) {
+            if (!targetSchema.aggregates)
+                continue;
+            const ags = targetSchema.aggregates.filter((a) => a.sourceModel.toLowerCase() === sourceModelName.toLowerCase());
+            if (ags.length === 0)
+                continue;
+            for (const ag of ags) {
+                const parentId = doc[ag.foreignField];
+                if (!parentId)
+                    continue;
+                // Recalculate and update target document (Doctor)
+                await this.recalculate(targetSchema.modelName, parentId, ag);
+            }
+        }
+    }
+    async recalculate(targetModelName, targetId, ag) {
+        try {
+            const sourceModel = this.ctx.getModel(ag.sourceModel.toLowerCase());
+            const targetModel = this.ctx.getModel(targetModelName.toLowerCase());
+            const filter = { [ag.foreignField]: targetId };
+            let result = 0;
+            if (ag.op === 'count') {
+                result = await sourceModel.count(filter, true);
+            }
+            else if (ag.op === 'avg' || ag.op === 'sum') {
+                const adapter = this.ctx.dbAdapter;
+                if (adapter.dataSource.options.type === 'mongodb') {
+                    const repo = adapter.dataSource.getMongoRepository(ag.sourceModel);
+                    const aggregation = [
+                        { $match: adapter.transformQuery(filter, sourceModel.schema) },
+                        { $group: { _id: null, val: { [`$${ag.op}`]: `$${ag.field}` } } },
+                    ];
+                    const res = await repo.aggregate(aggregation).toArray();
+                    result = res[0]?.val || 0;
+                }
+                else {
+                    // SQL
+                    const repo = adapter.repositories.get(ag.sourceModel.toLowerCase());
+                    const qb = repo.createQueryBuilder('entity');
+                    qb.select(`${ag.op === 'avg' ? 'AVG' : 'SUM'}(entity.${ag.field})`, 'val');
+                    qb.where(adapter.transformQuery(filter, sourceModel.schema));
+                    const res = await qb.getRawOne();
+                    result = parseFloat(res?.val || res?.VAL || 0);
+                }
+            }
+            // Update target document (e.g. Doctor)
+            const updateData = {};
+            const parts = ag.targetField.split('.');
+            let curr = updateData;
+            for (let i = 0; i < parts.length - 1; i++) {
+                curr[parts[i]] = {};
+                curr = curr[parts[i]];
+            }
+            curr[parts[parts.length - 1]] = result;
+            await targetModel.update(targetId, updateData, true);
+            Logger_1.default.debug('AggregateService', `Updated ${targetModelName}:${targetId} aggregate ${ag.targetField} to ${result}`);
+        }
+        catch (err) {
+            Logger_1.default.error('AggregateService', `Failed to recalculate aggregate for ${targetModelName}:${targetId}`, err);
+        }
+    }
+}
+exports.AggregateService = AggregateService;

package/dist/utils/Events.js

@@ -21,7 +21,7 @@ class NextMinEvents extends events_1.EventEmitter {
      * Typed emit to provide better DX (Developer Experience)
      */
     emitEvent(event, payload) {
-        Logger_1.default.info('NextMinEvents', `Emitting event: ${event}`);
+        Logger_1.default.debug('NextMinEvents', `Emitting event: ${event}`);
         this.emit(event, payload);
     }
 }

package/dist/utils/Logger.d.ts

@@ -1,8 +1,9 @@
 export declare class Logger {
-    private isDevelopment;
+    private get isDevelopment();
     constructor();
     private getCallerInfo;
     private formatMessage;
+    debug(label: string, ...messages: any[]): void;
     log(label: string, ...messages: any[]): void;
     info(label: string, ...messages: any[]): void;
     warn(label: string, ...messages: any[]): void;

package/dist/utils/Logger.js

@@ -8,9 +8,11 @@ const kleur_1 = __importDefault(require("kleur"));
 const util_1 = require("util");
 const path_1 = __importDefault(require("path"));
 class Logger {
-    constructor() {
-        this.isDevelopment = process.env.APP_MODE !== 'production' && process.env.NODE_ENV !== 'production';
+    get isDevelopment() {
+        return (process.env.APP_MODE?.toLowerCase() !== 'production' &&
+            process.env.NODE_ENV?.toLowerCase() !== 'production');
     }
+    constructor() { }
     getCallerInfo() {
         const originalPrepareStackTrace = Error.prepareStackTrace;
         Error.prepareStackTrace = (err, stack) => stack;
@@ -45,12 +47,21 @@ class Logger {
             case 'ERROR':
                 formattedLabel = kleur_1.default.red(`[ERROR] ${label} (${callerInfo}):`);
                 break;
+            case 'DEBUG':
+                formattedLabel = kleur_1.default.magenta(`[DEBUG] ${label} (${callerInfo}):`);
+                break;
             default:
                 formattedLabel = `[${level}] ${label} (${callerInfo}):`;
         }
         const formattedMessage = (0, util_1.format)(...messages);
         return `${formattedLabel} ${formattedMessage}`;
     }
+    debug(label, ...messages) {
+        if (this.isDevelopment) {
+            const formatted = this.formatMessage('DEBUG', label, messages);
+            console.debug(formatted);
+        }
+    }
     log(label, ...messages) {
         if (this.isDevelopment) {
             const formatted = this.formatMessage('LOG', label, messages);
@@ -70,10 +81,8 @@ class Logger {
         }
     }
     error(label, ...messages) {
-        if (this.isDevelopment) {
-            const formatted = this.formatMessage('ERROR', label, messages);
-            console.error(formatted);
-        }
+        const formatted = this.formatMessage('ERROR', label, messages);
+        console.error(formatted);
     }
 }
 exports.Logger = Logger;

package/dist/utils/SchemaLoader.d.ts

@@ -17,7 +17,7 @@ export declare class SchemaLoader {
     schemas: {
         [key: string]: Schema;
     };
-    private isDevelopment;
+    private get isDevelopment();
     private nonOverridableSchemas;
     private userSchemasDir;
     private packageSchemasDir;

package/dist/utils/SchemaLoader.js

@@ -58,6 +58,10 @@ function validateSchema(obj) {
     return missing;
 }
 class SchemaLoader {
+    get isDevelopment() {
+        return (process.env.APP_MODE?.toLowerCase() !== 'production' &&
+            process.env.NODE_ENV?.toLowerCase() !== 'production');
+    }
     // Singleton instance
     static getInstance() {
         if (!SchemaLoader._instance) {
@@ -68,10 +72,8 @@ class SchemaLoader {
     constructor() {
         this.emitter = new events_1.EventEmitter();
         this.schemas = {};
-        this.isDevelopment = false;
         this.nonOverridableSchemas = new Set(['User', 'Role']);
         this.watcher = null; // <-- TS-safe
-        this.isDevelopment = process.env.APP_MODE !== 'production';
         const baseDir = process.cwd();
         const basePackageDir = path_1.default.resolve(__dirname, '..');
         this.packageSchemasDir = path_1.default.join(basePackageDir, 'schemas');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airoom/nextmin-node",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",