mongodb-dynamic-api 2.3.0 → 2.3.1

package/src/services/base/base.service.d.ts

@@ -24,21 +24,29 @@
 /// <reference types="mongoose/types/inferschematype" />
 import { Type } from '@nestjs/common';
 import { FilterQuery, Model, Schema } from 'mongoose';
-import { AbilityPredicate, DynamicApiCallbackMethods } from '../../interfaces';
+import { AbilityPredicate, DeleteResult, DynamicApiCallbackMethods, UpdateResult } from '../../interfaces';
 import { BaseEntity } from '../../models';
 import { DynamicApiResetPasswordOptions } from '../../modules';
 export declare abstract class BaseService<Entity extends BaseEntity> {
     protected readonly model: Model<Entity>;
-    abilityPredicate: AbilityPredicate<Entity> | undefined;
-    user: unknown;
+    protected user: unknown;
     protected readonly entity: Type<Entity>;
+    protected readonly abilityPredicate: AbilityPredicate<Entity> | undefined;
     protected readonly passwordField: keyof Entity | undefined;
     protected readonly resetPasswordOptions: DynamicApiResetPasswordOptions<Entity> | undefined;
-    protected readonly callbackMethods: DynamicApiCallbackMethods<Entity>;
+    protected readonly callbackMethods: DynamicApiCallbackMethods;
     protected constructor(model: Model<Entity>);
     get isSoftDeletable(): boolean;
-    findManyDocuments(conditions?: FilterQuery<Entity>): Promise<Entity[]>;
-    findOneDocument(_id: string | Schema.Types.ObjectId | undefined, conditions?: FilterQuery<Entity>): Promise<Entity>;
+    protected findManyDocumentsWithAbilityPredicate(conditions?: FilterQuery<Entity>): Promise<Entity[]>;
+    protected findOneDocumentWithAbilityPredicate(_id: string | Schema.Types.ObjectId | undefined, conditions?: FilterQuery<Entity>): Promise<Entity>;
+    protected findManyDocuments<T>(entity: Type<T>, query: FilterQuery<T>): Promise<T[]>;
+    protected findOneDocument<T>(entity: Type<T>, query: FilterQuery<T>): Promise<T | undefined>;
+    protected createManyDocuments<T>(entity: Type<T>, data: Partial<T>[]): Promise<T[]>;
+    protected createOneDocument<T>(entity: Type<T>, data: Partial<T>): Promise<T>;
+    protected updateManyDocuments<T>(entity: Type<T>, query: FilterQuery<T>, data: Partial<T>): Promise<UpdateResult>;
+    protected updateOneDocument<T>(entity: Type<T>, query: FilterQuery<T>, data: Partial<T>): Promise<UpdateResult>;
+    protected deleteManyDocuments<T>(entity: Type<T>, ids: string[]): Promise<DeleteResult>;
+    protected deleteOneDocument<T>(entity: Type<T>, id: string): Promise<DeleteResult>;
     protected buildInstance(document: Entity): Entity;
     protected handleAbilityPredicate(document: Entity): void;
     protected handleDuplicateKeyError(error: any): void;

package/src/services/base/base.service.js

@@ -3,51 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseService = void 0;
 const common_1 = require("@nestjs/common");
 const builder_pattern_1 = require("builder-pattern");
+const dynamic_api_global_state_service_1 = require("../dynamic-api-global-state/dynamic-api-global-state.service");
 class BaseService {
     constructor(model) {
         this.model = model;
         this.callbackMethods = {
-            findById: async (id) => {
-                const entity = await this.model.findOne({ _id: id }).lean().exec();
-                if (!entity) {
-                    return;
-                }
-                return this.buildInstance(entity);
-            },
-            findAndUpdateById: async (id, update) => {
-                if (this.passwordField && typeof update[this.passwordField] !== 'undefined') {
-                    throw new common_1.BadRequestException(`${this.passwordField} cannot be updated using this method because it is hashed. Use reset password process instead.`);
-                }
-                const updated = await this.model.findOneAndUpdate({ _id: id }, update, { new: true }).lean().exec();
-                if (!updated) {
-                    this.handleDocumentNotFound();
-                }
-                return this.buildInstance(updated);
-            },
+            findManyDocuments: this.findManyDocuments.bind(this),
+            findOneDocument: this.findOneDocument.bind(this),
+            createManyDocuments: this.createManyDocuments.bind(this),
+            createOneDocument: this.createOneDocument.bind(this),
+            updateManyDocuments: this.updateManyDocuments.bind(this),
+            updateOneDocument: this.updateOneDocument.bind(this),
+            deleteManyDocuments: this.deleteManyDocuments.bind(this),
+            deleteOneDocument: this.deleteOneDocument.bind(this),
         };
     }
     get isSoftDeletable() {
         const paths = Object.getOwnPropertyNames(this.model.schema.paths);
         return paths.includes('deletedAt') && paths.includes('isDeleted');
     }
-    async findManyDocuments(conditions = {}) {
-        const documents = await this.model
-            .find(conditions)
-            .lean()
-            .exec();
+    async findManyDocumentsWithAbilityPredicate(conditions = {}) {
+        const documents = await this.findManyDocuments(this.entity, conditions);
         if (this.abilityPredicate) {
             documents.forEach((d) => this.handleAbilityPredicate(d));
         }
         return documents;
     }
-    async findOneDocument(_id, conditions = {}) {
-        const document = await this.model
-            .findOne({
+    async findOneDocumentWithAbilityPredicate(_id, conditions = {}) {
+        const document = await this.findOneDocument(this.entity, {
             ...(_id ? { _id } : {}),
             ...conditions,
-        })
-            .lean()
-            .exec();
+        });
         if (!document) {
             throw new common_1.BadRequestException('Document not found');
         }
@@ -56,6 +42,50 @@ class BaseService {
         }
         return document;
     }
+    async findManyDocuments(entity, query) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        return model.find(query).lean().exec();
+    }
+    async findOneDocument(entity, query) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        return model.findOne(query).lean().exec();
+    }
+    async createManyDocuments(entity, data) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        return model.create(data);
+    }
+    async createOneDocument(entity, data) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        return model.create(data);
+    }
+    async updateManyDocuments(entity, query, data) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        return model.updateMany(query, data).exec();
+    }
+    async updateOneDocument(entity, query, data) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        return model.updateOne(query, data).exec();
+    }
+    async deleteManyDocuments(entity, ids) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        const paths = Object.getOwnPropertyNames(model.schema.paths);
+        const isSoftDeletable = paths.includes('deletedAt') && paths.includes('isDeleted');
+        if (isSoftDeletable) {
+            const result = await model.updateMany({ _id: { $in: ids } }, { isDeleted: true, deletedAt: new Date() }).exec();
+            return { deletedCount: result.modifiedCount };
+        }
+        return model.deleteMany({ _id: { $in: ids } }).exec();
+    }
+    async deleteOneDocument(entity, id) {
+        const model = await dynamic_api_global_state_service_1.DynamicApiGlobalStateService.getEntityModel(entity);
+        const paths = Object.getOwnPropertyNames(model.schema.paths);
+        const isSoftDeletable = paths.includes('deletedAt') && paths.includes('isDeleted');
+        if (isSoftDeletable) {
+            const result = await model.updateOne({ _id: id }, { isDeleted: true, deletedAt: new Date() }).exec();
+            return { deletedCount: result.modifiedCount };
+        }
+        return model.deleteOne({ _id: id }).exec();
+    }
     buildInstance(document) {
         const { _id, id, __v, ...rest } = document;
         return (0, builder_pattern_1.Builder)(this.entity, rest)

package/src/services/dynamic-api-global-state/dynamic-api-global-state.service.d.ts

@@ -22,18 +22,20 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { Schema } from 'mongoose';
+import { Type } from '@nestjs/common';
+import { Model, Schema } from 'mongoose';
 import { BehaviorSubject } from 'rxjs';
 import { DynamicApiGlobalState } from '../../interfaces';
 export declare class DynamicApiGlobalStateService {
     private static readonly initialized$;
     private static readonly entitySchemas$;
-    private _;
+    private static connection;
+    private static _;
     private readonly defaultGlobalState;
     constructor(initialGlobalState?: Partial<DynamicApiGlobalState>);
     static onInitialized(): BehaviorSubject<boolean>;
-    static addEntitySchema<T = any>(name: string, schema: Schema<T>): void;
-    static getEntitySchema<T = any>(name: string): Schema<T, import("mongoose").Model<T, any, any, any, import("mongoose").IfAny<T, any, import("mongoose").Document<unknown, any, T> & import("mongoose").Require_id<T>>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>, import("mongoose").IfAny<import("mongoose").FlatRecord<import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>>, any, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>>> & import("mongoose").Require_id<import("mongoose").FlatRecord<import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>>>>>;
+    static addEntitySchema<T = any>(entity: Type<T>, schema: Schema<T>): void;
+    static getEntityModel<T = any>(entity: Type<T>): Promise<Model<T, {}, {}, {}, import("mongoose").IfAny<T, any, import("mongoose").Document<unknown, {}, T> & import("mongoose").Require_id<T>>, any>>;
     set<V>([target, value]: ([keyof DynamicApiGlobalState, value: V] | ['partial', Partial<DynamicApiGlobalState>])): void;
     get<T = DynamicApiGlobalState>(key?: keyof DynamicApiGlobalState): T;
     private updateState;

package/src/services/dynamic-api-global-state/dynamic-api-global-state.service.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicApiGlobalStateService = void 0;
+const mongoose_1 = require("mongoose");
 const rxjs_1 = require("rxjs");
 class DynamicApiGlobalStateService {
     constructor(initialGlobalState) {
-        this._ = {};
         this.defaultGlobalState = {
+            uri: '',
             connectionName: 'dynamic-api-connection',
             isGlobalCacheEnabled: true,
             isAuthEnabled: false,
@@ -29,37 +30,41 @@ class DynamicApiGlobalStateService {
                 ],
             },
         };
-        Object.assign(this._, this.defaultGlobalState, initialGlobalState);
+        Object.assign(DynamicApiGlobalStateService._, this.defaultGlobalState, initialGlobalState);
     }
     static onInitialized() {
         return this.initialized$;
     }
-    static addEntitySchema(name, schema) {
+    static addEntitySchema(entity, schema) {
         const entitySchemas = this.entitySchemas$.value;
-        entitySchemas[name] = schema;
+        entitySchemas[entity.name] = schema;
         this.entitySchemas$.next(entitySchemas);
     }
-    static getEntitySchema(name) {
-        const schema = this.entitySchemas$.value[name];
+    static async getEntityModel(entity) {
+        const schema = this.entitySchemas$.value[entity.name];
         if (!schema) {
-            throw new Error(`Entity schema for "${name}" not found`);
+            throw new Error(`Entity schema for "${entity.name}" not found`);
         }
-        return schema;
+        if (!this.connection) {
+            this.connection =
+                await (0, mongoose_1.createConnection)(this._.uri, { retryWrites: true, writeConcern: { w: 'majority' } }).asPromise();
+        }
+        return this.connection.model(entity.name, schema);
     }
     set([target, value]) {
         if (target === 'partial') {
-            Object.assign(this._, value);
+            Object.assign(DynamicApiGlobalStateService._, value);
         }
         else {
-            Object.assign(this._, { [target]: value });
+            Object.assign(DynamicApiGlobalStateService._, { [target]: value });
         }
         this.updateState();
     }
     get(key) {
-        return (key ? this._[key] : this._);
+        return (key ? DynamicApiGlobalStateService._[key] : DynamicApiGlobalStateService._);
     }
     updateState() {
-        if (this._.initialized && !DynamicApiGlobalStateService.initialized$.value) {
+        if (DynamicApiGlobalStateService._.initialized && !DynamicApiGlobalStateService.initialized$.value) {
             DynamicApiGlobalStateService.initialized$.next(true);
         }
     }
@@ -67,3 +72,4 @@ class DynamicApiGlobalStateService {
 exports.DynamicApiGlobalStateService = DynamicApiGlobalStateService;
 DynamicApiGlobalStateService.initialized$ = new rxjs_1.BehaviorSubject(false);
 DynamicApiGlobalStateService.entitySchemas$ = new rxjs_1.BehaviorSubject({});
+DynamicApiGlobalStateService._ = {};

package/src/version.json

@@ -1,3 +1,3 @@
 {
-    "version": "2.3.0"
+    "version": "2.3.1"
 }