@airoom/nextmin-node 1.1.0 → 1.2.0

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

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

package/dist/api/router/mountSearchRoutes_extended.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.map(String)
+                : [];
+            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) {
+                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);
+            // Expand a logical field to likely nested properties too (name/slug/title).
+            // If the caller already passes a nested path (e.g. districts.name), keep as-is.
+            const expandFieldVariants = (fld) => {
+                // If it’s already a dotted path beyond a simple top-level, keep it.
+                if (fld.includes('.'))
+                    return [fld];
+                // Try common subkeys for collections or embedded docs
+                // (kept generic and cheap; adjust if you want a schema-aware expansion).
+                return Array.from(new Set([fld, `${fld}.name`, `${fld}.slug`, `${fld}.title`]));
+            };
+            // Build an OR filter with regex for a set of fields (already expanded)
+            const buildOrFilter = (flds) => {
+                const orClauses = [];
+                for (const f of flds) {
+                    orClauses.push({ [f]: { $regex: `^${textEsc}`, $options: 'i' } }); // starts-with
+                    orClauses.push({ [f]: { $regex: textEsc, $options: 'i' } }); // contains
+                }
+                return { $or: orClauses };
+            };
+            // Pull values by a dot-path (supports arrays and nested objects) for in-memory fallback
+            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);
+            };
+            // Compute the fields that apply to a given model:
+            // - If a field starts with "<model>.", strip the prefix and use the remainder.
+            // - If a field is a nested path not starting with any requested model prefix (e.g. "districts.name"), keep as-is.
+            // - If a field is a simple key (no dots), keep as-is.
+            const fieldsForModel = (modelNameLC) => {
+                const prefix = modelNameLC + '.';
+                const requestedModelSet = new Set(modelsLC);
+                const out = [];
+                for (const f of fields) {
+                    if (f.startsWith(prefix)) {
+                        out.push(f.slice(prefix.length));
+                    }
+                    else if (f.includes('.')) {
+                        const first = f.split('.')[0];
+                        // If it looks like a model prefix but is NOT this model and IS one of the requested models, skip.
+                        if (requestedModelSet.has(first) && first !== modelNameLC) {
+                            continue;
+                        }
+                        out.push(f); // nested field like "districts.name" or "specialities.slug"
+                    }
+                    else {
+                        out.push(f); // simple top-level field
+                    }
+                }
+                // Expand variants (name/slug/title) for top-level collection fields.
+                return Array.from(new Set(out.flatMap((fld) => expandFieldVariants(fld))));
+            };
+            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 modelFields = fieldsForModel(modelNameLC);
+                    const mongoStyleFilter = buildOrFilter(modelFields);
+                    const useAdapter = typeof adapterAny.findMany === 'function' &&
+                        typeof schema?.modelName === 'string';
+                    if (useAdapter) {
+                        // Adapter branch — passes dot-paths directly (Mongo-like)
+                        items = await adapterAny.findMany(schema.modelName, mongoStyleFilter, { sort: undefined, skip: 0, limit: undefined, projection });
+                    }
+                    else {
+                        // In-memory fallback — evaluate dot paths client-side
+                        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) => modelFields.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);
+                            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;
+                        });
+                    }
+                    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/dist/schemas/Users.json

@@ -22,8 +22,7 @@
     "password": {
       "type": "string",
       "required": true,
-      "private": true,
-      "writeOnly": true
+      "private": true
     },
 
     "profilePicture": [

package/package.json

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