@airoom/nextmin-node 0.1.4 → 0.1.5

package/dist/api/router/mountFindRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { RouterCtx } from "./ctx";
+export declare function mountFindRoutes(ctx: RouterCtx): void;

package/dist/api/router/mountFindRoutes.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountFindRoutes = mountFindRoutes;
+const utils_1 = require("./utils");
+const authorize_1 = require("../../policy/authorize");
+function mountFindRoutes(ctx) {
+    const { router } = ctx;
+    const ctxFromReq = (req) => {
+        const raw = req.user?.role;
+        let roleStr = null;
+        if (typeof raw === "string")
+            roleStr = raw;
+        else if (Array.isArray(raw)) {
+            const first = raw[0];
+            if (typeof first === "string")
+                roleStr = first;
+            else if (first && typeof first === "object" && typeof first.name === "string") {
+                roleStr = first.name;
+            }
+        }
+        else if (raw && typeof raw === "object" && typeof raw.name === "string") {
+            roleStr = raw.name;
+        }
+        roleStr = roleStr ? roleStr.toLowerCase() : null;
+        return {
+            isAuthenticated: !!req.user,
+            role: roleStr,
+            userId: req.user?.id ?? req.user?._id ?? null,
+            isSuperadmin: roleStr === "superadmin",
+            apiKeyOk: true,
+        };
+    };
+    const safeGetContainerRefIDs = async (containerModelLC, id, refField) => {
+        const containerSchema = ctx.getSchema(containerModelLC);
+        const adapterAny = ctx.dbAdapter;
+        if (typeof adapterAny.findOne === "function") {
+            try {
+                const raw = await adapterAny.findOne(containerSchema.modelName, { id }, { projection: { [refField]: 1 } });
+                return (0, utils_1.extractIds)(raw?.[refField]);
+            }
+            catch { }
+        }
+        const containerDoc = (await ctx.getModel(containerModelLC).read({ id }, 1, 0, true))?.[0];
+        return (0, utils_1.extractIds)(containerDoc?.[refField]);
+    };
+    // FORWARD
+    router.get("/find/:container/:refField/:id", ctx.optionalAuthMiddleware, async (req, res) => {
+        try {
+            const containerLC = String(req.params.container || "").toLowerCase();
+            const refField = String(req.params.refField || "");
+            const id = String(req.params.id || "");
+            const schema = ctx.getSchema(containerLC);
+            const attr = schema.attributes?.[refField];
+            const rinfo = (0, utils_1.refInfoFromAttr)(attr);
+            if (!rinfo) {
+                return res.status(400).json({ error: true, message: "refField is not a reference field" });
+            }
+            const { limit, page, skip, projection, sort } = (0, utils_1.parseQuery)(req);
+            const cPolicy = { allowedMethods: schema.allowedMethods, access: schema.access };
+            const cDec = (0, authorize_1.authorize)(containerLC, "read", cPolicy, ctxFromReq(req));
+            if (!cDec.allow)
+                return res.status(403).json({ error: true, message: "forbidden" });
+            const ids = await safeGetContainerRefIDs(containerLC, id, refField);
+            const targetLC = String(rinfo.ref || "").toLowerCase();
+            const targetSchema = ctx.getSchema(targetLC);
+            const tPolicy = { allowedMethods: targetSchema.allowedMethods, access: targetSchema.access };
+            const tDec = (0, authorize_1.authorize)(targetLC, "read", tPolicy, ctxFromReq(req));
+            if (!tDec.allow)
+                return res.status(403).json({ error: true, message: "forbidden" });
+            if (ids.length === 0) {
+                return res.status(200).json({
+                    success: true,
+                    message: `Data fetched for ${targetSchema.modelName}`,
+                    data: [],
+                    pagination: { totalRows: 0, page, limit },
+                });
+            }
+            const adapterAny = ctx.dbAdapter;
+            let items = [];
+            if (typeof adapterAny.findMany === "function") {
+                items = await adapterAny.findMany(targetSchema.modelName, { id: { $in: ids } }, { sort, skip, limit, projection });
+            }
+            else {
+                items = await ctx.getModel(targetLC).read({ id: { $in: ids } }, limit, skip, !!tDec.exposePrivate);
+            }
+            // extended hydration if needed
+            if (targetSchema.extends && Array.isArray(items) && items.length) {
+                const baseName = String(targetSchema.extends);
+                const baseLC = baseName.toLowerCase();
+                const baseModel = ctx.getModel(baseLC);
+                const baseIds = Array.from(new Set(items.map((it) => it?.baseId).filter(Boolean)));
+                if (baseIds.length) {
+                    const baseDocs = await baseModel.read({ id: { $in: baseIds } }, baseIds.length, 0, !!tDec.exposePrivate);
+                    const baseMap = new Map(baseDocs.map((b) => [String(b?.id ?? b?._id), b]));
+                    items = items.map((it) => {
+                        const bid = String(it?.baseId || "");
+                        const b = bid ? baseMap.get(bid) : null;
+                        const merged = b ? { ...b, ...it } : { ...it };
+                        delete merged.baseId;
+                        return merged;
+                    });
+                }
+                else {
+                    items = items.map((it) => {
+                        const copy = { ...it };
+                        delete copy.baseId;
+                        return copy;
+                    });
+                }
+            }
+            const masked = tDec.exposePrivate ? (0, authorize_1.applyReadMaskMany)(items, tDec.sensitiveMask) : (0, authorize_1.applyReadMaskMany)(items, tDec.readMask);
+            const totalRows = ids.length;
+            return res.status(200).json({
+                success: true,
+                message: `Data fetched for ${targetSchema.modelName}`,
+                data: masked,
+                pagination: { totalRows, page, limit },
+            });
+        }
+        catch (err) {
+            if (err?.code === "MODEL_REMOVED") {
+                return res.status(410).json({ error: true, message: err.message });
+            }
+            return res.status(400).json({ error: true, message: err?.message || "Error" });
+        }
+    });
+    // REVERSE
+    router.get("/find/reverse/:target/:byField/:id", ctx.optionalAuthMiddleware, async (req, res) => {
+        try {
+            const targetLC = String(req.params.target || "").toLowerCase();
+            const byField = String(req.params.byField || "");
+            const id = String(req.params.id || "");
+            const targetSchema = ctx.getSchema(targetLC);
+            const attr = targetSchema.attributes?.[byField];
+            const rinfo = (0, utils_1.refInfoFromAttr)(attr);
+            if (!rinfo) {
+                return res.status(400).json({
+                    error: true,
+                    message: "byField is not a reference field",
+                });
+            }
+            const { limit, page, skip, projection, sort } = (0, utils_1.parseQuery)(req);
+            const tPolicy = { allowedMethods: targetSchema.allowedMethods, access: targetSchema.access };
+            const tDec = (0, authorize_1.authorize)(targetLC, "read", tPolicy, ctxFromReq(req));
+            if (!tDec.allow)
+                return res.status(403).json({ error: true, message: "forbidden" });
+            const filter = rinfo.isArray ? { [byField]: { $in: [id] } } : { [byField]: id };
+            const adapterAny = ctx.dbAdapter;
+            let items = [];
+            let totalRows = 0;
+            if (typeof adapterAny.findMany === "function") {
+                items = await adapterAny.findMany(targetSchema.modelName, filter, { sort, skip, limit, projection });
+                if (typeof adapterAny.count === "function") {
+                    totalRows = await adapterAny.count(targetSchema.modelName, filter);
+                }
+                else {
+                    const all = await ctx.getModel(targetLC).read(filter, 0, 0, !!tDec.exposePrivate);
+                    totalRows = all.length;
+                }
+            }
+            else {
+                const all = await ctx.getModel(targetLC).read(filter, 0, 0, !!tDec.exposePrivate);
+                totalRows = all.length;
+                items = all.slice(skip, skip + limit);
+            }
+            if (targetSchema.extends && Array.isArray(items) && items.length) {
+                const baseName = String(targetSchema.extends);
+                const baseLC = baseName.toLowerCase();
+                const baseModel = ctx.getModel(baseLC);
+                const baseIds = Array.from(new Set(items.map((it) => it?.baseId).filter(Boolean)));
+                if (baseIds.length) {
+                    const baseDocs = await baseModel.read({ id: { $in: baseIds } }, baseIds.length, 0, !!tDec.exposePrivate);
+                    const baseMap = new Map(baseDocs.map((b) => [String(b?.id ?? b?._id), b]));
+                    items = items.map((it) => {
+                        const bid = String(it?.baseId || "");
+                        const b = bid ? baseMap.get(bid) : null;
+                        const merged = b ? { ...b, ...it } : { ...it };
+                        delete merged.baseId;
+                        return merged;
+                    });
+                }
+                else {
+                    items = items.map((it) => {
+                        const copy = { ...it };
+                        delete copy.baseId;
+                        return copy;
+                    });
+                }
+            }
+            const masked = tDec.exposePrivate ? (0, authorize_1.applyReadMaskMany)(items, tDec.sensitiveMask) : (0, authorize_1.applyReadMaskMany)(items, tDec.readMask);
+            return res.status(200).json({
+                success: true,
+                message: `Data fetched for ${targetSchema.modelName}`,
+                data: masked,
+                pagination: { totalRows, page, limit },
+            });
+        }
+        catch (err) {
+            if (err?.code === "MODEL_REMOVED") {
+                return res.status(410).json({ error: true, message: err.message });
+            }
+            return res.status(400).json({ error: true, message: err?.message || "Error" });
+        }
+    });
+}

package/dist/api/router/setupAuthRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { RouterCtx } from './ctx';
+export declare function setupAuthRoutes(ctx: RouterCtx): void;

package/dist/api/router/setupAuthRoutes.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupAuthRoutes = setupAuthRoutes;
+const bcrypt_1 = __importDefault(require("bcrypt"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+function setupAuthRoutes(ctx) {
+    const basePath = '/auth/users';
+    // REGISTER
+    ctx.router.post(`${basePath}/register`, ctx.apiKeyMiddleware, async (req, res) => {
+        try {
+            let { email, username, password, ...rest } = req.body;
+            if (String(password).length < 8) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'Password must be at least 8 characters long',
+                });
+            }
+            const userModel = ctx.getModel('users');
+            const usersSchema = ctx.getSchema('users');
+            if (email)
+                email = String(email).trim().toLowerCase();
+            if (username)
+                username = String(username).trim();
+            const data = { ...rest };
+            if (email)
+                data.email = email;
+            if (username)
+                data.username = username;
+            if (data.status == null)
+                data.status = 'pending';
+            if (usersSchema) {
+                const missing = ctx.validateRequiredFields(usersSchema, {
+                    ...data,
+                    password,
+                });
+                if (missing.length > 0) {
+                    return res.status(400).json({
+                        error: true,
+                        message: `Missing required field(s): ${missing.join(', ')}`,
+                    });
+                }
+                const conflicts = await ctx.checkUniqueFields(usersSchema, data);
+                if (conflicts && conflicts.length) {
+                    return res.status(400).json({
+                        error: true,
+                        message: `Duplicate value for field(s): ${conflicts.join(', ')}`,
+                    });
+                }
+            }
+            const salt = await bcrypt_1.default.genSalt(10);
+            const hashed = await bcrypt_1.default.hash(String(password) + ctx.jwtSecret, salt);
+            data.password = hashed;
+            const created = await userModel.create(data);
+            const roleName = (await ctx.normalizeRoleName(created.role)) ?? '';
+            const token = jsonwebtoken_1.default.sign({ id: created.id, role: roleName }, ctx.jwtSecret, { expiresIn: '7days' });
+            delete created.password;
+            return res.json({
+                success: true,
+                message: 'Registration successful.',
+                data: { token, user: created },
+            });
+        }
+        catch (error) {
+            ctx.handleWriteError(error, res);
+        }
+    });
+    // LOGIN
+    ctx.router.post(`${basePath}/login`, ctx.apiKeyMiddleware, async (req, res) => {
+        let { email, username, password } = req.body;
+        if ((!email && !username) || !password) {
+            return res
+                .status(400)
+                .json({
+                error: true,
+                message: 'Email/username and password are required',
+            });
+        }
+        try {
+            const userModel = ctx.getModel('users');
+            const findBy = email
+                ? { email: String(email).trim().toLowerCase() }
+                : { username: String(username).trim() };
+            const users = await userModel.read(findBy, 1, 0, true);
+            const user = users?.[0];
+            if (!user)
+                return res
+                    .status(400)
+                    .json({ error: true, message: 'Invalid credentials' });
+            const hashedPassword = user.password;
+            if (!hashedPassword)
+                return res
+                    .status(400)
+                    .json({ error: true, message: 'User password not set' });
+            const isMatch = await bcrypt_1.default.compare(String(password) + ctx.jwtSecret, hashedPassword);
+            if (!isMatch)
+                return res
+                    .status(400)
+                    .json({ error: true, message: 'Invalid credentials' });
+            const status = user.status;
+            if (status && status !== 'active') {
+                const msg = status === 'pending'
+                    ? 'Your account is awaiting approval.'
+                    : 'Your account is suspended.';
+                return res.status(403).json({ error: true, message: msg });
+            }
+            const roleName = (await ctx.normalizeRoleName(user.role)) ?? '';
+            const token = jsonwebtoken_1.default.sign({ id: user.id, role: roleName }, ctx.jwtSecret, { expiresIn: '7days' });
+            delete user.password;
+            res.json({
+                success: true,
+                message: 'You are successfully logged in.',
+                data: { token, user },
+            });
+        }
+        catch (error) {
+            if (error?.code === 'MODEL_REMOVED')
+                return res.status(410).json({ error: true, message: error.message });
+            res.status(500).json({ error: true, message: error.message });
+        }
+    });
+    // ME
+    ctx.router.get(`${basePath}/me`, ctx.apiKeyMiddleware, ctx.authenticateMiddleware, async (req, res) => {
+        try {
+            const userId = req.user?.id ?? req.user?._id ?? null;
+            if (!userId) {
+                return res
+                    .status(401)
+                    .json({ error: true, message: 'Not authenticated' });
+            }
+            const userModel = ctx.getModel('users');
+            const arr = await userModel.read({ id: userId }, 1, 0, true);
+            const user = arr?.[0];
+            if (!user) {
+                return res
+                    .status(404)
+                    .json({ error: true, message: 'User not found' });
+            }
+            delete user.password;
+            return res.json({ success: true, data: user });
+        }
+        catch (error) {
+            return res
+                .status(400)
+                .json({ error: true, message: error?.message || 'Error' });
+        }
+    });
+    // CHANGE PASSWORD
+    ctx.router.post(`${basePath}/change-password`, ctx.apiKeyMiddleware, ctx.authenticateMiddleware, async (req, res) => {
+        try {
+            const { oldPassword, newPassword } = req.body;
+            if (!oldPassword || !newPassword) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'oldPassword and newPassword are required',
+                });
+            }
+            if (String(newPassword).length < 8) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'New password must be at least 8 characters long',
+                });
+            }
+            if (String(newPassword) === String(oldPassword)) {
+                return res
+                    .status(400)
+                    .json({
+                    error: true,
+                    message: 'New password must be different from old password',
+                });
+            }
+            const userId = req.user?.id ?? req.user?._id ?? null;
+            if (!userId) {
+                return res
+                    .status(401)
+                    .json({ error: true, message: 'Not authenticated' });
+            }
+            const userModel = ctx.getModel('users');
+            const arr = await userModel.read({ id: userId }, 1, 0, true);
+            const user = arr?.[0];
+            if (!user) {
+                return res
+                    .status(404)
+                    .json({ error: true, message: 'User not found' });
+            }
+            const storedHash = user.password;
+            if (!storedHash) {
+                return res
+                    .status(400)
+                    .json({ error: true, message: 'User password not set' });
+            }
+            const match = await bcrypt_1.default.compare(String(oldPassword) + ctx.jwtSecret, storedHash);
+            if (!match) {
+                return res
+                    .status(400)
+                    .json({ error: true, message: 'Old password is incorrect' });
+            }
+            const salt = await bcrypt_1.default.genSalt(10);
+            const newHash = await bcrypt_1.default.hash(String(newPassword) + ctx.jwtSecret, salt);
+            await userModel.update(user.id, { password: newHash });
+            return res.json({
+                success: true,
+                message: 'Password changed successfully.',
+            });
+        }
+        catch (error) {
+            res
+                .status(400)
+                .json({ error: true, message: error?.message || 'Error' });
+        }
+    });
+    // FORGOT PASSWORD
+    const forgotPasswordHandler = async (req, res) => {
+        try {
+            const { email } = (req.body || {});
+            if (!email || !String(email).trim()) {
+                return res
+                    .status(400)
+                    .json({ error: true, message: 'Email is required' });
+            }
+            const normalizedEmail = String(email).trim().toLowerCase();
+            try {
+                const userModel = ctx.getModel('users');
+                await userModel.read({ email: normalizedEmail }, 1, 0, true);
+            }
+            catch { }
+            return res.json({
+                success: true,
+                message: 'If an account exists, reset instructions have been sent.',
+            });
+        }
+        catch (error) {
+            return res
+                .status(400)
+                .json({ error: true, message: error?.message || 'Error' });
+        }
+    };
+    ctx.router.post(`${basePath}/forgot-password`, ctx.apiKeyMiddleware, forgotPasswordHandler);
+}

package/dist/api/router/setupFileRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { RouterCtx } from "./ctx";
+export declare function setupFileRoutes(ctx: RouterCtx): void;

package/dist/api/router/setupFileRoutes.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupFileRoutes = setupFileRoutes;
+const multer_1 = __importDefault(require("multer"));
+const filename_1 = require("../../files/filename");
+function setupFileRoutes(ctx) {
+    if (!ctx.fileStorage)
+        return;
+    const upload = (0, multer_1.default)({
+        storage: multer_1.default.memoryStorage(),
+        limits: { fileSize: 50 * 1024 * 1024, files: 20 },
+    });
+    const fileAuthMiddleware = (req, res, next) => ctx.authenticateMiddleware(req, res, next);
+    ctx.router.post("/files", fileAuthMiddleware, upload.any(), async (req, res) => {
+        try {
+            const files = req.files ?? [];
+            if (!files.length) {
+                return res.status(400).json({ error: true, message: "No files uploaded" });
+            }
+            const results = await Promise.all(files.map(async (f) => {
+                const folder = shortFolder();
+                const ext = (f.originalname.match(/\.([A-Za-z0-9]{1,8})$/)?.[1] ??
+                    (0, filename_1.extFromMime)(f.mimetype) ??
+                    "bin").toLowerCase();
+                const key = `${folder}/${shortUid()}.${ext}`;
+                const out = await ctx.fileStorage.upload({
+                    key,
+                    body: f.buffer,
+                    contentType: f.mimetype,
+                    metadata: { originalName: f.originalname || "" },
+                });
+                return {
+                    provider: out.provider,
+                    bucket: out.bucket,
+                    key: out.key,
+                    url: out.url,
+                    etag: out.etag,
+                    contentType: out.contentType,
+                    size: out.size,
+                    metadata: out.metadata,
+                    originalName: f.originalname,
+                };
+            }));
+            return res.json({
+                success: true,
+                message: "Files uploaded successfully",
+                data: results,
+            });
+        }
+        catch (err) {
+            return res.status(400).json({ error: true, message: err?.message ?? "Upload failed" });
+        }
+    });
+    ctx.router.delete("/files/:key(*)", fileAuthMiddleware, async (req, res) => {
+        try {
+            const key = String(req.params.key || "");
+            if (!key) {
+                return res.status(400).json({ error: true, message: "Key is required" });
+            }
+            const { deleted } = await ctx.fileStorage.delete(key);
+            return res.json({
+                success: true,
+                message: deleted ? "File deleted" : "Delete attempted",
+                key,
+                deleted,
+            });
+        }
+        catch (err) {
+            return res.status(400).json({ error: true, message: err?.message ?? "Delete failed" });
+        }
+    });
+}
+function shortFolder() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `uploads/${y}/${m}/${day}`;
+}
+function shortUid() {
+    return (Date.now().toString(36) + Math.random().toString(36).slice(2, 6)).toLowerCase();
+}

package/dist/api/router/utils.d.ts

@@ -0,0 +1,63 @@
+import type { Request } from "express";
+export type AnyRec = Record<string, any>;
+export type SortDir = 1 | -1;
+export type SortSpec = Record<string, SortDir>;
+export declare const isPlainObject: (v: unknown) => v is AnyRec;
+export declare const splitCSV: (raw: string) => string[];
+export declare function normalizeAttrType(attr: any): string;
+export declare function toIdString(v: any): string | null;
+export declare function splitFilterForExtended(filter: AnyRec, baseKeys: Set<string>): {
+    child: AnyRec;
+    base: AnyRec;
+};
+export declare function splitSortForExtended(sort: SortSpec, baseKeys: Set<string>): {
+    child: SortSpec;
+    base: SortSpec;
+};
+export declare function sortInMemory(rows: AnyRec[], sort: SortSpec): AnyRec[];
+export declare function matchDoc(doc: AnyRec, filter: AnyRec): boolean;
+export declare function buildPredicateForField(field: string, attr: any, raw: string): {
+    [field]: {
+        $in: string[];
+    };
+} | {
+    [field]: {
+        $regex: string;
+        $options: string;
+    };
+} | {
+    [field]: {
+        $in: number[];
+    };
+} | {
+    [field]: number;
+} | {
+    [field]: {
+        $in: boolean[];
+    };
+} | {
+    [field]: boolean;
+} | {
+    [field]: string;
+} | {
+    [field]: {
+        $in: Date[];
+    };
+} | {
+    [field]: Date;
+} | null;
+export declare function parseSort(expr?: string): Record<string, 1 | -1> | undefined;
+export declare function parseQuery(req: Request): {
+    limit: number;
+    page: number;
+    skip: number;
+    projection: {
+        [k: string]: 1;
+    } | undefined;
+    sort: Record<string, 1 | -1> | undefined;
+};
+export declare function extractIds(val: unknown): string[];
+export declare function refInfoFromAttr(attr: any): {
+    ref: string;
+    isArray: boolean;
+} | null;