@airoom/nextmin-node 1.4.6 → 2.0.1

package/dist/database/QueryEngine.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from '../models/BaseModel';
+/**
+ * QueryEngine is responsible for parsing and transforming complex filters
+ * into a format that DatabaseAdapters can understand.
+ * It also handles backward compatibility for legacy query parameters.
+ */
+export declare class QueryEngine {
+    /**
+     * Parses legacy query parameters and complex 'where' filters into a unified filter object.
+     */
+    static parse(reqQuery: any, schema: Schema): any;
+    private static getPredicate;
+    private static coerceValue;
+}

package/dist/database/QueryEngine.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryEngine = void 0;
+const utils_1 = require("../api/router/utils");
+/**
+ * QueryEngine is responsible for parsing and transforming complex filters
+ * into a format that DatabaseAdapters can understand.
+ * It also handles backward compatibility for legacy query parameters.
+ */
+class QueryEngine {
+    /**
+     * Parses legacy query parameters and complex 'where' filters into a unified filter object.
+     */
+    static parse(reqQuery, schema) {
+        let filter = {};
+        const RESERVED = new Set([
+            'page', 'limit',
+            'q', 'searchKey', 'searchKeys', 'searchMode', 'searchType', // Legacy Search
+            'dateFrom', 'dateTo', 'dateKey', // Legacy Date Filtering
+            'sort', 'sortType', 'fields', 'where'
+        ]);
+        // 1. Handle Complex 'where' filter (New Architecture)
+        if (reqQuery.where) {
+            try {
+                const where = typeof reqQuery.where === 'string' ? JSON.parse(reqQuery.where) : reqQuery.where;
+                if ((0, utils_1.isPlainObject)(where)) {
+                    Object.assign(filter, where);
+                }
+            }
+            catch (err) {
+                // Ignore invalid JSON in 'where'
+            }
+        }
+        // 2. Handle Legacy Global Search (q)
+        const q = String(reqQuery.q ?? '').trim();
+        if (q) {
+            const terms = (0, utils_1.splitCSV)(q);
+            const searchKey = String(reqQuery.searchKey ?? '').trim();
+            const searchKeysCSV = String(reqQuery.searchKeys ?? '').trim();
+            const searchMode = /^(and|or)$/i.test(String(reqQuery.searchMode ?? ''))
+                ? String(reqQuery.searchMode).toLowerCase()
+                : 'or';
+            const searchType = String(reqQuery.searchType ?? 'starts').toLowerCase();
+            const keys = searchKey ? [searchKey] : (searchKeysCSV ? (0, utils_1.splitCSV)(searchKeysCSV) : Object.keys(schema.attributes));
+            if (searchMode === 'and') {
+                const termPreds = terms.map(t => {
+                    const keyors = keys.map(k => this.getPredicate(k, t, schema, searchType)).filter(Boolean);
+                    if (keyors.length === 0)
+                        return null;
+                    if (keyors.length === 1)
+                        return keyors[0];
+                    return { $or: keyors };
+                }).filter(Boolean);
+                if (termPreds.length === 1) {
+                    Object.assign(filter, termPreds[0]);
+                }
+                else if (termPreds.length > 1) {
+                    // Try to merge into root if no keys collide and no $ operators at top-level
+                    let canMerge = true;
+                    const allKeys = new Set();
+                    for (const p of termPreds) {
+                        const pk = Object.keys(p);
+                        if (pk.length !== 1 || pk[0].startsWith('$') || allKeys.has(pk[0])) {
+                            canMerge = false;
+                            break;
+                        }
+                        allKeys.add(pk[0]);
+                    }
+                    if (canMerge) {
+                        termPreds.forEach(p => Object.assign(filter, p));
+                    }
+                    else {
+                        filter.$and = [...(filter.$and || []), ...termPreds];
+                    }
+                }
+            }
+            else {
+                const ors = [];
+                terms.forEach(t => {
+                    keys.forEach(k => {
+                        const p = this.getPredicate(k, t, schema, searchType);
+                        if (p)
+                            ors.push(p);
+                    });
+                });
+                if (ors.length) {
+                    if (ors.length === 1)
+                        Object.assign(filter, ors[0]);
+                    else
+                        filter.$or = [...(filter.$or || []), ...ors];
+                }
+            }
+        }
+        // 3. Handle Legacy Date Filters
+        const dateFrom = reqQuery.dateFrom;
+        const dateTo = reqQuery.dateTo;
+        if (dateFrom || dateTo) {
+            const dateKey = String(reqQuery.dateKey ?? 'createdAt').trim();
+            if (schema.attributes[dateKey]) {
+                const range = {};
+                if (dateFrom)
+                    range.$gte = new Date(dateFrom);
+                if (dateTo)
+                    range.$lte = new Date(dateTo);
+                filter[dateKey] = range;
+            }
+        }
+        // 4. Handle Legacy Shallow Field Filters
+        for (const [k, vRaw] of Object.entries(reqQuery)) {
+            if (RESERVED.has(k))
+                continue;
+            let effectiveKey = k;
+            let attr = schema.attributes[k];
+            // Support dotted paths in shallow filters (e.g. specialities.id)
+            if (!attr && k.includes('.')) {
+                const parts = k.split('.');
+                const root = parts[0];
+                const rootAttr = schema.attributes[root];
+                if (rootAttr) {
+                    const a = Array.isArray(rootAttr) ? rootAttr[0] : rootAttr;
+                    if (a.ref && (parts[parts.length - 1] === 'id' || parts[parts.length - 1] === '_id')) {
+                        effectiveKey = root;
+                        attr = rootAttr;
+                    }
+                }
+            }
+            if (!attr)
+                continue;
+            const v = Array.isArray(vRaw) ? vRaw.map(String).join(',') : String(vRaw);
+            if (!v?.length)
+                continue;
+            if (v.includes(',')) {
+                filter[effectiveKey] = { $in: v.split(',').map(s => this.coerceValue(s.trim())) };
+            }
+            else if (v.startsWith('!')) {
+                filter[effectiveKey] = { $ne: this.coerceValue(v.slice(1)) };
+            }
+            else if (/^(gt|gte|lt|lte):/i.test(v)) {
+                const [op, rest] = v.split(':', 2);
+                const map = { gt: '$gt', gte: '$gte', lt: '$lt', lte: '$lte' };
+                filter[effectiveKey] = { [map[op.toLowerCase()]]: this.coerceValue(rest) };
+            }
+            else {
+                filter[effectiveKey] = this.coerceValue(v);
+            }
+        }
+        return filter;
+    }
+    static getPredicate(key, value, schema, searchType = 'starts') {
+        let effectiveKey = key;
+        // Handle ModelName.field prefix
+        if (effectiveKey.includes('.')) {
+            const parts = effectiveKey.split('.');
+            if (parts[0].toLowerCase() === schema.modelName.toLowerCase()) {
+                effectiveKey = parts.slice(1).join('.');
+            }
+        }
+        // Support direct id/_id search
+        if (effectiveKey === 'id' || effectiveKey === '_id') {
+            return { [effectiveKey]: value };
+        }
+        // Handle dotted paths for relations (e.g. specialities.id -> specialities: value)
+        if (effectiveKey.includes('.')) {
+            const [root, ...rest] = effectiveKey.split('.');
+            const attr = schema.attributes[root];
+            if (attr) {
+                const a = Array.isArray(attr) ? attr[0] : attr;
+                const suffix = rest.join('.');
+                if (a.ref && (suffix === 'id' || suffix === '_id')) {
+                    return { [root]: value };
+                }
+            }
+        }
+        const attr = schema.attributes[effectiveKey];
+        if (!attr)
+            return null;
+        const type = (0, utils_1.normalizeAttrType)(attr);
+        // Handle reference fields with searchBy or show
+        const a = Array.isArray(attr) ? attr[0] : attr;
+        if (a.ref && (a.searchBy || a.show)) {
+            return {
+                [effectiveKey]: {
+                    $nestedSearch: {
+                        ref: a.ref,
+                        searchBy: a.searchBy,
+                        show: a.show,
+                        value: value
+                    }
+                }
+            };
+        }
+        if (type === 'string' || type === 'json' || type === 'array' || type === 'object') {
+            const anchoredValue = (searchType === 'includes' || value.startsWith('^')) ? value : `^${value}`;
+            return { [effectiveKey]: { $regex: anchoredValue, $options: 'i' } };
+        }
+        else if (type === 'objectid') {
+            return { [effectiveKey]: value };
+        }
+        else if (type === 'number' && !isNaN(Number(value))) {
+            return { [effectiveKey]: Number(value) };
+        }
+        return null;
+    }
+    static coerceValue(raw) {
+        const s = String(raw).trim();
+        if (/^(true|false)$/i.test(s))
+            return /^true$/i.test(s);
+        if (/^-?\d+(\.\d+)?$/.test(s))
+            return Number(s);
+        if (/^null$/i.test(s))
+            return null;
+        return s;
+    }
+}
+exports.QueryEngine = QueryEngine;

package/dist/database/utils.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from '../models/BaseModel';
+export declare function isExclusiveProjection(projection: Record<string, 0 | 1> | undefined, schema: Schema | undefined): boolean;

package/dist/database/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExclusiveProjection = isExclusiveProjection;
+function isExclusiveProjection(projection, schema) {
+    if (!projection)
+        return false;
+    return Object.keys(projection).some(k => {
+        if (k.includes('.') || k === 'id' || k === '_id' || k === 'baseId' || k === 'exId' || k === '__childId')
+            return false;
+        if (schema) {
+            const attr = schema.attributes[k];
+            if (!attr)
+                return true; // Root field not in attributes (e.g. fullName) -> Exclusive mode
+            const a = Array.isArray(attr) ? attr[0] : attr;
+            const isRelation = String(a?.type || '').toLowerCase() === 'objectid';
+            if (isRelation)
+                return false;
+        }
+        return true;
+    });
+}

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import { APIRouterOptions } from './api/apiRouter';
-export { MongoAdapter } from './database/MongoAdapter';
+/** @deprecated Use NMAdapter instead */
+export { NMAdapter } from './database/NMAdapter';
+export { QueryEngine } from './database/QueryEngine';
+export { events, Events } from './utils/Events';
 export { generateApiKey } from './utils/apiKey';
 export * from './files/FileStorageAdapter';
 export * from './files/S3FileStorageAdapter';

package/dist/index.js

@@ -17,13 +17,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateApiKey = exports.MongoAdapter = void 0;
+exports.generateApiKey = exports.Events = exports.events = exports.QueryEngine = exports.NMAdapter = void 0;
 exports.createNextMinRouter = createNextMinRouter;
 const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const apiRouter_1 = require("./api/apiRouter");
-var MongoAdapter_1 = require("./database/MongoAdapter");
-Object.defineProperty(exports, "MongoAdapter", { enumerable: true, get: function () { return MongoAdapter_1.MongoAdapter; } });
+/** @deprecated Use NMAdapter instead */
+var NMAdapter_1 = require("./database/NMAdapter");
+Object.defineProperty(exports, "NMAdapter", { enumerable: true, get: function () { return NMAdapter_1.NMAdapter; } });
+var QueryEngine_1 = require("./database/QueryEngine");
+Object.defineProperty(exports, "QueryEngine", { enumerable: true, get: function () { return QueryEngine_1.QueryEngine; } });
+var Events_1 = require("./utils/Events");
+Object.defineProperty(exports, "events", { enumerable: true, get: function () { return Events_1.events; } });
+Object.defineProperty(exports, "Events", { enumerable: true, get: function () { return Events_1.Events; } });
 var apiKey_1 = require("./utils/apiKey");
 Object.defineProperty(exports, "generateApiKey", { enumerable: true, get: function () { return apiKey_1.generateApiKey; } });
 __exportStar(require("./files/FileStorageAdapter"), exports);
@@ -65,8 +71,8 @@ function createNextMinRouter(options) {
         // Allow non-mutating methods and preflight
         if (!['POST', 'PUT', 'PATCH'].includes(req.method))
             return next();
-        // Never block /files (multer needs to see raw multipart)
-        if (req.path.startsWith('/files') || isMultipart(req))
+        // Never block /files (multer needs to see raw multipart) or /_cleanup (trigger action)
+        if (req.path.startsWith('/files') || req.path === '/_cleanup' || isMultipart(req))
             return next();
         // Enforce body presence only for JSON or urlencoded
         const mustHaveBody = isJson(req) || isUrlEncoded(req);

package/dist/models/BaseModel.d.ts

@@ -4,6 +4,7 @@ export type SortSpec = Record<string, SortDir>;
 export type ReadOptions = {
     sort?: SortSpec;
     projection?: Record<string, 0 | 1>;
+    depth?: number;
 };
 export interface Attributes {
     type: string;
@@ -14,9 +15,21 @@ export interface Attributes {
     select?: string[];
     private?: boolean;
     unique?: boolean;
+    sparse?: boolean;
     sensitive?: boolean;
     writeOnly?: boolean;
     rich?: boolean;
+    searchBy?: string;
+    show?: string;
+}
+export interface CustomAction {
+    label: string;
+    href: string;
+    icon?: string;
+    variant?: 'light' | 'flat' | 'solid' | 'bordered';
+    color?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    relatedModel?: string;
+    relatedField?: string;
 }
 export interface Schema {
     modelName: string;
@@ -32,6 +45,8 @@ export interface Schema {
         delete?: boolean;
     };
     extends?: string;
+    actions?: CustomAction[];
+    access?: any;
 }
 export declare class BaseModel {
     private schema;
@@ -43,4 +58,5 @@ export declare class BaseModel {
     update(id: string, data: any, includePrivateFields?: boolean): 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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseModel = void 0;
+const Events_1 = require("../utils/Events");
 class BaseModel {
     constructor(schema, adapter) {
         this.schema = schema;
@@ -8,24 +9,51 @@ class BaseModel {
         this.collectionName = schema.modelName.toLowerCase();
     }
     async create(data, includePrivateFields) {
+        const payload = { modelName: this.schema.modelName, data };
+        Events_1.events.emitEvent(Events_1.Events.BEFORE_CREATE, payload);
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'create', 'before'), payload);
         for (const [key, attr] of Object.entries(this.schema.attributes)) {
             if (data[key] === undefined && attr.default !== undefined) {
                 data[key] = attr.default;
             }
         }
-        return await this.adapter.create(this.collectionName, data, this.schema, includePrivateFields);
+        const result = await this.adapter.create(this.collectionName, data, this.schema, includePrivateFields);
+        Events_1.events.emitEvent(Events_1.Events.AFTER_CREATE, { ...payload, result });
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'create', 'after'), { ...payload, result });
+        return result;
     }
     async read(query, limit, skip, includePrivateFields, options) {
-        return await this.adapter.read(this.collectionName, query, limit, skip, this.schema, includePrivateFields, options);
+        const payload = { modelName: this.schema.modelName, query, limit, skip, options };
+        Events_1.events.emitEvent(Events_1.Events.BEFORE_READ, payload);
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'read', 'before'), payload);
+        const result = await this.adapter.read(this.collectionName, query, limit, skip, this.schema, includePrivateFields, options);
+        Events_1.events.emitEvent(Events_1.Events.AFTER_READ, { ...payload, result });
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'read', 'after'), { ...payload, result });
+        return result;
     }
     async update(id, data, includePrivateFields) {
-        return await this.adapter.update(this.collectionName, id, data, this.schema, includePrivateFields);
+        const payload = { modelName: this.schema.modelName, id, data };
+        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 });
+        return result;
     }
     async delete(id, includePrivateFields) {
-        return await this.adapter.delete(this.collectionName, id, this.schema, includePrivateFields);
+        const payload = { modelName: this.schema.modelName, id };
+        Events_1.events.emitEvent(Events_1.Events.BEFORE_DELETE, payload);
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'delete', 'before'), payload);
+        const result = await this.adapter.delete(this.collectionName, id, this.schema, includePrivateFields);
+        Events_1.events.emitEvent(Events_1.Events.AFTER_DELETE, { ...payload, result });
+        Events_1.events.emitEvent((0, Events_1.getModelEvent)(this.schema.modelName, 'delete', 'after'), { ...payload, result });
+        return result;
     }
     async count(query, includePrivateFields) {
         return await this.adapter.count(this.collectionName, query, this.schema, includePrivateFields);
     }
+    async findFirstRelatedIds(field, ids) {
+        return await this.adapter.findFirstRelatedIds(this.collectionName, field, ids);
+    }
 }
 exports.BaseModel = BaseModel;