springnext 0.0.1 → 0.0.2

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

@@ -0,0 +1,126 @@
+declare function jsonResponse<T>(data: T, init?: ResponseInit): import("undici-types").Response;
+import { type NextRequest, type NextResponse } from 'next/server';
+import z, { type ZodType, type ZodObject, type ZodUnion } from 'zod';
+import { type ControllerErrorModel, type ErrorBaseCreatingPayload } from './errors.utils';
+export declare enum DefaultErrorCodes {
+    REQUEST_PARSING = "NZMT-CONTROLLER___REQUEST-PARSING",
+    RESPONSE_PARSING = "NZMT-CONTROLLER___RESPONSE-PARSING"
+}
+type SuccessResponse<ResponseZodSchema> = ResponseZodSchema extends undefined ? {} : z.infer<ResponseZodSchema>;
+type ZodAPISchemas = {
+    body?: ZodObject | ZodUnion<[ZodObject<any>, ...ZodObject<any>[]]>;
+    query?: ZodObject | ZodUnion<[ZodObject<any>, ...ZodObject<any>[]]>;
+    response?: ZodType;
+};
+type ErrorResponse = {
+    code: string;
+    message?: 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>;
+export type EndpointList<T extends Metadata> = {
+    [K in keyof T['schemas']]: (request: NextRequest) => Promise<ReturnType<typeof jsonResponse>>;
+};
+type EndpointLogic<T extends ZodAPISchemas> = {
+    handler: (payload: (T['query'] extends ZodType ? z.infer<T['query']> : {}) & (T['body'] extends ZodType ? z.infer<T['body']> : {}), request: {
+        request: NextRequest;
+        flags: Record<string, boolean>;
+        endpointError: EndpointErrorGenerator;
+    }) => Promise<T['response'] extends ZodType ? z.infer<T['response']> : void>;
+    guards?: Guard[];
+    eventHandlers?: {
+        onSuccess?: Array<(data: {
+            requestPayload: (T['query'] extends ZodType ? z.infer<T['query']> : {}) & (T['body'] extends ZodType ? z.infer<T['body']> : {});
+            request: NextRequest;
+            result: T['response'] extends ZodType ? 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 endpoints: <T extends Schemas>(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<import("undici-types").Response>;
+type Schemas = 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 Metadata<T = Schemas> = {
+    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 Contract<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.spec.d.ts

@@ -0,0 +1 @@
+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 Schemas = Record<string, {
+    payload: ZodType;
+    response: ZodType;
+}>;
+export type Metadata = {
+    name: string;
+    schemas: Schemas;
+};
+export type DTOs<T extends Metadata> = {
+    [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 Methods<T extends Metadata> = {
+    [K in keyof T['schemas']]: (payload: z.infer<T['schemas'][K]['payload']>) => Promise<z.infer<T['schemas'][K]['response']>>;
+};
+export type Config = {
+    onError?: (e: ModuleErrorModel) => Promise<void>;
+};
+export declare const methods: <T extends Schemas>(metadata: {
+    schemas: T;
+    name: string;
+}, sharedConfig?: Config) => <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?: Config) => (payload: z.infer<T[Method]["payload"]>) => Promise<z.infer<T[Method]["response"]>>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "springnext",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -17,11 +17,22 @@
   ],
   "scripts": {
     "build": "rslib",
-    "dev": "rslib --watch"
+    "dev": "rslib --watch",
+    "test": "rstest"
   },
   "devDependencies": {
-    "@rslib/core": "^0.20.3",
+    "@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",
+    "zod": "^4.3.6",
     "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "next": ">=13 <17",
+    "zod": ">=3 <5",
+    "inversify": ">=7 <9",
+    "reflect-metadata": "^0.2.2"
   }
 }