@airoom/nextmin-node 0.1.0

package/dist/utils/SchemaLoader.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaLoader = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const Logger_1 = __importDefault(require("./Logger"));
+const events_1 = require("events");
+function validateSchema(obj) {
+    const missing = [];
+    if (!obj.modelName || typeof obj.modelName !== 'string')
+        missing.push('modelName');
+    if (!obj.attributes ||
+        typeof obj.attributes !== 'object' ||
+        Array.isArray(obj.attributes)) {
+        missing.push('attributes');
+    }
+    else {
+        for (const [key, attr] of Object.entries(obj.attributes)) {
+            if (Array.isArray(attr)) {
+                // Each element in the array must be an object with type:string
+                if (attr.length === 0 ||
+                    attr.some((item) => item === null ||
+                        typeof item !== 'object' ||
+                        Array.isArray(item) ||
+                        typeof item.type !== 'string')) {
+                    missing.push(`attributes.${key}[]`);
+                }
+            }
+            else {
+                if (attr === null ||
+                    typeof attr !== 'object' ||
+                    Array.isArray(attr) ||
+                    // @ts-ignore
+                    typeof attr.type !== 'string') {
+                    missing.push(`attributes.${key}.type`);
+                }
+            }
+        }
+    }
+    if (!obj.allowedMethods ||
+        typeof obj.allowedMethods !== 'object' ||
+        Array.isArray(obj.allowedMethods)) {
+        missing.push('allowedMethods');
+    }
+    else {
+        const allowed = obj.allowedMethods;
+        if (typeof allowed.create !== 'boolean' &&
+            typeof allowed.read !== 'boolean' &&
+            typeof allowed.update !== 'boolean' &&
+            typeof allowed.delete !== 'boolean') {
+            missing.push('allowedMethods.(at least one CRUD boolean)');
+        }
+    }
+    return missing;
+}
+class SchemaLoader {
+    // Singleton instance
+    static getInstance() {
+        if (!SchemaLoader._instance) {
+            SchemaLoader._instance = new SchemaLoader();
+        }
+        return SchemaLoader._instance;
+    }
+    constructor() {
+        this.emitter = new events_1.EventEmitter();
+        this.schemas = {};
+        this.isDevelopment = false;
+        this.nonOverridableSchemas = new Set(['User', 'Role']);
+        this.watcher = null; // <-- TS-safe
+        this.isDevelopment = process.env.APP_MODE !== 'production';
+        const baseDir = process.cwd();
+        const basePackageDir = path_1.default.resolve(__dirname, '..');
+        this.packageSchemasDir = path_1.default.join(basePackageDir, 'schemas');
+        this.userSchemasDir = path_1.default.resolve(baseDir, 'schemas');
+        this.loadSchemas();
+        if (this.isDevelopment) {
+            this.setupHotReload();
+        }
+    }
+    setupHotReload() {
+        if (!fs_1.default.existsSync(this.userSchemasDir)) {
+            Logger_1.default.warn(`User schemas directory not found for hot reload: ${this.userSchemasDir}`);
+            return;
+        }
+        Logger_1.default.info(`Watching user schemas directory for hot reload: ${this.userSchemasDir}`);
+        this.watcher = chokidar_1.default.watch(this.userSchemasDir, {
+            persistent: true,
+            ignoreInitial: true,
+            depth: 1,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 100,
+            },
+        });
+        this.watcher
+            .on('add', (filePath) => this.handleFileChange('added', filePath))
+            .on('change', (filePath) => this.handleFileChange('changed', filePath))
+            .on('unlink', (filePath) => this.handleFileChange('removed', filePath));
+    }
+    handleFileChange(type, filePath) {
+        if (!filePath.endsWith('.json'))
+            return;
+        Logger_1.default.info(`Schema file ${type}: ${filePath}`);
+        try {
+            this.loadSchemas();
+            Logger_1.default.info('Schemas hot-reloaded successfully!');
+            this.emitter.emit('schemasChanged', this.getPublicSchemaList());
+        }
+        catch (err) {
+            Logger_1.default.error(`Error during schema hot reload for ${filePath}:`, err);
+        }
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    loadSchemas() {
+        const schemas = {};
+        this.loadSchemasFromDirectory(this.packageSchemasDir, schemas, false, true);
+        if (fs_1.default.existsSync(this.userSchemasDir)) {
+            this.loadSchemasFromDirectory(this.userSchemasDir, schemas, true, false);
+        }
+        for (const schema of Object.values(schemas)) {
+            if (schema.extends) {
+                const baseSchema = schemas[schema.extends];
+                if (baseSchema) {
+                    schema.attributes = {
+                        ...baseSchema.attributes,
+                        ...schema.attributes,
+                    };
+                    schema.allowedMethods = {
+                        ...baseSchema.allowedMethods,
+                        ...schema.allowedMethods,
+                    };
+                }
+                else {
+                    throw new Error(`Base schema ${schema.extends} not found for ${schema.modelName}`);
+                }
+            }
+        }
+        this.processSchemas(schemas);
+        if (this.isDevelopment) {
+            Logger_1.default.info('Schemas loaded:', Object.keys(this.schemas).join(', '));
+        }
+    }
+    processSchemas(schemas) {
+        this.schemas = Object.fromEntries(Object.entries(schemas).filter(([_, schema]) => !schema.private));
+    }
+    loadSchemasFromDirectory(directory, schemas, isUserSchema, isPackageSchema) {
+        if (!fs_1.default.existsSync(directory))
+            return;
+        const schemaFiles = fs_1.default
+            .readdirSync(directory)
+            .filter((file) => file.endsWith('.json'));
+        for (const file of schemaFiles) {
+            const schemaPath = path_1.default.join(directory, file);
+            try {
+                const raw = fs_1.default.readFileSync(schemaPath, 'utf-8');
+                const schema = JSON.parse(raw);
+                // VALIDATION
+                const missing = validateSchema(schema);
+                if (missing.length > 0) {
+                    Logger_1.default.info(`Schema at ${schemaPath} is invalid. Missing/invalid fields: ${missing.join(', ')}. Skipping this schema.`);
+                    continue;
+                }
+                const modelName = schema.modelName;
+                if (this.nonOverridableSchemas.has(modelName)) {
+                    if (isPackageSchema) {
+                        schemas[modelName] = schema;
+                    }
+                    else if (isUserSchema) {
+                        // Instead of blocking, MERGE user changes into package default
+                        const base = schemas[modelName];
+                        if (base) {
+                            // shallow merge + attributes deep merge with delete support
+                            const merged = {
+                                ...base,
+                                ...schema,
+                                attributes: this.mergeAttributes(base.attributes, schema.attributes),
+                                allowedMethods: {
+                                    ...base.allowedMethods,
+                                    ...schema.allowedMethods,
+                                },
+                            };
+                            schemas[modelName] = merged;
+                        }
+                        else {
+                            schemas[modelName] = schema;
+                        }
+                    }
+                }
+                else {
+                    // current behavior for other models
+                    if (isUserSchema || !schemas[modelName]) {
+                        schemas[modelName] = schema;
+                    }
+                    else {
+                        Logger_1.default.warn(`Schema for '${modelName}' already exists. Skipping ${schemaPath}.`);
+                    }
+                }
+            }
+            catch (error) {
+                Logger_1.default.error(`Error loading schema file ${schemaPath}:`, error);
+            }
+        }
+    }
+    mergeAttributes(base, patch) {
+        const out = { ...base };
+        for (const [k, v] of Object.entries(patch || {})) {
+            if (v &&
+                typeof v === 'object' &&
+                !Array.isArray(v) &&
+                v.$delete) {
+                delete out[k]; // allow deletions via {"$delete": true}
+                continue;
+            }
+            out[k] = v; // override/relax required/unique/etc.
+        }
+        return out;
+    }
+    getSchemas() {
+        return this.schemas;
+    }
+    /** CLIENT/API: sanitized map with private attributes removed */
+    getPublicSchemas() {
+        const out = {};
+        for (const [name, s] of Object.entries(this.schemas)) {
+            // if (this.nonOverridableSchemas.has(name)) continue;
+            // Clone sanitized attributes and add timestamps
+            const attributesWithTimestamps = {
+                ...this.sanitizeAttributes(s.attributes),
+                createdAt: { type: 'datetime' },
+                updatedAt: { type: 'datetime' },
+            };
+            out[name] = {
+                modelName: s.modelName,
+                allowedMethods: s.allowedMethods,
+                attributes: attributesWithTimestamps,
+            };
+        }
+        return out;
+    }
+    /** CLIENT/API convenience: array of { modelName, attributes, allowedMethods } */
+    getPublicSchemaList() {
+        const pub = this.getPublicSchemas();
+        return Object.values(pub);
+    }
+    /** 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.
+     */
+    sanitizeAttributes(attrs) {
+        const out = {};
+        if (!attrs || typeof attrs !== 'object' || Array.isArray(attrs))
+            return out;
+        for (const [key, attr] of Object.entries(attrs)) {
+            // Array attributes (e.g., relations) expect a single descriptor in [0]
+            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 }];
+                }
+                else {
+                    // Fallback: keep as-is
+                    out[key] = attr;
+                }
+                continue;
+            }
+            // Single attribute object
+            if (attr && typeof attr === 'object') {
+                // Keep `private`, `sensitive`, `writeOnly`, etc.
+                out[key] = { ...attr };
+                continue;
+            }
+            // Unexpected primitives — pass through
+            out[key] = attr;
+        }
+        return out;
+    }
+    closeWatcher() {
+        if (this.watcher) {
+            this.watcher.close();
+        }
+    }
+    coerceIndexDir(val) {
+        if (val === true || val === 'asc' || val === 1)
+            return 1;
+        if (val === 'desc' || val === -1)
+            return -1;
+        return null;
+    }
+    /** 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() {
+        const plan = {};
+        for (const [name, s] of Object.entries(this.schemas)) {
+            const spec = {};
+            // from declared attributes
+            const attrs = s.attributes || {};
+            for (const [field, rawAttr] of Object.entries(attrs)) {
+                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.
+            spec.createdAt = spec.createdAt ?? -1;
+            spec.updatedAt = spec.updatedAt ?? -1;
+            plan[name] = spec;
+        }
+        return plan;
+    }
+}
+exports.SchemaLoader = SchemaLoader;

package/dist/utils/apiKey.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates a cryptographically strong API key.
+ * Uses 32 bytes (256 bits) hex string.
+ */
+export declare function generateApiKey(): string;

package/dist/utils/apiKey.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApiKey = generateApiKey;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Generates a cryptographically strong API key.
+ * Uses 32 bytes (256 bits) hex string.
+ */
+function generateApiKey() {
+    return crypto_1.default.randomBytes(32).toString('hex');
+}

package/dist/utils/fieldCodecs.d.ts

@@ -0,0 +1,13 @@
+export type Json = string | number | boolean | null | Json[] | {
+    [k: string]: Json;
+};
+/**
+ * DB-agnostic payload coercion:
+ * - time → "HH:mm"
+ * - date → "YYYY-MM-DD" (or "YYYY-MM-DDTHH:mm" when withTime)
+ * - range(timeOnly) → "HH:mm..HH:mm"
+ * - range(date[/time]) → "YYYY-MM-DD[..THH:mm]..YYYY-MM-DD[..THH:mm]"
+ */
+export declare function coerceForStorage(modelSchema: {
+    attributes: Record<string, any>;
+}, payload: Record<string, any>): Record<string, Json>;

package/dist/utils/fieldCodecs.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceForStorage = coerceForStorage;
+function toTimeString(v) {
+    if (v == null)
+        return '';
+    let s = String(v).trim();
+    // 930 / 1530 → 09:30 / 15:30
+    if (/^\d{3,4}$/.test(s)) {
+        const pad = s.padStart(4, '0');
+        return `${pad.slice(0, 2)}:${pad.slice(2)}`;
+    }
+    // "h:mm AM/PM"
+    const ampm = s.match(/\s*([AaPp][Mm])\s*$/);
+    if (ampm) {
+        const core = s.replace(/\s*[AaPp][Mm]\s*$/, '').trim();
+        const m = core.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+        if (!m)
+            return '';
+        let h = Number(m[1]);
+        const min = Number(m[2]);
+        const isPM = /^[Pp]/.test(ampm[1]);
+        if (isPM && h < 12)
+            h += 12;
+        if (!isPM && h === 12)
+            h = 0;
+        const hh = String(h).padStart(2, '0');
+        const mm = String(min).padStart(2, '0');
+        return `${hh}:${mm}`;
+    }
+    // "H:mm" / "HH:mm" / "HH:mm:ss"
+    const m24 = s.match(/^(\d{1,2}):(\d{2})(?::\d{2})?$/);
+    if (m24) {
+        const hh = String(Number(m24[1])).padStart(2, '0');
+        const mm = String(Number(m24[2])).padStart(2, '0');
+        return `${hh}:${mm}`;
+    }
+    return '';
+}
+function toDateString(v, withTime) {
+    if (v == null)
+        return '';
+    const s = String(v).trim();
+    // Already in target formats
+    if (!withTime && /^\d{4}-\d{2}-\d{2}$/.test(s))
+        return s;
+    if (withTime && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(s))
+        return s;
+    // Try to parse Date-ish strings or epoch numbers
+    const d = new Date(s);
+    if (Number.isFinite(Number(s))) {
+        const n = Number(s);
+        if (n > 0)
+            d.setTime(n);
+    }
+    if (isNaN(d.getTime()))
+        return '';
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    if (!withTime)
+        return `${yyyy}-${mm}-${dd}`;
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mi = String(d.getMinutes()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}T${hh}:${mi}`;
+}
+function toRangeString(v, opts) {
+    if (v == null)
+        return '';
+    // Object {start,end}
+    if (typeof v === 'object' && !Array.isArray(v)) {
+        const anyv = v;
+        const s = anyv?.start ?? '';
+        const e = anyv?.end ?? '';
+        if (opts.timeOnly) {
+            return `${toTimeString(s)}..${toTimeString(e)}`;
+        }
+        return `${toDateString(s, !!opts.withTime)}..${toDateString(e, !!opts.withTime)}`;
+    }
+    // Array [start, end]
+    if (Array.isArray(v)) {
+        const [s, e] = v;
+        if (opts.timeOnly) {
+            return `${toTimeString(s)}..${toTimeString(e)}`;
+        }
+        return `${toDateString(s, !!opts.withTime)}..${toDateString(e, !!opts.withTime)}`;
+    }
+    // String "start..end" (leave as-is, but normalize empties)
+    if (typeof v === 'string') {
+        const [s = '', e = ''] = v.split('..');
+        if (opts.timeOnly)
+            return `${toTimeString(s)}..${toTimeString(e)}`;
+        return `${toDateString(s, !!opts.withTime)}..${toDateString(e, !!opts.withTime)}`;
+    }
+    return '';
+}
+/**
+ * DB-agnostic payload coercion:
+ * - time → "HH:mm"
+ * - date → "YYYY-MM-DD" (or "YYYY-MM-DDTHH:mm" when withTime)
+ * - range(timeOnly) → "HH:mm..HH:mm"
+ * - range(date[/time]) → "YYYY-MM-DD[..THH:mm]..YYYY-MM-DD[..THH:mm]"
+ */
+function coerceForStorage(modelSchema, payload) {
+    const out = { ...payload };
+    for (const [name, attr] of Object.entries(modelSchema.attributes ?? {})) {
+        if (!(name in out))
+            continue;
+        const t = String(attr?.type ?? '').toLowerCase();
+        const withTime = Boolean(attr?.withTime);
+        const timeOnly = Boolean(attr?.timeOnly);
+        const val = out[name];
+        switch (t) {
+            case 'time': {
+                out[name] = toTimeString(val);
+                break;
+            }
+            case 'date':
+            case 'datetime': {
+                out[name] = toDateString(val, withTime);
+                break;
+            }
+            case 'range': {
+                out[name] = toRangeString(val, { timeOnly, withTime });
+                break;
+            }
+            default:
+                // leave as-is
+                break;
+        }
+    }
+    return out;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@airoom/nextmin-node",
+  "version": "0.1.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rm -rf dist && tsc --project tsconfig.json && copyfiles -u 2 \"src/schemas/**/*\" dist/schemas",
+    "watch": "tsc --project tsconfig.json --watch",
+    "prepublishOnly": "npm run build && npm pack --dry-run | (! grep -E '\\bsrc/|\\.map$')"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.864.0",
+    "@aws-sdk/s3-request-presigner": "^3.864.0",
+    "bcrypt": "^6.0.0",
+    "body-parser": "^2.2.0",
+    "chokidar": "^4.0.3",
+    "fast-glob": "^3.3.1",
+    "jsonwebtoken": "^9.0.2",
+    "kleur": "^4.1.5",
+    "mongoose": "^8.17.0",
+    "mongoose-autopopulate": "^1.1.0",
+    "multer": "^2.0.2",
+    "socket.io": "^4.7.5"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^6.0.0",
+    "@types/chokidar": "^2.1.7",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/multer": "^2.0.0",
+    "copyfiles": "^2.4.1",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "tsconfig.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "sourceMap": false
+  },
+  "include": ["src"]
+}