@drax/crud-back 0.4.0

package/dist/controllers/AbstractFastifyController.js

@@ -0,0 +1,193 @@
+import { ValidationError } from "@drax/common-back";
+import { UnauthorizedError } from "@drax/identity-back";
+class AbstractFastifyController {
+    constructor(service, permission) {
+        this.service = service;
+        this.permission = permission;
+        console.log("AbstractFastifyController created. Permissions", this.permission);
+    }
+    async findById(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            if (!request.params.id) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const id = request.params.id;
+            let item = await this.service.findById(id);
+            return item;
+        }
+        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' });
+            }
+        }
+    }
+    async findByIds(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            if (!request.params.ids) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const ids = request.params.ids.split(",");
+            let items = await this.service.findByIds(ids);
+            return items;
+        }
+        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' });
+            }
+        }
+    }
+    async search(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            const search = request.query.search;
+            let item = await this.service.search(search);
+            return item;
+        }
+        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' });
+            }
+        }
+    }
+    async paginate(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const orderBy = request.query.orderBy;
+            const order = request.query.order;
+            const search = request.query.search;
+            let paginateResult = await this.service.paginate({ page, limit, orderBy, order, search });
+            return paginateResult;
+        }
+        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' });
+            }
+        }
+    }
+    async create(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.Create);
+            const payload = request.body;
+            let item = await this.service.create(payload);
+            return item;
+        }
+        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' });
+            }
+        }
+    }
+    async update(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.Update);
+            if (!request.params.id) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const id = request.params.id;
+            const payload = request.body;
+            let item = await this.service.update(id, payload);
+            return item;
+        }
+        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' });
+            }
+        }
+    }
+    async delete(request, reply) {
+        try {
+            request.rbac.assertPermission(this.permission.Delete);
+            if (!request.params.id) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const id = request.params.id;
+            await this.service.delete(id);
+            reply.send({ message: 'Item deleted successfully' });
+        }
+        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 AbstractFastifyController;
+export { AbstractFastifyController };

package/dist/index.js

@@ -0,0 +1,8 @@
+//CRUD
+import AbstractMongoRepository from "./repository/AbstractMongoRepository.js";
+import AbstractSqliteRepository from "./repository/AbstractSqliteRepository.js";
+import AbstractService from "./services/AbstractService.js";
+import AbstractFastifyController from "./controllers/AbstractFastifyController.js";
+export { 
+//CRUD
+AbstractMongoRepository, AbstractSqliteRepository, AbstractService, AbstractFastifyController, };

package/dist/interfaces/ICrudRepository.js

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

package/dist/interfaces/IEntityPermission.js

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

package/dist/interfaces/IEntityRepository.js

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

package/dist/repository/AbstractMongoRepository.js

@@ -0,0 +1,87 @@
+import "mongoose-paginate-v2";
+import mongoose from "mongoose";
+import { MongooseQueryFilter, MongooseSort, MongooseErrorToValidationError } from "@drax/common-back";
+class AbstractMongoRepository {
+    constructor() {
+        this._searchFields = [];
+        this._populateFields = [];
+    }
+    async create(data) {
+        try {
+            const item = new this._model(data);
+            await item.save();
+            //@ts-ignore
+            await item.populate(this._populateFields);
+            return item;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
+    async update(id, data) {
+        try {
+            const item = await this._model.findOneAndUpdate({ _id: id }, data, { new: true }).populate(this._populateFields).exec();
+            return item;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        const result = await this._model.deleteOne({ _id: id }).exec();
+        return result.deletedCount == 1;
+    }
+    async findById(id) {
+        const item = await this._model.findById(id).populate(this._populateFields).exec();
+        return item;
+    }
+    async findByIds(ids) {
+        const items = await this._model.find({ _id: { $in: ids } }).populate(this._populateFields).exec();
+        return items;
+    }
+    async findOneBy(field, value) {
+        const filter = { [field]: value };
+        const item = await this._model.findOne(filter).populate(this._populateFields).exec();
+        return item;
+    }
+    async findBy(field, value) {
+        const filter = { [field]: value };
+        const items = await this._model.find(filter).populate(this._populateFields).exec();
+        return items;
+    }
+    async fetchAll() {
+        const items = await this._model.find().populate(this._populateFields).exec();
+        return items;
+    }
+    async search(value, limit = 1000) {
+        const query = {};
+        query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value, 'i') }));
+        const items = await this._model.find(query).limit(limit).exec();
+        return items;
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
+        const query = {};
+        if (search) {
+            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search, 'i') }));
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const sort = MongooseSort.applySort(orderBy, order);
+        const populate = this._populateFields;
+        const options = { page, limit, sort, populate };
+        const items = await this._model.paginate(query, options);
+        return {
+            page: page,
+            limit: limit,
+            total: items.totalDocs,
+            items: items.docs
+        };
+    }
+}
+export default AbstractMongoRepository;
+export { AbstractMongoRepository };

package/dist/repository/AbstractSqliteRepository.js

@@ -0,0 +1,121 @@
+import sqlite from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { SqlSort, SqlQueryFilter, SqliteTableBuilder, SqliteErrorToValidationError } from "@drax/common-back";
+class AbstractSqliteRepository {
+    constructor(dataBase, tableName, identifier = 'id', searchFields = [], booleanFields = [], verbose = false) {
+        this.searchFields = [];
+        this.booleanFields = [];
+        this.identifier = 'id';
+        if (!dataBase) {
+            throw new Error("dataBase is required");
+        }
+        if (!tableName) {
+            throw new Error("tableName is required");
+        }
+        this.dataBase = dataBase;
+        this.tableName = tableName;
+        this.identifier = identifier;
+        this.searchFields = searchFields;
+        this.booleanFields = booleanFields;
+        this.verbose = verbose;
+        this.db = new sqlite(dataBase, { verbose: verbose ? console.log : null });
+    }
+    build() {
+        const builder = new SqliteTableBuilder(this.dataBase, this.tableName, this.tableFields, this.verbose);
+        builder.build(this.identifier);
+    }
+    async create(data) {
+        try {
+            if (!data[this.identifier]) {
+                data[this.identifier] = randomUUID();
+            }
+            for (const key in data) {
+                if (typeof data[key] === 'boolean') {
+                    data[key] = data[key] ? 1 : 0;
+                }
+            }
+            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 ${this.tableName} (${fields}) VALUES (${values})`);
+            stmt.run(data);
+            return this.findById(data[this.identifier]);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, data);
+        }
+    }
+    async findById(id) {
+        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${this.identifier} = ?`).get(id);
+        return item;
+    }
+    async findBy(field, value) {
+        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${field} = ?`).all(value);
+        return item;
+    }
+    async findOneBy(field, value) {
+        const item = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${field} = ?`).get(value);
+        return item;
+    }
+    async update(id, data) {
+        try {
+            for (const key in data) {
+                if (typeof data[key] === 'boolean') {
+                    data[key] = data[key] ? 1 : 0;
+                }
+            }
+            const setClauses = Object.keys(data)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            data.identifier = id;
+            const stmt = this.db.prepare(`UPDATE ${this.tableName} SET ${setClauses} WHERE ${this.identifier} = @identifier `);
+            stmt.run(data);
+            return this.findById(id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, data);
+        }
+    }
+    async delete(id) {
+        const stmt = this.db.prepare(`DELETE FROM ${this.tableName} WHERE ${this.identifier} = ?`);
+        stmt.run(id);
+        return true;
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', order = 'desc', search = '', filters = [] }) {
+        const offset = page > 1 ? (page - 1) * limit : 0;
+        let where = "";
+        if (search && this.searchFields.length > 0) {
+            where = ` WHERE ${this.searchFields.map(field => `${field} LIKE '%${search}%'`).join(" OR ")}`;
+        }
+        if (filters.length > 0) {
+            where = SqlQueryFilter.applyFilters(where, filters);
+        }
+        const sort = SqlSort.applySort(orderBy, order);
+        const rCount = this.db.prepare(`SELECT COUNT(*) as count FROM ${this.tableName} ${where}`).get();
+        const items = this.db.prepare(`SELECT * FROM ${this.tableName} ${where} ${sort} LIMIT ? OFFSET ? `).all([limit, offset]);
+        for (const item of items) {
+            for (const key in item) {
+                if (this.booleanFields.includes(key)) {
+                    //@ts-ignore
+                    item[key] = item[key] ? true : false;
+                }
+            }
+        }
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: items
+        };
+    }
+    async fetchAll() {
+        const tenants = this.db.prepare(`SELECT * FROM ${this.tableName}`).all();
+        return tenants;
+    }
+}
+export default AbstractSqliteRepository;

package/dist/services/AbstractService.js

@@ -0,0 +1,122 @@
+import { ZodErrorToValidationError } from "@drax/common-back";
+import { ZodError } from "zod";
+class AbstractService {
+    constructor(repository, schema) {
+        this._repository = repository;
+        this._schema = schema;
+    }
+    async create(data) {
+        try {
+            if (this._schema) {
+                await this._schema.parseAsync(data);
+            }
+            const item = await this._repository.create(data);
+            return item;
+        }
+        catch (e) {
+            console.error("Error creating", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data);
+            }
+            throw e;
+        }
+    }
+    async update(id, data) {
+        try {
+            if (this._schema) {
+                await this._schema.parseAsync(data);
+            }
+            const item = await this._repository.update(id, data);
+            return item;
+        }
+        catch (e) {
+            console.error("Error updating", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data);
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        try {
+            const deleted = await this._repository.delete(id);
+            return deleted;
+        }
+        catch (e) {
+            console.error("Error deleting", e);
+            throw e;
+        }
+    }
+    async findById(id) {
+        try {
+            const item = await this._repository.findById(id);
+            return item;
+        }
+        catch (e) {
+            console.error("Error finding Auto by id", e);
+            throw e;
+        }
+    }
+    async findByIds(ids) {
+        try {
+            const items = await this._repository.findByIds(ids);
+            return items;
+        }
+        catch (e) {
+            console.error("Error finding Auto by id", e);
+            throw e;
+        }
+    }
+    async findOneBy(field, value) {
+        try {
+            const item = await this._repository.findOneBy(field, value);
+            return item;
+        }
+        catch (e) {
+            console.error("Error finding Auto findOneBy", e);
+            throw e;
+        }
+    }
+    async findBy(field, value) {
+        try {
+            const items = await this._repository.findBy(field, value);
+            return items;
+        }
+        catch (e) {
+            console.error("Error finding Auto findBy", e);
+            throw e;
+        }
+    }
+    async fetchAll() {
+        try {
+            const items = await this._repository.fetchAll();
+            return items;
+        }
+        catch (e) {
+            console.error("Error fetching all Autos", e);
+            throw e;
+        }
+    }
+    async search(value) {
+        try {
+            const items = await this._repository.search(value);
+            return items;
+        }
+        catch (e) {
+            console.error("Error fetching all Autos", e);
+            throw e;
+        }
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, order, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating", e);
+            throw e;
+        }
+    }
+}
+export default AbstractService;
+export { AbstractService };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@drax/crud-back",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.4.0",
+  "description": "Crud utils across modules",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "prepublish": "tsc && npm run copygql",
+    "tscrun": "tsc",
+    "clean": "rm -rf dist",
+    "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
+    "tsc": "tsc -b tsconfig.json",
+    "test": "node --import tsx --test test/**/*",
+    "testCache": "node --import tsx --test test/cache/*",
+    "testMongoose": "node --import tsx --test test/mongoose/*"
+  },
+  "author": "Cristian Incarnato & Drax Team",
+  "license": "ISC",
+  "dependencies": {
+    "@drax/common-back": "^0.4.0",
+    "@drax/common-share": "^0.4.0",
+    "@graphql-tools/load-files": "^7.0.0",
+    "@graphql-tools/merge": "^9.0.4",
+    "mongoose": "^8.6.3",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
+  "peerDependencies": {
+    "dayjs": "^1.11.13",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.10",
+    "copyfiles": "^2.4.1",
+    "mongoose-paginate-v2": "^1.8.3",
+    "nodemon": "^3.1.0",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.6.2"
+  },
+  "gitHead": "481b302fe72f403abf092806ceca540dd2765dfa"
+}