@drax/settings-back 0.11.3

package/dist/controller/SettingController.js

@@ -0,0 +1,89 @@
+import { SettingPermissions } from "../permissions/SettingPermissions.js";
+import SettingServiceFactory from "../factory/SettingServiceFactory.js";
+import { UnauthorizedError, ValidationError } from "@drax/common-back";
+class SettingController {
+    constructor() {
+        this.service = SettingServiceFactory();
+    }
+    async fetchAll(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.View);
+            const settings = await this.service.fetchAll();
+            return settings;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async fetchGrouped(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.View);
+            const settings = await this.service.fetchGrouped();
+            return settings;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async findByKey(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.View);
+            const key = request.params.key;
+            const setting = await this.service.findByKey(key);
+            return setting;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async updateValue(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.Update);
+            const id = request.params.id;
+            let { value } = request.body;
+            const setting = await this.service.updateValue(id, value);
+            return setting;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+}
+export default SettingController;
+export { SettingController };

package/dist/factory/SettingServiceFactory.js

@@ -0,0 +1,24 @@
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+import { SettingService } from "../services/SettingService.js";
+import SettingMongoRepository from "../repository/mongo/SettingMongoRepository.js";
+import SettingSqliteRepository from "../repository/sqlite/SettingSqliteRepository.js";
+let settingService;
+const SettingServiceFactory = (verbose = false) => {
+    if (!settingService) {
+        let settingRepository;
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
+                settingRepository = new SettingMongoRepository();
+                break;
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                settingRepository = new SettingSqliteRepository(dbFile, verbose);
+                break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+        }
+        settingService = new SettingService(settingRepository);
+    }
+    return settingService;
+};
+export default SettingServiceFactory;

package/dist/index.js

@@ -0,0 +1,8 @@
+import { SettingModel, SettingSchema } from "./model/SettingsModel.js";
+import { SettingMongoRepository } from "./repository/mongo/SettingMongoRepository.js";
+import { SettingService } from "./services/SettingService.js";
+import SettingServiceFactory from "./factory/SettingServiceFactory.js";
+import SettingController from "./controller/SettingController.js";
+import SettingRoutes from "./routes/SettingRoutes.js";
+import { SettingPermissions } from "./permissions/SettingPermissions.js";
+export { SettingSchema, SettingModel, SettingMongoRepository, SettingService, SettingServiceFactory, SettingController, SettingRoutes, SettingPermissions };

package/dist/interfaces/ISettingRepository.js

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

package/dist/model/SettingsModel.js

@@ -0,0 +1,28 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+const SettingSchema = new mongoose.Schema({
+    key: { type: String, required: true, unique: true },
+    value: { type: mongoose.Schema.Types.Mixed, required: false, unique: false },
+    //valueList: [{type: String, required: false, unique: false}],
+    label: { type: String, required: false },
+    group: { type: String, required: true },
+    type: { type: String, default: "string", enum: ['string', 'longString', 'number', 'enum', 'boolean', 'password', 'stringList', 'numberList', 'enumList', 'ref', 'secret'], required: false, unique: false },
+    options: [{ type: String }],
+    regex: { type: String },
+    entity: { type: String, required: false },
+    entityValue: { type: String, required: false },
+    entityText: { type: String, required: false, unique: false },
+    prefix: { type: String, required: false },
+    suffix: { type: String, required: false },
+});
+SettingSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+SettingSchema.set('toJSON', { getters: true, virtuals: true });
+SettingSchema.set('toObject', { getters: true, virtuals: true });
+SettingSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+const MODEL_NAME = 'Setting';
+const COLLECTION_NAME = 'settings';
+const SettingModel = mongoose.model(MODEL_NAME, SettingSchema, COLLECTION_NAME);
+export { SettingSchema, SettingModel };
+export default SettingModel;

package/dist/permissions/SettingPermissions.js

@@ -0,0 +1,8 @@
+var SettingPermissions;
+(function (SettingPermissions) {
+    SettingPermissions["Update"] = "setting:update";
+    SettingPermissions["View"] = "setting:view";
+    SettingPermissions["Manage"] = "setting:manage";
+})(SettingPermissions || (SettingPermissions = {}));
+export default SettingPermissions;
+export { SettingPermissions };

package/dist/repository/mongo/SettingMongoRepository.js

@@ -0,0 +1,13 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { SettingModel } from "../../model/SettingsModel.js";
+class SettingMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        //@ts-ignore
+        this._model = SettingModel;
+        this._searchFields = ['_id', 'key'];
+        this._populateFields = [];
+    }
+}
+export default SettingMongoRepository;
+export { SettingMongoRepository };

package/dist/repository/sqlite/SettingSqliteRepository.js

@@ -0,0 +1,113 @@
+import sqlite from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort } from "@drax/common-back";
+const tableFields = [
+    { name: "key", type: "TEXT", unique: true, primary: false },
+    { name: "value", type: "TEXT", unique: false, primary: false },
+];
+class SettingSqliteRepository {
+    constructor(dataBaseFile, verbose = false) {
+        this._searchFields = [];
+        this.dataBaseFile = dataBaseFile;
+        this._searchFields = ['_id', 'key'];
+        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
+        this.table();
+    }
+    table() {
+        const builder = new SqliteTableBuilder(this.dataBaseFile, 'settings', tableFields, false);
+        builder.build('id');
+    }
+    async create(data) {
+        try {
+            if (!data.id) {
+                data.id = randomUUID();
+            }
+            // data.createdAt = (new Date().toISOString())
+            const fields = Object.keys(data)
+                .map(field => `${field}`)
+                .join(', ');
+            const values = Object.keys(data)
+                .map(field => `@${field}`)
+                .join(', ');
+            const stmt = this.db.prepare(`INSERT INTO settings (${fields}) VALUES (${values})`);
+            stmt.run(data);
+            return this.findById(data.id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, data);
+        }
+    }
+    async update(id, data) {
+        try {
+            // data.updatedAt = (new Date().toISOString())
+            const setClauses = Object.keys(data)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            data.id = id;
+            const stmt = this.db.prepare(`UPDATE settings SET ${setClauses} WHERE id = @id `);
+            stmt.run(data);
+            return this.findById(id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, data);
+        }
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
+        const offset = page > 1 ? (page - 1) * limit : 0;
+        let where = "";
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%'`;
+        }
+        where = SqlQueryFilter.applyFilters(where, filters);
+        const sort = SqlSort.applySort(orderBy, order);
+        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM settings' + where).get();
+        where += sort;
+        const settings = this.db.prepare('SELECT * FROM settings ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: settings
+        };
+    }
+    async delete(id) {
+        const stmt = this.db.prepare('DELETE FROM settings WHERE id = ?');
+        stmt.run(id);
+        return true;
+    }
+    async deleteAll() {
+        const stmt = this.db.prepare('DELETE FROM settings');
+        stmt.run();
+        return true;
+    }
+    async findById(id) {
+        const setting = this.db.prepare('SELECT * FROM settings WHERE id = ?').get(id);
+        if (setting) {
+            return setting;
+        }
+        return undefined;
+    }
+    async findByKey(key) {
+        const setting = this.db.prepare('SELECT * FROM settings WHERE key = ?').get(key);
+        if (setting) {
+            return setting;
+        }
+        return undefined;
+    }
+    async fetchAll() {
+        const settings = this.db.prepare('SELECT * FROM settings').all();
+        return settings;
+    }
+    async search(value, limit = 1000) {
+        let where = "";
+        if (value && this._searchFields.length > 0) {
+            where = ` WHERE ${this._searchFields.map(field => `${field} LIKE '%${value}%'`).join(" OR ")}`;
+        }
+        const items = this.db.prepare(`SELECT * FROM settings ${where}`).all();
+        return items;
+    }
+}
+export default SettingSqliteRepository;
+export { SettingSqliteRepository };

package/dist/routes/SettingRoutes.js

@@ -0,0 +1,10 @@
+import SettingController from "../controller/SettingController.js";
+async function SettingsRoutes(fastify, options) {
+    const controller = new SettingController();
+    fastify.get('/api/settings', (req, rep) => controller.fetchAll(req, rep));
+    fastify.get('/api/settings/grouped', (req, rep) => controller.fetchGrouped(req, rep));
+    fastify.get('/api/settings/:key', (req, rep) => controller.findByKey(req, rep));
+    fastify.patch('/api/settings/:id', (req, rep) => controller.updateValue(req, rep));
+}
+export default SettingsRoutes;
+export { SettingsRoutes };

package/dist/schemas/SettingSchema.js

@@ -0,0 +1,7 @@
+import { object, string } from "zod";
+const settingSchema = object({
+    key: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+});
+export default settingSchema;
+export { settingSchema };

package/dist/services/SettingService.js

@@ -0,0 +1,95 @@
+import { settingSchema } from "../schemas/SettingSchema.js";
+import { AbstractService } from "@drax/crud-back";
+import { DraxCache, ZodErrorToValidationError } from "@drax/common-back";
+import { ZodError } from "zod";
+class SettingService extends AbstractService {
+    constructor(repostitory) {
+        super(repostitory, settingSchema);
+        this._cache = new DraxCache();
+        this._repository = repostitory;
+        console.log("SettingService constructor");
+    }
+    async cache(key) {
+        return this._cache.getOrLoad(key, async () => {
+            return await this.findByKey(key);
+        }, 20000);
+    }
+    async cacheValue(key) {
+        let setting = await this.cache(key);
+        return setting?.value;
+    }
+    async findByKey(key) {
+        return this._repository.findOneBy("key", key);
+    }
+    async fetchAll() {
+        return await this._repository.fetchAll();
+    }
+    async fetchGrouped() {
+        const settings = await this._repository.fetchAll();
+        return settings.reduce((acc, setting) => {
+            if (!acc[setting.group]) {
+                acc[setting.group] = [];
+            }
+            acc[setting.group].push(setting);
+            return acc;
+        }, {});
+    }
+    async updateValue(id, value) {
+        return this._repository.updatePartial(id, { value });
+    }
+    async create(data) {
+        try {
+            await settingSchema.parseAsync(data);
+            if (Array.isArray(data.value)) {
+                data.value = JSON.stringify(data.value);
+            }
+            const setting = await this._repository.create(data);
+            return setting;
+        }
+        catch (e) {
+            console.error("Error on create setting", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data);
+            }
+            throw e;
+        }
+    }
+    async update(id, data) {
+        try {
+            await settingSchema.parseAsync(data);
+            //Borramos el valor para evitar el conflicto de actualización
+            delete data.value;
+            const setting = await this._repository.update(id, data);
+            return setting;
+        }
+        catch (e) {
+            console.error("Error on update setting", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data);
+            }
+            throw e;
+        }
+    }
+    async createOrUpdate(data) {
+        try {
+            await settingSchema.parseAsync(data);
+            const setting = await this._repository.findOneBy("key", data.key);
+            if (setting) {
+                delete data.value;
+                return await this._repository.updatePartial(setting.id, data);
+            }
+            else {
+                return await this._repository.create(data);
+            }
+        }
+        catch (e) {
+            console.error("Error on create or update setting", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data);
+            }
+            throw e;
+        }
+    }
+}
+export default SettingService;
+export { SettingService };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@drax/settings-back",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.11.3",
+  "description": "Setting module for nice management options.",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "prepublish": "tsc && npm run copygql",
+    "clean": "rm -rf dist",
+    "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
+    "tsc": "tsc -b tsconfig.json",
+    "tsclistFiles": "tsc --listFiles",
+    "tscexplain": "tsc --explainFiles",
+    "test": "node --import tsx --test test/**/*",
+    "testMongoRepositoryRole": "node --import tsx --test test/repository/mongo/role*",
+    "testMongoRepositoryUser": "node --import tsx --test test/repository/mongo/user-mongo*",
+    "testMongoRepositoryUserApiKey": "node --import tsx --test test/repository/mongo/user-apikey-mongo*",
+    "testSqliteRepositoryUser": "node --import tsx --test test/repository/sqlite/user*",
+    "testSqliteRepositoryRole": "node --import tsx --test test/repository/sqlite/role*",
+    "testServiceRole": "node --import tsx --test test/service/role*",
+    "testServiceUser": "node --import tsx --test test/service/user*",
+    "testcoverage": "node --import tsx --experimental-test-coverage  test/service/*"
+  },
+  "author": "Cristian Incarnato & Drax Team",
+  "license": "ISC",
+  "dependencies": {
+    "@drax/common-back": "^0.11.3",
+    "@drax/crud-back": "^0.11.3",
+    "@drax/crud-share": "^0.11.3",
+    "@drax/email-back": "^0.11.3",
+    "@drax/identity-share": "^0.11.3",
+    "bcryptjs": "^2.4.3",
+    "express-jwt": "^8.4.1",
+    "graphql": "^16.8.2",
+    "jsonwebtoken": "^9.0.2",
+    "zod": "^3.23.8"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^11.0.0",
+    "fastify": "^4.27.0",
+    "mongoose": "^8.6.3",
+    "mongoose-paginate-v2": "^1.8.3",
+    "mongoose-unique-validator": "^5.0.1"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/node": "^20.12.10",
+    "copyfiles": "^2.4.1",
+    "glob": "^10.2.6",
+    "mongodb-memory-server": "^9.2.0",
+    "nodemon": "^3.1.0",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.4.5"
+  },
+  "config": {
+    "mongodbMemoryServer": {
+      "debug": "0"
+    }
+  },
+  "gitHead": "54216d94d68dac488969f9c95d3c6be780935f9d"
+}

package/src/controller/SettingController.ts

@@ -0,0 +1,92 @@
+import {SettingPermissions} from "../permissions/SettingPermissions.js";
+import SettingService from "../services/SettingService.js";
+import SettingServiceFactory from "../factory/SettingServiceFactory.js";
+import {UnauthorizedError, ValidationError} from "@drax/common-back";
+
+class SettingController {
+
+    protected service: SettingService
+    protected permission
+
+    constructor() {
+        this.service = SettingServiceFactory()
+    }
+
+    async fetchAll(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.View)
+            const settings = await this.service.fetchAll()
+            return settings
+        } catch (e) {
+            console.error(e)
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    }
+
+    async fetchGrouped(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.View)
+            const settings = await this.service.fetchGrouped()
+            return settings
+        } catch (e) {
+            console.error(e)
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    }
+
+    async findByKey(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.View)
+            const key = request.params.key
+            const setting = await this.service.findByKey(key)
+            return setting
+        } catch (e) {
+            console.error(e)
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    }
+
+    async updateValue(request, reply) {
+        try {
+            request.rbac.assertPermission(SettingPermissions.Update)
+            const id = request.params.id
+            let {value} = request.body
+            const setting = await this.service.updateValue(id, value)
+            return setting
+        } catch (e) {
+            console.error(e)
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message, inputErrors: e.errors})
+            } else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode
+                reply.send({error: e.message})
+            } else {
+                reply.statusCode = 500
+                reply.send({error: 'INTERNAL_SERVER_ERROR'})
+            }
+        }
+    }
+}
+
+
+export default SettingController;
+export {SettingController}

package/src/factory/SettingServiceFactory.ts

@@ -0,0 +1,32 @@
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back"
+import {SettingService} from "../services/SettingService.js";
+import SettingMongoRepository from "../repository/mongo/SettingMongoRepository.js";
+import SettingSqliteRepository from "../repository/sqlite/SettingSqliteRepository.js";
+import type {ISettingRepository} from "../interfaces/ISettingRepository";
+
+let settingService: SettingService
+
+const SettingServiceFactory = (verbose: boolean = false): SettingService => {
+
+    if (!settingService) {
+        let settingRepository: ISettingRepository
+
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
+                settingRepository = new SettingMongoRepository()
+                break;
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                settingRepository = new SettingSqliteRepository(dbFile, verbose)
+                break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+        }
+
+        settingService = new SettingService(settingRepository)
+    }
+
+    return settingService
+}
+
+export default SettingServiceFactory

package/src/index.ts

@@ -0,0 +1,24 @@
+import {ISettingRepository} from "./interfaces/ISettingRepository";
+export type {ISettingRepository};
+
+
+import {SettingModel, SettingSchema} from "./model/SettingsModel.js"
+import {SettingMongoRepository} from "./repository/mongo/SettingMongoRepository.js"
+import {SettingService} from "./services/SettingService.js"
+import SettingServiceFactory from "./factory/SettingServiceFactory.js"
+import SettingController from "./controller/SettingController.js"
+import SettingRoutes from "./routes/SettingRoutes.js"
+import {SettingPermissions} from "./permissions/SettingPermissions.js"
+
+
+
+export {
+    SettingSchema,
+    SettingModel,
+    SettingMongoRepository,
+    SettingService,
+    SettingServiceFactory,
+    SettingController,
+    SettingRoutes,
+    SettingPermissions
+}

package/src/interfaces/ISettingRepository.ts

@@ -0,0 +1,6 @@
+import {ISetting, ISettingBase} from "@drax/settings-share";
+import {IDraxCrud} from "@drax/crud-share";
+interface ISettingRepository extends IDraxCrud<ISetting,ISettingBase,ISettingBase>{
+}
+
+export {ISettingRepository}