@ug.software/opposer 3.0.10

package/lib/cjs/server/services/delete.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../constants/index.js");
+const index_js_2 = require("../helpers/index.js");
+const index_js_3 = __importDefault(require("../../system/index.js"));
+const index_js_4 = require("../index.js");
+exports.default = async (props) => {
+    const customModels = index_js_4.Context.get('models');
+    const allModels = await index_js_3.default.getAllModels(customModels);
+    const model = allModels.find((x) => x.name === props.model);
+    const db = index_js_4.Context.get('db');
+    if (!db) {
+        return (0, index_js_2.Exception)({
+            name: index_js_1.HttpStatus[500].name,
+            code: index_js_1.HttpStatus[500].code,
+            message: 'Database not connected.',
+        });
+    }
+    if (model) {
+        const repository = db.getRepository(model.entity);
+        if (!props.filter || Object.keys(props.filter).length === 0) {
+            return (0, index_js_2.Exception)({
+                ...index_js_1.HttpStatus[400],
+                message: 'Necessary to set query params for delete items.',
+            });
+        }
+        try {
+            await repository.delete(props.filter);
+            return (0, index_js_2.Success)({
+                message: 'Success removing item',
+            });
+        }
+        catch (err) {
+            return (0, index_js_2.Exception)({
+                name: index_js_1.HttpStatus[500].name,
+                code: index_js_1.HttpStatus[500].code,
+                message: err.message,
+            });
+        }
+    }
+    return (0, index_js_2.Exception)({
+        name: index_js_1.HttpStatus[400].name,
+        code: index_js_1.HttpStatus[400].code,
+        message: 'Unable to identify Model.',
+    });
+};

package/lib/cjs/server/services/get.d.ts

@@ -0,0 +1,4 @@
+import { HandleGetProps } from '../../interfaces/controller.js';
+import { HandleRequestResult } from '../../interfaces/request.js';
+declare const _default: (props: HandleGetProps) => Promise<HandleRequestResult<unknown>>;
+export default _default;

package/lib/cjs/server/services/get.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../helpers/index.js");
+const index_js_2 = require("../constants/index.js");
+const index_js_3 = __importDefault(require("../../system/index.js"));
+const index_js_4 = require("../index.js");
+exports.default = async (props) => {
+    const customModels = index_js_4.Context.get('models');
+    const allModels = await index_js_3.default.getAllModels(customModels);
+    const model = allModels.find((x) => {
+        return x.name.toLowerCase() === props.model.toLowerCase();
+    });
+    if (!model) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: 'Unable to identify Model.',
+        });
+    }
+    const db = index_js_4.Context.get('db');
+    if (!db) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[500].name,
+            code: index_js_2.HttpStatus[500].code,
+            message: 'Database not connected.',
+        });
+    }
+    if (!props.query) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: 'Search parameters missing.',
+        });
+    }
+    const repository = db.getRepository(model.entity);
+    const queryKeys = ['filter', 'find', 'count', 'exists', 'aggregate', 'distinct', 'group'];
+    const presentKeys = queryKeys.filter((k) => {
+        return k in props.query;
+    });
+    if (presentKeys.length > 1) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: `Conflicting search parameters: multiple types provided (${presentKeys.join(', ')}).`,
+        });
+    }
+    let type = props.query.type;
+    if (presentKeys.length === 1) {
+        type = presentKeys[0];
+    }
+    if (!type) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: 'Search type not identified. Please provide one of: ' + queryKeys.join(', '),
+        });
+    }
+    try {
+        switch (type) {
+            case 'filter': {
+                const filter = props.query.filter || {};
+                const select = props.query.select || [];
+                const relation = props.query.relation || [];
+                const pagination = props.pagination;
+                const items = await repository.find({
+                    where: filter,
+                    select,
+                    relation,
+                    pagination,
+                });
+                if (props.pagination) {
+                    const totalItems = await repository.count(filter);
+                    const totalPages = Math.ceil(totalItems / (props.pagination.take || 10));
+                    return (0, index_js_1.Success)({
+                        items,
+                        totalItems,
+                        totalPages: totalPages > 0 ? totalPages : 0,
+                    });
+                }
+                return (0, index_js_1.Success)(items);
+            }
+            case 'find': {
+                const find = props.query.find || {};
+                const select = props.query.select || [];
+                const relation = props.query.relation || [];
+                const result = await repository.findOne({
+                    where: find,
+                    select,
+                    relation,
+                });
+                return (0, index_js_1.Success)(result);
+            }
+            case 'count': {
+                const count = props.query.count || {};
+                const result = await repository.count(count);
+                return (0, index_js_1.Success)({ count: result });
+            }
+            case 'exists': {
+                const exists = props.query.exists || {};
+                const result = await repository.exists(exists);
+                return (0, index_js_1.Success)({ exists: result });
+            }
+            case 'aggregate': {
+                const aggregate = props.query.aggregate;
+                if (!aggregate) {
+                    throw new Error('Aggregate configuration missing.');
+                }
+                const result = await repository.aggregate(aggregate);
+                return (0, index_js_1.Success)(result);
+            }
+            case 'distinct': {
+                const distinct = props.query.distinct;
+                if (!distinct) {
+                    throw new Error('Distinct configuration missing.');
+                }
+                const result = await repository.distinct(distinct);
+                return (0, index_js_1.Success)(result);
+            }
+            case 'group': {
+                const group = props.query.group;
+                if (!group) {
+                    throw new Error('Group configuration missing.');
+                }
+                const result = await repository.group(group);
+                return (0, index_js_1.Success)(result);
+            }
+            default:
+                return (0, index_js_1.Exception)({
+                    name: index_js_2.HttpStatus[400].name,
+                    code: index_js_2.HttpStatus[400].code,
+                    message: `Search type '${type}' not understood.`,
+                });
+        }
+    }
+    catch (err) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: err.message,
+        });
+    }
+};

package/lib/cjs/server/services/insert.d.ts

@@ -0,0 +1,13 @@
+import { HandleInsertProps } from '../../interfaces/controller.js';
+declare const _default: (props: HandleInsertProps) => Promise<{
+    readonly success: true;
+    readonly data: any;
+} | {
+    readonly success: false;
+    readonly error: {
+        name: string;
+        code: number;
+        message: any;
+    };
+}>;
+export default _default;

package/lib/cjs/server/services/insert.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../helpers/index.js");
+const index_js_2 = require("../constants/index.js");
+const index_js_3 = __importDefault(require("../../system/index.js"));
+const index_js_4 = require("../index.js");
+exports.default = async (props) => {
+    try {
+        const customModels = index_js_4.Context.get('models');
+        const allModels = await index_js_3.default.getAllModels(customModels);
+        const model = allModels.find((x) => x.name === props.model);
+        if (!model) {
+            return (0, index_js_1.Exception)({
+                name: index_js_2.HttpStatus[400].name,
+                code: index_js_2.HttpStatus[400].code,
+                message: 'Unable to identify Model',
+            });
+        }
+        const db = index_js_4.Context.get('db');
+        if (!db) {
+            return (0, index_js_1.Exception)({
+                name: index_js_2.HttpStatus[500].name,
+                code: index_js_2.HttpStatus[500].code,
+                message: 'Database not connected.',
+            });
+        }
+        const repository = db.getRepository(model.entity);
+        if (typeof props.data !== 'object') {
+            return (0, index_js_1.Exception)({
+                name: index_js_2.HttpStatus[400].name,
+                code: index_js_2.HttpStatus[400].code,
+                message: "'Data' is not of type 'object'.",
+            });
+        }
+        const repositoryFields = repository.Fields.map((f) => f.name);
+        const checkDataProperties = (data) => {
+            return Object.keys(data).every((key) => repositoryFields.includes(key) || key === 'id');
+        };
+        if (Array.isArray(props.data)) {
+            for (const item of props.data) {
+                if (!checkDataProperties(item)) {
+                    return (0, index_js_1.Exception)({
+                        name: index_js_2.HttpStatus[400].name,
+                        code: index_js_2.HttpStatus[400].code,
+                        message: 'Some data properties are outside the expected range.',
+                    });
+                }
+            }
+            const results = await Promise.all(props.data.map((item) => repository.insert(item)));
+            return (0, index_js_1.Success)(results);
+        }
+        else {
+            if (!checkDataProperties(props.data)) {
+                return (0, index_js_1.Exception)({
+                    name: index_js_2.HttpStatus[400].name,
+                    code: index_js_2.HttpStatus[400].code,
+                    message: "'Data' outside of expected range.",
+                });
+            }
+            const result = await repository.insert(props.data);
+            return (0, index_js_1.Success)(result);
+        }
+    }
+    catch (err) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[500].name,
+            code: index_js_2.HttpStatus[500].code,
+            message: err.message,
+        });
+    }
+};

package/lib/cjs/server/services/update.d.ts

@@ -0,0 +1,13 @@
+import { HandleUpdateProps } from '../../interfaces/controller.js';
+declare const _default: (props: HandleUpdateProps) => Promise<{
+    readonly success: true;
+    readonly data: any;
+} | {
+    readonly success: false;
+    readonly error: {
+        name: string;
+        code: number;
+        message: any;
+    };
+}>;
+export default _default;

package/lib/cjs/server/services/update.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../helpers/index.js");
+const index_js_2 = require("../constants/index.js");
+const index_js_3 = __importDefault(require("../../system/index.js"));
+const index_js_4 = require("../index.js");
+exports.default = async (props) => {
+    const customModels = index_js_4.Context.get('models');
+    const allModels = await index_js_3.default.getAllModels(customModels);
+    const model = allModels.find((x) => x.name === props.model);
+    if (!model) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: 'Unable to identify Model',
+        });
+    }
+    const db = index_js_4.Context.get('db');
+    if (!db) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[500].name,
+            code: index_js_2.HttpStatus[500].code,
+            message: 'Database not connected.',
+        });
+    }
+    const repository = db.getRepository(model.entity);
+    const repositoryFields = repository.Fields.map((f) => f.name);
+    const thereIsPropertyOutsideTheRule = Object.keys(props.data).some((key) => {
+        return !repositoryFields.includes(key) && key !== 'id';
+    });
+    if (thereIsPropertyOutsideTheRule) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[400].name,
+            code: index_js_2.HttpStatus[400].code,
+            message: "'Data' out of expected range, check your data and try again",
+        });
+    }
+    if (!props.filter || Object.keys(props.filter).length === 0) {
+        return (0, index_js_1.Exception)({
+            ...index_js_2.HttpStatus[400],
+            message: 'Necessary to set query params for update items.',
+        });
+    }
+    try {
+        await repository.update(props.filter, props.data);
+        return (0, index_js_1.Success)({
+            message: 'Success updating item',
+        });
+    }
+    catch (err) {
+        return (0, index_js_1.Exception)({
+            name: index_js_2.HttpStatus[500].name,
+            code: index_js_2.HttpStatus[500].code,
+            message: err.message,
+        });
+    }
+};

package/lib/cjs/system/index.d.ts

@@ -0,0 +1,13 @@
+import { OpposerSystemConfigOptions, ClassType, ModelDefinition } from "../interfaces/system.js";
+export declare class OpposerSystem {
+    getFileName(filePath: string, withExtension?: boolean): string;
+    getAllModels(customModels?: string | ClassType<unknown>[]): Promise<ModelDefinition[]>;
+    private getAuthModels;
+    getAllControllers(customControllers?: string | ClassType<unknown>[]): Promise<ClassType<unknown>[]>;
+    getAllSchedules(customSchedules?: string | ClassType<unknown>[]): Promise<ClassType<unknown>[]>;
+    getSettingsFile(): OpposerSystemConfigOptions;
+    getAllFiles(dir: string): string[];
+    saveSettingsFile(settings: OpposerSystemConfigOptions): void;
+}
+declare const system: OpposerSystem;
+export default system;

package/lib/cjs/system/index.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpposerSystem = void 0;
+const url_1 = require("url");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const crp_js_1 = __importDefault(require("../server/security/models/crp.js"));
+const ke_js_1 = __importDefault(require("../server/security/models/ke.js"));
+const rl_js_1 = __importDefault(require("../server/security/models/rl.js"));
+const se_js_1 = __importDefault(require("../server/security/models/se.js"));
+const usr_js_1 = __importDefault(require("../server/security/models/usr.js"));
+const history_js_1 = __importDefault(require("../scheduler/models/history.js"));
+const metadata_js_1 = require("../orm/metadata.js");
+class OpposerSystem {
+    getFileName(filePath, withExtension = true) {
+        if (withExtension) {
+            return path_1.default.basename(filePath);
+        }
+        else {
+            return path_1.default.basename(filePath, path_1.default.extname(filePath));
+        }
+    }
+    async getAllModels(customModels) {
+        const settings = this.getSettingsFile();
+        const root = process.cwd();
+        if (typeof customModels === "string") {
+            const modelsPath = path_1.default.resolve(root, customModels);
+            if (fs_1.default.existsSync(modelsPath)) {
+                const modelsFiles = this.getAllFiles(modelsPath);
+                await Promise.all(modelsFiles.map(async (filePath) => {
+                    const fileUrl = (0, url_1.pathToFileURL)(filePath).href;
+                    return await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)));
+                }));
+            }
+        }
+        else if (Array.isArray(customModels)) {
+            // If models are passed as an array, they are already imported/defined.
+            // We don't need to do anything here as they should have registered themselves
+            // via decorators if they are in the array.
+        }
+        const allEntities = metadata_js_1.MetadataStore.getAllEntities();
+        const authModels = this.getAuthModels(settings);
+        const models = allEntities.map((meta) => ({
+            name: meta.name,
+            entity: meta.target,
+        }));
+        // Combine with auth models if they aren't already there
+        authModels.forEach((auth) => {
+            if (!models.find((m) => m.name === auth.name)) {
+                models.push(auth);
+            }
+        });
+        return models;
+    }
+    getAuthModels(settings) {
+        const models = [];
+        if (settings.auth) {
+            models.push({ name: "crp", entity: crp_js_1.default }, { name: "ke", entity: ke_js_1.default }, { name: "rl", entity: rl_js_1.default }, { name: "se", entity: se_js_1.default }, { name: "usr", entity: usr_js_1.default });
+        }
+        // Always include ScheduleHistory as it's a core feature
+        models.push({ name: "sh", entity: history_js_1.default });
+        return models;
+    }
+    async getAllControllers(customControllers) {
+        const settings = this.getSettingsFile();
+        const root = process.cwd();
+        // Dynamic import to avoid circular dependency
+        const SchedulerController = (await Promise.resolve().then(() => __importStar(require("../scheduler/controllers/index.js")))).default;
+        const internalControllers = [SchedulerController];
+        if (Array.isArray(customControllers)) {
+            return [...internalControllers, ...customControllers];
+        }
+        let controllersPath = customControllers || path_1.default.resolve(root, "src", "controllers");
+        if (!customControllers && settings.controllers) {
+            controllersPath = path_1.default.resolve(root, settings.controllers, "controllers");
+        }
+        if (!fs_1.default.existsSync(controllersPath)) {
+            return internalControllers;
+        }
+        const controllersFiles = this.getAllFiles(controllersPath);
+        const userControllers = await Promise.all(controllersFiles.map(async (filePath) => {
+            const fileUrl = (0, url_1.pathToFileURL)(filePath).href;
+            //@ts-ignore
+            return (await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)))).default;
+        }));
+        return [...internalControllers, ...userControllers.filter((h) => h)];
+    }
+    async getAllSchedules(customSchedules) {
+        const settings = this.getSettingsFile();
+        const root = process.cwd();
+        if (Array.isArray(customSchedules)) {
+            return customSchedules;
+        }
+        let schedulesPath = customSchedules || path_1.default.resolve(root, "src", "schedules");
+        if (!customSchedules && settings.schedules) {
+            schedulesPath = path_1.default.resolve(root, settings.schedules, "schedules");
+        }
+        if (!fs_1.default.existsSync(schedulesPath)) {
+            return [];
+        }
+        const schedulesFiles = this.getAllFiles(schedulesPath);
+        const userSchedules = await Promise.all(schedulesFiles.map(async (filePath) => {
+            const fileUrl = (0, url_1.pathToFileURL)(filePath).href;
+            //@ts-ignore
+            return (await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)))).default;
+        }));
+        return userSchedules.filter((s) => s);
+    }
+    getSettingsFile() {
+        let config = {};
+        try {
+            const root = process.cwd();
+            const configPath = path_1.default.resolve(root, "opposer-settings.json");
+            if (fs_1.default.existsSync(configPath)) {
+                const fileContent = fs_1.default.readFileSync(configPath, "utf8");
+                config = JSON.parse(fileContent);
+            }
+        }
+        catch (error) {
+            // Normal if file doesn't exist
+        }
+        // Override with Environment Variables
+        config.port = process.env.OPPOSER_PORT
+            ? parseInt(process.env.OPPOSER_PORT)
+            : config.port || 3000;
+        config.url = process.env.OPPOSER_URL || config.url;
+        if (process.env.OPPOSER_DATABASE_TYPE || config.database) {
+            config.database = {
+                ...config.database,
+                type: process.env.OPPOSER_DATABASE_TYPE ||
+                    config.database?.type,
+                host: process.env.OPPOSER_DATABASE_HOST || config.database?.host,
+                port: process.env.OPPOSER_DATABASE_PORT
+                    ? parseInt(process.env.OPPOSER_DATABASE_PORT)
+                    : config.database?.port,
+                username: process.env.OPPOSER_DATABASE_USER ||
+                    config.database?.username,
+                password: process.env.OPPOSER_DATABASE_PASSWORD ||
+                    config.database?.password,
+                database: process.env.OPPOSER_DATABASE_NAME || config.database?.database,
+                logging: process.env.OPPOSER_DATABASE_LOGGING === "true" || config.database?.logging,
+            };
+        }
+        if (process.env.OPPOSER_JWT_ACCESS || config.jwt) {
+            config.jwt = {
+                ...(config.jwt || { access: "", refresh: "", recover: "" }),
+                access: process.env.OPPOSER_JWT_ACCESS || config.jwt?.access || "",
+                refresh: process.env.OPPOSER_JWT_REFRESH || config.jwt?.refresh || "",
+                recover: process.env.OPPOSER_JWT_RECOVER || config.jwt?.recover || "",
+            };
+        }
+        if (process.env.OPPOSER_MANAGER_LOGIN || config.manager) {
+            config.manager = {
+                ...(config.manager || {
+                    login: "",
+                    password: "",
+                    firstName: "",
+                    lastName: "",
+                }),
+                login: process.env.OPPOSER_MANAGER_LOGIN || config.manager?.login || "",
+                password: process.env.OPPOSER_MANAGER_PASSWORD ||
+                    config.manager?.password ||
+                    "",
+                firstName: process.env.OPPOSER_MANAGER_FIRST_NAME ||
+                    config.manager?.firstName ||
+                    "",
+                lastName: process.env.OPPOSER_MANAGER_LAST_NAME ||
+                    config.manager?.lastName ||
+                    "",
+            };
+        }
+        return config;
+    }
+    getAllFiles(dir) {
+        let results = [];
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        const list = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        list.forEach((file) => {
+            const filePath = path_1.default.resolve(dir, file.name);
+            if (file.isDirectory()) {
+                results = results.concat(this.getAllFiles(filePath));
+            }
+            else if (file.isFile() &&
+                (file.name.endsWith(".js") || file.name.endsWith(".ts"))) {
+                results.push(filePath);
+            }
+        });
+        return results;
+    }
+    saveSettingsFile(settings) {
+        const root = process.cwd();
+        const configPath = path_1.default.resolve(root, "opposer-settings.json");
+        return fs_1.default.writeFileSync(configPath, JSON.stringify(settings, null, 2), {
+            encoding: "utf8",
+        });
+    }
+}
+exports.OpposerSystem = OpposerSystem;
+const system = new OpposerSystem();
+exports.default = system;

package/lib/esm/examples/full-app/index.d.ts

@@ -0,0 +1 @@
+export {};