@drax/crud-back 2.11.0 → 3.0.0

package/test/people/controllers/PersonController.ts

@@ -0,0 +1,29 @@
+
+import PersonServiceFactory from "../factory/services/PersonServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import PersonPermissions from "../permissions/PersonPermissions.js";
+import type {IPerson, IPersonBase} from "../interfaces/IPerson";
+
+class PersonController extends AbstractFastifyController<IPerson, IPersonBase, IPersonBase>   {
+
+    constructor() {
+        super(PersonServiceFactory.instance, PersonPermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+        
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+        
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+
+}
+
+export default PersonController;
+export {
+    PersonController
+}
+

package/test/people/factory/services/CountryServiceFactory.ts

@@ -0,0 +1,41 @@
+
+import CountryMongoRepository from '../../repository/mongo/CountryMongoRepository.js'
+import CountrySqliteRepository from '../../repository/sqlite/CountrySqliteRepository.js'
+import type {ICountryRepository} from "../../interfaces/ICountryRepository";
+import {CountryService} from '../../services/CountryService.js'
+import {CountryBaseSchema, CountrySchema} from "../../schemas/CountrySchema.js";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+class CountryServiceFactory {
+    private static service: CountryService;
+
+    public static get instance(): CountryService {
+        if (!CountryServiceFactory.service) {
+            
+            let repository: ICountryRepository
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new CountryMongoRepository()
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                    repository = new CountrySqliteRepository(dbFile, false)
+                    repository.build()
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            
+            const baseSchema = CountryBaseSchema;
+            const fullSchema = CountrySchema;
+            CountryServiceFactory.service = new CountryService(repository, baseSchema, fullSchema);
+        }
+        return CountryServiceFactory.service;
+    }
+}
+
+export default CountryServiceFactory
+export {
+    CountryServiceFactory
+}
+

package/test/people/factory/services/LanguageServiceFactory.ts

@@ -0,0 +1,41 @@
+
+import LanguageMongoRepository from '../../repository/mongo/LanguageMongoRepository.js'
+import LanguageSqliteRepository from '../../repository/sqlite/LanguageSqliteRepository.js'
+import type {ILanguageRepository} from "../../interfaces/ILanguageRepository";
+import {LanguageService} from '../../services/LanguageService.js'
+import {LanguageBaseSchema, LanguageSchema} from "../../schemas/LanguageSchema.js";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+class LanguageServiceFactory {
+    private static service: LanguageService;
+
+    public static get instance(): LanguageService {
+        if (!LanguageServiceFactory.service) {
+            
+            let repository: ILanguageRepository
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new LanguageMongoRepository()
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                    repository = new LanguageSqliteRepository(dbFile, false)
+                    repository.build()
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            
+            const baseSchema = LanguageBaseSchema;
+            const fullSchema = LanguageSchema;
+            LanguageServiceFactory.service = new LanguageService(repository, baseSchema, fullSchema);
+        }
+        return LanguageServiceFactory.service;
+    }
+}
+
+export default LanguageServiceFactory
+export {
+    LanguageServiceFactory
+}
+

package/test/people/factory/services/PersonServiceFactory.ts

@@ -0,0 +1,41 @@
+
+import PersonMongoRepository from '../../repository/mongo/PersonMongoRepository.js'
+import PersonSqliteRepository from '../../repository/sqlite/PersonSqliteRepository.js'
+import type {IPersonRepository} from "../../interfaces/IPersonRepository";
+import {PersonService} from '../../services/PersonService.js'
+import {PersonBaseSchema, PersonSchema} from "../../schemas/PersonSchema.js";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+class PersonServiceFactory {
+    private static service: PersonService;
+
+    public static get instance(): PersonService {
+        if (!PersonServiceFactory.service) {
+            
+            let repository: IPersonRepository
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new PersonMongoRepository()
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                    repository = new PersonSqliteRepository(dbFile, false)
+                    repository.build()
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            
+            const baseSchema = PersonBaseSchema;
+            const fullSchema = PersonSchema;
+            PersonServiceFactory.service = new PersonService(repository, baseSchema, fullSchema);
+        }
+        return PersonServiceFactory.service;
+    }
+}
+
+export default PersonServiceFactory
+export {
+    PersonServiceFactory
+}
+

package/test/people/interfaces/ICountry.ts

@@ -0,0 +1,28 @@
+
+interface ICountryBase {
+    name: string
+    description?: string
+    flag?: string
+    metadata?: Record<string, any>
+    tenant?: any
+    createdBy: any
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+interface ICountry {
+    _id: string
+    name: string
+    description?: string
+    flag?: string
+    metadata?: Record<string, any>
+    tenant?: any
+    createdBy: any
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+export type {
+ICountryBase, 
+ICountry
+}

package/test/people/interfaces/ICountryRepository.ts

@@ -0,0 +1,11 @@
+
+import type {ICountry, ICountryBase} from './ICountry'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface ICountryRepository extends IDraxCrudRepository<ICountry, ICountryBase, ICountryBase>{
+
+}
+
+export {ICountryRepository}
+
+

package/test/people/interfaces/ILanguage.ts

@@ -0,0 +1,32 @@
+
+interface ILanguageBase {
+    name: string
+    icon?: {
+                filename: string,
+                filepath: string,
+                size: number,
+                mimetype?: string,
+                url: string
+                }
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+interface ILanguage {
+    _id: string
+    name: string
+    icon?: {
+                filename: string,
+                filepath: string,
+                size: number,
+                mimetype?: string,
+                url: string
+                }
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+export type {
+ILanguageBase, 
+ILanguage
+}

package/test/people/interfaces/ILanguageRepository.ts

@@ -0,0 +1,11 @@
+
+import type {ILanguage, ILanguageBase} from './ILanguage'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface ILanguageRepository extends IDraxCrudRepository<ILanguage, ILanguageBase, ILanguageBase>{
+
+}
+
+export {ILanguageRepository}
+
+

package/test/people/interfaces/IPerson.ts

@@ -0,0 +1,58 @@
+
+interface IPersonBase {
+    fullname: string
+    live?: boolean
+    birthdate?: Date
+    secret?: string
+    money?: number
+    nationality?: any
+    hobbies?: Array<string>
+    race?: string
+    interests?: Array<string>
+    languages?: Array<any>
+    address?: {    country?: string
+    city?: string
+    street: string
+    zip?: number
+    casa?: boolean}
+    skills?: Array<{
+    name: string
+    level?: number
+    }>
+    tenant?: any
+    user?: any
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+interface IPerson {
+    _id: string
+    fullname: string
+    live?: boolean
+    birthdate?: Date
+    secret?: string
+    money?: number
+    nationality?: any
+    hobbies?: Array<string>
+    race?: string
+    interests?: Array<string>
+    languages?: Array<any>
+    address?: {    country?: string
+    city?: string
+    street: string
+    zip?: number
+    casa?: boolean}
+    skills?: Array<{
+    name: string
+    level?: number
+    }>
+    tenant?: any
+    user?: any
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+export type {
+IPersonBase, 
+IPerson
+}

package/test/people/interfaces/IPersonRepository.ts

@@ -0,0 +1,11 @@
+
+import type {IPerson, IPersonBase} from './IPerson'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IPersonRepository extends IDraxCrudRepository<IPerson, IPersonBase, IPersonBase>{
+
+}
+
+export {IPersonRepository}
+
+

package/test/people/models/CountryModel.ts

@@ -0,0 +1,38 @@
+
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {ICountry} from '../interfaces/ICountry'
+
+const CountrySchema = new mongoose.Schema<ICountry>({
+            name: {type: String,   required: true, index: true, unique: true },
+            description: {type: String,   required: false, index: false, unique: false },
+            flag: {type: String,   required: false, index: false, unique: false },
+            metadata: {type: mongoose.Schema.Types.Mixed,   required: false, index: false, unique: false },
+            tenant: {type: mongoose.Schema.Types.ObjectId, ref: 'Tenant',  required: false, index: false, unique: false },
+            createdBy: {type: mongoose.Schema.Types.ObjectId, ref: 'User',  required: true, index: false, unique: false }
+}, {timestamps: true});
+
+CountrySchema.plugin(uniqueValidator, {message: 'validation.unique'});
+CountrySchema.plugin(mongoosePaginate);
+
+CountrySchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+
+CountrySchema.set('toJSON', {getters: true, virtuals: true});
+
+CountrySchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'Country';
+const COLLECTION_NAME = 'Country';
+const CountryModel = mongoose.model<ICountry, PaginateModel<ICountry>>(MODEL_NAME, CountrySchema,COLLECTION_NAME);
+
+export {
+    CountrySchema,
+    CountryModel
+}
+
+export default CountryModel

package/test/people/models/LanguageModel.ts

@@ -0,0 +1,40 @@
+
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {ILanguage} from '../interfaces/ILanguage'
+
+const LanguageSchema = new mongoose.Schema<ILanguage>({
+            name: {type: String,   required: true, index: true, unique: true },
+            icon: {
+        filename: {type: String ,  required: false, index: false, unique: false },
+        filepath: {type: String ,  required: false, index: false, unique: false },
+        size: {type: Number ,  required: false, index: false, unique: false },
+        mimetype: {type: String ,  required: false, index: false, unique: false },
+        url: {type: String ,  required: false, index: false, unique: false },
+        }
+}, {timestamps: true});
+
+LanguageSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+LanguageSchema.plugin(mongoosePaginate);
+
+LanguageSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+
+LanguageSchema.set('toJSON', {getters: true, virtuals: true});
+
+LanguageSchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'Language';
+const COLLECTION_NAME = 'Language';
+const LanguageModel = mongoose.model<ILanguage, PaginateModel<ILanguage>>(MODEL_NAME, LanguageSchema,COLLECTION_NAME);
+
+export {
+    LanguageSchema,
+    LanguageModel
+}
+
+export default LanguageModel

package/test/people/models/PersonModel.ts

@@ -0,0 +1,61 @@
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+// @ts-ignore
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IPerson} from '../interfaces/IPerson'
+
+const PersonSchema = new mongoose.Schema<IPerson>({
+    fullname: {type: String, required: true, index: true, unique: true},
+    live: {type: Boolean, required: false, index: false, unique: false},
+    birthdate: {type: Date, required: false, index: false, unique: false},
+    secret: {type: String, required: false, index: false, unique: false},
+    money: {type: Number, required: false, index: false, unique: false},
+    nationality: {type: mongoose.Schema.Types.ObjectId, ref: 'Country', required: false, index: false, unique: false},
+    hobbies: [{type: String, required: false, index: false, unique: false}],
+    race: {type: String, enum: ['human', 'elf', 'orc'], required: false, index: false, unique: false},
+    interests: [{
+        type: String,
+        enum: ['sports', 'music', 'reading', 'travel', 'cooking', 'technology'],
+        required: false,
+        index: false,
+        unique: false
+    }],
+    languages: [{type: mongoose.Schema.Types.ObjectId, ref: 'Language', required: false, index: false, unique: false}],
+    address: {
+        country: {type: String, required: false, index: false, unique: false},
+        city: {type: String, required: false, index: false, unique: false},
+        street: {type: String, required: true, index: false, unique: false},
+        zip: {type: Number, required: false, index: false, unique: false},
+        casa: {type: Boolean, required: false, index: false, unique: false}
+    },
+    skills: [{
+        name: {type: String, required: true, index: false, unique: false},
+        level: {type: Number, required: false, index: false, unique: false}
+    }],
+    tenant: {type: mongoose.Schema.Types.ObjectId, ref: 'Tenant', required: false, index: false, unique: false},
+    user: {type: mongoose.Schema.Types.ObjectId, ref: 'User', required: false, index: false, unique: false}
+}, {timestamps: true});
+
+PersonSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+PersonSchema.plugin(mongoosePaginate);
+
+PersonSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+
+PersonSchema.set('toJSON', {getters: true, virtuals: true});
+
+PersonSchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'Person';
+const COLLECTION_NAME = 'Person';
+const PersonModel = mongoose.model<IPerson, PaginateModel<IPerson>>(MODEL_NAME, PersonSchema, COLLECTION_NAME);
+
+export {
+    PersonSchema,
+    PersonModel
+}
+
+export default PersonModel

package/test/people/permissions/CountryPermissions.ts

@@ -0,0 +1,14 @@
+
+enum CountryPermissions {
+
+    Create = "country:create",
+    Update = "country:update",
+    Delete = "country:delete",
+    View = "country:view",
+    Manage = "country:manage"
+
+}
+
+export { CountryPermissions };
+export default CountryPermissions;
+

package/test/people/permissions/LanguagePermissions.ts

@@ -0,0 +1,14 @@
+
+enum LanguagePermissions {
+
+    Create = "language:create",
+    Update = "language:update",
+    Delete = "language:delete",
+    View = "language:view",
+    Manage = "language:manage"
+
+}
+
+export { LanguagePermissions };
+export default LanguagePermissions;
+

package/test/people/permissions/PersonPermissions.ts

@@ -0,0 +1,18 @@
+
+enum PersonPermissions {
+
+    Create = "person:create",
+    Update = "person:update",
+    Delete = "person:delete",
+    View = "person:view",
+    Manage = "person:manage",
+
+    ViewAll = "person:viewAll",
+    UpdateAll = "person:updateAll",
+    DeleteAll = "person:deleteAll",
+
+}
+
+export { PersonPermissions };
+export default PersonPermissions;
+

package/test/people/repository/mongo/CountryMongoRepository.ts

@@ -0,0 +1,22 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {CountryModel} from "../../models/CountryModel.js";
+import type {ICountryRepository} from '../../interfaces/ICountryRepository'
+import type {ICountry, ICountryBase} from "../../interfaces/ICountry";
+
+
+class CountryMongoRepository extends AbstractMongoRepository<ICountry, ICountryBase, ICountryBase> implements ICountryRepository {
+
+    constructor() {
+        super();
+        this._model = CountryModel;
+        this._searchFields = ['name'];
+        this._populateFields = ['tenant', 'createdBy'];
+        this._lean = true
+    }
+
+}
+
+export default CountryMongoRepository
+export {CountryMongoRepository}
+

package/test/people/repository/mongo/LanguageMongoRepository.ts

@@ -0,0 +1,22 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {LanguageModel} from "../../models/LanguageModel.js";
+import type {ILanguageRepository} from '../../interfaces/ILanguageRepository'
+import type {ILanguage, ILanguageBase} from "../../interfaces/ILanguage";
+
+
+class LanguageMongoRepository extends AbstractMongoRepository<ILanguage, ILanguageBase, ILanguageBase> implements ILanguageRepository {
+
+    constructor() {
+        super();
+        this._model = LanguageModel;
+        this._searchFields = ['name'];
+        this._populateFields = [];
+        this._lean = true
+    }
+
+}
+
+export default LanguageMongoRepository
+export {LanguageMongoRepository}
+

package/test/people/repository/mongo/PersonMongoRepository.ts

@@ -0,0 +1,22 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {PersonModel} from "../../models/PersonModel.js";
+import type {IPersonRepository} from '../../interfaces/IPersonRepository'
+import type {IPerson, IPersonBase} from "../../interfaces/IPerson";
+
+
+class PersonMongoRepository extends AbstractMongoRepository<IPerson, IPersonBase, IPersonBase> implements IPersonRepository {
+
+    constructor() {
+        super();
+        this._model = PersonModel;
+        this._searchFields = ['fullname', 'hobbies', 'race', 'interests'];
+        this._populateFields = ['nationality', 'languages', 'tenant', 'user'];
+        this._lean = true
+    }
+
+}
+
+export default PersonMongoRepository
+export {PersonMongoRepository}
+

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

@@ -0,0 +1,33 @@
+
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import type {ICountryRepository} from '../../interfaces/ICountryRepository'
+import type {ICountry, ICountryBase} from "../../interfaces/ICountry";
+import {SqliteTableField} from "@drax/common-back";
+
+class CountrySqliteRepository extends AbstractSqliteRepository<ICountry, ICountryBase, ICountryBase> implements ICountryRepository {
+
+    protected db: any;
+    protected tableName: string = 'Country';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = ['name'];
+    protected booleanFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = [
+        { field: 'tenant', table: 'tenant', identifier: '_id' },
+{ field: 'createdBy', table: 'createdBy', identifier: '_id' }
+    ]
+    protected verbose: boolean = false;
+    protected tableFields: SqliteTableField[] = [
+        {name: "name", type: "TEXT", unique: true, primary: false},
+{name: "description", type: "TEXT", unique: false, primary: false},
+{name: "flag", type: "TEXT", unique: false, primary: false},
+{name: "metadata", type: "TEXT", unique: false, primary: false},
+{name: "tenant", type: "TEXT", unique: false, primary: false},
+{name: "createdBy", type: "TEXT", unique: false, primary: false}
+    ]
+  
+}
+
+export default CountrySqliteRepository
+export {CountrySqliteRepository}
+

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

@@ -0,0 +1,37 @@
+
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import type {ILanguageRepository} from '../../interfaces/ILanguageRepository'
+import type {ILanguage, ILanguageBase} from "../../interfaces/ILanguage";
+import {SqliteTableField} from "@drax/common-back";
+
+class LanguageSqliteRepository extends AbstractSqliteRepository<ILanguage, ILanguageBase, ILanguageBase> implements ILanguageRepository {
+
+    protected db: any;
+    protected tableName: string = 'Language';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = ['name'];
+    protected booleanFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = [
+
+    ]
+    protected verbose: boolean = false;
+    protected tableFields: SqliteTableField[] = [
+        {name: "name", type: "TEXT", unique: true, primary: false},
+{name: "icon", type: "TEXT", unique: false, primary: false}
+    ]
+
+
+    async prepareData(data: any): Promise<any> {
+        data.icon = JSON.stringify(data.icon)
+    }
+
+    async prepareItem(item: any): Promise<any> {
+        item.icon = JSON.parse(item.icon)
+    }
+
+}
+
+export default LanguageSqliteRepository
+export {LanguageSqliteRepository}
+