arkos 1.2.32-test → 1.3.0-beta

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

@@ -1,6 +1,5 @@
 import multer from "multer";
-import { NextFunction } from "express";
-import { ArkosRequest, ArkosResponse } from "../../types";
+import { ArkosRequest, ArkosRequestHandler, ArkosResponse } from "../../types";
 export declare class FileUploadService {
     readonly uploadDir: string;
     private fileSizeLimit;
@@ -10,9 +9,9 @@ export declare class FileUploadService {
     constructor(uploadDir: string, fileSizeLimit?: number, allowedFileTypes?: RegExp, maxCount?: number);
     private fileFilter;
     getUpload(): multer.Multer;
-    handleSingleUpload(oldFilePath?: string): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => void;
-    handleMultipleUpload(): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => void;
-    handleDeleteSingleFile(oldFilePath: string): (req: ArkosRequest, res: ArkosResponse, next: NextFunction) => Promise<void>;
+    handleSingleUpload(oldFilePath?: string): ArkosRequestHandler;
+    handleMultipleUpload(): ArkosRequestHandler;
+    handleDeleteSingleFile(oldFilePath: string): ArkosRequestHandler;
     deleteFileByUrl(fileUrl: string): Promise<boolean>;
     private getFieldName;
     upload(req: ArkosRequest, res: ArkosResponse, options?: {

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

@@ -1,2 +1,4 @@
 import { OpenAPIV3 } from "openapi-types";
-export declare function getAuthenticationJsonSchemaPaths(): OpenAPIV3.PathsObject<{}, {}>;
+import { ArkosConfig } from "../../../../exports";
+export declare const getSchemaMode: (action: string, arkosConfig: ArkosConfig) => Promise<"prisma" | "zod" | "class-validator">;
+export default function getAuthenticationJsonSchemaPaths(arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject<{}, {}>>;

package/dist/types/modules/swagger/utils/helpers/get-swagger-default-configs.d.ts

@@ -0,0 +1,46 @@
+import { OpenAPIV3 } from "openapi-types";
+export default function getSwaggerDefaultConfig(defaultModelsPaths: Record<string, any>, defaultJsonSchemas: OpenAPIV3.PathsObject<{}, {}>): Promise<{
+    enableAfterBuild?: boolean;
+    endpoint?: string;
+    mode: "prisma" | "class-validator" | "zod";
+    strict?: boolean;
+    options?: {
+        definition?: {
+            openapi?: string;
+            info?: {
+                title?: string;
+                version?: string;
+                description?: string;
+            };
+            servers?: {
+                url: string;
+                description?: string;
+            }[];
+            paths?: OpenAPIV3.PathsObject;
+            termsOfService?: string;
+            contact?: {
+                name?: string;
+                url?: string;
+                email?: string;
+            };
+            license?: {
+                name: string;
+                url?: string;
+            };
+            tags?: {
+                name: string;
+                description?: string;
+            }[];
+            components?: {
+                securitySchemes?: Record<string, any>;
+                schemas?: Record<string, any>;
+            };
+            security?: Array<Record<string, string[]>>;
+        };
+        apis?: string[];
+        deepLinking?: boolean;
+        tryItOutEnabled?: boolean;
+        persistAuthorization?: boolean;
+    };
+    scalarApiReferenceConfiguration?: Partial<import("@scalar/express-api-reference").ApiReferenceConfiguration>;
+} | undefined>;

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

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

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

@@ -0,0 +1,4 @@
+import { ArkosConfig } from "../../../../../exports";
+export default function generateSystemJsonSchemas(arkosConfig: ArkosConfig): {
+    FindManyAuthActionSystemSchema: any;
+};

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

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

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

@@ -1,7 +1,9 @@
 import { ArkosConfig } from "../../../../exports";
 import { OpenAPIV3 } from "openapi-types";
-export declare function getOpenAPIJsonSchemasByConfigMode(swaggerConfig: ArkosConfig["swagger"]): Promise<void | Record<string, any>>;
+import { ValidationFileMappingKey } from "../../../../utils/dynamic-loader";
+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: string): string;
+export declare function getSchemaRef(schemaName: string, mode: "prisma" | "zod" | "class-validator"): string;
 export declare function generatePathsForModels(arkosConfig: ArkosConfig): Promise<OpenAPIV3.PathsObject>;
+export declare function localValidatorFileExists(action: ValidationFileMappingKey, modelName: string, arkosConfig: ArkosConfig): Promise<boolean>;

package/dist/types/server.d.ts

@@ -5,7 +5,7 @@ declare let server: Server<typeof IncomingMessage, typeof ServerResponse>;
 export declare let _arkosConfig: ArkosConfig & {
     available?: boolean;
 };
-declare function initApp(arkosConfig?: ArkosConfig): Promise<Express>;
+declare function initApp(arkosConfig?: ArkosConfig): Promise<Express | undefined>;
 export declare function terminateApplicationRunningProcessAndServer(): void;
 export declare function getArkosConfig(): ArkosConfig;
 export declare function getExpressApp(): Express;

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

@@ -8,6 +8,7 @@ import { Options as QueryParserOptions } from "../utils/helpers/query-parser.hel
 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?: {
@@ -84,7 +85,7 @@ export type ArkosConfig = {
     };
     middlewares?: {
         additional?: express.RequestHandler[];
-        disable?: ("compression" | "global-rate-limit" | "auth-rate-limit" | "cors" | "express-json" | "cookie-parser" | "query-parser" | "database-connection" | "request-logger" | "global-error-handler")[];
+        disable?: ("compression" | "global-rate-limit" | "auth-rate-limit" | "cors" | "express-json" | "cookie-parser" | "query-parser" | "request-logger" | "global-error-handler")[];
         replace?: {
             compression?: express.RequestHandler;
             globalRateLimit?: express.RequestHandler;
@@ -93,12 +94,12 @@ export type ArkosConfig = {
             expressJson?: express.RequestHandler;
             cookieParser?: express.RequestHandler;
             queryParser?: express.RequestHandler;
-            databaseConnection?: express.RequestHandler;
             requestLogger?: express.RequestHandler;
             globalErrorHandler?: express.ErrorRequestHandler;
         };
     };
     routers?: {
+        strict?: boolean | "no-bulk";
         additional?: express.Router[];
         disable?: ("auth-router" | "prisma-models-router" | "file-upload" | "welcome-endpoint")[];
         replace?: {
@@ -124,6 +125,7 @@ export type ArkosConfig = {
         enableAfterBuild?: boolean;
         endpoint?: string;
         mode: "prisma" | "class-validator" | "zod";
+        strict?: boolean;
         options?: {
             definition?: {
                 openapi?: string;
@@ -158,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/types/auth.d.ts

@@ -1,7 +1,13 @@
 import { JwtPayload } from "jsonwebtoken";
 export type AccessAction = "Create" | "Update" | "Delete" | "View" | string;
+export type DetailedAccessControlRule = {
+    roles: string[];
+    name?: string;
+    description?: string;
+    errorMessage?: string;
+};
 export type AccessControlRules = {
-    [key in AccessAction]: string[];
+    [key in AccessAction]: string[] | DetailedAccessControlRule;
 };
 export type AuthenticationControlRules = {
     [key in AccessAction]: boolean;

package/dist/types/types/index.d.ts

@@ -1,4 +1,4 @@
-import { NextFunction, Request, RequestHandler, Response } from "express";
+import { ErrorRequestHandler, NextFunction, Request, RequestHandler, Response } from "express";
 export type PrismaOperations = "findMany";
 export type PrismaQueryOptions<T extends Record<string, any>> = {
     queryOptions?: Partial<Parameters<T["findMany"]>[0]>;
@@ -122,6 +122,7 @@ export interface ArkosRequest<Body = any, Query = any> extends Request {
     responseStatus?: number | string | null | undefined;
     body: Body;
     prismaQueryOptions?: Record<string, any>;
+    accessToken?: string;
 }
 export interface ArkosResponse extends Response {
 }
@@ -129,3 +130,5 @@ export interface ArkosNextFunction extends NextFunction {
 }
 export interface ArkosRequestHandler extends RequestHandler {
 }
+export interface ArkosErrorRequestHandler extends ErrorRequestHandler {
+}

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

@@ -1,10 +1,32 @@
 export type RouterEndpoint = "createOne" | "findOne" | "updateOne" | "deleteOne" | "findMany" | "createMany" | "updateMany" | "deleteMany";
-export type RouterConfig = {
+export type AuthRouterEndpoint = "getMe" | "updateMe" | "deleteMe" | "login" | "logout" | "signup" | "updatePassword" | "findManyAuthAction" | "findOneAuthAction";
+export type FileUploadRouterEndpoint = "findFile" | "uploadFile" | "updateFile" | "deleteFile";
+interface PrismaBaseRouterConfig {
     parent?: {
         model?: string;
         foreignKeyField?: string;
         endpoints?: "*" | RouterEndpoint[];
     };
+}
+export type RouterConfig<T extends string = string> = T extends "auth" ? {
+    disable?: boolean | {
+        getMe?: boolean;
+        updateMe?: boolean;
+        deleteMe?: boolean;
+        login?: boolean;
+        logout?: boolean;
+        signup?: boolean;
+        updatePassword?: boolean;
+        findManyAuthAction?: boolean;
+    };
+} : T extends "file-upload" ? {
+    disable?: boolean | {
+        findFile?: boolean;
+        uploadFile?: boolean;
+        updateFile?: boolean;
+        deleteFile?: boolean;
+    };
+} : PrismaBaseRouterConfig & {
     disable?: boolean | {
         createOne?: boolean;
         findOne?: boolean;
@@ -16,3 +38,4 @@ export type RouterConfig = {
         deleteMany?: boolean;
     };
 };
+export {};

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

@@ -6,8 +6,9 @@ export declare const generateCommand: {
     controller: (options: GenerateOptions) => Promise<void>;
     service: (options: GenerateOptions) => Promise<void>;
     router: (options: GenerateOptions) => Promise<void>;
-    middlewares: (options: GenerateOptions) => Promise<void>;
+    interceptors: (options: GenerateOptions) => Promise<void>;
     authConfigs: (options: GenerateOptions) => Promise<void>;
+    hooks: (options: GenerateOptions) => Promise<void>;
     queryOptions: (options: GenerateOptions) => Promise<void>;
 };
 export {};

package/dist/types/utils/cli/utils/smart-fs-watcher.d.ts

@@ -0,0 +1,11 @@
+declare class SmartFSWather {
+    private watchedFiles;
+    private watcher;
+    private onNewFile;
+    start(onNewFile: (filePath: string) => void): void;
+    private setupListeners;
+    reset(): void;
+    close(): void;
+}
+declare const smartFsWatcher: SmartFSWather;
+export default smartFsWatcher;

package/dist/types/utils/cli/utils/template-generator/templates/generate-hooks-template.d.ts

@@ -0,0 +1,2 @@
+import { TemplateOptions } from "../../template-generators";
+export default function generateHooksTemplate(options: TemplateOptions): 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/{helpers/models.helpers.d.ts → dynamic-loader.d.ts}

@@ -1,13 +1,14 @@
-import { AuthConfigs } from "../../types/auth";
-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 declare function getFileModelModulesFileStructure(modelName: string): {
+import { ZodTypeAny } from "zod";
+import { AuthConfigs } from "../types/auth";
+import { ArkosConfig } from "../exports";
+type AppModuleComponent = Awaited<ReturnType<typeof importModuleComponents>>;
+export declare function setModuleComponents(modelName: string, modules: AppModuleComponent): any;
+export declare function getModuleComponents(modelName: string): importModuleComponentsReturnType;
+export type ValidationFileMappingKey = keyof ReturnType<typeof getFileModuleComponentsFileStructure>["dtos"];
+export declare function getFileModuleComponentsFileStructure(modelName: string): {
     core: {
-        service: string;
-        controller: string;
-        middlewares: string;
+        hooks: string;
+        interceptors: string;
         authConfigs: string;
         authConfigsNew: string;
         prismaQueryOptions: string;
@@ -17,63 +18,76 @@ 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;
-        query?: undefined;
     } | {
         model: string;
         create: string;
+        createOne: string;
         createMany: string;
         update: string;
+        updateOne: string;
         updateMany: string;
+        query: string;
         findOne: string;
         findMany: string;
-        query: 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;
-        query?: undefined;
     } | {
         model: string;
         create: string;
+        createOne: string;
         createMany: string;
         update: string;
+        updateOne: string;
         updateMany: string;
+        query: string;
         findOne: string;
         findMany: string;
-        query: string;
         login?: undefined;
         signup?: undefined;
+        getMe?: undefined;
         updateMe?: undefined;
         updatePassword?: undefined;
     };
 };
+export declare function isClass(value: any): boolean;
+export declare function isZodSchema(value: any): value is ZodTypeAny;
 export declare function processSubdir(modelName: string, type: "dtos" | "schemas"): Promise<Record<string, any>>;
-type importPrismaModelModulesReturnType = {
-    service?: any;
-    controller?: any;
-    middlewares?: any;
+type importModuleComponentsReturnType = {
+    hooks?: any;
+    interceptors?: any;
     authConfigs?: AuthConfigs;
     authConfigsNew?: AuthConfigs;
     prismaQueryOptions?: any;
@@ -82,26 +96,9 @@ type importPrismaModelModulesReturnType = {
     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, arkosConfig: ArkosConfig): Promise<importPrismaModelModulesReturnType>;
-export type ModelFieldDefition = {
-    name: string;
-    type: string;
-    isUnique: boolean;
-};
-export type RelationFields = {
-    singular: Omit<ModelFieldDefition, "isUnique">[];
-    list: Omit<ModelFieldDefition, "isUnique">[];
-};
-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 { getModels, getModelUniqueFields };
+export declare function validateNamingConventions(key: string, fileName: string, result: importModuleComponentsReturnType): void;
+export declare function assignModuleToResult(appModule: string, key: string, module: any, result: importModuleComponentsReturnType, arkosConfig: ArkosConfig): void;
+export declare function importModuleComponents(modelName: string, arkosConfig: ArkosConfig, moduleDirExists?: boolean): Promise<importModuleComponentsReturnType>;
+export declare const appModules: string[];
+export declare function loadAllModuleComponents(arkosConfig: ArkosConfig): Promise<void>;
+export {};

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/dynamic-loader.helpers.d.ts

@@ -0,0 +1,3 @@
+import { ArkosConfig, RouterConfig } from "../../exports";
+export declare function applyStrictRoutingRules<T extends string>(appModule: T, arkosConfig: ArkosConfig, moduleConfig?: RouterConfig<T>): RouterConfig<T>;
+export declare function pathExists(path: string): Promise<boolean>;

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

@@ -1,7 +1,3 @@
-import fs from "fs";
-export declare const statAsync: typeof fs.stat.__promisify__;
-export declare const accessAsync: typeof fs.access.__promisify__;
-export declare const mkdirAsync: typeof fs.mkdir.__promisify__;
 export declare const crd: () => string;
 export declare function fullCleanCwd(path: string): string;
 export declare let userFileExtension: "ts" | "js" | undefined;

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

@@ -3,4 +3,5 @@ export declare function isEsm(): boolean;
 export declare function importModule(modulePath: string, options?: {
     fixExtension: boolean;
 }): Promise<any>;
+export declare function importEsmPreventingTsTransformation(path: string): Promise<any>;
 export declare function detectPackageManagerFromUserAgent(): string;

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

@@ -1,4 +1,3 @@
 export declare let prismaInstance: any;
 export declare function loadPrismaModule(): Promise<any>;
 export declare function getPrismaInstance(): any;
-export declare const checkDatabaseConnection: (req: import("../../types").ArkosRequest, res: import("../../types").ArkosResponse, next: import("../../types").ArkosNextFunction) => Promise<void>;

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

@@ -1,2 +1,6 @@
-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>)[];
+export declare const safeCatchAsync: (middleware: any, options?: {
+    type: "error" | "normal";
+}) => any;
+export declare const processMiddleware: (middleware: any, options?: {
+    type: "error" | "normal";
+}) => any[];

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

@@ -0,0 +1,34 @@
+import { ArkosConfig } from "../../exports";
+import { ValidationFileMappingKey } from "../dynamic-loader";
+import { JsonSchema } from "./types";
+export interface SchemaGenerationConfig {
+    modelName: string;
+    arkosConfig: ArkosConfig;
+    schemasToGenerate?: ValidationFileMappingKey[];
+}
+export interface GeneratedSchemas {
+    [key: string]: JsonSchema;
+}
+export declare class PrismaJsonSchemaGenerator {
+    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 prismaJsonSchemaGenerator: PrismaJsonSchemaGenerator;
+export default prismaJsonSchemaGenerator;

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

@@ -0,0 +1,28 @@
+import { PrismaSchema, PrismaModel, PrismaEnum, PrismaField } from "./types";
+export declare class PrismaSchemaParser {
+    enums: PrismaEnum[];
+    models: PrismaModel[];
+    prismaSchemasContent: string;
+    parsed: boolean;
+    constructor();
+    parse({ override }?: {
+        override: boolean;
+    }): PrismaSchema;
+    private extractEnums;
+    private parseEnumBlock;
+    private extractModels;
+    private extractModelBlocks;
+    private parseModelBlock;
+    private parseFields;
+    private parseFieldLine;
+    private parseDefaultValue;
+    getPrismaSchemasContent(): string;
+    private getAllPrismaFiles;
+    isEnum(typeName: string): boolean;
+    isModel(typeName: string): boolean;
+    getModelUniqueFields(modelName: string): PrismaField[] | undefined;
+    getModelRelations(modelName: string): PrismaField[] | undefined;
+    getModelsAsArrayOfStrings(): string[];
+}
+declare const prismaSchemaParser: PrismaSchemaParser;
+export default prismaSchemaParser;

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

@@ -0,0 +1,49 @@
+export interface PrismaField {
+    name: string;
+    type: string;
+    isOptional: boolean;
+    isArray: boolean;
+    connectionField?: string;
+    isRelation: boolean;
+    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[];
+    }[];
+}