@airoom/nextmin-node 0.1.3 → 0.1.5

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

@@ -136,7 +136,19 @@ class MongoAdapter {
     /** Build a fresh Mongoose schema from our NextMin schema definition. */
     buildMongooseSchema(def) {
         const shape = {};
+        // If this schema extends a base, only include child-own attributes for storage
+        let baseKeys = null;
+        const baseName = def?.extends;
+        if (baseName) {
+            const baseSchema = this.getSchema(baseName);
+            if (baseSchema) {
+                baseKeys = new Set(Object.keys(baseSchema.attributes || {}));
+            }
+        }
         for (const [key, attr] of Object.entries(def.attributes)) {
+            // Exclude base attributes from child storage schema; always allow link field
+            if (baseKeys && key !== 'baseId' && baseKeys.has(key))
+                continue;
             shape[key] = this.mapAttribute(attr);
         }
         const s = new mongoose_1.Schema(shape, { timestamps: true });
@@ -366,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);
@@ -125,16 +125,44 @@ class SchemaLoader {
         }
         for (const schema of Object.values(schemas)) {
             if (schema.extends) {
-                const baseSchema = schemas[schema.extends];
+                const baseName = schema.extends;
+                const baseSchema = schemas[baseName];
                 if (baseSchema) {
-                    schema.attributes = {
+                    // Merge attributes and methods for READ surface
+                    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,
+                        };
+                    }
                 }
                 else {
                     throw new Error(`Base schema ${schema.extends} not found for ${schema.modelName}`);
@@ -262,19 +290,29 @@ class SchemaLoader {
             if (Array.isArray(attr)) {
                 const elem = attr[0];
                 if (elem && typeof elem === 'object') {
-                    // Keep as an array with a single shallow-cloned descriptor, preserving flags like `private`, `sensitive`, `writeOnly`
-                    out[key] = [{ ...elem }];
+                    // If the inner descriptor is private, omit this field entirely from public schema
+                    if (elem.private) {
+                        continue;
+                    }
+                    // Keep as an array with a single shallow-cloned descriptor (without leaking private flag)
+                    const { private: _omit, ...rest } = elem;
+                    out[key] = [{ ...rest }];
                 }
                 else {
-                    // Fallback: keep as-is
+                    // Fallback: keep as-is (no private flag to check)
                     out[key] = attr;
                 }
                 continue;
             }
             // Single attribute object
             if (attr && typeof attr === 'object') {
-                // Keep `private`, `sensitive`, `writeOnly`, etc.
-                out[key] = { ...attr };
+                // If marked private, omit from public schema entirely
+                if (attr.private) {
+                    continue;
+                }
+                // Shallow clone and drop the private flag if present
+                const { private: _omit, ...rest } = attr;
+                out[key] = { ...rest };
                 continue;
             }
             // Unexpected primitives — pass through
@@ -302,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,7 +1,7 @@
 {
   "name": "@airoom/nextmin-node",
-  "version": "0.1.3",
-  "license": "SEE LICENSE IN LICENSE",
+  "version": "0.1.5",
+  "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {