@recursyve/nestjs-unique-codes-sequelize 8.0.0-beta.4 → 8.0.0-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@recursyve/nestjs-unique-codes-sequelize",
-    "version": "8.0.0-beta.4",
+    "version": "8.0.0-beta.6",
     "publishConfig": {
         "access": "public"
     },

package/services/unique-codes.service.d.ts

@@ -1,13 +1,19 @@
 import { UniqueCodes, UniqueCodesService } from "@recursyve/nestjs-unique-codes-core";
 import { SequelizeUniqueCodes } from "../models";
-export declare class SequelizeUniqueCodesService extends UniqueCodesService {
+import { Transaction } from "sequelize";
+interface SequelizeUniqueCodeOptions {
+    transaction?: Transaction;
+}
+export declare class SequelizeUniqueCodesService extends UniqueCodesService<SequelizeUniqueCodeOptions> {
     private readonly repository;
     constructor(repository: typeof SequelizeUniqueCodes);
-    create(uniqueCode: Partial<UniqueCodes>): Promise<UniqueCodes>;
-    getByCode(code: string): Promise<UniqueCodes>;
-    findByCode(code: string): Promise<UniqueCodes | null>;
-    getByCodeAndType(code: string, type: string): Promise<UniqueCodes>;
-    findByCodeAndType(code: string, type: string): Promise<UniqueCodes | null>;
-    validate(uniqueCode: string | UniqueCodes): Promise<boolean>;
-    use(id: number, metadata?: Record<string, any>): Promise<void>;
+    create(uniqueCode: Partial<UniqueCodes>, options?: SequelizeUniqueCodeOptions): Promise<UniqueCodes>;
+    bulkCreate(uniqueCodes: Partial<UniqueCodes>[], options?: SequelizeUniqueCodeOptions): Promise<UniqueCodes[]>;
+    getByCode(code: string, options?: SequelizeUniqueCodeOptions): Promise<UniqueCodes>;
+    findByCode(code: string, options?: SequelizeUniqueCodeOptions): Promise<UniqueCodes | null>;
+    getByCodeAndType(code: string, type: string, options?: SequelizeUniqueCodeOptions): Promise<UniqueCodes>;
+    findByCodeAndType(code: string, type: string, options?: SequelizeUniqueCodeOptions): Promise<UniqueCodes | null>;
+    validate(uniqueCode: string | UniqueCodes, options?: SequelizeUniqueCodeOptions): Promise<boolean>;
+    use(id: number, metadata?: Record<string, any>, options?: SequelizeUniqueCodeOptions): Promise<void>;
 }
+export {};

package/services/unique-codes.service.js

@@ -12,49 +12,44 @@ let SequelizeUniqueCodesService = class SequelizeUniqueCodesService extends nest
         super();
         this.repository = repository;
     }
-    create(uniqueCode) {
-        return this.repository.create(uniqueCode);
+    create(uniqueCode, options) {
+        return this.repository.create(uniqueCode, options);
     }
-    async getByCode(code) {
-        const uniqueCode = await this.repository.findOne({
-            where: {
+    bulkCreate(uniqueCodes, options) {
+        return this.repository.bulkCreate(uniqueCodes, options);
+    }
+    async getByCode(code, options) {
+        const uniqueCode = await this.repository.findOne(Object.assign({ where: {
                 code
-            }
-        });
+            } }, options));
         if (!uniqueCode)
             throw new common_1.NotFoundException(`Unique code '${code}' not found`);
         return uniqueCode;
     }
-    findByCode(code) {
-        return this.repository.findOne({
-            where: {
+    findByCode(code, options) {
+        return this.repository.findOne(Object.assign({ where: {
                 code
-            }
-        });
+            } }, options));
     }
-    async getByCodeAndType(code, type) {
-        const uniqueCode = await this.repository.findOne({
-            where: {
+    async getByCodeAndType(code, type, options) {
+        const uniqueCode = await this.repository.findOne(Object.assign({ where: {
                 code,
                 type
-            }
-        });
+            } }, options));
         if (!uniqueCode)
             throw new common_1.NotFoundException(`Unique code '${code}' with type '${type}' not found`);
         return uniqueCode;
     }
-    findByCodeAndType(code, type) {
-        return this.repository.findOne({
-            where: {
+    findByCodeAndType(code, type, options) {
+        return this.repository.findOne(Object.assign({ where: {
                 code,
                 type
-            }
-        });
+            } }, options));
     }
-    async validate(uniqueCode) {
+    async validate(uniqueCode, options) {
         var _a, _b;
         if (typeof uniqueCode === "string") {
-            uniqueCode = await this.getByCode(uniqueCode);
+            uniqueCode = await this.getByCode(uniqueCode, options);
         }
         if (uniqueCode.availableUsageCount <= 0) {
             return false;
@@ -65,25 +60,23 @@ let SequelizeUniqueCodesService = class SequelizeUniqueCodesService extends nest
             end: (_b = uniqueCode.expiresAt) !== null && _b !== void 0 ? _b : now
         });
     }
-    async use(id, metadata) {
+    async use(id, metadata, options) {
         var _a;
-        const uniqueCode = await this.repository.findByPk(id);
-        const isValid = await this.validate(uniqueCode);
+        const uniqueCode = await this.repository.findByPk(id, options);
+        const isValid = await this.validate(uniqueCode, options);
         if (!isValid) {
             throw new common_1.BadRequestException(`Unique code ${uniqueCode.code} invalid`);
         }
         const usages = (_a = uniqueCode.usages) !== null && _a !== void 0 ? _a : [];
         usages.push(Object.assign(Object.assign({}, metadata), { usedAt: new Date() }));
         if (uniqueCode.availableUsageCount) {
-            await uniqueCode.decrement("availableUsageCount");
+            await uniqueCode.decrement("availableUsageCount", options);
         }
         await this.repository.update({
             usages
-        }, {
-            where: {
+        }, Object.assign({ where: {
                 id
-            }
-        });
+            } }, options));
     }
 };
 SequelizeUniqueCodesService = tslib_1.__decorate([