@drax/crud-back 2.11.0 → 3.0.0

package/test/people/repository/sqlite/PersonSqliteRepository.ts

@@ -0,0 +1,42 @@
+
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import type {IPersonRepository} from '../../interfaces/IPersonRepository'
+import type {IPerson, IPersonBase} from "../../interfaces/IPerson";
+import {SqliteTableField} from "@drax/common-back";
+
+class PersonSqliteRepository extends AbstractSqliteRepository<IPerson, IPersonBase, IPersonBase> implements IPersonRepository {
+
+    protected db: any;
+    protected tableName: string = 'Person';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = ['fullname', 'hobbies', 'race', 'interests'];
+    protected booleanFields: string[] = ['live'];
+    protected identifier: string = '_id';
+    protected populateFields = [
+        { field: 'nationality', table: 'nationality', identifier: '_id' },
+{ field: 'languages', table: 'languages', identifier: '_id' },
+{ field: 'tenant', table: 'tenant', identifier: '_id' },
+{ field: 'user', table: 'user', identifier: '_id' }
+    ]
+    protected verbose: boolean = false;
+    protected tableFields: SqliteTableField[] = [
+        {name: "fullname", type: "TEXT", unique: true, primary: false},
+{name: "live", type: "TEXT", unique: false, primary: false},
+{name: "birthdate", type: "TEXT", unique: false, primary: false},
+{name: "secret", type: "TEXT", unique: false, primary: false},
+{name: "nationality", type: "TEXT", unique: false, primary: false},
+{name: "hobbies", type: "TEXT", unique: false, primary: false},
+{name: "race", type: "TEXT", unique: false, primary: false},
+{name: "interests", type: "TEXT", unique: false, primary: false},
+{name: "languages", type: "TEXT", unique: false, primary: false},
+{name: "address", type: "TEXT", unique: undefined, primary: false},
+{name: "skills", type: "TEXT", unique: undefined, primary: false},
+{name: "tenant", type: "TEXT", unique: false, primary: false},
+{name: "user", type: "TEXT", unique: false, primary: false}
+    ]
+  
+}
+
+export default PersonSqliteRepository
+export {PersonSqliteRepository}
+

package/test/people/routes/CountryRoutes.ts

@@ -0,0 +1,34 @@
+
+import CountryController from "../controllers/CountryController.js";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {CountrySchema, CountryBaseSchema} from '../schemas/CountrySchema.js'
+
+async function CountryFastifyRoutes(fastify, options) {
+
+    const controller: CountryController = new CountryController()
+    const schemas = new CrudSchemaBuilder(CountrySchema, CountryBaseSchema,CountryBaseSchema, 'Country', 'openapi-3.0', ['ABM']);
+
+    fastify.get('/api/countries', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
+    
+    fastify.get('/api/countries/find', {schema: schemas.findSchema}, (req,rep) => controller.find(req,rep))
+    
+    fastify.get('/api/countries/search', {schema: schemas.searchSchema}, (req,rep) => controller.search(req,rep))
+    
+    fastify.get('/api/countries/:id', {schema: schemas.findByIdSchema}, (req,rep) => controller.findById(req,rep))
+    
+    fastify.get('/api/countries/find-one', {schema: schemas.findOneSchema}, (req,rep) => controller.findOne(req,rep))
+    
+    fastify.get('/api/countries/group-by', {schema: schemas.groupBySchema}, (req,rep) => controller.groupBy(req,rep))
+
+    fastify.post('/api/countries', {schema: schemas.createSchema}, (req,rep) =>controller.create(req,rep))
+
+    fastify.put('/api/countries/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.update(req,rep))
+    
+    fastify.patch('/api/countries/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.updatePartial(req,rep))
+
+    fastify.delete('/api/countries/:id', {schema: schemas.deleteSchema}, (req,rep) =>controller.delete(req,rep))
+    
+}
+
+export default CountryFastifyRoutes;
+export {CountryFastifyRoutes}

package/test/people/routes/LanguageRoutes.ts

@@ -0,0 +1,34 @@
+
+import LanguageController from "../controllers/LanguageController.js";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {LanguageSchema, LanguageBaseSchema} from '../schemas/LanguageSchema.js'
+
+async function LanguageFastifyRoutes(fastify, options) {
+
+    const controller: LanguageController = new LanguageController()
+    const schemas = new CrudSchemaBuilder(LanguageSchema, LanguageBaseSchema,LanguageBaseSchema, 'Language', 'openapi-3.0', ['people']);
+
+    fastify.get('/api/language', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
+    
+    fastify.get('/api/language/find', {schema: schemas.findSchema}, (req,rep) => controller.find(req,rep))
+    
+    fastify.get('/api/language/search', {schema: schemas.searchSchema}, (req,rep) => controller.search(req,rep))
+    
+    fastify.get('/api/language/:id', {schema: schemas.findByIdSchema}, (req,rep) => controller.findById(req,rep))
+    
+    fastify.get('/api/language/find-one', {schema: schemas.findOneSchema}, (req,rep) => controller.findOne(req,rep))
+    
+    fastify.get('/api/language/group-by', {schema: schemas.groupBySchema}, (req,rep) => controller.groupBy(req,rep))
+
+    fastify.post('/api/language', {schema: schemas.createSchema}, (req,rep) =>controller.create(req,rep))
+
+    fastify.put('/api/language/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.update(req,rep))
+    
+    fastify.patch('/api/language/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.updatePartial(req,rep))
+
+    fastify.delete('/api/language/:id', {schema: schemas.deleteSchema}, (req,rep) =>controller.delete(req,rep))
+    
+}
+
+export default LanguageFastifyRoutes;
+export {LanguageFastifyRoutes}

package/test/people/routes/PersonRoutes.ts

@@ -0,0 +1,40 @@
+
+import PersonController from "../controllers/PersonController.js";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {PersonSchema, PersonBaseSchema} from '../schemas/PersonSchema.js'
+
+async function PersonFastifyRoutes(fastify, options) {
+
+    const controller: PersonController = new PersonController()
+    const schemas = new CrudSchemaBuilder(PersonSchema, PersonBaseSchema,PersonBaseSchema, 'Person', 'openapi-3.0', ['people']);
+
+    fastify.get('/api/person', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
+
+    fastify.get('/api/person/find', {schema: schemas.findSchema}, (req,rep) => controller.find(req,rep))
+
+    fastify.get('/api/person/search', {schema: schemas.searchSchema}, (req,rep) => controller.search(req,rep))
+
+    fastify.get('/api/person/:id', {schema: schemas.findByIdSchema}, (req,rep) => controller.findById(req,rep))
+    
+    fastify.get('/api/person/find-one', {schema: schemas.findOneSchema}, (req,rep) => controller.findOne(req,rep))
+
+    fastify.get('/api/person/find-by/:field/:value', {schema: schemas.findBySchema}, (req,rep) => controller.findBy(req,rep))
+
+    fastify.get('/api/person/find-one-by/:field/:value', {schema: schemas.findOneBySchema}, (req,rep) => controller.findOneBy(req,rep))
+    
+    fastify.get('/api/person/group-by', {schema: schemas.groupBySchema}, (req,rep) => controller.groupBy(req,rep))
+
+    fastify.post('/api/person', {schema: schemas.createSchema}, (req,rep) =>controller.create(req,rep))
+
+    fastify.put('/api/person/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.update(req,rep))
+
+    fastify.patch('/api/person/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.updatePartial(req,rep))
+
+    fastify.delete('/api/person/:id', {schema: schemas.deleteSchema}, (req,rep) =>controller.delete(req,rep))
+
+    fastify.get('/api/person/export',  (req,rep) =>controller.export(req,rep))
+
+}
+
+export default PersonFastifyRoutes;
+export {PersonFastifyRoutes}

package/test/people/schemas/CountrySchema.ts

@@ -0,0 +1,22 @@
+
+import { z } from 'zod';
+
+
+const CountryBaseSchema = z.object({
+      name: z.string().min(1,'validation.required'),
+    description: z.string().optional().default('Some Description'),
+    flag: z.string().optional(),
+    metadata: z.record(z.string(),z.unknown()).optional().nullable(),
+    tenant: z.coerce.string().optional().nullable(),
+    createdBy: z.coerce.string().optional()
+});
+
+const CountrySchema = CountryBaseSchema
+    .extend({
+      _id: z.coerce.string(),
+       tenant: z.object({_id: z.coerce.string(), name: z.string()}).nullable().optional(),
+createdBy: z.object({_id: z.coerce.string(), username: z.string()})
+    })
+
+export default CountrySchema;
+export {CountrySchema, CountryBaseSchema}

package/test/people/schemas/LanguageSchema.ts

@@ -0,0 +1,22 @@
+import {z} from 'zod';
+
+
+const LanguageBaseSchema = z.object({
+    name: z.string().min(1, 'validation.required'),
+    icon: z.object({
+        filename: z.string().min(1, 'validation.required'),
+        filepath: z.string().min(1, 'validation.required'),
+        size: z.number().min(1, 'validation.required'),
+        mimetype: z.string().optional(),
+        url: z.string().min(1, 'validation.required')
+    }).optional()
+});
+
+const LanguageSchema = LanguageBaseSchema
+    .extend({
+        _id: z.coerce.string(),
+
+    })
+
+export default LanguageSchema;
+export {LanguageSchema, LanguageBaseSchema}

package/test/people/schemas/PersonSchema.ts

@@ -0,0 +1,42 @@
+import {z} from 'zod';
+
+
+const PersonBaseSchema = z.object({
+    fullname: z.string().min(1, 'validation.required'),
+    live: z.boolean().optional(),
+    birthdate: z.coerce.date().nullable().optional(),
+    secret: z.string().optional(),
+    money: z.number().nullable().optional(),
+    nationality: z.coerce.string().optional().nullable(),
+    hobbies: z.array(z.string()).optional(),
+    race: z.enum(['human', 'elf', 'orc']).optional(),
+    interests: z.array(z.enum(['sports', 'music', 'reading', 'travel', 'cooking', 'technology'])).optional().default(["sports", "music"]),
+    languages: z.array(z.coerce.string()).optional(),
+    address: z.object({
+        country: z.string().optional(),
+        city: z.string().optional(),
+        street: z.string().min(1, 'validation.required'),
+        zip: z.number().nullable().optional(),
+        casa: z.boolean().optional()
+    }),
+    skills: z.array(
+        z.object({
+            name: z.string().min(1, 'validation.required'),
+            level: z.number().nullable().optional()
+        })
+    ).optional(),
+    tenant: z.coerce.string().optional().nullable(),
+    user: z.coerce.string().optional().nullable()
+});
+
+const PersonSchema = PersonBaseSchema
+    .extend({
+        _id: z.coerce.string(),
+        nationality: z.object({_id: z.coerce.string(), name: z.string()}).nullable().optional(),
+        languages: z.array(z.object({_id: z.coerce.string(), name: z.string()})).optional(),
+        tenant: z.object({_id: z.coerce.string(), name: z.string()}).nullable().optional(),
+        user: z.object({_id: z.coerce.string(), username: z.string()}).nullable().optional()
+    })
+
+export default PersonSchema;
+export {PersonSchema, PersonBaseSchema}

package/test/people/services/CountryService.ts

@@ -0,0 +1,20 @@
+
+import type{ICountryRepository} from "../interfaces/ICountryRepository";
+import type {ICountryBase, ICountry} from "../interfaces/ICountry";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class CountryService extends AbstractService<ICountry, ICountryBase, ICountryBase> {
+
+
+    constructor(CountryRepository: ICountryRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
+        super(CountryRepository, baseSchema, fullSchema);
+        
+        this._validateOutput = true
+        
+    }
+
+}
+
+export default CountryService
+export {CountryService}

package/test/people/services/LanguageService.ts

@@ -0,0 +1,20 @@
+
+import type{ILanguageRepository} from "../interfaces/ILanguageRepository";
+import type {ILanguageBase, ILanguage} from "../interfaces/ILanguage";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class LanguageService extends AbstractService<ILanguage, ILanguageBase, ILanguageBase> {
+
+
+    constructor(LanguageRepository: ILanguageRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
+        super(LanguageRepository, baseSchema, fullSchema);
+        
+        this._validateOutput = true
+        
+    }
+
+}
+
+export default LanguageService
+export {LanguageService}

package/test/people/services/PersonService.ts

@@ -0,0 +1,20 @@
+
+import type{IPersonRepository} from "../interfaces/IPersonRepository";
+import type {IPersonBase, IPerson} from "../interfaces/IPerson";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class PersonService extends AbstractService<IPerson, IPersonBase, IPersonBase> {
+
+
+    constructor(PersonRepository: IPersonRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
+        super(PersonRepository, baseSchema, fullSchema);
+        
+        this._validateOutput = true
+        
+    }
+
+}
+
+export default PersonService
+export {PersonService}

package/test/services/AbstractService.test.ts

@@ -1,19 +1,23 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
+import { test, assert } from 'vitest';
 import MockRepository from "../_mocks/MockRepository.js";
 import {AbstractService} from "../../src/services/AbstractService.js";
 import {fileURLToPath} from "url";
-import path from "path";
+import * as path from "path";
 
 //@ts-ignore
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const mockRepository = new MockRepository();
-const abstractService = new AbstractService(mockRepository);
+
+class MockService extends AbstractService<any,any,any>{
+
+}
+
+const service = new MockService(mockRepository);
 
 test('create', async () => {
-    const item: any = await abstractService.create({name: 'John Doe'})
+    const item: any = await service.create({name: 'John Doe'})
     assert.deepStrictEqual(item.name, 'John Doe');
 })
 
@@ -22,7 +26,7 @@ test('export', async () => {
     const file = 'test.csv'
     const outputPath = path.resolve(__dirname, file);
 
-    const result:any = await abstractService.export(
+    const result:any = await service.export(
         {
             format: 'CSV',
             headers: ['name'],
@@ -30,7 +34,7 @@ test('export', async () => {
             limit: 0,
             search: '',
             filters: [],
-        }
+        },"/tmp"
     )
 
     console.log("result",result)

package/test/setup/MongoInMemory.ts

@@ -0,0 +1,56 @@
+import {mongoose} from '@drax/common-back';
+import {MongoMemoryServer} from 'mongodb-memory-server';
+
+class MongoInMemory {
+
+    mongoServer: MongoMemoryServer
+
+    async connect() {
+        this.mongoServer = await MongoMemoryServer.create();
+        if (this.mongoServer.state == "new") {
+            await this.mongoServer.start()
+        }
+        if (!mongoose.connection.readyState) {
+            await mongoose.connect(this.mongoServer.getUri(), {dbName: "verifyMASTER"});
+        }
+        return
+    }
+
+    get mongooseStatus() {
+        return mongoose.connection.readyState
+    }
+
+    get serverStatus() {
+        return this.mongoServer.state
+    }
+
+    get status() {
+        return mongoose.connection.readyState
+    }
+
+    async disconnect() {
+        await mongoose.disconnect();
+    }
+
+    async dropCollections() {
+        const collections = await mongoose.connection.listCollections()
+        for (let collection of collections) {
+            console.log(`Dropping collection: ${collection.name}`)
+            await mongoose.connection.dropCollection(collection.name)
+        }
+    }
+
+    async dropCollection(name: string) {
+        await mongoose.connection.dropCollection(name)
+    }
+
+    async dropAndClose() {
+        if (this.mongoServer) {
+            await mongoose.connection.dropDatabase();
+            await mongoose.connection.close();
+            await this.mongoServer.stop();
+        }
+    }
+}
+
+export default MongoInMemory