@airoom/nextmin-node 1.4.6 → 2.0.2

package/dist/api/router/mountFindRoutes.js

@@ -83,31 +83,7 @@ function mountFindRoutes(ctx) {
             else {
                 items = await ctx.getModel(targetLC).read({ id: { $in: ids } }, limit, skip, !!tDec.exposePrivate);
             }
-            // extended hydration if needed
-            if (targetSchema.extends && Array.isArray(items) && items.length) {
-                const baseName = String(targetSchema.extends);
-                const baseLC = baseName.toLowerCase();
-                const baseModel = ctx.getModel(baseLC);
-                const baseIds = Array.from(new Set(items.map((it) => it?.baseId).filter(Boolean)));
-                if (baseIds.length) {
-                    const baseDocs = await baseModel.read({ id: { $in: baseIds } }, baseIds.length, 0, !!tDec.exposePrivate);
-                    const baseMap = new Map(baseDocs.map((b) => [String(b?.id ?? b?._id), b]));
-                    items = items.map((it) => {
-                        const bid = String(it?.baseId || "");
-                        const b = bid ? baseMap.get(bid) : null;
-                        const merged = b ? { ...b, ...it } : { ...it };
-                        delete merged.baseId;
-                        return merged;
-                    });
-                }
-                else {
-                    items = items.map((it) => {
-                        const copy = { ...it };
-                        delete copy.baseId;
-                        return copy;
-                    });
-                }
-            }
+            // extended hydration is handled by adapter.read/findMany
             const masked = tDec.exposePrivate ? (0, authorize_1.applyReadMaskMany)(items, tDec.sensitiveMask) : (0, authorize_1.applyReadMaskMany)(items, tDec.readMask);
             const totalRows = ids.length;
             return res.status(200).json({
@@ -163,30 +139,7 @@ function mountFindRoutes(ctx) {
                 totalRows = all.length;
                 items = all.slice(skip, skip + limit);
             }
-            if (targetSchema.extends && Array.isArray(items) && items.length) {
-                const baseName = String(targetSchema.extends);
-                const baseLC = baseName.toLowerCase();
-                const baseModel = ctx.getModel(baseLC);
-                const baseIds = Array.from(new Set(items.map((it) => it?.baseId).filter(Boolean)));
-                if (baseIds.length) {
-                    const baseDocs = await baseModel.read({ id: { $in: baseIds } }, baseIds.length, 0, !!tDec.exposePrivate);
-                    const baseMap = new Map(baseDocs.map((b) => [String(b?.id ?? b?._id), b]));
-                    items = items.map((it) => {
-                        const bid = String(it?.baseId || "");
-                        const b = bid ? baseMap.get(bid) : null;
-                        const merged = b ? { ...b, ...it } : { ...it };
-                        delete merged.baseId;
-                        return merged;
-                    });
-                }
-                else {
-                    items = items.map((it) => {
-                        const copy = { ...it };
-                        delete copy.baseId;
-                        return copy;
-                    });
-                }
-            }
+            // extended hydration is handled by adapter.read/findMany
             const masked = tDec.exposePrivate ? (0, authorize_1.applyReadMaskMany)(items, tDec.sensitiveMask) : (0, authorize_1.applyReadMaskMany)(items, tDec.readMask);
             return res.status(200).json({
                 success: true,

package/dist/api/router/mountSearchRoutes.js

@@ -18,6 +18,7 @@ function mountSearchRoutes(ctx) {
             const perModelLimit = typeof body.limit === 'number' && body.limit > 0
                 ? Math.floor(body.limit)
                 : 10;
+            const searchType = body.searchType === 'includes' ? 'includes' : 'starts';
             if (!text || text.length < 2) {
                 return res
                     .status(400)
@@ -62,8 +63,8 @@ function mountSearchRoutes(ctx) {
             const buildOrFilter = (flds) => {
                 const orClauses = [];
                 for (const f of flds) {
-                    orClauses.push({ [f]: { $regex: `^${textEsc}`, $options: 'i' } });
-                    orClauses.push({ [f]: { $regex: textEsc, $options: 'i' } });
+                    const pattern = searchType === 'includes' ? textEsc : `^${textEsc}`;
+                    orClauses.push({ [f]: { $regex: pattern, $options: 'i' } });
                 }
                 return { $or: orClauses };
             };
@@ -126,56 +127,13 @@ function mountSearchRoutes(ctx) {
                             return it;
                         });
                     }
-                    // If model extends Users, enrich results from base users via baseId
-                    if (extendsUsers && Array.isArray(items) && items.length) {
-                        const baseIds = Array.from(new Set(items
-                            .map((row) => String(row?.baseId?._id ?? row?.baseId ?? ''))
-                            .filter(Boolean)));
-                        if (baseIds.length) {
-                            const userModel = ctx.getModel('users');
-                            const baseUsers = await userModel.read({ id: { $in: baseIds } }, baseIds.length, 0, true);
-                            // keep only pure base users and sensible visibility
-                            const validUsers = baseUsers.filter((u) => !('baseId' in u) &&
-                                (!u.type || u.type === 'user') &&
-                                (!u.status || u.status === 'active'));
-                            const userMap = new Map(validUsers.map((u) => [String(u.id ?? u._id), u]));
-                            items = items.map((row) => {
-                                const bid = String(row?.baseId?._id ?? row?.baseId ?? '');
-                                const u = bid ? userMap.get(bid) : undefined;
-                                const merged = u
-                                    ? {
-                                        ...row,
-                                        firstName: u.firstName ?? row.firstName,
-                                        lastName: u.lastName ?? row.lastName,
-                                        profilePicture: u.profilePicture ?? row.profilePicture,
-                                        status: u.status ?? row.status,
-                                        type: u.type ?? row.type,
-                                        email: u.email ?? row.email,
-                                        phone: u.phone ?? row.phone,
-                                    }
-                                    : row;
-                                // remove baseId before returning
-                                if ('baseId' in merged)
-                                    delete merged.baseId;
-                                return merged;
-                            });
-                        }
-                        else {
-                            items = items.map((row) => {
-                                if ('baseId' in row)
-                                    delete row.baseId;
-                                return row;
-                            });
-                        }
-                    }
-                    else {
-                        // Not extended — ensure baseId removed if present
-                        items = items.map((row) => {
-                            if ('baseId' in row)
-                                delete row.baseId;
-                            return row;
-                        });
-                    }
+                    // Enrichment: If model extends Users, the adapter already hydrated basic fields.
+                    // We just ensure baseId is removed for the response.
+                    items = items.map((row) => {
+                        if ('baseId' in row)
+                            delete row.baseId;
+                        return row;
+                    });
                     results[modelNameLC] = Array.isArray(items)
                         ? items.slice(0, perModelLimit)
                         : [];

package/dist/api/router/mountSearchRoutes_extended.js

@@ -157,54 +157,13 @@ function mountSearchRoutes(ctx) {
                             return it;
                         });
                     }
-                    // If model extends Users, enrich results from base users via baseId
-                    if (extendsUsers && Array.isArray(items) && items.length) {
-                        const baseIds = Array.from(new Set(items
-                            .map((row) => String(row?.baseId?._id ?? row?.baseId ?? ''))
-                            .filter(Boolean)));
-                        if (baseIds.length) {
-                            const userModel = ctx.getModel('users');
-                            const baseUsers = await userModel.read({ id: { $in: baseIds } }, baseIds.length, 0, true);
-                            const validUsers = baseUsers.filter((u) => !('baseId' in u) &&
-                                (!u.type || u.type === 'user') &&
-                                (!u.status || u.status === 'active'));
-                            const userMap = new Map(validUsers.map((u) => [String(u.id ?? u._id), u]));
-                            items = items.map((row) => {
-                                const bid = String(row?.baseId?._id ?? row?.baseId ?? '');
-                                const u = bid ? userMap.get(bid) : undefined;
-                                const merged = u
-                                    ? {
-                                        ...row,
-                                        firstName: u.firstName ?? row.firstName,
-                                        lastName: u.lastName ?? row.lastName,
-                                        profilePicture: u.profilePicture ?? row.profilePicture,
-                                        status: u.status ?? row.status,
-                                        type: u.type ?? row.type,
-                                        email: u.email ?? row.email,
-                                        phone: u.phone ?? row.phone,
-                                    }
-                                    : row;
-                                if ('baseId' in merged)
-                                    delete merged.baseId;
-                                return merged;
-                            });
-                        }
-                        else {
-                            items = items.map((row) => {
-                                if ('baseId' in row)
-                                    delete row.baseId;
-                                return row;
-                            });
-                        }
-                    }
-                    else {
-                        // Not extended — ensure baseId removed if present
-                        items = items.map((row) => {
-                            if ('baseId' in row)
-                                delete row.baseId;
-                            return row;
-                        });
-                    }
+                    // Enrichment: If model extends Users, the adapter already hydrated basic fields.
+                    // We just ensure baseId is removed for the response.
+                    items = items.map((row) => {
+                        if ('baseId' in row)
+                            delete row.baseId;
+                        return row;
+                    });
                     results[modelNameLC] = Array.isArray(items)
                         ? items.slice(0, perModelLimit)
                         : [];

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

@@ -50,10 +50,15 @@ function toIdString(v) {
     if (typeof v === 'object') {
         if (typeof v.id === 'string')
             return v.id;
+        if (typeof v.toString === 'function' && v.constructor.name === 'ObjectId')
+            return v.toString();
         if (v._id && typeof v._id.toString === 'function')
             return v._id.toString();
         if (typeof v._id === 'string')
             return v._id;
+        // Fallback for generic objects that might be IDs
+        if (typeof v.toString === 'function' && !Array.isArray(v))
+            return v.toString();
     }
     return null;
 }
@@ -82,7 +87,9 @@ function splitFilterForExtended(filter, baseKeys) {
                     outBase[k] = baseArr;
                 continue;
             }
-            if (baseKeys.has(k))
+            if (exports.VIRTUAL_SORT_KEYS.has(k))
+                outChild[k] = v;
+            else if (baseKeys.has(k))
                 outBase[k] = v;
             else
                 outChild[k] = v;
@@ -95,10 +102,15 @@ function splitSortForExtended(sort, baseKeys) {
     const child = {};
     const base = {};
     for (const [k, dir] of Object.entries(sort || {})) {
-        if (baseKeys.has(k))
+        if (exports.VIRTUAL_SORT_KEYS.has(k)) {
+            child[k] = dir;
+        }
+        else if (baseKeys.has(k)) {
             base[k] = dir;
-        else
+        }
+        else {
             child[k] = dir;
+        }
     }
     return { child, base };
 }
@@ -257,14 +269,15 @@ function parseSort(sortRaw, sortTypeRaw, allowedKeys) {
         // client sent sort but none validated → honor “no default”
         return spec;
     }
-    // no sort sent → default
-    return { createdAt: -1 };
+    // no sort sent → default cascade
+    return { createdAt: -1, _id: -1, id: -1 };
 }
 function parseQuery(req, allowedKeys) {
-    const limit = Math.min(Number.parseInt(String(req.query.limit ?? '12'), 10) || 12, 100);
+    const limit = Math.min(Number.parseInt(String(req.query.limit ?? '12'), 10) || 12, 100000);
     const page = Math.max(Number.parseInt(String(req.query.page ?? '1'), 10) || 1, 1);
     const skip = (page - 1) * limit;
-    const fields = String(req.query.fields ?? '')
+    const fieldsRaw = req.query.fields ?? req.query.select;
+    const fields = String(fieldsRaw ?? '')
         .split(',')
         .map((s) => s.trim())
         .filter(Boolean);
@@ -274,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/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NMAdapter_1 = require("./database/NMAdapter");
+const SchemaLoader_1 = require("./utils/SchemaLoader");
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+async function repairMongo() {
+    const mongoUri = process.env.MONGODB_URI;
+    const dbName = process.env.DB_NAME || 'test';
+    const schemasDir = process.env.SCHEMAS_DIR || path_1.default.join(process.cwd(), 'schemas');
+    if (!mongoUri) {
+        console.error('MONGODB_URI is required in .env');
+        process.exit(1);
+    }
+    console.log('--- NextMin MongoDB Repair Tool ---');
+    console.log(`Connecting to: ${mongoUri}`);
+    const loader = SchemaLoader_1.SchemaLoader.getInstance();
+    const schemaDefs = loader.getSchemas();
+    const adapter = new NMAdapter_1.NMAdapter({
+        type: 'mongodb',
+        url: mongoUri,
+        database: dbName,
+        useNewUrlParser: true,
+        useUnifiedTopology: true,
+        schemas: schemaDefs
+    });
+    try {
+        await adapter.connect();
+        await adapter.registerSchemas(schemaDefs);
+        for (const [name, schema] of Object.entries(schemaDefs)) {
+            if (schema.extends) {
+                console.log(`Checking ${name} (extends ${schema.extends})...`);
+                const items = await adapter.read(name, {});
+                const broken = items.filter(it => !it.baseId);
+                if (broken.length > 0) {
+                    console.log(`Found ${broken.length} items missing baseId in ${name}. Attempting repair...`);
+                    for (const item of broken) {
+                        const searchVal = item.slug || item.username || item.name;
+                        if (!searchVal)
+                            continue;
+                        // Try to find matching base record
+                        const baseMatches = await adapter.read(schema.extends, {
+                            $or: [
+                                { slug: searchVal },
+                                { username: searchVal },
+                                { name: searchVal }
+                            ]
+                        });
+                        if (baseMatches.length > 0) {
+                            const baseId = baseMatches[0].id;
+                            await adapter.update(name, item.id, { baseId });
+                            console.log(`  ✅ Repaired ${name} item '${searchVal}' -> baseId: ${baseId}`);
+                        }
+                        else {
+                            console.warn(`  ❌ Could not find matching ${schema.extends} for ${name} item '${searchVal}'`);
+                        }
+                    }
+                }
+                else {
+                    console.log(`  No broken links found in ${name}.`);
+                }
+            }
+        }
+        console.log('Repair process completed.');
+    }
+    catch (err) {
+        console.error('Repair failed:', err);
+    }
+    finally {
+        await adapter.disconnect();
+    }
+}
+const command = process.argv[2];
+if (command === 'repair-mongo') {
+    repairMongo();
+}
+else {
+    console.log('Usage: ts-node src/cli.ts repair-mongo');
+}

package/dist/database/DatabaseAdapter.d.ts

@@ -10,5 +10,13 @@ export interface DatabaseAdapter {
     update(collection: string, id: string, data: any, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<any>;
     delete(collection: string, id: string, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<any>;
     count(collection: string, query: any, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<number>;
+    /**
+     * Bulk existence check for related records.
+     * 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

@@ -0,0 +1,46 @@
+import { DatabaseAdapter, FieldIndexSpec } from './DatabaseAdapter';
+import { ReadOptions, Schema as NextMinSchema } from '../models/BaseModel';
+/**
+ * NMAdapter implements the DatabaseAdapter interface.
+ * It supports SQL databases (PostgreSQL, MySQL, MariaDB, SQLite, MSSQL) and MongoDB.
+ */
+export declare class NMAdapter implements DatabaseAdapter {
+    private options;
+    private dataSource;
+    private repositories;
+    private entitySchemas;
+    private registeredSchemas;
+    private imageProxyOptions;
+    constructor(options: any);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    registerSchemas(schemas: Record<string, NextMinSchema>): Promise<void>;
+    syncIndexes(modelName: string, spec: FieldIndexSpec): Promise<void>;
+    private buildEntitySchema;
+    private mapType;
+    private getRepository;
+    create(collection: string, data: any, schemaDefinition?: NextMinSchema): Promise<any>;
+    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
+     * Recursively scans for $nestedSearch operators and resolves them to { $in: [ids] }
+     */
+    private resolveNestedSearches;
+    private transformQuery;
+    private mapOperator;
+    cleanupUnusedFields(schemas: Record<string, NextMinSchema>): Promise<Record<string, string[]>>;
+    isExclusiveProjection(projection: Record<string, 0 | 1> | undefined, schema: NextMinSchema | undefined): boolean;
+}