arkos 1.2.13-test → 1.2.13-test.1

package/dist/types/modules/error-handler/utils/error-handler.helpers.d.ts

@@ -40,3 +40,7 @@ export declare function handleNetworkError(err: AppError): AppError;
 export declare function handleUnhandledPromiseError(err: AppError): AppError;
 export declare function handleDataTypeError(err: AppError): AppError;
 export declare function handleEmptyResultError(err: AppError): AppError;
+export declare function handleNonExistingRecord(err: {
+    meta?: Record<string, any>;
+    [x: string]: any;
+}): AppError;

package/dist/types/modules/file-upload/file-upload.router.d.ts

@@ -1,3 +1,3 @@
 import { Router } from "express";
 import { ArkosConfig } from "../../types/arkos-config";
-export declare function getFileUploadRouter({ fileUpload }: ArkosConfig): Promise<Router>;
+export declare function getFileUploadRouter(arkosConfig: ArkosConfig): Promise<Router>;

package/dist/types/modules/file-upload/utils/helpers/file-upload.helpers.d.ts

@@ -1,4 +1,5 @@
-import { ArkosRequest } from "../../../../types";
+import { ArkosNextFunction, ArkosRequest, ArkosResponse } from "../../../../types";
+export declare function adjustRequestUrl(req: ArkosRequest, _: ArkosResponse, next: ArkosNextFunction): void;
 export declare function extractRequestInfo(req: ArkosRequest): {
     baseURL: string;
     baseRoute: string;

package/dist/types/modules/swagger/swagger.router.d.ts

@@ -1,3 +1,3 @@
 import { Router } from "express";
 import { ArkosConfig } from "../../types/arkos-config";
-export declare function getSwaggerRouter(arkosConfig: ArkosConfig): Router;
+export declare function getSwaggerRouter(arkosConfig: ArkosConfig): Promise<Router>;

package/dist/types/modules/swagger/utils/helpers/get-authentication-json-schema-paths.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../exports";
+export declare function getAuthenticationJsonSchemaPaths(arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject<{}, {}>>;

package/dist/types/modules/swagger/utils/helpers/get-system-json-schema-paths.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIV3 } from "openapi-types";
+export declare function getSystemJsonSchemaPaths(): OpenAPIV3.PathsObject<{}, {}>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/generate-class-validator-json-schemas.d.ts

@@ -0,0 +1 @@
+export declare function generateClassValidatorJsonSchemas(): Promise<Record<string, any>>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/generate-prisma-json-schemas.d.ts

@@ -0,0 +1,2 @@
+import { ArkosConfig } from "../../../../../exports";
+export declare function generatePrismaJsonSchemas(arkosConfig: ArkosConfig): Promise<import("../../../../../utils/prisma/enhaced-prisma-json-schema-generator").GeneratedSchemas>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/generate-zod-json-schema.d.ts

@@ -0,0 +1 @@
+export declare function generateZodJsonSchemas(): Promise<Record<string, any>>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/prisma-models/generate-prisma-model-main-routes.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../../../exports";
+export declare function generatePrismaModelMainRoutesPaths(model: string, paths: OpenAPIV3.PathsObject, arkosConfig: ArkosConfig): Promise<void>;

package/dist/types/modules/swagger/utils/helpers/json-schema-generators/prisma-models/generate-prisma-model-parent-routes.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../../../exports";
+export declare function generatePrismaModelParentRoutePaths(model: string, paths: OpenAPIV3.PathsObject, arkosConfig: ArkosConfig): Promise<void>;

package/dist/types/modules/swagger/utils/helpers/missing-json-schemas-generator.d.ts

@@ -0,0 +1,34 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../exports";
+declare class MissingJsonSchemasGenerator {
+    private extractModelNameFromSchemaRef;
+    private extractActionFromOperationId;
+    private extractModelNameFromOperationId;
+    private extractSchemaRefsWithContext;
+    private extractPathSchemaRefs;
+    private getSchemaNameFromRef;
+    generateMissingJsonSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>, arkosConfig: ArkosConfig): Promise<Record<string, any>>;
+    private extractActionFromSchemaRef;
+    analyzeMissingSchemas(currentPaths: OpenAPIV3.PathsObject, currentJsonSchemas: Record<string, any>): {
+        allRefs: Array<{
+            ref: string;
+            context: any;
+        }>;
+        missingRefs: Array<{
+            ref: string;
+            context: any;
+        }>;
+        existingRefs: Array<{
+            ref: string;
+            context: any;
+        }>;
+        modelActions: {
+            model: string;
+            action: string;
+            ref: string;
+            operationId?: string;
+        }[];
+    };
+}
+declare const missingJsonSchemaGenerator: MissingJsonSchemasGenerator;
+export default missingJsonSchemaGenerator;

package/dist/types/modules/swagger/utils/helpers/swagger.router.helpers.d.ts

@@ -0,0 +1,7 @@
+import { ArkosConfig } from "../../../../exports";
+import { OpenAPIV3 } from "openapi-types";
+export declare function getOpenAPIJsonSchemasByConfigMode(arkosConfig: ArkosConfig): Promise<Record<string, any>>;
+export declare function getCorrectJsonSchemaName(type: string, modelName: string, suffix: "Dto" | "Schema"): string;
+export declare function kebabToHuman(kebabStr: string): string;
+export declare function getSchemaRef(schemaName: string, mode: "prisma" | "zod" | "class-validator"): string;
+export declare function generatePathsForModels(arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject>;

package/dist/types/router-config.js

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

package/dist/types/server.d.ts

@@ -2,6 +2,9 @@ import { IncomingMessage, Server, ServerResponse } from "http";
 import { Express } from "express";
 import { ArkosConfig } from "./types/arkos-config";
 declare let server: Server<typeof IncomingMessage, typeof ServerResponse>;
+export declare let _arkosConfig: ArkosConfig & {
+    available?: boolean;
+};
 declare function initApp(arkosConfig?: ArkosConfig): Promise<Express>;
 export declare function terminateApplicationRunningProcessAndServer(): void;
 export declare function getArkosConfig(): ArkosConfig;

package/dist/types/types/arkos-config.d.ts

@@ -7,6 +7,8 @@ import compression from "compression";
 import { Options as QueryParserOptions } from "../utils/helpers/query-parser.helpers";
 import { ValidatorOptions } from "class-validator";
 import { MsDuration } from "../modules/auth/utils/helpers/auth.controller.helpers";
+import { OpenAPIV3 } from "openapi-types";
+import type { ApiReferenceConfiguration } from "@scalar/express-api-reference" with { "resolution-mode": "import" };
 export type ArkosConfig = {
     request?: {
         parameters?: {
@@ -120,10 +122,12 @@ export type ArkosConfig = {
         name?: string;
     };
     swagger?: {
+        enableAfterBuild?: boolean;
         endpoint?: string;
-        mode: "prisma" | "class-validator" | "zod" | "json-schema";
-        options: {
-            definition: {
+        mode: "prisma" | "class-validator" | "zod";
+        strict: boolean;
+        options?: {
+            definition?: {
                 openapi?: string;
                 info?: {
                     title?: string;
@@ -132,8 +136,9 @@ export type ArkosConfig = {
                 };
                 servers?: {
                     url: string;
-                    description: string;
+                    description?: string;
                 }[];
+                paths?: OpenAPIV3.PathsObject;
                 termsOfService?: string;
                 contact?: {
                     name?: string;
@@ -155,10 +160,10 @@ export type ArkosConfig = {
                 security?: Array<Record<string, string[]>>;
             };
             apis?: string[];
-            swaggerUiOptions?: Record<string, any>;
             deepLinking?: boolean;
             tryItOutEnabled?: boolean;
             persistAuthorization?: boolean;
         };
+        scalarApiReferenceConfiguration?: Partial<ApiReferenceConfiguration>;
     };
 };

package/dist/types/utils/cli/utils/cli.helpers.d.ts

@@ -1,3 +1,3 @@
 export declare function ensureDirectoryExists(dirPath: string): void;
 export declare function killServerChildProcess(): void;
-export declare function getVersion(): any;
+export declare function getVersion(): string;

package/dist/types/utils/features/api.features.d.ts

@@ -6,6 +6,7 @@ export default class APIFeatures {
     searchParams: any;
     searchParamsWithModifiers: any;
     filters: any;
+    reqFiltersSearchParam: any;
     modelName?: ModelName;
     excludedFields: string[];
     constructor(req?: Request, modelName?: ModelName);

package/dist/types/utils/helpers/global.helpers.d.ts

@@ -1 +1,6 @@
-export declare function importModule(path: string): Promise<any>;
+export declare function getPackageJson(): any;
+export declare function isEsm(): boolean;
+export declare function importModule(modulePath: string, options?: {
+    fixExtension: boolean;
+}): Promise<any>;
+export declare function detectPackageManagerFromUserAgent(): string;

package/dist/types/utils/helpers/models.helpers.d.ts

@@ -1,6 +1,9 @@
 import { AuthConfigs } from "../../types/auth";
-export declare let prismaModelsModules: Record<string, Awaited<ReturnType<typeof importPrismaModelModules>>>;
+import { ArkosConfig } from "../../exports";
+type ModeModules = Awaited<ReturnType<typeof importPrismaModelModules>>;
+export declare function setModelModules(modelName: string, modules: ModeModules): void;
 export declare function getModelModules(modelName: string): importPrismaModelModulesReturnType;
+export type ValidationFileMappingKey = keyof ReturnType<typeof getFileModelModulesFileStructure>["dtos"];
 export declare function getFileModelModulesFileStructure(modelName: string): {
     core: {
         service: string;
@@ -15,51 +18,71 @@ export declare function getFileModelModulesFileStructure(modelName: string): {
     dtos: {
         login: string;
         signup: string;
+        getMe: string;
         updateMe: string;
         updatePassword: string;
         model?: undefined;
         create?: undefined;
+        createOne?: undefined;
         createMany?: undefined;
         update?: undefined;
+        updateOne?: undefined;
         updateMany?: undefined;
         query?: undefined;
+        findOne?: undefined;
+        findMany?: undefined;
     } | {
         model: string;
         create: string;
+        createOne: string;
         createMany: string;
         update: string;
+        updateOne: string;
         updateMany: string;
         query: string;
+        findOne: string;
+        findMany: string;
         login?: undefined;
         signup?: undefined;
+        getMe?: undefined;
         updateMe?: undefined;
         updatePassword?: undefined;
     };
     schemas: {
         login: string;
         signup: string;
+        getMe: string;
         updateMe: string;
         updatePassword: string;
         model?: undefined;
         create?: undefined;
+        createOne?: undefined;
         createMany?: undefined;
         update?: undefined;
+        updateOne?: undefined;
         updateMany?: undefined;
         query?: undefined;
+        findOne?: undefined;
+        findMany?: undefined;
     } | {
         model: string;
         create: string;
+        createOne: string;
         createMany: string;
         update: string;
+        updateOne: string;
         updateMany: string;
         query: string;
+        findOne: string;
+        findMany: string;
         login?: undefined;
         signup?: undefined;
+        getMe?: undefined;
         updateMe?: undefined;
         updatePassword?: undefined;
     };
 };
-export declare function processSubdir(modelName: string, type: "dtos" | "schemas", result: Record<string, any>): Promise<void>;
+export declare function processSubdir(modelName: string, type: "dtos" | "schemas"): Promise<Record<string, any>>;
 type importPrismaModelModulesReturnType = {
     service?: any;
     controller?: any;
@@ -69,12 +92,12 @@ type importPrismaModelModulesReturnType = {
     prismaQueryOptions?: any;
     prismaQueryOptionsNew?: any;
     router?: any;
-    dtos: Record<string, any>;
-    schemas: Record<string, any>;
+    dtos?: Record<string, any>;
+    schemas?: Record<string, any>;
 };
 export declare function validateNamingConventions(key: string, fileName: string, result: importPrismaModelModulesReturnType): void;
 export declare function assignModuleToResult(key: string, module: any, result: importPrismaModelModulesReturnType): void;
-export declare function importPrismaModelModules(modelName: string): Promise<importPrismaModelModulesReturnType>;
+export declare function importPrismaModelModules(modelName: string, arkosConfig: ArkosConfig): Promise<importPrismaModelModulesReturnType>;
 export type ModelFieldDefition = {
     name: string;
     type: string;
@@ -87,9 +110,12 @@ export type RelationFields = {
 export declare const prismaModelRelationFields: Record<string, RelationFields>;
 export declare function getAllPrismaFiles(dirPath: string, fileList?: string[]): string[];
 export declare const models: string[];
+export declare let prismaSchemasContent: string;
 export declare const prismaModelsUniqueFields: Record<string, ModelFieldDefition[]>;
 export declare function initializePrismaModels(): void;
 export declare function getPrismaModelRelations(modelName: string): RelationFields | undefined;
 declare function getModels(): string[];
+export declare function getPrismaSchemasContent(): string;
 declare function getModelUniqueFields(modelName: string): ModelFieldDefition[];
+export declare function localValidatorFileExists(action: ValidationFileMappingKey, modelName: string, arkosConfig: ArkosConfig): Promise<boolean>;
 export { getModels, getModelUniqueFields };

package/dist/types/utils/helpers/routers.helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const safeCatchAsync: (middleware: any) => ((req: import("../../types").ArkosRequest, res: import("../../types").ArkosResponse, next: import("../../types").ArkosNextFunction) => Promise<void>) | undefined;
+export declare const processMiddleware: (middleware: any) => ((req: import("../../types").ArkosRequest, res: import("../../types").ArkosResponse, next: import("../../types").ArkosNextFunction) => Promise<void>)[];

package/dist/types/utils/prisma/enhaced-prisma-json-schema-generator.d.ts

@@ -0,0 +1,34 @@
+import { ArkosConfig } from "../../exports";
+import { ValidationFileMappingKey } from "../helpers/models.helpers";
+import { JsonSchema } from "./types";
+export interface SchemaGenerationConfig {
+    modelName: string;
+    arkosConfig: ArkosConfig;
+    schemasToGenerate?: ValidationFileMappingKey[];
+}
+export interface GeneratedSchemas {
+    [key: string]: JsonSchema;
+}
+export declare class EnhancedPrismaJsonSchemaGenerator {
+    private schema;
+    generateModelSchemas(config: SchemaGenerationConfig): Promise<GeneratedSchemas>;
+    private generateAuthSchemas;
+    private generateCrudSchemas;
+    private generateCreateSchema;
+    private generateUpdateSchema;
+    private generateResponseSchema;
+    private generateNestedRelationSchema;
+    private generateLoginSchema;
+    private generateSignupSchema;
+    private generateUpdateMeSchema;
+    private generateUpdatePasswordSchema;
+    private resolvePrismaQueryOptions;
+    private getGeneralOptionsForAction;
+    private isEndpointDisabled;
+    private isModelRelation;
+    private convertFieldToJsonSchema;
+    private mapPrismaTypeToJsonSchema;
+    private isEnum;
+}
+declare const enhancedPrismaJsonSchemaGenerator: EnhancedPrismaJsonSchemaGenerator;
+export default enhancedPrismaJsonSchemaGenerator;

package/dist/types/utils/prisma/prisma-json-schema-generator.d.ts

@@ -0,0 +1,10 @@
+import { PrismaModel, JsonSchema } from "./types";
+export declare class PrismaJsonSchemaGenerator {
+    generateSchema(model: PrismaModel): JsonSchema;
+    private convertFieldToJsonSchema;
+    private mapPrismaTypeToJsonSchema;
+    private isEnum;
+    private isModel;
+}
+declare const prismaJsonSchemaGenerator: PrismaJsonSchemaGenerator;
+export default prismaJsonSchemaGenerator;

package/dist/types/utils/prisma/prisma-schema-parser.d.ts

@@ -0,0 +1,18 @@
+import { PrismaSchema } from "./types";
+export declare class PrismaSchemaParser {
+    private enums;
+    private models;
+    parse(): PrismaSchema;
+    private extractEnums;
+    private parseEnumBlock;
+    private extractModels;
+    private extractModelBlocks;
+    private parseModelBlock;
+    private parseFields;
+    private parseFieldLine;
+    private parseDefaultValue;
+    isEnum(typeName: string): boolean;
+    isModel(typeName: string): boolean;
+}
+declare const prismaSchemaParser: PrismaSchemaParser;
+export default prismaSchemaParser;

package/dist/types/utils/prisma/types.d.ts

@@ -0,0 +1,48 @@
+export interface PrismaField {
+    name: string;
+    type: string;
+    isOptional: boolean;
+    isArray: boolean;
+    connectionField: string;
+    defaultValue?: any;
+    isId?: boolean;
+    isUnique?: boolean;
+    attributes: string[];
+}
+export interface PrismaModel {
+    name: string;
+    fields: PrismaField[];
+    mapName?: string;
+}
+export interface PrismaEnum {
+    name: string;
+    values: string[];
+}
+export interface PrismaSchema {
+    models: PrismaModel[];
+    enums: PrismaEnum[];
+}
+export type JsonSchemaProperty = {
+    type: string;
+    default?: any;
+    items?: {
+        type: string;
+    };
+    format?: string;
+    enum?: string[];
+    $ref?: string;
+    [key: string]: any;
+} & Partial<JsonSchema>;
+export interface JsonSchema {
+    type: string;
+    properties?: {
+        [key: string]: JsonSchemaProperty;
+    };
+    items?: {
+        $ref?: string;
+    } | JsonSchema;
+    required?: string[];
+    anyOf?: {
+        required: string[];
+    }[];
+}

package/dist/types/utils/sheu.d.ts

@@ -0,0 +1,70 @@
+declare class Sheu {
+    private getTimestamp;
+    private formatText;
+    private getColorCode;
+    red(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    blue(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    green(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    yellow(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    cyan(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    magenta(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    white(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    black(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    gray(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    orange(text: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    bold(text: string, options?: {
+        timestamp?: boolean | string;
+    }): string;
+    info(message: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    error(message: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    ready(message: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    done(message: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+    warn(message: string, options?: {
+        timestamp?: boolean | string;
+        bold?: boolean;
+    }): string;
+}
+declare const sheu: Sheu;
+export default sheu;

package/dist/utils/arkos-env.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const arkosEnv={JWT_SECRET:"13a9279eedb286f756212511267152e9585055809ec0606ea9f7eb98a87660c1616fbd39c44d4238a82f29df90b529e24bfdf72a480d1149d79c991c863a22b5ae0fb3ae6f5323bfd6664faef99792637477c38da488e7aa0d39b83ba99aba8e8a20efde7fd5c7ba21a6c938e17a9f99f73226dc61e89cd63f159257841194323f100d1a49b88ce4fdcdf2b066a5f32f88ee12f6487b55b4b5687d7c0caffdd8524e2adc4b941cf52e948f5b330f527eb1354341c876eed12dfa92cef3c341d030d05e6beb1e0a7f6d3e08e7b1aac045130457fd3a53ee469fecdd20fdd2c7a6a72b07cbcb1157c5b1cc581e6767bea32be8e125016a48951e85c7bdb961d9c9fab28444499ce063664fe0bd1a05d60294323bdd69af6d6ff1a2533dac8d4a869f76dbc746ee12f144e0af41029f620471817843140c23d036e731f3ebee21a70ff1549e97486fdf9cbef132ff2ced59fde9be35dd04b358c9a25ec4fd9cc0e36dae651e626d8c13b0c6d2a21f237517a05059680173e71817597062c792ea9c66030ca0d8ed82987e29189947692a0be5fffac4c988ca33f14ce96349661ef850dbff6909c7797676c90a5e47655346f59759482ef8a3a948e97e30f889bd4571610fd19e8ea4818651d37f6529cf32f0fc805bc053e911f0fe96f52b4420d54bd1f40739a95f5853b036c86ab9a51bed57fa9bd48607b5302e88db00900adf",JWT_EXPIRES_IN:"30d",PRISMA_SCHEMA_PATH:"./prisma/schema"};exports.default=arkosEnv;

package/dist/utils/dotenv.helpers.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.loadEnvironmentVariables=loadEnvironmentVariables;const path_1=__importDefault(require("path")),fs_1=__importDefault(require("fs")),dotenv_1=__importDefault(require("dotenv"));function loadEnvironmentVariables(){const e=process.env.NODE_ENV,n=process.cwd();let o=[];[path_1.default.resolve(n,".env.defaults"),path_1.default.resolve(n,`.env.${e}`),path_1.default.resolve(n,`.env.${e}.local`),path_1.default.resolve(n,".env.local"),path_1.default.resolve(n,".env")].forEach(r=>{if(fs_1.default.existsSync(r))if(e==="production"&&r.endsWith(".local"))console.info(`Skipping the local ${r.replace(n,"")} files in production`);else{const t=dotenv_1.default.config({path:r,override:!0});t.error?console.warn(`Warning: Error loading ${r}`,t.error):o.push(r)}});const s=["DATABASE_URL"].filter(r=>!process.env[r]);if(s.length>0&&console.error("Missing required environment variables:",s.join(", ")),o)return o}

package/dist/utils/sheu.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});class Sheu{getTimestamp(){return new Date().toTimeString().split(" ")[0]}formatText(t="",e={}){const r=e?.label?t?e?.label+" ":e?.label:"";let o=`${r}${t}`;if(e.timestamp){const m=this.getTimestamp();if(e.timestamp===!0)o=`${r}\x1B[90m${m}\x1B[0m ${t}`;else if(typeof e.timestamp=="string"){const x=this.getColorCode(e.timestamp);o=`${r}${x}${m}\x1B[0m ${t}`}}return e.bold&&(o=`\x1B[1m${o}\x1B[0m`),o}getColorCode(t){return{red:"\x1B[31m",blue:"\x1B[34m",green:"\x1B[32m",yellow:"\x1B[33m",cyan:"\x1B[36m",magenta:"\x1B[35m",white:"\x1B[37m",black:"\x1B[30m",gray:"\x1B[90m",orange:"\x1B[91m"}[t]||"\x1B[90m"}red(t,e){const r=`\x1B[31m${t}\x1B[0m`;return this.formatText(r,e||{})}blue(t,e){const r=`\x1B[34m${t}\x1B[0m`;return this.formatText(r,e||{})}green(t,e){const r=`\x1B[32m${t}\x1B[0m`;return this.formatText(r,e||{})}yellow(t,e){const r=`\x1B[33m${t}\x1B[0m`;return this.formatText(r,e||{})}cyan(t,e){const r=`\x1B[36m${t}\x1B[0m`;return this.formatText(r,e||{})}magenta(t,e){const r=`\x1B[35m${t}\x1B[0m`;return this.formatText(r,e||{})}white(t,e){const r=`\x1B[37m${t}\x1B[0m`;return this.formatText(r,e||{})}black(t,e){const r=`\x1B[30m${t}\x1B[0m`;return this.formatText(r,e||{})}gray(t,e){const r=`\x1B[90m${t}\x1B[0m`;return this.formatText(r,e||{})}orange(t,e){const r=`\x1B[91m${t}\x1B[0m`;return this.formatText(r,e||{})}bold(t,e){const r=`\x1B[1m${t}\x1B[0m`;return this.formatText(r,{...e,bold:!1})}info(t,e){const o=this.formatText(t,{...e,label:"[\x1B[36mINFO\x1B[0m]"});return console.info(o),o}error(t,e){const o=this.formatText(t,{...e,label:"[\x1B[31mERROR\x1B[0m]"});return console.error(o),o}ready(t,e){const o=this.formatText(t,{...e,label:"[\x1B[32mREADY\x1B[0m]"});return console.info(o),o}done(t,e){const o=this.formatText(t,{...e,label:"[\x1B[32mDONE\x1B[0m]"});return console.info(o),o}warn(t,e){const o=this.formatText(t,{...e,label:"[\x1B[33mWARN\x1B[0m]"});return console.warn(o),o}}const sheu=new Sheu;exports.default=sheu;

package/dist/utils/validate-dto.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=validateDto;const class_transformer_1=require("class-transformer"),class_validator_1=require("class-validator"),app_error_1=__importDefault(require("../modules/error-handler/utils/app-error"));async function validateDto(e,a,s){const r=(0,class_transformer_1.plainToInstance)(e,a),t=await(0,class_validator_1.validate)(r,s);if(t.length>0)throw new app_error_1.default("Invalid request body",400,t,"invalid_request_body");return r}

package/dist/utils/validate-schema.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=validateSchema;const app_error_1=__importDefault(require("../modules/error-handler/utils/app-error"));async function validateSchema(e,t){const r=e.safeParse(t);if(!r.success)throw new app_error_1.default("Invalid request body",400,r.error.format(),"invalid_request_body");return r.data}