@airoom/nextmin-node 1.4.5 → 2.0.1

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/setupAuthRoutes.js

@@ -114,7 +114,7 @@ function setupAuthRoutes(ctx) {
             res.json({
                 success: true,
                 message: 'You are successfully logged in.',
-                data: { token, user },
+                data: { token, user: { ...user, roleName } },
             });
         }
         catch (error) {
@@ -140,8 +140,12 @@ function setupAuthRoutes(ctx) {
                     .status(404)
                     .json({ error: true, message: 'User not found' });
             }
+            const roleName = (await ctx.normalizeRoleName(user.role)) ?? '';
             delete user.password;
-            return res.json({ success: true, data: user });
+            return res.json({
+                success: true,
+                data: { ...user, roleName },
+            });
         }
         catch (error) {
             return res

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);

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,12 @@ 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>>;
     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,41 @@
+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;
+    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 idToString;
+    private convertToObjectId;
+    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>;
+    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;
+}