@drax/settings-back 0.11.3

package/src/model/SettingsModel.ts

@@ -0,0 +1,46 @@
+import {mongoose} from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import {ISetting} from "@drax/settings-share";
+
+
+const SettingSchema = new mongoose.Schema<ISetting>({
+
+    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<ISetting>(MODEL_NAME, SettingSchema,COLLECTION_NAME);
+
+export {
+    SettingSchema,
+    SettingModel
+}
+
+export default SettingModel

package/src/permissions/SettingPermissions.ts

@@ -0,0 +1,9 @@
+enum SettingPermissions {
+    Update = "setting:update",
+    View = "setting:view",
+    Manage = "setting:manage",
+
+}
+
+export default SettingPermissions;
+export {SettingPermissions};

package/src/repository/mongo/SettingMongoRepository.ts

@@ -0,0 +1,23 @@
+import {AbstractMongoRepository} from "@drax/crud-back";
+import type {ISettingRepository} from "../../interfaces/ISettingRepository";
+import {SettingModel} from "../../model/SettingsModel.js";
+import {ISetting, ISettingBase} from "@drax/settings-share";
+
+
+class SettingMongoRepository extends AbstractMongoRepository<ISetting,ISettingBase,ISettingBase> implements ISettingRepository {
+
+
+    constructor() {
+        super();
+        //@ts-ignore
+        this._model = SettingModel;
+
+        this._searchFields = ['_id', 'key'];
+        this._populateFields = [];
+    }
+
+
+}
+
+export default SettingMongoRepository;
+export {SettingMongoRepository};

package/src/repository/sqlite/SettingSqliteRepository.ts

@@ -0,0 +1,176 @@
+import {ISettingRepository} from '../../interfaces/ISettingRepository'
+import {UUID} from "crypto";
+import sqlite from "better-sqlite3";
+import {randomUUID} from "node:crypto";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
+import {ISetting, ISettingBase} from "@drax/settings-share";
+import {
+    SqliteErrorToValidationError,
+    SqliteTableBuilder,
+    SqliteTableField,
+    SqlQueryFilter,
+    SqlSort
+} from "@drax/common-back";
+
+const tableFields: SqliteTableField[] = [
+    {name: "key", type: "TEXT", unique: true, primary: false},
+    {name: "value", type: "TEXT", unique: false, primary: false},
+]
+
+
+class SettingSqliteRepository implements ISettingRepository{
+
+    protected db: any;
+    protected dataBaseFile: string;
+    protected _searchFields: string[] = []
+
+    constructor(dataBaseFile:string, verbose:boolean = false) {
+        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: ISettingBase): Promise<ISetting> {
+        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 as UUID)
+        }catch (e){
+            console.log(e)
+            throw SqliteErrorToValidationError(e, data)
+        }
+    }
+
+
+
+    async update(id: string, data: ISettingBase): Promise<ISetting> {
+        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= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ISetting>>{
+        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: string): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM settings WHERE id = ?');
+        stmt.run(id);
+        return true
+    }
+
+    async deleteAll(): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM settings');
+        stmt.run();
+        return true
+    }
+
+    async findById(id: string): Promise<ISetting | null>{
+        const setting = this.db.prepare('SELECT * FROM settings WHERE id = ?').get(id);
+        if(setting){
+            return setting
+        }
+        return undefined
+    }
+
+    async findByKey(key: string): Promise<ISetting | null>{
+        const setting = this.db.prepare('SELECT * FROM settings WHERE key = ?').get(key);
+        if(setting){
+            return setting
+        }
+        return undefined
+    }
+
+    async fetchAll(): Promise<ISetting[]>{
+        const settings = this.db.prepare('SELECT * FROM settings').all();
+        return settings
+    }
+
+
+    async search(value: any, limit: number = 1000): Promise<any[]>{
+        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/src/routes/SettingRoutes.ts

@@ -0,0 +1,17 @@
+import SettingController from "../controller/SettingController.js";
+
+
+async function SettingsRoutes(fastify, options) {
+    const controller: SettingController = 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/src/schemas/SettingSchema.ts

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

package/src/services/SettingService.ts

@@ -0,0 +1,111 @@
+import {ISettingRepository} from "../interfaces/ISettingRepository";
+import {settingSchema} from "../schemas/SettingSchema.js";
+import {ISetting, ISettingBase} from "@drax/settings-share";
+import {AbstractService} from "@drax/crud-back";
+import {DraxCache, ZodErrorToValidationError} from "@drax/common-back";
+import {ZodError} from "zod";
+
+class SettingService extends AbstractService<ISetting, ISettingBase, ISettingBase> {
+
+    protected _repository: ISettingRepository
+    protected _cache: DraxCache<ISetting> = new DraxCache()
+
+    constructor(repostitory: ISettingRepository) {
+        super(repostitory, settingSchema)
+        this._repository = repostitory
+        console.log("SettingService constructor")
+    }
+
+
+    async cache(key: string): Promise<ISetting> {
+        return this._cache.getOrLoad(key,
+            async () => {
+                return await this.findByKey(key)
+            },
+            20000)
+    }
+
+    async cacheValue(key: string): Promise<any> {
+        let setting = await this.cache(key)
+        return setting?.value
+    }
+
+    async findByKey(key: string): Promise<ISetting | undefined> {
+        return this._repository.findOneBy("key", key)
+    }
+
+    async fetchAll(): Promise<ISetting[]> {
+        return await this._repository.fetchAll()
+    }
+
+    async fetchGrouped(): Promise<{ [key: string]: ISetting[] }> {
+        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;
+        }, {} as { [key: string]: ISetting[] });
+    }
+
+    async updateValue(id: string, value: string): Promise<ISetting | undefined> {
+        return this._repository.updatePartial(id, {value})
+    }
+
+    async create(data: ISettingBase): Promise<ISetting> {
+        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: string, data: ISettingBase): Promise<ISetting> {
+        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: ISettingBase): Promise<ISetting> {
+        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/test/repository/mongo/MongoInMemory.ts

@@ -0,0 +1,43 @@
+import {mongoose} from '@drax/common-back';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+
+let mongoServer
+
+class MongoInMemory{
+
+    static async connect(){
+        mongoServer = await MongoMemoryServer.create();
+        if(mongoServer.state == "new"){
+            await mongoServer.start()
+        }
+        if(!mongoose.connection.readyState){
+            await mongoose.connect(mongoServer.getUri(), { dbName: "verifyMASTER" });
+        }
+        return
+    }
+    static get mongooseStatus(){
+        return mongoose.connection.readyState
+    }
+
+    static get serverStatus(){
+        return mongoServer.state
+    }
+
+    static get status(){
+        return mongoose.connection.readyState
+    }
+
+    static async disconnect(){
+        await mongoose.disconnect();
+    }
+
+    static async DropAndClose(){
+        if (mongoServer) {
+            await mongoose.connection.dropDatabase();
+            await mongoose.connection.close();
+            await mongoServer.stop();
+        }
+    }
+}
+
+export default MongoInMemory

package/test/repository/mongo/SettingMongoRepository.test.ts

@@ -0,0 +1,180 @@
+import {describe, beforeAll, it, vi, expect} from "vitest"
+import {SettingMongoRepository} from "../../../src/repository/mongo/SettingMongoRepository.js";
+import {ISetting, ISettingBase} from "@drax/settings-share";
+import {AbstractMongoRepository} from "@drax/crud-back";
+import MongoInMemory from "./MongoInMemory.js";
+
+describe('SettingMongoRepository', () => {
+
+    beforeAll(async () => {
+        await MongoInMemory.connect();
+    })
+
+
+    it('should initialize _searchFields with the correct default values', () => {
+        // Arrange & Act
+        const repository = new SettingMongoRepository();
+
+        // Assert
+        expect(repository._searchFields).toEqual(['_id', 'key']);
+    });
+
+    it('should verify that SettingMongoRepository is an instance of AbstractMongoRepository', () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+
+        // Assert
+        expect(repository).toBeInstanceOf(AbstractMongoRepository);
+    });
+
+
+
+    it('should correctly handle adding a new setting to the repository', async () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+        const newSetting: ISettingBase = {
+            key: 'newKey',
+            value: 'newValue',
+            label: 'New Key Label',
+            group: 'Default Group',
+            type: 'string',
+            options: []
+        };
+        const expectedSetting = {id: '2', ...newSetting};
+
+        // Mock the create method of the repository
+        vi.spyOn(repository, 'create').mockResolvedValue(expectedSetting);
+
+        // Act
+        const createdSetting = await repository.create(newSetting);
+
+        // Assert
+        expect(createdSetting).toEqual(expectedSetting);
+        expect(repository.create).toHaveBeenCalledWith(newSetting);
+    });
+
+    it('should correctly handle updating an existing setting in the repository', async () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+        const existingSettingId = '1';
+        const updatedData: ISettingBase = {
+            key: 'existingKey',
+            value: 'updatedValue',
+            label: 'Updated Key Label',
+            group: 'Default Group',
+            type: 'string',
+            options: []
+        };
+        const expectedUpdatedSetting: ISetting = {
+            id: existingSettingId,
+            ...updatedData
+        };
+
+        // Mock the update method of the repository
+        vi.spyOn(repository, 'update').mockResolvedValue(expectedUpdatedSetting);
+
+        // Act
+        const updatedSetting = await repository.update(existingSettingId, updatedData);
+
+        // Assert
+        expect(updatedSetting).toEqual(expectedUpdatedSetting);
+        expect(repository.update).toHaveBeenCalledWith(existingSettingId, updatedData);
+    });
+
+
+    it('should correctly handle searching for a setting by _id', async () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+        const settingId = '1';
+        const expectedSetting: ISetting = {
+            id: settingId,
+            key: 'existingKey',
+            value: 'existingValue',
+            label: 'Existing Key Label',
+            group: 'Default Group',
+            type: 'string',
+            options: []
+        };
+
+        // Mock the findById method of the repository
+        vi.spyOn(repository, 'findById').mockResolvedValue(expectedSetting);
+
+        // Act
+        const foundSetting = await repository.findById(settingId);
+
+        // Assert
+        expect(foundSetting).toEqual(expectedSetting);
+        expect(repository.findById).toHaveBeenCalledWith(settingId);
+    });
+
+
+    it('should correctly handle searching for a setting by key', async () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+        const searchKey = 'sampleKey';
+        const expectedSettings: ISetting[] = [{
+            id: '1',
+            key: 'sampleKey',
+            value: 'sampleValue',
+            label: 'Sample Setting Label',
+            group: 'Sample Group',
+            type: 'string',
+            options: []
+        }];
+
+        // Mock the search method of the repository
+        vi.spyOn(repository, 'search').mockResolvedValue(expectedSettings);
+
+        // Act
+        const foundSettings = await repository.search(searchKey);
+
+        // Assert
+        expect(foundSettings).toEqual(expectedSettings);
+        expect(repository.search).toHaveBeenCalledWith(searchKey);
+    });
+
+
+
+    it('should correctly handle deleting a setting from the repository', async () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+        const settingId = '1';
+        const expectedDeletionResult = true;
+
+        // Mock the delete method of the repository
+        vi.spyOn(repository, 'delete').mockResolvedValue(expectedDeletionResult);
+
+        // Act
+        const deletionResult = await repository.delete(settingId);
+
+        // Assert
+        expect(deletionResult).toBe(expectedDeletionResult);
+        expect(repository.delete).toHaveBeenCalledWith(settingId);
+    });
+
+
+    it('should correctly handle retrieving all settings from the repository', async () => {
+        // Arrange
+        const repository = new SettingMongoRepository();
+        const expectedSettings: ISetting[] = [{
+            id: '1',
+            key: 'existingKey',
+            value: 'existingValue',
+            label: 'Existing Key Label',
+            group: 'Default Group',
+            type: 'string',
+            options: []
+        }];
+
+        // Mock the fetchAll method of the repository
+        vi.spyOn(repository, 'fetchAll').mockResolvedValue(expectedSettings);
+
+        // Act
+        const allSettings = await repository.fetchAll();
+
+        // Assert
+        expect(allSettings).toEqual(expectedSettings);
+        expect(repository.fetchAll).toHaveBeenCalled();
+    });
+
+})