@airoom/nextmin-node 0.1.0

package/dist/utils/DefaultDataInitializer.js

@@ -0,0 +1,269 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDataInitializer = void 0;
+const Logger_1 = __importDefault(require("./Logger"));
+const apiKey_1 = require("./apiKey");
+const bcrypt_1 = __importDefault(require("bcrypt"));
+const DEFAULT_ROLES = [
+    {
+        name: 'superadmin',
+        description: 'Super administrator with all privileges',
+        type: 'system',
+    },
+    {
+        name: 'admin',
+        description: 'Administrator with elevated privileges',
+        type: 'system',
+    },
+    {
+        name: 'user',
+        description: 'Regular user with limited privileges',
+        type: 'system',
+    },
+];
+// Keep your env override as requested
+const DEFAULT_SITE_NAME = process.env.siteName || 'NextMin';
+const DEFAULT_SITE_LOGO_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="512" height="128" viewBox="0 0 512 128" role="img" aria-label="NextMin">
+  <rect width="100%" height="100%" rx="16" ry="16" fill="#0B1220"/>
+  <text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle"
+        font-family="Inter, ui-sans-serif, system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial"
+        font-size="48" font-weight="700" letter-spacing="1">
+    <tspan fill="#22d3ee">Next</tspan><tspan fill="#a78bfa">Min</tspan>
+  </text>
+</svg>`;
+class DefaultDataInitializer {
+    constructor(dbAdapter, models, opts) {
+        this.dbAdapter = dbAdapter;
+        this.models = models;
+        this.apiKey = null;
+        this.jwtSecret =
+            opts?.jwtSecret ?? (process.env.JWT_SECRET || 'default_jwt_secret');
+    }
+    getApiKey() {
+        return this.apiKey;
+    }
+    async initialize() {
+        await this.ensureRoles();
+        await this.ensureSuperAdminUser();
+        await this.ensureSettingsDocument(); // <-- unified for new schema
+    }
+    /* ---------------- helpers ---------------- */
+    getModel(...candidates) {
+        for (const raw of candidates) {
+            const key = raw.toLowerCase();
+            if (this.models[key])
+                return this.models[key];
+        }
+        for (const key of Object.keys(this.models)) {
+            if (candidates.some((c) => key === c.toLowerCase() || key.startsWith(c.toLowerCase()))) {
+                return this.models[key];
+            }
+        }
+        return null;
+    }
+    inferUserRoleStorage(userModel) {
+        try {
+            const roleAttr = userModel?.schema?.attributes?.role;
+            const a = Array.isArray(roleAttr) ? roleAttr?.[0] : roleAttr;
+            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') {
+                const tl = t.toLowerCase();
+                if (tl === 'string')
+                    return 'string';
+                if (tl === 'objectid' || tl === 'oid' || tl === 'ref')
+                    return 'ref';
+            }
+        }
+        catch { }
+        return 'string';
+    }
+    async ensureHash(plain) {
+        const salt = await bcrypt_1.default.genSalt(10);
+        return bcrypt_1.default.hash(plain + this.jwtSecret, salt);
+    }
+    /* ---------------- roles ---------------- */
+    async ensureRoles() {
+        const roleModel = this.getModel('roles', 'role');
+        if (!roleModel) {
+            Logger_1.default.warn('DefaultDataInitializer', 'Roles model not found, skipping roles initialization.');
+            return;
+        }
+        for (const role of DEFAULT_ROLES) {
+            const exists = await roleModel.read({ name: role.name }, 1, 0);
+            if (!exists?.length) {
+                try {
+                    await roleModel.create({ ...role });
+                    Logger_1.default.info('DefaultDataInitializer', `Role created: ${role.name}`);
+                }
+                catch (err) {
+                    Logger_1.default.error('DefaultDataInitializer', `Failed to create role ${role.name}:`, err);
+                }
+            }
+        }
+    }
+    /* ---------------- superadmin user ---------------- */
+    async ensureSuperAdminUser() {
+        const userModel = this.getModel('users', 'user');
+        if (!userModel) {
+            Logger_1.default.warn('DefaultDataInitializer', 'Users model not found, skipping superadmin init.');
+            return;
+        }
+        const roleModel = this.getModel('roles', 'role');
+        const roleStorage = this.inferUserRoleStorage(userModel);
+        let superRoleId = null;
+        if (roleStorage === 'ref') {
+            if (!roleModel) {
+                Logger_1.default.error('DefaultDataInitializer', 'Roles model missing; cannot seed super user with ref role.');
+                return;
+            }
+            const superRole = (await roleModel.read({ name: 'superadmin' }, 1, 0))?.[0];
+            superRoleId = superRole?.id ?? superRole?._id ?? null;
+            if (!superRoleId) {
+                Logger_1.default.error('DefaultDataInitializer', 'Superadmin role missing; cannot seed super user (ref role).');
+                return;
+            }
+        }
+        const email = 'super@example.com';
+        const username = 'superadmin';
+        const lower = email.toLowerCase();
+        const foundByEmail = (await userModel.read({ email: lower }, 1, 0, true))?.[0];
+        const foundByUsername = (await userModel.read({ username }, 1, 0, true))?.[0];
+        const user = foundByEmail || foundByUsername;
+        const roleValue = roleStorage === 'ref' ? superRoleId : 'superadmin';
+        if (!user) {
+            const password = await this.ensureHash('supersecurepassword');
+            const payload = {
+                username,
+                email: lower,
+                firstName: 'Super',
+                lastName: 'Admin',
+                password,
+                role: roleValue,
+                status: 'active',
+                type: 'system',
+                createdAt: new Date().toISOString(),
+            };
+            try {
+                await userModel.create(payload);
+                Logger_1.default.info('DefaultDataInitializer', 'Super admin user created.');
+            }
+            catch (err) {
+                Logger_1.default.error('DefaultDataInitializer', 'Failed to create super admin user:', err);
+            }
+            return;
+        }
+        const updates = {};
+        if (user.email !== lower)
+            updates.email = lower;
+        const existingRoleRaw = user.role;
+        const existingRoleName = typeof existingRoleRaw === 'string'
+            ? existingRoleRaw
+            : (existingRoleRaw?.name ?? null);
+        const existingRoleId = typeof existingRoleRaw === 'object'
+            ? (existingRoleRaw?.id ?? existingRoleRaw?._id ?? null)
+            : null;
+        const hasCorrectRole = roleStorage === 'string'
+            ? existingRoleRaw === 'superadmin' || existingRoleName === 'superadmin'
+            : existingRoleId === superRoleId || existingRoleRaw === superRoleId;
+        if (!hasCorrectRole)
+            updates.role = roleValue;
+        if (user.status !== 'active')
+            updates.status = 'active';
+        const ok = user.password
+            ? await bcrypt_1.default.compare('supersecurepassword' + this.jwtSecret, user.password)
+            : false;
+        if (!ok) {
+            updates.password = await this.ensureHash('supersecurepassword');
+        }
+        if (Object.keys(updates).length) {
+            try {
+                await userModel.update(user.id ?? user._id, updates);
+                Logger_1.default.info('DefaultDataInitializer', 'Super admin user normalized/updated.');
+            }
+            catch (err) {
+                Logger_1.default.error('DefaultDataInitializer', 'Failed to update super admin user:', err);
+            }
+        }
+        else {
+            Logger_1.default.info('DefaultDataInitializer', 'Super admin user already OK.');
+        }
+    }
+    /* ---------------- unified Settings (new schema) ---------------- */
+    async ensureSettingsDocument() {
+        const settingsModel = this.getModel('settings', 'setting');
+        if (!settingsModel) {
+            Logger_1.default.warn('DefaultDataInitializer', 'Settings model not found; skipping settings initialization.');
+            return;
+        }
+        // Read (singleton)
+        let doc = (await settingsModel.read({}, 1, 0, true))?.[0];
+        // Figure out desired values
+        const generatedApiKey = process.env.NEXTMIN_API_KEY || (0, apiKey_1.generateApiKey)();
+        const desiredSiteName = DEFAULT_SITE_NAME;
+        const desiredSiteLogoArr = [DEFAULT_SITE_LOGO_SVG]; // schema says array of string
+        // Create if missing
+        if (!doc) {
+            try {
+                const payload = {
+                    apiKey: generatedApiKey,
+                    siteName: desiredSiteName,
+                    siteLogo: desiredSiteLogoArr,
+                };
+                const created = await settingsModel.create(payload);
+                // ensure we keep in-memory api key
+                this.apiKey = payload.apiKey;
+                Logger_1.default.info('DefaultDataInitializer', 'Settings document created.');
+                return;
+            }
+            catch (err) {
+                Logger_1.default.error('DefaultDataInitializer', 'Failed to create Settings document:', err);
+                // still store generated in memory for server use
+                this.apiKey = generatedApiKey;
+                return;
+            }
+        }
+        // Update only missing/empty fields (do not overwrite existing values)
+        const updates = {};
+        // apiKey
+        if (doc.apiKey && String(doc.apiKey).trim().length > 0) {
+            this.apiKey = doc.apiKey; // honor existing
+        }
+        else {
+            updates.apiKey = generatedApiKey;
+            this.apiKey = generatedApiKey;
+        }
+        // siteName
+        if (!doc.siteName || String(doc.siteName).trim().length === 0) {
+            updates.siteName = desiredSiteName;
+        }
+        // siteLogo (array of strings). If absent or empty, seed with default SVG.
+        const siteLogoArray = doc.siteLogo;
+        const hasValidLogo = Array.isArray(siteLogoArray) &&
+            siteLogoArray.length > 0 &&
+            typeof siteLogoArray[0] === 'string' &&
+            String(siteLogoArray[0]).trim().length > 0;
+        if (!hasValidLogo) {
+            updates.siteLogo = desiredSiteLogoArr;
+        }
+        if (Object.keys(updates).length) {
+            try {
+                await settingsModel.update(doc.id ?? doc._id, updates);
+                Logger_1.default.info('DefaultDataInitializer', 'Settings document normalized/updated.');
+            }
+            catch (err) {
+                Logger_1.default.error('DefaultDataInitializer', 'Failed to update Settings document:', err);
+            }
+        }
+        else {
+            Logger_1.default.info('DefaultDataInitializer', 'Settings document already OK.');
+        }
+    }
+}
+exports.DefaultDataInitializer = DefaultDataInitializer;

package/dist/utils/Logger.d.ts

@@ -0,0 +1,12 @@
+export declare class Logger {
+    private isDevelopment;
+    constructor();
+    private getCallerInfo;
+    private formatMessage;
+    log(label: string, ...messages: any[]): void;
+    info(label: string, ...messages: any[]): void;
+    warn(label: string, ...messages: any[]): void;
+    error(label: string, ...messages: any[]): void;
+}
+declare const logger: Logger;
+export default logger;

package/dist/utils/Logger.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const kleur_1 = __importDefault(require("kleur"));
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+class Logger {
+    constructor() {
+        const env = process.env.NODE_ENV || 'development';
+        this.isDevelopment = env === 'development';
+    }
+    getCallerInfo() {
+        const originalPrepareStackTrace = Error.prepareStackTrace;
+        Error.prepareStackTrace = (err, stack) => stack;
+        const err = new Error();
+        Error.captureStackTrace(err, this.getCallerInfo);
+        const stack = err.stack;
+        Error.prepareStackTrace = originalPrepareStackTrace;
+        // Find the first stack frame outside of Logger class and this function
+        const callerFrame = stack.find((frame) => frame.getFileName() &&
+            !frame.getFileName()?.includes('Logger.ts') &&
+            !frame.getFunctionName()?.includes('getCallerInfo'));
+        if (!callerFrame) {
+            return 'unknown:0:0';
+        }
+        const fileName = path_1.default.relative(process.cwd(), callerFrame.getFileName() || 'unknown');
+        const lineNumber = callerFrame.getLineNumber() || 0;
+        const columnNumber = callerFrame.getColumnNumber() || 0;
+        return `${fileName}:${lineNumber}:${columnNumber}`;
+    }
+    formatMessage(level, label, messages) {
+        const callerInfo = this.getCallerInfo();
+        let formattedLabel = '';
+        switch (level) {
+            case 'LOG':
+                formattedLabel = kleur_1.default.black(`[LOG] ${label} (${callerInfo}):`);
+                break;
+            case 'INFO':
+                formattedLabel = kleur_1.default.cyan(`[INFO] ${label} (${callerInfo}):`);
+                break;
+            case 'WARN':
+                formattedLabel = kleur_1.default.yellow(`[WARN] ${label} (${callerInfo}):`);
+                break;
+            case 'ERROR':
+                formattedLabel = kleur_1.default.red(`[ERROR] ${label} (${callerInfo}):`);
+                break;
+            default:
+                formattedLabel = `[${level}] ${label} (${callerInfo}):`;
+        }
+        const formattedMessage = (0, util_1.format)(...messages);
+        return `${formattedLabel} ${formattedMessage}`;
+    }
+    log(label, ...messages) {
+        if (this.isDevelopment) {
+            const formatted = this.formatMessage('LOG', label, messages);
+            console.log(formatted);
+        }
+    }
+    info(label, ...messages) {
+        if (this.isDevelopment) {
+            const formatted = this.formatMessage('INFO', label, messages);
+            console.info(formatted);
+        }
+    }
+    warn(label, ...messages) {
+        const formatted = this.formatMessage('WARN', label, messages);
+        console.warn(formatted);
+    }
+    error(label, ...messages) {
+        const formatted = this.formatMessage('ERROR', label, messages);
+        console.error(formatted);
+    }
+}
+exports.Logger = Logger;
+const logger = new Logger();
+exports.default = logger;

package/dist/utils/SchemaLoader.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from '../models/BaseModel';
+import { FieldIndexSpec } from '../database/DatabaseAdapter';
+type PublicAttributes = Record<string, any>;
+type PublicSchema = Omit<Schema, 'attributes'> & {
+    modelName: string;
+    attributes: PublicAttributes;
+    allowedMethods: Schema['allowedMethods'];
+};
+export declare class SchemaLoader {
+    private emitter;
+    schemas: {
+        [key: string]: Schema;
+    };
+    private isDevelopment;
+    private nonOverridableSchemas;
+    private userSchemasDir;
+    private packageSchemasDir;
+    private watcher;
+    private static _instance;
+    static getInstance(): SchemaLoader;
+    constructor();
+    private setupHotReload;
+    private handleFileChange;
+    on(event: 'schemasChanged', listener: (schemas: {
+        [key: string]: Schema;
+    }) => void): void;
+    private loadSchemas;
+    private processSchemas;
+    private loadSchemasFromDirectory;
+    private mergeAttributes;
+    getSchemas(): {
+        [key: string]: Schema;
+    };
+    /** CLIENT/API: sanitized map with private attributes removed */
+    getPublicSchemas(): Record<string, PublicSchema>;
+    /** CLIENT/API convenience: array of { modelName, attributes, allowedMethods } */
+    getPublicSchemaList(): Array<PublicSchema>;
+    /** Strip any attr marked private; also remove the `private` flag from others */
+    /** Keep private/sensitive flags so the UI and policy layer can decide.
+     *  We only shallow-clone values to avoid leaking references.
+     */
+    private sanitizeAttributes;
+    closeWatcher(): void;
+    private coerceIndexDir;
+    /** Build desired single-field indexes per model from schemas.
+     *  - respects attribute.index (true|1|-1|'asc'|'desc')
+     *  - always adds createdAt/updatedAt (desc) to help common sorts.
+     */
+    getIndexPlan(): Record<string, FieldIndexSpec>;
+}
+export {};