@ug.software/opposer 3.0.10

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

@@ -0,0 +1,69 @@
+import { Exception, Success } from '../helpers/index.js';
+import { HttpStatus } from '../constants/index.js';
+import system from '../../system/index.js';
+import { Context } from '../index.js';
+export default async (props) => {
+    try {
+        const customModels = Context.get('models');
+        const allModels = await system.getAllModels(customModels);
+        const model = allModels.find((x) => x.name === props.model);
+        if (!model) {
+            return Exception({
+                name: HttpStatus[400].name,
+                code: HttpStatus[400].code,
+                message: 'Unable to identify Model',
+            });
+        }
+        const db = Context.get('db');
+        if (!db) {
+            return Exception({
+                name: HttpStatus[500].name,
+                code: HttpStatus[500].code,
+                message: 'Database not connected.',
+            });
+        }
+        const repository = db.getRepository(model.entity);
+        if (typeof props.data !== 'object') {
+            return Exception({
+                name: HttpStatus[400].name,
+                code: 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 Exception({
+                        name: HttpStatus[400].name,
+                        code: 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 Success(results);
+        }
+        else {
+            if (!checkDataProperties(props.data)) {
+                return Exception({
+                    name: HttpStatus[400].name,
+                    code: HttpStatus[400].code,
+                    message: "'Data' outside of expected range.",
+                });
+            }
+            const result = await repository.insert(props.data);
+            return Success(result);
+        }
+    }
+    catch (err) {
+        return Exception({
+            name: HttpStatus[500].name,
+            code: HttpStatus[500].code,
+            message: err.message,
+        });
+    }
+};

package/lib/esm/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/esm/server/services/update.js

@@ -0,0 +1,55 @@
+import { Exception, Success } from '../helpers/index.js';
+import { HttpStatus } from '../constants/index.js';
+import system from '../../system/index.js';
+import { Context } from '../index.js';
+export default async (props) => {
+    const customModels = Context.get('models');
+    const allModels = await system.getAllModels(customModels);
+    const model = allModels.find((x) => x.name === props.model);
+    if (!model) {
+        return Exception({
+            name: HttpStatus[400].name,
+            code: HttpStatus[400].code,
+            message: 'Unable to identify Model',
+        });
+    }
+    const db = Context.get('db');
+    if (!db) {
+        return Exception({
+            name: HttpStatus[500].name,
+            code: 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 Exception({
+            name: HttpStatus[400].name,
+            code: 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 Exception({
+            ...HttpStatus[400],
+            message: 'Necessary to set query params for update items.',
+        });
+    }
+    try {
+        await repository.update(props.filter, props.data);
+        return Success({
+            message: 'Success updating item',
+        });
+    }
+    catch (err) {
+        return Exception({
+            name: HttpStatus[500].name,
+            code: HttpStatus[500].code,
+            message: err.message,
+        });
+    }
+};

package/lib/esm/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/esm/system/index.js

@@ -0,0 +1,197 @@
+import { pathToFileURL } from "url";
+import path from "path";
+import fs from "fs";
+import ChangeRequestPassword from "../server/security/models/crp.js";
+import Key from "../server/security/models/ke.js";
+import Role from "../server/security/models/rl.js";
+import Session from "../server/security/models/se.js";
+import User from "../server/security/models/usr.js";
+import ScheduleHistory from "../scheduler/models/history.js";
+import { MetadataStore } from "../orm/metadata.js";
+export class OpposerSystem {
+    getFileName(filePath, withExtension = true) {
+        if (withExtension) {
+            return path.basename(filePath);
+        }
+        else {
+            return path.basename(filePath, path.extname(filePath));
+        }
+    }
+    async getAllModels(customModels) {
+        const settings = this.getSettingsFile();
+        const root = process.cwd();
+        if (typeof customModels === "string") {
+            const modelsPath = path.resolve(root, customModels);
+            if (fs.existsSync(modelsPath)) {
+                const modelsFiles = this.getAllFiles(modelsPath);
+                await Promise.all(modelsFiles.map(async (filePath) => {
+                    const fileUrl = pathToFileURL(filePath).href;
+                    return await import(fileUrl);
+                }));
+            }
+        }
+        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 = 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: ChangeRequestPassword }, { name: "ke", entity: Key }, { name: "rl", entity: Role }, { name: "se", entity: Session }, { name: "usr", entity: User });
+        }
+        // Always include ScheduleHistory as it's a core feature
+        models.push({ name: "sh", entity: ScheduleHistory });
+        return models;
+    }
+    async getAllControllers(customControllers) {
+        const settings = this.getSettingsFile();
+        const root = process.cwd();
+        // Dynamic import to avoid circular dependency
+        const SchedulerController = (await import("../scheduler/controllers/index.js")).default;
+        const internalControllers = [SchedulerController];
+        if (Array.isArray(customControllers)) {
+            return [...internalControllers, ...customControllers];
+        }
+        let controllersPath = customControllers || path.resolve(root, "src", "controllers");
+        if (!customControllers && settings.controllers) {
+            controllersPath = path.resolve(root, settings.controllers, "controllers");
+        }
+        if (!fs.existsSync(controllersPath)) {
+            return internalControllers;
+        }
+        const controllersFiles = this.getAllFiles(controllersPath);
+        const userControllers = await Promise.all(controllersFiles.map(async (filePath) => {
+            const fileUrl = pathToFileURL(filePath).href;
+            //@ts-ignore
+            return (await import(fileUrl)).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.resolve(root, "src", "schedules");
+        if (!customSchedules && settings.schedules) {
+            schedulesPath = path.resolve(root, settings.schedules, "schedules");
+        }
+        if (!fs.existsSync(schedulesPath)) {
+            return [];
+        }
+        const schedulesFiles = this.getAllFiles(schedulesPath);
+        const userSchedules = await Promise.all(schedulesFiles.map(async (filePath) => {
+            const fileUrl = pathToFileURL(filePath).href;
+            //@ts-ignore
+            return (await import(fileUrl)).default;
+        }));
+        return userSchedules.filter((s) => s);
+    }
+    getSettingsFile() {
+        let config = {};
+        try {
+            const root = process.cwd();
+            const configPath = path.resolve(root, "opposer-settings.json");
+            if (fs.existsSync(configPath)) {
+                const fileContent = fs.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.existsSync(dir))
+            return [];
+        const list = fs.readdirSync(dir, { withFileTypes: true });
+        list.forEach((file) => {
+            const filePath = path.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.resolve(root, "opposer-settings.json");
+        return fs.writeFileSync(configPath, JSON.stringify(settings, null, 2), {
+            encoding: "utf8",
+        });
+    }
+}
+const system = new OpposerSystem();
+export default system;

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@ug.software/opposer",
+  "version": "3.0.10",
+  "description": "Ecossistema modular para construção de aplicações modernas focado em alta produtividade e organização por Domínios.",
+  "type": "module",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "types": "./lib/esm/index.d.ts",
+  "bin": {
+    "opposer": "./lib/bin/opposer.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://www.opposer.uiaranguilherme.com"
+  },
+  "keywords": [
+    "orm",
+    "scheduler",
+    "http-server",
+    "modular",
+    "typescript",
+    "opposer",
+    "backend",
+    "framework"
+  ],
+  "author": "UG Software",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ug-software/opposer/issues"
+  },
+  "homepage": "https://github.com/ug-software/opposer#readme",
+  "exports": {
+    ".": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "./orm": {
+      "import": "./lib/esm/orm/index.js",
+      "require": "./lib/cjs/orm/index.js"
+    },
+    "./persistent": {
+      "import": "./lib/esm/persistent/index.js",
+      "require": "./lib/cjs/persistent/index.js"
+    },
+    "./playground": {
+      "import": "./lib/esm/playground/index.js",
+      "require": "./lib/cjs/playground/index.js"
+    },
+    "./schedule": {
+      "import": "./lib/esm/scheduler/index.js",
+      "require": "./lib/cjs/scheduler/index.js"
+    },
+    "./scheduler": {
+      "import": "./lib/esm/scheduler/index.js",
+      "require": "./lib/cjs/scheduler/index.js"
+    },
+    "./server": {
+      "import": "./lib/esm/server/index.js",
+      "require": "./lib/cjs/server/index.js"
+    },
+    "./system": {
+      "import": "./lib/esm/system/index.js",
+      "require": "./lib/cjs/system/index.js"
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "bcrypt": "^6.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "node-cron": "^4.2.1",
+    "reflect-metadata": "^0.2.2",
+    "yargs": "^17.7.2"
+  },
+  "peerDependencies": {
+    "mysql2": "^3.12.0",
+    "pg": "^8.13.3",
+    "sqlite3": "^5.1.7"
+  },
+  "peerDependenciesMeta": {
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    }
+  }
+}