@koalarx/nest 0.0.3

package/services/env/env.module.js

@@ -0,0 +1,19 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvModule = void 0;
+const common_1 = require("@nestjs/common");
+const env_service_1 = require("./env.service");
+let EnvModule = exports.EnvModule = class EnvModule {
+};
+exports.EnvModule = EnvModule = __decorate([
+    (0, common_1.Module)({
+        providers: [env_service_1.EnvService],
+        exports: [env_service_1.EnvService],
+    })
+], EnvModule);

package/services/env/env.service.d.ts

@@ -0,0 +1,14 @@
+import { ConfigService } from '@nestjs/config';
+import { Env } from './env';
+export declare class EnvService {
+    private readonly configService;
+    constructor(configService: ConfigService<Env, true>);
+    get<T extends keyof Env>(key: T): import("@nestjs/config").PathValue<{
+        NODE_ENV: "test" | "develop" | "staging" | "production";
+        PORT: number;
+        PRISMA_QUERY_LOG: boolean;
+        SWAGGER_USERNAME: string;
+        SWAGGER_PASSWORD: string;
+        REDIS_CONNECTION_STRING: string;
+    }, T>;
+}

package/services/env/env.service.js

@@ -0,0 +1,22 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvService = void 0;
+const common_1 = require("@nestjs/common");
+let EnvService = exports.EnvService = class EnvService {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    get(key) {
+        return this.configService.get(key, { infer: true });
+    }
+};
+exports.EnvService = EnvService = __decorate([
+    (0, common_1.Injectable)()
+], EnvService);

package/services/logging/ilogging.service.d.ts

@@ -0,0 +1,16 @@
+export interface LoggingReportProps {
+    loggedUsername: string;
+    packageName: string;
+    error: Error;
+    httpRequest?: {
+        method: string;
+        endpoint: string;
+        queryParams?: string;
+        payload?: object;
+        statusCode: number;
+        response?: object;
+    };
+}
+export declare abstract class ILoggingService {
+    abstract report(data: LoggingReportProps): Promise<void>;
+}

package/services/logging/ilogging.service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ILoggingService = void 0;
+class ILoggingService {
+}
+exports.ILoggingService = ILoggingService;

package/services/logging/logging.service.d.ts

@@ -0,0 +1,4 @@
+import { ILoggingService, LoggingReportProps } from './ilogging.service';
+export declare class LoggingService implements ILoggingService {
+    report(data: LoggingReportProps): Promise<void>;
+}

package/services/logging/logging.service.js

@@ -0,0 +1,19 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingService = void 0;
+const common_1 = require("@nestjs/common");
+let LoggingService = exports.LoggingService = class LoggingService {
+    async report(data) {
+        console.log(JSON.stringify({ ...data, error: undefined }, null, 2));
+        console.error(data.error);
+    }
+};
+exports.LoggingService = LoggingService = __decorate([
+    (0, common_1.Injectable)()
+], LoggingService);

package/services/prisma/prisma-client-with-custom-transaction.interface.d.ts

@@ -0,0 +1,8 @@
+import { Prisma } from '@prisma/client';
+export interface PrismaClientWithCustomTransaction extends Readonly<Prisma.TransactionClient> {
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>, options?: {
+        maxWait?: number | undefined;
+        timeout?: number | undefined;
+        isolationLevel?: Prisma.TransactionIsolationLevel | undefined;
+    }): Promise<F>;
+}

package/services/prisma/prisma-client-with-custom-transaction.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/services/prisma/prisma-transactional-client.d.ts

@@ -0,0 +1,11 @@
+import { Prisma, PrismaPromise } from '@prisma/client';
+import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface';
+export declare class PrismaTransactionalClient implements PrismaClientWithCustomTransaction {
+    protected readonly transactionalClient: Prisma.TransactionClient;
+    constructor(transactionalClient: Prisma.TransactionClient);
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>): Promise<F>;
+    $executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): PrismaPromise<number>;
+    $executeRawUnsafe(query: string, ...values: any[]): PrismaPromise<number>;
+    $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): PrismaPromise<T>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): PrismaPromise<T>;
+}

package/services/prisma/prisma-transactional-client.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaTransactionalClient = void 0;
+class PrismaTransactionalClient {
+    transactionalClient;
+    constructor(transactionalClient) {
+        this.transactionalClient = transactionalClient;
+    }
+    async withTransaction(fn) {
+        return await fn(this.transactionalClient);
+    }
+    $executeRaw(query, ...values) {
+        return this.transactionalClient.$executeRaw(query, ...values);
+    }
+    $executeRawUnsafe(query, ...values) {
+        return this.transactionalClient.$executeRawUnsafe(query, ...values);
+    }
+    $queryRaw(query, ...values) {
+        return this.transactionalClient.$queryRaw(query, ...values);
+    }
+    $queryRawUnsafe(query, ...values) {
+        return this.transactionalClient.$queryRawUnsafe(query, ...values);
+    }
+}
+exports.PrismaTransactionalClient = PrismaTransactionalClient;

package/services/prisma/prisma.service.d.ts

@@ -0,0 +1,13 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { Prisma, PrismaClient } from '@prisma/client';
+import { PrismaClientWithCustomTransaction } from './prisma-client-with-custom-transaction.interface';
+export declare class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy, PrismaClientWithCustomTransaction {
+    constructor();
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    withTransaction<F>(fn: (prisma: Prisma.TransactionClient) => Promise<F>, options?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: Prisma.TransactionIsolationLevel;
+    }): Promise<F>;
+}

package/services/prisma/prisma.service.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaService = void 0;
+const common_1 = require("@nestjs/common");
+const client_1 = require("@prisma/client");
+let PrismaService = exports.PrismaService = class PrismaService extends client_1.PrismaClient {
+    constructor() {
+        super({
+            log: [
+                {
+                    emit: 'event',
+                    level: 'query',
+                },
+            ],
+        });
+    }
+    async onModuleInit() {
+        return this.$connect();
+    }
+    onModuleDestroy() {
+        return this.$disconnect();
+    }
+    withTransaction(fn, options) {
+        return this.$transaction(fn, options ?? {
+            maxWait: 20000,
+            timeout: 20000,
+        });
+    }
+};
+exports.PrismaService = PrismaService = __decorate([
+    (0, common_1.Injectable)()
+], PrismaService);

package/services/prisma/prisma.types.d.ts

@@ -0,0 +1,36 @@
+import { Prisma, PrismaClient } from '@prisma/client';
+import PrismaRuntime from '@prisma/client/runtime/library';
+import PrismaTypes = PrismaRuntime.Types;
+export { PrismaTypes };
+export { Prisma, PrismaClient } from '@prisma/client';
+export * as PrismaRuntime from '@prisma/client/runtime/library';
+export type ModelName = Prisma.ModelName;
+export type PrismaModelName = ModelName;
+export type PrismaModelProp<N extends ModelName = ModelName> = Uncapitalize<N>;
+export type PrismaModelType<N extends ModelName = ModelName> = Prisma.TypeMap['model'][N];
+export type PrismaModelPayload<N extends ModelName = ModelName> = PrismaModelType<N>['payload'];
+export type PrismaModelDelegate<N extends ModelName = ModelName> = PrismaClient[PrismaModelProp<N>];
+export type PrismaModel<N extends ModelName = ModelName> = PrismaTypes.Result.DefaultSelection<PrismaModelPayload<N>>;
+export type PrismaModels = {
+    [N in Prisma.ModelName]: PrismaModel<N>;
+};
+export type PrismaModelProps = {
+    [N in Prisma.ModelName]: PrismaModelProp<N>;
+};
+export type PrismaModelTypes = {
+    [N in Prisma.ModelName]: PrismaModelType<N>;
+};
+export type PrismaModelPayloads = {
+    [N in Prisma.ModelName]: PrismaModelPayload<N>;
+};
+export type PrismaModelDelegates = {
+    [N in Prisma.ModelName]: PrismaModelDelegate<N>;
+};
+export type FindManyArgs<N extends ModelName> = PrismaModelType<N>['operations']['findMany']['args'];
+export type FindUniqueArgs<N extends ModelName> = PrismaModelType<N>['operations']['findUnique']['args'];
+export type WhereInput<N extends ModelName = ModelName> = NonNullable<FindManyArgs<N>['where']>;
+export type WhereAnd<N extends ModelName = ModelName> = NonNullable<WhereInput<N>['AND']>;
+export type WhereOr<N extends ModelName = ModelName> = NonNullable<WhereInput<N>['OR']>;
+export type WhereUniqueInput<N extends ModelName = ModelName> = NonNullable<FindUniqueArgs<N>['where']>;
+export declare function getPrismaModelProp<N extends PrismaModelName>(name: N): Uncapitalize<N>;
+export declare function getPrismaDelegate<N extends PrismaModelName>(name: N, prisma: PrismaClient): PrismaModelDelegate<N>;

package/services/prisma/prisma.types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrismaDelegate = exports.getPrismaModelProp = exports.PrismaRuntime = exports.PrismaClient = exports.Prisma = void 0;
+var client_1 = require("@prisma/client");
+Object.defineProperty(exports, "Prisma", { enumerable: true, get: function () { return client_1.Prisma; } });
+Object.defineProperty(exports, "PrismaClient", { enumerable: true, get: function () { return client_1.PrismaClient; } });
+exports.PrismaRuntime = require("@prisma/client/runtime/library");
+function getPrismaModelProp(name) {
+    return `${name.charAt(0).toLowerCase()}${name.slice(1)}`;
+}
+exports.getPrismaModelProp = getPrismaModelProp;
+function getPrismaDelegate(name, prisma) {
+    return prisma[getPrismaModelProp(name)];
+}
+exports.getPrismaDelegate = getPrismaDelegate;

package/services/redis/iredis.service.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class IRedisService {
+    abstract getCache(key: string): Promise<string | null>;
+    abstract setCache(key: string, ttlSecondsCache: number, payload: any): Promise<void>;
+    abstract deleteCache(key: string): Promise<void>;
+}

package/services/redis/iredis.service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRedisService = void 0;
+class IRedisService {
+}
+exports.IRedisService = IRedisService;

package/services/redis/redis.service.d.ts

@@ -0,0 +1,13 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { EnvService } from '../env/env.service';
+import { IRedisService } from './iredis.service';
+export declare class RedisService implements IRedisService, OnModuleDestroy {
+    private readonly redisClient;
+    private readonly environment;
+    constructor(env: EnvService);
+    onModuleDestroy(): void;
+    getCache(key: string): Promise<string | null>;
+    setCache(key: string, ttlSecondsCache: number, payload: any): Promise<void>;
+    deleteCache(key: string): Promise<void>;
+    private getKeyCache;
+}

package/services/redis/redis.service.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisService = void 0;
+const common_1 = require("@nestjs/common");
+const ioredis_1 = require("ioredis");
+const env_config_1 = require("../../core/utils/env.config");
+let RedisService = exports.RedisService = class RedisService {
+    redisClient;
+    environment;
+    constructor(env) {
+        if (!env_config_1.EnvConfig.isEnvTest) {
+            const url = new URL(env.get('REDIS_CONNECTION_STRING'));
+            this.environment = env.get('NODE_ENV');
+            this.redisClient = new ioredis_1.default({
+                host: url.hostname,
+                port: Number(url.port),
+                password: url.password,
+                username: url.username,
+            });
+        }
+    }
+    onModuleDestroy() {
+        this.redisClient.disconnect();
+    }
+    async getCache(key) {
+        if (env_config_1.EnvConfig.isEnvTest) {
+            return '';
+        }
+        return await this.redisClient.get(this.getKeyCache(key));
+    }
+    async setCache(key, ttlSecondsCache, payload) {
+        if (!env_config_1.EnvConfig.isEnvTest) {
+            await this.redisClient.set(this.getKeyCache(key), JSON.stringify(payload), 'EX', ttlSecondsCache);
+        }
+    }
+    async deleteCache(key) {
+        if (!env_config_1.EnvConfig.isEnvTest) {
+            await this.redisClient.del(this.getKeyCache(key));
+        }
+    }
+    getKeyCache(key) {
+        return `${this.environment}:app:${key}`;
+    }
+};
+exports.RedisService = RedisService = __decorate([
+    (0, common_1.Injectable)()
+], RedisService);

package/services/redlock/ired-lock.service.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class IRedLockService {
+    abstract acquiredLock(key: string, ttlSecondsLock: number): Promise<boolean>;
+    abstract releaseLock(key: string): Promise<void>;
+}

package/services/redlock/ired-lock.service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRedLockService = void 0;
+class IRedLockService {
+}
+exports.IRedLockService = IRedLockService;

package/services/redlock/red-lock.service.d.ts

@@ -0,0 +1,9 @@
+import { IRedisService } from '../redis/iredis.service';
+import { IRedLockService } from './ired-lock.service';
+export declare class RedLockService implements IRedLockService {
+    private readonly redisService;
+    constructor(redisService: IRedisService);
+    acquiredLock(key: string, ttlSecondsLock: number): Promise<boolean>;
+    releaseLock(key: string): Promise<void>;
+    private getLockKey;
+}

package/services/redlock/red-lock.service.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedLockService = void 0;
+const common_1 = require("@nestjs/common");
+const env_config_1 = require("../../core/utils/env.config");
+let RedLockService = exports.RedLockService = class RedLockService {
+    redisService;
+    constructor(redisService) {
+        this.redisService = redisService;
+    }
+    async acquiredLock(key, ttlSecondsLock) {
+        if (env_config_1.EnvConfig.isEnvTest) {
+            return true;
+        }
+        const lockKey = this.getLockKey(key);
+        const canLock = await this.redisService.getCache(lockKey);
+        if (canLock) {
+            return false;
+        }
+        await this.redisService.setCache(lockKey, ttlSecondsLock, 'RedLockService');
+        return true;
+    }
+    async releaseLock(key) {
+        if (!env_config_1.EnvConfig.isEnvTest) {
+            await this.redisService.deleteCache(this.getLockKey(key));
+        }
+    }
+    getLockKey(key) {
+        return `redLock:${key}`;
+    }
+};
+exports.RedLockService = RedLockService = __decorate([
+    (0, common_1.Injectable)()
+], RedLockService);