@alevnyacow/nzmt 0.0.1

package/dist/zod-controller.utils.d.ts

@@ -0,0 +1,122 @@
+import { type NextRequest, NextResponse } from 'next/server';
+import z, { type ZodObject } from 'zod';
+import { type ControllerErrorModel, type ErrorBaseCreatingPayload } from './errors.utils';
+export declare enum ZodControllerDefaultErrorCodes {
+    REQUEST_PARSING = "ZOD-CONTROLLER___REQUEST-PARSING",
+    RESPONSE_PARSING = "ZOD-CONTROLLER___RESPONSE-PARSING"
+}
+type SuccessResponse<ResponseZodSchema> = ResponseZodSchema extends undefined ? {} : z.infer<ResponseZodSchema>;
+type ZodAPISchemas = {
+    body?: ZodObject;
+    query?: ZodObject;
+    response?: ZodObject;
+};
+type ErrorResponse = {
+    message: string;
+    code?: string;
+    details?: any;
+};
+type EndpointErrorGenerator = (payload: string | ErrorBaseCreatingPayload, errorStatus?: number, cause?: unknown) => ControllerErrorModel;
+export type Guard = (payload: {
+    request: NextRequest;
+    endpointError: EndpointErrorGenerator;
+}) => Promise<undefined | ControllerErrorModel>;
+export type OnErrorHandler = (request: {
+    error: ControllerErrorModel;
+    req: NextRequest;
+}) => Promise<void>;
+type EndpointLogic<T extends ZodAPISchemas> = {
+    handler: (payload: (T['query'] extends ZodObject ? z.infer<T['query']> : {}) & (T['body'] extends ZodObject ? z.infer<T['body']> : {}), request: {
+        request: NextRequest;
+        flags: Record<string, boolean>;
+        endpointError: EndpointErrorGenerator;
+    }) => Promise<T['response'] extends ZodObject ? z.infer<T['response']> : void>;
+    guards?: Guard[];
+    eventHandlers?: {
+        onSuccess?: Array<(data: {
+            requestPayload: (T['query'] extends ZodObject ? z.infer<T['query']> : {}) & (T['body'] extends ZodObject ? z.infer<T['body']> : {});
+            request: NextRequest;
+            result: T['response'] extends ZodObject ? z.infer<T['response']> : undefined;
+            flags: Record<string, boolean>;
+        }) => Promise<void>>;
+        onError?: Array<OnErrorHandler>;
+    };
+    customResponseLogic?: {
+        onSuccess?: (payload: {
+            req: NextRequest;
+            response: T['response'] extends undefined ? undefined : z.infer<T['response']>;
+        }) => Promise<NextResponse>;
+        onError?: (payload: {
+            req: NextRequest;
+            error: ControllerErrorModel;
+        }) => Promise<NextResponse>;
+    };
+};
+export type SharedConfig = Partial<{
+    guards: Guard[];
+    onErrorHandlers?: Array<OnErrorHandler>;
+}>;
+export declare const zodAPIEndpointFactory: <T extends ZodControllerSchemas>(metadata: {
+    schemas: T;
+    name: string;
+}, sharedConfig?: SharedConfig) => <Method extends keyof T>(method: Method, handler: EndpointLogic<T[Method]>["handler"], configuration?: Omit<EndpointLogic<T[Method]>, "handler">) => (request: NextRequest) => Promise<NextResponse<unknown>>;
+type ZodControllerSchemas = Record<string, ZodAPISchemas>;
+type Flatten<T extends Record<string, object>> = {
+    [K in keyof T]: T[K];
+}[keyof T];
+type OnlyObject<T> = T extends object ? T : never;
+type SchemaShape = {
+    body?: unknown;
+    query?: unknown;
+    response?: unknown;
+};
+export type ZodControllerMetadata<T = ZodControllerSchemas> = {
+    name: string;
+    schemas: T;
+};
+type NormalizeSchema<T extends SchemaShape> = {
+    body: T extends {
+        body: infer B;
+    } ? B : undefined;
+    query: T extends {
+        query: infer Q;
+    } ? Q : undefined;
+    response: T extends {
+        response: infer R;
+    } ? R : undefined;
+};
+type RequestPayload<T extends SchemaShape> = Flatten<{
+    [K in Exclude<keyof NormalizeSchema<T>, 'response'> as OnlyObject<NormalizeSchema<T>[K]> extends never ? never : K]: z.infer<OnlyObject<NormalizeSchema<T>[K]>>;
+}>;
+type ResponsePayload<T extends SchemaShape> = T extends {
+    response: infer R;
+} ? z.infer<R> : never;
+type ZodAPIPayload<QueryParams, BodyParams> = (QueryParams extends undefined ? {} : {
+    query: z.infer<QueryParams>;
+}) & (BodyParams extends undefined ? {} : {
+    body: z.infer<BodyParams>;
+});
+type ZodAPIMethod<Schemas extends {
+    body: unknown;
+    query: unknown;
+    response: unknown;
+}> = {
+    payload: ZodAPIPayload<Schemas['query'], Schemas['body']>;
+    response: SuccessResponse<Schemas['response']>;
+    error: ErrorResponse;
+};
+export type ZodControllerAPI<Metadata extends {
+    schemas: Record<string, SchemaShape>;
+}, CustomModels extends Record<string, unknown> | undefined = undefined> = {
+    endpoints: {
+        [K in keyof Metadata['schemas']]: ZodAPIMethod<NormalizeSchema<Metadata['schemas'][K]>>;
+    };
+    customModels: CustomModels extends undefined ? {} : CustomModels;
+    requestDTOs: {
+        [K in keyof Metadata['schemas']]: RequestPayload<Metadata['schemas'][K]>;
+    };
+    responseDTOs: {
+        [K in keyof Metadata['schemas']]: ResponsePayload<Metadata['schemas'][K]>;
+    };
+};
+export {};

package/dist/zod-module.utils.d.ts

@@ -0,0 +1,29 @@
+import type z from 'zod';
+import type { ZodType } from 'zod';
+import { type ErrorBaseCreatingPayload, type ModuleErrorModel } from './errors.utils';
+type ZodModuleSchemas = Record<string, {
+    payload: ZodType;
+    response: ZodType;
+}>;
+export type ZodModuleMetadata = {
+    name: string;
+    schemas: ZodModuleSchemas;
+};
+export type ZodModuleDTOs<T extends ZodModuleMetadata> = {
+    [K in keyof T['schemas'] as `${Extract<K, string>}Payload`]: z.infer<T['schemas'][K]['payload']>;
+} & {
+    [K in keyof T['schemas'] as `${Extract<K, string>}Response`]: z.infer<T['schemas'][K]['response']>;
+};
+export type ZodModuleMethods<T extends ZodModuleMetadata> = {
+    [K in keyof T['schemas']]: (payload: z.infer<T['schemas'][K]['payload']>) => Promise<z.infer<T['schemas'][K]['response']>>;
+};
+export type ZodModuleConfig = {
+    onError?: (e: ModuleErrorModel) => Promise<void>;
+};
+export declare const zodModuleMethodFactory: <T extends ZodModuleSchemas>(metadata: {
+    schemas: T;
+    name: string;
+}, sharedConfig?: ZodModuleConfig) => <Method extends keyof T>(methodName: Method, handler: (payload: z.infer<T[Method]["payload"]>, config: {
+    methodError: (payload: string | ErrorBaseCreatingPayload, cause?: unknown) => ModuleErrorModel;
+}) => Promise<z.infer<T[Method]["response"]>>, config?: ZodModuleConfig) => (payload: z.infer<T[Method]["payload"]>) => Promise<z.infer<T[Method]["response"]>>;
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@alevnyacow/nzmt",
+  "version": "0.0.1",
+  "description": "Next Zod Modules Toolkit",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rslib build",
+    "check": "biome check --write",
+    "dev": "rslib build --watch",
+    "format": "biome format --write",
+    "test": "rstest",
+    "test:watch": "rstest --watch"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.6",
+    "@rslib/core": "^0.20.0",
+    "@rstest/adapter-rslib": "^0.2.1",
+    "@rstest/core": "^0.9.0",
+    "@types/node": "^24.12.0",
+    "next": "^16.1.6",
+    "typescript": "^5.9.3"
+  },
+  "private": false,
+  "dependencies": {
+    "uuid": "^13.0.0",
+    "zod": "^4.3.6"
+  }
+}