arkos 1.2.15-test.1 → 1.2.15-test.3

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

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

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

@@ -0,0 +1,3 @@
+import { OpenAPIV3 } from "openapi-types";
+import { ArkosConfig } from "../../../../../../exports";
+export default function generatePrismaModelParentRoutesPaths(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/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/cli/utils/watermark-stamper.d.ts

@@ -0,0 +1,9 @@
+declare class WatermarkStamper {
+    stamp({ envFiles, host, port, }: {
+        envFiles: string[] | undefined;
+        host: string | undefined;
+        port: string | undefined;
+    }): void;
+}
+declare const watermarkStamper: WatermarkStamper;
+export default watermarkStamper;

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/features/port-and-host-allocator.d.ts

@@ -0,0 +1,21 @@
+import { ArkosConfig } from "../../exports";
+declare class PortAndHostAllocator {
+    private host;
+    private port;
+    private prevWarnings;
+    getCorrectHostAndPortToUse(env: Record<string, any>, config?: ArkosConfig): {
+        port: string;
+        host: string;
+    };
+    getHostAndAvailablePort(env: Record<string, any>, config?: ArkosConfig & {
+        logWarning?: boolean;
+        caller?: string;
+    }): Promise<{
+        port: string;
+        host: string;
+    }>;
+    private isPortAvailable;
+    logWarnings(): void;
+}
+declare const portAndHostAllocator: PortAndHostAllocator;
+export default portAndHostAllocator;

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 {
+    schema: import("./types").PrismaSchema;
+    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-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;