@airoom/nextmin-node 0.1.4 → 0.1.6

package/dist/api/router/utils.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCSV = exports.isPlainObject = void 0;
+exports.normalizeAttrType = normalizeAttrType;
+exports.toIdString = toIdString;
+exports.splitFilterForExtended = splitFilterForExtended;
+exports.splitSortForExtended = splitSortForExtended;
+exports.sortInMemory = sortInMemory;
+exports.matchDoc = matchDoc;
+exports.buildPredicateForField = buildPredicateForField;
+exports.parseSort = parseSort;
+exports.parseQuery = parseQuery;
+exports.extractIds = extractIds;
+exports.refInfoFromAttr = refInfoFromAttr;
+const isPlainObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+exports.isPlainObject = isPlainObject;
+const splitCSV = (raw) => raw.split(",").map(s => s.trim()).filter(Boolean);
+exports.splitCSV = splitCSV;
+function normalizeAttrType(attr) {
+    const a = Array.isArray(attr) ? attr?.[0] : attr;
+    let t = a?.type ?? a;
+    if (typeof t === "function" && t.name)
+        t = t.name;
+    if (t && typeof t === "object" && "name" in t)
+        t = t.name;
+    if (typeof t === "string")
+        t = t.toLowerCase();
+    if (t === "bool")
+        t = "boolean";
+    if (t === "objectid" || t === "oid" || t === "ref")
+        t = "objectid";
+    return String(t || "");
+}
+function toIdString(v) {
+    if (!v)
+        return null;
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "number")
+        return String(v);
+    if (typeof v === "object") {
+        if (typeof v.id === "string")
+            return v.id;
+        if (v._id && typeof v._id.toString === "function")
+            return v._id.toString();
+        if (typeof v._id === "string")
+            return v._id;
+    }
+    return null;
+}
+function splitFilterForExtended(filter, baseKeys) {
+    const walk = (node) => {
+        if (!(0, exports.isPlainObject)(node))
+            return { child: node, base: {} };
+        const outChild = {};
+        const outBase = {};
+        for (const [k, v] of Object.entries(node)) {
+            if (k === "$and" || k === "$or" || k === "$nor") {
+                if (!Array.isArray(v))
+                    continue;
+                const childArr = [];
+                const baseArr = [];
+                for (const sub of v) {
+                    const split = walk(sub);
+                    if (Object.keys(split.child).length)
+                        childArr.push(split.child);
+                    if (Object.keys(split.base).length)
+                        baseArr.push(split.base);
+                }
+                if (childArr.length)
+                    outChild[k] = childArr;
+                if (baseArr.length)
+                    outBase[k] = baseArr;
+                continue;
+            }
+            if (baseKeys.has(k))
+                outBase[k] = v;
+            else
+                outChild[k] = v;
+        }
+        return { child: outChild, base: outBase };
+    };
+    return walk(filter || {});
+}
+function splitSortForExtended(sort, baseKeys) {
+    const child = {};
+    const base = {};
+    for (const [k, dir] of Object.entries(sort || {})) {
+        if (baseKeys.has(k))
+            base[k] = dir;
+        else
+            child[k] = dir;
+    }
+    return { child, base };
+}
+function sortInMemory(rows, sort) {
+    const keys = Object.keys(sort || {});
+    if (!keys.length)
+        return rows;
+    return [...rows].sort((a, b) => {
+        for (const k of keys) {
+            const dir = sort[k];
+            const av = a?.[k];
+            const bv = b?.[k];
+            const ax = av instanceof Date ? +av : (av ?? "");
+            const bx = bv instanceof Date ? +bv : (bv ?? "");
+            if (ax > bx)
+                return dir;
+            if (ax < bx)
+                return -dir;
+        }
+        return 0;
+    });
+}
+function matchDoc(doc, filter) {
+    const evalNode = (node) => {
+        for (const [k, v] of Object.entries(node)) {
+            if (k === "$and" && Array.isArray(v))
+                return v.every((n) => evalNode(n));
+            if (k === "$or" && Array.isArray(v))
+                return v.some((n) => evalNode(n));
+            if (k === "$nor" && Array.isArray(v))
+                return !v.some((n) => evalNode(n));
+            const dv = doc[k];
+            if ((0, exports.isPlainObject)(v)) {
+                if ("$in" in v && !v.$in.includes(dv))
+                    return false;
+                if ("$gte" in v && !(dv >= v.$gte))
+                    return false;
+                if ("$lte" in v && !(dv <= v.$lte))
+                    return false;
+                if ("$regex" in v) {
+                    const re = new RegExp(v.$regex, v.$options || "");
+                    if (!re.test(String(dv ?? "")))
+                        return false;
+                }
+            }
+            else {
+                if (dv !== v)
+                    return false;
+            }
+        }
+        return true;
+    };
+    return evalNode(filter || {});
+}
+function buildPredicateForField(field, attr, raw) {
+    const isArray = Array.isArray(attr);
+    const base = isArray ? attr[0] : attr;
+    const attrType = normalizeAttrType(base);
+    const tokens = (0, exports.splitCSV)(raw);
+    switch (attrType) {
+        case "string":
+            return isArray ? { [field]: { $in: tokens.length ? tokens : [raw] } } : { [field]: { $regex: raw, $options: "i" } };
+        case "number": {
+            const nums = tokens.map(Number).filter((n) => !Number.isNaN(n));
+            return isArray ? (nums.length ? { [field]: { $in: nums } } : null) : (nums.length ? { [field]: nums[0] } : null);
+        }
+        case "boolean": {
+            const toBool = (t) => /^(true|1|yes)$/i.test(t) ? true : /^(false|0|no)$/i.test(t) ? false : null;
+            if (isArray) {
+                const bools = tokens.map(toBool).filter((v) => v !== null);
+                return bools.length ? { [field]: { $in: bools } } : null;
+            }
+            const b = toBool(raw);
+            return b === null ? null : { [field]: b };
+        }
+        case "objectid":
+            return isArray || tokens.length > 1 ? { [field]: { $in: tokens } } : (raw ? { [field]: raw } : null);
+        case "date": {
+            const toDate = (t) => {
+                const d = new Date(t);
+                return Number.isNaN(+d) ? null : d;
+            };
+            if (isArray) {
+                const ds = tokens.map(toDate).filter((d) => !!d);
+                return ds.length ? { [field]: { $in: ds } } : null;
+            }
+            const d = toDate(raw);
+            return d ? { [field]: d } : null;
+        }
+        default:
+            return isArray ? { [field]: { $in: tokens.length ? tokens : [raw] } } : { [field]: raw };
+    }
+}
+function parseSort(expr) {
+    if (!expr)
+        return;
+    const out = {};
+    for (const raw of expr.split(",").map((s) => s.trim()).filter(Boolean)) {
+        if (raw.startsWith("-"))
+            out[raw.slice(1)] = -1;
+        else if (raw.startsWith("+"))
+            out[raw.slice(1)] = 1;
+        else
+            out[raw] = 1;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function parseQuery(req) {
+    const limit = Math.min(parseInt(String(req.query.limit ?? "12"), 10) || 12, 100);
+    const page = Math.max(parseInt(String(req.query.page ?? "1"), 10) || 1, 1);
+    const skip = (page - 1) * limit;
+    const fields = String(req.query.fields ?? "")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const projection = fields.length ? Object.fromEntries(fields.map((f) => [f, 1])) : undefined;
+    const sort = parseSort(String(req.query.sort ?? "-createdAt"));
+    return { limit, page, skip, projection, sort };
+}
+function extractIds(val) {
+    if (val == null)
+        return [];
+    const arr = Array.isArray(val) ? val : [val];
+    const toId = (v) => {
+        if (!v)
+            return null;
+        if (typeof v === "string")
+            return v;
+        if (typeof v === "number")
+            return String(v);
+        if (typeof v === "object") {
+            if (typeof v.id === "string")
+                return v.id;
+            if (v._id && typeof v._id === "string")
+                return v._id;
+            if (v._id && typeof v._id.toString === "function")
+                return v._id.toString();
+        }
+        return null;
+    };
+    return arr.map(toId).filter((s) => !!s);
+}
+function refInfoFromAttr(attr) {
+    if (!attr)
+        return null;
+    if (Array.isArray(attr) && attr[0] && attr[0].ref) {
+        return { ref: String(attr[0].ref), isArray: true };
+    }
+    const a = Array.isArray(attr) ? attr?.[0] : attr;
+    const t = (typeof a?.type === "string" ? a.type : String(a?.type || "")).toLowerCase();
+    if (a?.ref && (t === "objectid" || t === "ref")) {
+        return { ref: String(a.ref), isArray: false };
+    }
+    return null;
+}

package/dist/database/MongoAdapter.d.ts

@@ -48,5 +48,5 @@ export declare class MongoAdapter implements DatabaseAdapter {
      *  Only touches indexes named with the prefix below (won't touch user indexes).
      */
     private managedIndexName;
-    syncIndexes(modelName: string, desired: FieldIndexSpec): Promise<void>;
+    syncIndexes(modelName: string, spec: FieldIndexSpec): Promise<void>;
 }

package/dist/database/MongoAdapter.js

@@ -378,44 +378,33 @@ class MongoAdapter {
     managedIndexName(field) {
         return `nextmin_idx_${field}`;
     }
-    async syncIndexes(modelName, desired) {
+    async syncIndexes(modelName, spec) {
         const col = this.getNativeCollectionByModelName(modelName);
-        // list existing and pick only the ones we manage
-        const existing = await col.indexes();
-        const managed = new Map();
-        for (const ix of existing) {
-            const name = String(ix.name || '');
-            if (name.startsWith('nextmin_idx_')) {
-                managed.set(name, { key: ix.key });
-            }
-        }
-        // desired names from spec
-        const desiredEntries = Object.entries(desired);
-        const desiredNames = new Set(desiredEntries.map(([field]) => this.managedIndexName(field)));
-        // create / recreate if needed
-        for (const [field, dir] of desiredEntries) {
-            const name = this.managedIndexName(field);
-            const have = managed.get(name);
-            const wantKey = { [field]: dir };
-            if (!have || JSON.stringify(have.key) !== JSON.stringify(wantKey)) {
-                if (have) {
-                    try {
-                        await col.dropIndex(name);
-                    }
-                    catch { }
-                }
-                await col.createIndex(wantKey, { name, background: true });
-            }
-        }
-        // drop stale managed indexes
-        for (const name of managed.keys()) {
-            if (!desiredNames.has(name)) {
+        const existing = await col.indexes(); // [{ name, key, unique, sparse, ... }]
+        // desired => only from 'spec'
+        const desired = Object.entries(spec).map(([field, dir]) => ({
+            name: `${field}_${dir === 1 ? 'asc' : 'desc'}`,
+            key: { [field]: dir },
+        }));
+        const desiredNames = new Set(desired.map((d) => d.name));
+        // drop indexes not in desired (except _id_)
+        for (const idx of existing) {
+            if (idx.name === '_id_')
+                continue;
+            if (!desiredNames.has(idx.name)) {
                 try {
-                    await col.dropIndex(name);
+                    await col.dropIndex(idx.name);
                 }
                 catch { }
             }
         }
+        // create missing
+        const existingNames = new Set((await col.indexes()).map((i) => i.name));
+        for (const d of desired) {
+            if (!existingNames.has(d.name)) {
+                await col.createIndex(d.key, { name: d.name });
+            }
+        }
     }
 }
 exports.MongoAdapter = MongoAdapter;

package/dist/schemas/Roles.json

@@ -8,6 +8,11 @@
       "enum": ["system", "default", "user"],
       "default": "user",
       "required": true
+    },
+    "isPublic": {
+      "type": "boolean",
+      "default": false,
+      "index": true
     }
   },
 
@@ -20,8 +25,8 @@
 
   "access": {
     "public": {
-      "create": true,
-      "read": false,
+      "create": false,
+      "read": true,
       "update": false,
       "delete": false
     },

package/dist/utils/DefaultDataInitializer.js

@@ -12,16 +12,19 @@ const DEFAULT_ROLES = [
         name: 'superadmin',
         description: 'Super administrator with all privileges',
         type: 'system',
+        isPublic: false,
     },
     {
         name: 'admin',
         description: 'Administrator with elevated privileges',
         type: 'system',
+        isPublic: false,
     },
     {
         name: 'user',
         description: 'Regular user with limited privileges',
         type: 'system',
+        isPublic: true,
     },
 ];
 // Keep your env override as requested

package/dist/utils/SchemaLoader.js

@@ -108,7 +108,7 @@ class SchemaLoader {
         try {
             this.loadSchemas();
             Logger_1.default.info('Schemas hot-reloaded successfully!');
-            this.emitter.emit('schemasChanged', this.getPublicSchemaList());
+            this.emitter.emit('schemasChanged', this.getSchemas());
         }
         catch (err) {
             Logger_1.default.error(`Error during schema hot reload for ${filePath}:`, err);
@@ -129,23 +129,38 @@ class SchemaLoader {
                 const baseSchema = schemas[baseName];
                 if (baseSchema) {
                     // Merge attributes and methods for READ surface
-                    schema.attributes = {
+                    const mergedAttrs = {
                         ...baseSchema.attributes,
                         ...schema.attributes,
                     };
+                    for (const key of Object.keys(baseSchema.attributes || {})) {
+                        if (key === 'baseId')
+                            continue;
+                        if (Object.prototype.hasOwnProperty.call(mergedAttrs, key)) {
+                            const val = mergedAttrs[key];
+                            if (Array.isArray(val) && val[0] && typeof val[0] === 'object') {
+                                const { unique: _u, index: _i, ...rest } = val[0];
+                                mergedAttrs[key] = [{ ...rest }];
+                            }
+                            else if (val && typeof val === 'object') {
+                                const { unique: _u, index: _i, ...rest } = val;
+                                mergedAttrs[key] = { ...rest };
+                            }
+                        }
+                    }
+                    schema.attributes = mergedAttrs;
                     schema.allowedMethods = {
                         ...baseSchema.allowedMethods,
                         ...schema.allowedMethods,
                     };
                     // Inject hidden link field to base (used for storage join)
+                    // Ensure hidden link field
                     const linkField = 'baseId';
                     if (!schema.attributes[linkField]) {
                         schema.attributes[linkField] = {
                             type: 'ObjectId',
                             ref: baseName,
                             private: true,
-                            // Not required on create; server auto-fills for extended creates.
-                            // Presence is enforced for existing docs on update.
                         };
                     }
                 }
@@ -325,18 +340,24 @@ class SchemaLoader {
         const plan = {};
         for (const [name, s] of Object.entries(this.schemas)) {
             const spec = {};
-            // from declared attributes
+            const baseName = s?.extends;
+            let baseKeys = null;
+            if (baseName && this.schemas[baseName]) {
+                baseKeys = new Set(Object.keys(this.schemas[baseName].attributes || {}));
+            }
             const attrs = s.attributes || {};
             for (const [field, rawAttr] of Object.entries(attrs)) {
+                // Skip base attributes for child collections (except link 'baseId')
+                if (baseKeys && field !== 'baseId' && baseKeys.has(field))
+                    continue;
                 const attr = Array.isArray(rawAttr) ? rawAttr[0] : rawAttr;
                 if (!attr || typeof attr !== 'object')
                     continue;
-                // allow `index` on any attribute
                 const dir = this.coerceIndexDir(attr.index);
                 if (dir)
                     spec[field] = dir;
             }
-            // always add timestamps (desc). Does not require attributes to exist.
+            // Always add timestamps (desc)
             spec.createdAt = spec.createdAt ?? -1;
             spec.updatedAt = spec.updatedAt ?? -1;
             plan[name] = spec;

package/package.json

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