@airoom/nextmin-node 0.1.9 → 1.1.0

package/dist/api/apiRouter.d.ts

@@ -16,6 +16,7 @@ export declare class APIRouter {
     private schemaLoader;
     private isDevelopment;
     private findRoutesMounted;
+    private searchRoutesMounted;
     private authRoutesInitialized;
     private schemasRouteRegistered;
     private registeredModels;
@@ -33,6 +34,7 @@ export declare class APIRouter {
     private mountSchemasEndpointOnce;
     private mountRoutes;
     private mountFindRoutes;
+    private mountSearchRoutes;
     private mountFileRoutes;
     private createCtx;
     private getSchema;

package/dist/api/apiRouter.js

@@ -16,10 +16,12 @@ 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");
 class APIRouter {
     constructor(options) {
         this.models = {};
         this.findRoutesMounted = false;
+        this.searchRoutesMounted = false;
         this.authRoutesInitialized = false;
         this.schemasRouteRegistered = false;
         this.registeredModels = new Set();
@@ -196,6 +198,7 @@ class APIRouter {
             this.mountSchemasEndpointOnce();
             this.mountRoutes(initialSchemas);
             this.mountFindRoutes();
+            this.mountSearchRoutes();
             this.mountFileRoutes();
             await this.syncAllIndexes(initialSchemas);
             const initializer = new DefaultDataInitializer_1.DefaultDataInitializer(this.dbAdapter, this.models);
@@ -334,6 +337,13 @@ class APIRouter {
         (0, mountFindRoutes_1.mountFindRoutes)(this.createCtx());
         this.ensureNotFoundLast();
     }
+    mountSearchRoutes() {
+        if (this.searchRoutesMounted)
+            return;
+        this.searchRoutesMounted = true;
+        (0, mountSearchRoutes_1.mountSearchRoutes)(this.createCtx());
+        this.ensureNotFoundLast();
+    }
     mountFileRoutes() {
         if (this.fileRoutesMounted)
             return;

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

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

package/dist/api/router/mountSearchRoutes.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountSearchRoutes = mountSearchRoutes;
+const utils_1 = require("./utils");
+function mountSearchRoutes(ctx) {
+    const { router } = ctx;
+    router.post('/search', ctx.optionalAuthMiddleware, async (req, res) => {
+        try {
+            const body = (0, utils_1.isPlainObject)(req.body)
+                ? req.body
+                : {};
+            const text = typeof body.text === 'string' ? body.text.trim() : '';
+            const models = Array.isArray(body.models) ? body.models : [];
+            const fields = Array.isArray(body.fields) ? body.fields : [];
+            const select = (0, utils_1.isPlainObject)(body.select)
+                ? body.select
+                : {};
+            const perModelLimit = typeof body.limit === 'number' && body.limit > 0
+                ? Math.floor(body.limit)
+                : 10;
+            if (!text || text.length < 2) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'text must be at least 2 characters',
+                });
+            }
+            if (!models.length) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'models must be a non-empty string array',
+                });
+            }
+            if (!fields.length) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'fields must be a non-empty string array',
+                });
+            }
+            // 🚫 Block sensitive/non-searchable models
+            const forbidden = new Set(['users', 'roles', 'settings']);
+            const modelsLC = models.map((m) => String(m || '').toLowerCase());
+            const forbiddenInRequest = modelsLC.filter((m) => forbidden.has(m));
+            if (forbiddenInRequest.length) {
+                // build an empty results shape for client predictability
+                const emptyResults = Object.fromEntries(modelsLC.map((m) => [m, []]));
+                return res.status(400).json({
+                    error: true,
+                    message: `These models are not searchable: ${forbiddenInRequest.join(', ')}`,
+                    data: emptyResults,
+                });
+            }
+            const adapterAny = ctx.dbAdapter;
+            const results = {};
+            const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const textEsc = escapeRegex(text);
+            const buildOrFilter = (flds) => {
+                const orClauses = [];
+                for (const f of flds) {
+                    orClauses.push({ [f]: { $regex: `^${textEsc}`, $options: 'i' } });
+                    orClauses.push({ [f]: { $regex: textEsc, $options: 'i' } });
+                }
+                return { $or: orClauses };
+            };
+            const getValuesForPath = (row, path) => {
+                const parts = path.split('.');
+                const walk = (node, i) => {
+                    if (node == null)
+                        return [];
+                    if (i >= parts.length)
+                        return Array.isArray(node) ? node : [node];
+                    const key = parts[i];
+                    if (Array.isArray(node)) {
+                        const out = [];
+                        for (const el of node)
+                            out.push(...walk(el?.[key], i + 1));
+                        return out;
+                    }
+                    return walk(node[key], i + 1);
+                };
+                return walk(row, 0).filter((v) => v !== undefined && v !== null);
+            };
+            for (const rawName of models) {
+                const modelNameLC = String(rawName || '').toLowerCase();
+                let items = [];
+                try {
+                    const schema = ctx.getSchema(modelNameLC);
+                    const extendsUsers = String(schema?.extends || '').toLowerCase() === 'users';
+                    // Projection with baseId if extends Users
+                    const projection = Array.isArray(select?.[modelNameLC])
+                        ? Object.fromEntries(select[modelNameLC].map((k) => [k, 1]))
+                        : undefined;
+                    if (extendsUsers && projection)
+                        projection['baseId'] = 1;
+                    const filter = buildOrFilter(fields);
+                    const useAdapter = typeof adapterAny.findMany === 'function' &&
+                        typeof schema?.modelName === 'string';
+                    if (useAdapter) {
+                        items = await adapterAny.findMany(schema.modelName, filter, {
+                            sort: undefined,
+                            skip: 0,
+                            limit: undefined,
+                            projection,
+                        });
+                    }
+                    else {
+                        const all = await ctx.getModel(modelNameLC).read({}, 0, 0, true);
+                        const reStart = new RegExp('^' + escapeRegex(text), 'i');
+                        const reContain = new RegExp(escapeRegex(text), 'i');
+                        const matches = all.filter((row) => fields.some((f) => {
+                            const vals = getValuesForPath(row, f).map((v) => String(v ?? ''));
+                            return vals.some((s) => reStart.test(s) || reContain.test(s));
+                        }));
+                        items = matches.map((it) => {
+                            if (projection) {
+                                const picked = { id: it.id ?? it._id };
+                                for (const k of Object.keys(projection))
+                                    picked[k] = it[k];
+                                return picked;
+                            }
+                            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;
+                        });
+                    }
+                    results[modelNameLC] = Array.isArray(items)
+                        ? items.slice(0, perModelLimit)
+                        : [];
+                }
+                catch {
+                    results[modelNameLC] = [];
+                }
+            }
+            return res
+                .status(200)
+                .json({ success: true, message: 'Search results', data: results });
+        }
+        catch (err) {
+            return res
+                .status(400)
+                .json({ error: true, message: err?.message || 'Error' });
+        }
+    });
+}

package/package.json

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