nextlove 2.1.4 → 2.1.6

package/dist/index.mjs

@@ -0,0 +1,270 @@
+import {
+  init_esm_shims
+} from "./chunk-2HL2TLDY.mjs";
+
+// src/index.ts
+init_esm_shims();
+export * from "nextjs-exception-middleware";
+
+// src/with-route-spec/index.ts
+init_esm_shims();
+import { withExceptionHandling } from "nextjs-exception-middleware";
+import wrappers from "nextjs-middleware-wrappers";
+
+// src/with-route-spec/middlewares/with-methods.ts
+init_esm_shims();
+import { MethodNotAllowedException } from "nextjs-exception-middleware";
+var withMethods = (methods) => (next) => (req, res) => {
+  if (!methods.includes(req.method)) {
+    throw new MethodNotAllowedException({
+      type: "method_not_allowed",
+      message: `only ${methods.join(",")} accepted`
+    });
+  }
+  return next(req, res);
+};
+var with_methods_default = withMethods;
+
+// src/with-route-spec/middlewares/with-validation.ts
+init_esm_shims();
+import { z, ZodFirstPartyTypeKind } from "zod";
+import {
+  BadRequestException,
+  InternalServerErrorException
+} from "nextjs-exception-middleware";
+import { isEmpty } from "lodash";
+var getZodObjectSchemaFromZodEffectSchema = (isZodEffect, schema) => {
+  if (!isZodEffect) {
+    return schema;
+  }
+  let currentSchema = schema;
+  while (currentSchema instanceof z.ZodEffects) {
+    currentSchema = currentSchema._def.schema;
+  }
+  return currentSchema;
+};
+var getZodDefFromZodSchemaHelpers = (schema) => {
+  const special_zod_types = [
+    ZodFirstPartyTypeKind.ZodOptional,
+    ZodFirstPartyTypeKind.ZodDefault,
+    ZodFirstPartyTypeKind.ZodEffects
+  ];
+  while (special_zod_types.includes(schema._def.typeName)) {
+    if (schema._def.typeName === ZodFirstPartyTypeKind.ZodOptional || schema._def.typeName === ZodFirstPartyTypeKind.ZodDefault) {
+      schema = schema._def.innerType;
+      continue;
+    }
+    if (schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
+      schema = schema._def.schema;
+      continue;
+    }
+  }
+  return schema._def;
+};
+var parseQueryParams = (schema, input) => {
+  const parsed_input = Object.assign({}, input);
+  const isZodEffect = schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects;
+  const safe_schema = getZodObjectSchemaFromZodEffectSchema(isZodEffect, schema);
+  const isZodObject = safe_schema._def.typeName === ZodFirstPartyTypeKind.ZodObject;
+  if (isZodObject) {
+    const obj_schema = safe_schema;
+    for (const [key, value] of Object.entries(obj_schema.shape)) {
+      const def = getZodDefFromZodSchemaHelpers(value);
+      const isArray = def.typeName === ZodFirstPartyTypeKind.ZodArray;
+      if (isArray) {
+        const array_input = input[key];
+        if (typeof array_input === "string") {
+          parsed_input[key] = array_input.split(",");
+        }
+        const bracket_syntax_array_input = input[`${key}[]`];
+        if (typeof bracket_syntax_array_input === "string") {
+          const pre_split_array = bracket_syntax_array_input;
+          parsed_input[key] = pre_split_array.split(",");
+        }
+        if (Array.isArray(bracket_syntax_array_input)) {
+          parsed_input[key] = bracket_syntax_array_input;
+        }
+        continue;
+      }
+      const isBoolean = def.typeName === ZodFirstPartyTypeKind.ZodBoolean;
+      if (isBoolean) {
+        const boolean_input = input[key];
+        if (typeof boolean_input === "string") {
+          parsed_input[key] = boolean_input === "true";
+        }
+      }
+    }
+  }
+  return schema.parse(parsed_input);
+};
+var zodIssueToString = (issue) => {
+  if (issue.path.join(".") === "") {
+    return issue.message;
+  }
+  if (issue.message === "Required") {
+    return `${issue.path.join(".")} is required`;
+  }
+  return `${issue.message} for "${issue.path.join(".")}"`;
+};
+function validateJsonResponse(jsonResponse, res) {
+  const original_res_json = res.json;
+  const override_res_json = (json) => {
+    const is_success = res.statusCode >= 200 && res.statusCode < 300;
+    if (!is_success) {
+      return original_res_json(json);
+    }
+    try {
+      jsonResponse == null ? void 0 : jsonResponse.parse(json);
+    } catch (err) {
+      throw new InternalServerErrorException({
+        type: "invalid_response",
+        message: "the response does not match with jsonResponse",
+        zodError: err
+      });
+    }
+    return original_res_json(json);
+  };
+  res.json = override_res_json;
+}
+var withValidation = (input) => (next) => async (req, res) => {
+  var _a, _b, _c, _d;
+  if (input.formData && input.jsonBody || input.formData && input.commonParams) {
+    throw new Error("Cannot use formData with jsonBody or commonParams");
+  }
+  if ((req.method === "POST" || req.method === "PATCH") && (input.jsonBody || input.commonParams) && !((_a = req.headers["content-type"]) == null ? void 0 : _a.includes("application/json")) && !isEmpty(req.body)) {
+    throw new BadRequestException({
+      type: "invalid_content_type",
+      message: `${req.method} requests must have Content-Type header with "application/json"`
+    });
+  }
+  if (input.formData && req.method !== "GET" && !((_b = req.headers["content-type"]) == null ? void 0 : _b.includes(
+    "application/x-www-form-urlencoded"
+  ))) {
+    throw new BadRequestException({
+      type: "invalid_content_type",
+      message: `Must have Content-Type header with "application/x-www-form-urlencoded"`
+    });
+  }
+  try {
+    const original_combined_params = { ...req.query, ...req.body };
+    const willValidateRequestBody = input.shouldValidateGetRequestBody ? true : req.method !== "GET";
+    const isFormData = Boolean(input.formData);
+    if (isFormData && willValidateRequestBody) {
+      req.body = (_c = input.formData) == null ? void 0 : _c.parse(req.body);
+    }
+    if (!isFormData && willValidateRequestBody) {
+      req.body = (_d = input.jsonBody) == null ? void 0 : _d.parse(req.body);
+    }
+    if (input.queryParams) {
+      req.query = parseQueryParams(input.queryParams, req.query);
+    }
+    if (input.commonParams) {
+      ;
+      req.commonParams = parseQueryParams(
+        input.commonParams,
+        original_combined_params
+      );
+    }
+  } catch (error) {
+    if (error.name === "ZodError") {
+      let message;
+      if (error.issues.length === 1) {
+        const issue = error.issues[0];
+        message = zodIssueToString(issue);
+      } else {
+        const message_components = [];
+        for (const issue of error.issues) {
+          message_components.push(zodIssueToString(issue));
+        }
+        message = `${error.issues.length} Input Errors: ` + message_components.join(", ");
+      }
+      throw new BadRequestException({
+        type: "invalid_input",
+        message,
+        validation_errors: error.format()
+      });
+    }
+    throw new BadRequestException({
+      type: "invalid_input",
+      message: "Error while parsing input"
+    });
+  }
+  if (input.shouldValidateResponses) {
+    validateJsonResponse(input.jsonResponse, res);
+  }
+  return next(req, res);
+};
+var with_validation_default = withValidation;
+
+// src/with-route-spec/index.ts
+import { z as z2 } from "zod";
+var checkRouteSpec = (spec) => spec;
+var createWithRouteSpec = (setupParams) => {
+  const {
+    authMiddlewareMap = {},
+    globalMiddlewares = [],
+    shouldValidateResponses,
+    shouldValidateGetRequestBody = true,
+    exceptionHandlingMiddleware = withExceptionHandling({
+      addOkStatus: setupParams.addOkStatus,
+      exceptionHandlingOptions: {
+        getErrorContext: (req, error) => {
+          if (process.env.NODE_ENV === "production") {
+            return {};
+          }
+          return error;
+        }
+      }
+    }),
+    globalSchemas = setupParams.addOkStatus ? {
+      ok: z2.boolean()
+    } : {}
+  } = setupParams;
+  const withRouteSpec = (spec) => {
+    const createRouteExport = (userDefinedRouteFn) => {
+      const rootRequestHandler = async (req, res) => {
+        authMiddlewareMap["none"] = (next) => next;
+        const auth_middleware = authMiddlewareMap[spec.auth];
+        if (!auth_middleware)
+          throw new Error(`Unknown auth type: ${spec.auth}`);
+        return wrappers(
+          ...exceptionHandlingMiddleware ? [exceptionHandlingMiddleware] : [],
+          ...globalMiddlewares || [],
+          auth_middleware,
+          ...spec.middlewares || [],
+          with_methods_default(spec.methods),
+          with_validation_default({
+            jsonBody: spec.jsonBody,
+            queryParams: spec.queryParams,
+            commonParams: spec.commonParams,
+            formData: spec.formData,
+            jsonResponse: spec.jsonResponse,
+            shouldValidateResponses,
+            shouldValidateGetRequestBody
+          }),
+          userDefinedRouteFn
+        )(req, res);
+      };
+      rootRequestHandler._setupParams = setupParams;
+      rootRequestHandler._routeSpec = spec;
+      return rootRequestHandler;
+    };
+    createRouteExport._setupParams = setupParams;
+    createRouteExport._routeSpec = spec;
+    return createRouteExport;
+  };
+  withRouteSpec._setupParams = setupParams;
+  return withRouteSpec;
+};
+
+// src/index.ts
+import { wrappers as wrappers2 } from "nextjs-middleware-wrappers";
+
+// src/types/index.ts
+init_esm_shims();
+export {
+  checkRouteSpec,
+  createWithRouteSpec,
+  wrappers2 as wrappers
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/with-route-spec/index.ts", "../src/with-route-spec/middlewares/with-methods.ts", "../src/with-route-spec/middlewares/with-validation.ts", "../src/types/index.ts"],
  "sourcesContent": ["export * from \"nextjs-exception-middleware\"\nexport * from \"./with-route-spec\"\nexport { wrappers } from \"nextjs-middleware-wrappers\"\nexport * from \"./types\"\n", "import { NextApiResponse, NextApiRequest } from \"next\"\nimport { withExceptionHandling } from \"nextjs-exception-middleware\"\nimport wrappers, { Middleware } from \"nextjs-middleware-wrappers\"\nimport { CreateWithRouteSpecFunction, RouteSpec } from \"../types\"\nimport withMethods, { HTTPMethods } from \"./middlewares/with-methods\"\nimport withValidation from \"./middlewares/with-validation\"\nimport { z } from \"zod\"\n\ntype ParamDef = z.ZodTypeAny | z.ZodEffects<z.ZodTypeAny>\n\nexport const checkRouteSpec = <\n  AuthType extends string = string,\n  Methods extends HTTPMethods[] = HTTPMethods[],\n  JsonBody extends ParamDef = z.ZodTypeAny,\n  QueryParams extends ParamDef = z.ZodTypeAny,\n  CommonParams extends ParamDef = z.ZodTypeAny,\n  Middlewares extends readonly Middleware<any, any>[] = readonly Middleware<\n    any,\n    any\n  >[],\n  FormData extends ParamDef = z.ZodTypeAny,\n  Spec extends RouteSpec<\n    AuthType,\n    Methods,\n    JsonBody,\n    QueryParams,\n    CommonParams,\n    Middlewares,\n    FormData\n  > = RouteSpec<\n    AuthType,\n    Methods,\n    JsonBody,\n    QueryParams,\n    CommonParams,\n    Middlewares,\n    FormData\n  >\n>(\n  spec: Spec\n): string extends Spec[\"auth\"]\n  ? `your route spec is underspecified, add \"as const\"`\n  : Spec => spec as any\n\nexport const createWithRouteSpec: CreateWithRouteSpecFunction = ((\n  setupParams\n) => {\n  const {\n    authMiddlewareMap = {},\n    globalMiddlewares = [],\n    shouldValidateResponses,\n    shouldValidateGetRequestBody = true,\n    exceptionHandlingMiddleware = withExceptionHandling({\n      addOkStatus: setupParams.addOkStatus,\n      exceptionHandlingOptions: {\n        getErrorContext: (req, error) => {\n          if (process.env.NODE_ENV === \"production\") {\n            return {}\n          }\n\n          return error\n        },\n      },\n    }) as any,\n    globalSchemas = setupParams.addOkStatus\n      ? {\n          ok: z.boolean(),\n        }\n      : {},\n  } = setupParams\n\n  const withRouteSpec = (spec: RouteSpec) => {\n    const createRouteExport = (userDefinedRouteFn) => {\n      const rootRequestHandler = async (\n        req: NextApiRequest,\n        res: NextApiResponse\n      ) => {\n        authMiddlewareMap[\"none\"] = (next) => next\n\n        const auth_middleware = authMiddlewareMap[spec.auth]\n        if (!auth_middleware) throw new Error(`Unknown auth type: ${spec.auth}`)\n\n        return wrappers(\n          ...((exceptionHandlingMiddleware\n            ? [exceptionHandlingMiddleware]\n            : []) as [any]),\n          ...((globalMiddlewares || []) as []),\n          auth_middleware,\n          ...((spec.middlewares || []) as []),\n          withMethods(spec.methods),\n          withValidation({\n            jsonBody: spec.jsonBody,\n            queryParams: spec.queryParams,\n            commonParams: spec.commonParams,\n            formData: spec.formData,\n            jsonResponse: spec.jsonResponse,\n            shouldValidateResponses,\n            shouldValidateGetRequestBody,\n          }),\n          userDefinedRouteFn\n        )(req as any, res)\n      }\n\n      rootRequestHandler._setupParams = setupParams\n      rootRequestHandler._routeSpec = spec\n\n      return rootRequestHandler\n    }\n\n    createRouteExport._setupParams = setupParams\n    createRouteExport._routeSpec = spec\n\n    return createRouteExport\n  }\n\n  withRouteSpec._setupParams = setupParams\n\n  return withRouteSpec\n}) as any\n", "import { MethodNotAllowedException } from \"nextjs-exception-middleware\"\n\nexport type HTTPMethods =\n  | \"GET\"\n  | \"POST\"\n  | \"DELETE\"\n  | \"PUT\"\n  | \"PATCH\"\n  | \"HEAD\"\n  | \"OPTIONS\"\n\nexport const withMethods = (methods: HTTPMethods[]) => (next) => (req, res) => {\n  if (!methods.includes(req.method)) {\n    throw new MethodNotAllowedException({\n      type: \"method_not_allowed\",\n      message: `only ${methods.join(\",\")} accepted`,\n    })\n  }\n  return next(req, res)\n}\n\nexport default withMethods\n", "import type { NextApiRequest, NextApiResponse } from \"next\"\nimport { z, ZodFirstPartyTypeKind } from \"zod\"\nimport {\n  BadRequestException,\n  InternalServerErrorException,\n} from \"nextjs-exception-middleware\"\nimport { isEmpty } from \"lodash\"\n\nconst getZodObjectSchemaFromZodEffectSchema = (\n  isZodEffect: boolean,\n  schema: z.ZodTypeAny\n): z.ZodTypeAny | z.ZodObject<any> => {\n  if (!isZodEffect) {\n    return schema as z.ZodObject<any>\n  }\n\n  let currentSchema = schema\n\n  while (currentSchema instanceof z.ZodEffects) {\n    currentSchema = currentSchema._def.schema\n  }\n\n  return currentSchema as z.ZodObject<any>\n}\n\n/**\n * This function is used to get the correct schema from a ZodEffect | ZodDefault | ZodOptional schema.\n * TODO: this function should handle all special cases of ZodSchema and not just ZodEffect | ZodDefault | ZodOptional\n */\nconst getZodDefFromZodSchemaHelpers = (schema: z.ZodTypeAny) => {\n  const special_zod_types = [\n    ZodFirstPartyTypeKind.ZodOptional,\n    ZodFirstPartyTypeKind.ZodDefault,\n    ZodFirstPartyTypeKind.ZodEffects,\n  ]\n\n  while (special_zod_types.includes(schema._def.typeName)) {\n    if (\n      schema._def.typeName === ZodFirstPartyTypeKind.ZodOptional ||\n      schema._def.typeName === ZodFirstPartyTypeKind.ZodDefault\n    ) {\n      schema = schema._def.innerType\n      continue\n    }\n\n    if (schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {\n      schema = schema._def.schema\n      continue\n    }\n  }\n  return schema._def\n}\n\nconst parseQueryParams = (\n  schema: z.ZodTypeAny,\n  input: Record<string, unknown>\n) => {\n  const parsed_input = Object.assign({}, input)\n  const isZodEffect = schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects\n  const safe_schema = getZodObjectSchemaFromZodEffectSchema(isZodEffect, schema)\n  const isZodObject =\n    safe_schema._def.typeName === ZodFirstPartyTypeKind.ZodObject\n\n  if (isZodObject) {\n    const obj_schema = safe_schema as z.ZodObject<any>\n\n    for (const [key, value] of Object.entries(obj_schema.shape)) {\n      const def = getZodDefFromZodSchemaHelpers(value as z.ZodTypeAny)\n      const isArray = def.typeName === ZodFirstPartyTypeKind.ZodArray\n      if (isArray) {\n        const array_input = input[key]\n\n        if (typeof array_input === \"string\") {\n          parsed_input[key] = array_input.split(\",\")\n        }\n\n        const bracket_syntax_array_input = input[`${key}[]`]\n        if (typeof bracket_syntax_array_input === \"string\") {\n          const pre_split_array = bracket_syntax_array_input\n          parsed_input[key] = pre_split_array.split(\",\")\n        }\n\n        if (Array.isArray(bracket_syntax_array_input)) {\n          parsed_input[key] = bracket_syntax_array_input\n        }\n\n        continue\n      }\n\n      const isBoolean = def.typeName === ZodFirstPartyTypeKind.ZodBoolean\n      if (isBoolean) {\n        const boolean_input = input[key]\n\n        if (typeof boolean_input === \"string\") {\n          parsed_input[key] = boolean_input === \"true\"\n        }\n      }\n    }\n  }\n\n  return schema.parse(parsed_input)\n}\n\nexport interface RequestInput<\n  JsonBody extends z.ZodTypeAny,\n  QueryParams extends z.ZodTypeAny,\n  CommonParams extends z.ZodTypeAny,\n  FormData extends z.ZodTypeAny,\n  JsonResponse extends z.ZodTypeAny\n> {\n  jsonBody?: JsonBody\n  queryParams?: QueryParams\n  commonParams?: CommonParams\n  formData?: FormData\n  jsonResponse?: JsonResponse\n  shouldValidateResponses?: boolean\n  shouldValidateGetRequestBody?: boolean\n}\n\nconst zodIssueToString = (issue: z.ZodIssue) => {\n  if (issue.path.join(\".\") === \"\") {\n    return issue.message\n  }\n  if (issue.message === \"Required\") {\n    return `${issue.path.join(\".\")} is required`\n  }\n  return `${issue.message} for \"${issue.path.join(\".\")}\"`\n}\n\nfunction validateJsonResponse<JsonResponse extends z.ZodTypeAny>(\n  jsonResponse: JsonResponse | undefined,\n  res: NextApiResponse\n) {\n  const original_res_json = res.json\n  const override_res_json = (json: any) => {\n    const is_success = res.statusCode >= 200 && res.statusCode < 300\n    if (!is_success) {\n      return original_res_json(json)\n    }\n\n    try {\n      jsonResponse?.parse(json)\n    } catch (err) {\n      throw new InternalServerErrorException({\n        type: \"invalid_response\",\n        message: \"the response does not match with jsonResponse\",\n        zodError: err,\n      })\n    }\n\n    return original_res_json(json)\n  }\n  res.json = override_res_json\n}\n\nexport const withValidation =\n  <\n    JsonBody extends z.ZodTypeAny,\n    QueryParams extends z.ZodTypeAny,\n    CommonParams extends z.ZodTypeAny,\n    FormData extends z.ZodTypeAny,\n    JsonResponse extends z.ZodTypeAny\n  >(\n    input: RequestInput<\n      JsonBody,\n      QueryParams,\n      CommonParams,\n      FormData,\n      JsonResponse\n    >\n  ) =>\n  (next) =>\n  async (req: NextApiRequest, res: NextApiResponse) => {\n    if (\n      (input.formData && input.jsonBody) ||\n      (input.formData && input.commonParams)\n    ) {\n      throw new Error(\"Cannot use formData with jsonBody or commonParams\")\n    }\n\n    if (\n      (req.method === \"POST\" || req.method === \"PATCH\") &&\n      (input.jsonBody || input.commonParams) &&\n      !req.headers[\"content-type\"]?.includes(\"application/json\") &&\n      !isEmpty(req.body)\n    ) {\n      throw new BadRequestException({\n        type: \"invalid_content_type\",\n        message: `${req.method} requests must have Content-Type header with \"application/json\"`,\n      })\n    }\n\n    if (\n      input.formData &&\n      req.method !== \"GET\" &&\n      !req.headers[\"content-type\"]?.includes(\n        \"application/x-www-form-urlencoded\"\n      )\n      // TODO eventually we should support multipart/form-data\n    ) {\n      throw new BadRequestException({\n        type: \"invalid_content_type\",\n        message: `Must have Content-Type header with \"application/x-www-form-urlencoded\"`,\n      })\n    }\n\n    try {\n      const original_combined_params = { ...req.query, ...req.body }\n\n      const willValidateRequestBody = input.shouldValidateGetRequestBody\n        ? true\n        : req.method !== \"GET\"\n\n      const isFormData = Boolean(input.formData)\n\n      if (isFormData && willValidateRequestBody) {\n        req.body = input.formData?.parse(req.body)\n      }\n\n      if (!isFormData && willValidateRequestBody) {\n        req.body = input.jsonBody?.parse(req.body)\n      }\n\n      if (input.queryParams) {\n        req.query = parseQueryParams(input.queryParams, req.query)\n      }\n\n      if (input.commonParams) {\n        /**\n         * as commonParams includes query params, we can use the parseQueryParams function\n         */\n        ;(req as any).commonParams = parseQueryParams(\n          input.commonParams,\n          original_combined_params\n        )\n      }\n    } catch (error: any) {\n      if (error.name === \"ZodError\") {\n        let message\n        if (error.issues.length === 1) {\n          const issue = error.issues[0]\n          message = zodIssueToString(issue)\n        } else {\n          const message_components: string[] = []\n          for (const issue of error.issues) {\n            message_components.push(zodIssueToString(issue))\n          }\n          message =\n            `${error.issues.length} Input Errors: ` +\n            message_components.join(\", \")\n        }\n\n        throw new BadRequestException({\n          type: \"invalid_input\",\n          message,\n          validation_errors: error.format(),\n        })\n      }\n\n      throw new BadRequestException({\n        type: \"invalid_input\",\n        message: \"Error while parsing input\",\n      })\n    }\n\n    /**\n     * this will override the res.json method to validate the response\n     */\n    if (input.shouldValidateResponses) {\n      validateJsonResponse(input.jsonResponse, res)\n    }\n\n    return next(req, res)\n  }\n\nexport default withValidation\n", "import { NextApiResponse, NextApiRequest } from \"next\"\nimport { Middleware as WrapperMiddleware } from \"nextjs-middleware-wrappers\"\nimport { z } from \"zod\"\nimport { HTTPMethods } from \"../with-route-spec/middlewares/with-methods\"\nimport {\n  SecuritySchemeObject,\n  SecurityRequirementObject,\n} from \"openapi3-ts/oas31\"\n\nexport type Middleware<T, Dep = {}> = WrapperMiddleware<T, Dep> & {\n  /**\n   * @deprecated moved to setupParams\n   */\n  securitySchema?: SecuritySchemeObject\n  securityObjects?: SecurityRequirementObject[]\n}\n\ntype ParamDef = z.ZodTypeAny | z.ZodEffects<z.ZodTypeAny>\n\nexport interface RouteSpec<\n  Auth extends string = string,\n  Methods extends HTTPMethods[] = any,\n  JsonBody extends ParamDef = z.ZodObject<any, any, any, any, any>,\n  QueryParams extends ParamDef = z.ZodObject<any, any, any, any, any>,\n  CommonParams extends ParamDef = z.ZodObject<any, any, any, any, any>,\n  Middlewares extends readonly Middleware<any, any>[] = any[],\n  JsonResponse extends ParamDef = z.ZodObject<any, any, any, any, any>,\n  FormData extends ParamDef = z.ZodTypeAny\n> {\n  methods: Methods\n  auth: Auth\n  jsonBody?: JsonBody\n  queryParams?: QueryParams\n  commonParams?: CommonParams\n  middlewares?: Middlewares\n  jsonResponse?: JsonResponse\n  formData?: FormData\n}\n\nexport type MiddlewareChainOutput<\n  MWChain extends readonly Middleware<any, any>[]\n> = MWChain extends readonly []\n  ? {}\n  : MWChain extends readonly [infer First, ...infer Rest]\n  ? First extends Middleware<infer T, any>\n    ? T &\n        (Rest extends readonly Middleware<any, any>[]\n          ? MiddlewareChainOutput<Rest>\n          : never)\n    : never\n  : never\n\nexport type AuthMiddlewares = {\n  [auth_type: string]: Middleware<any, any>\n}\n\nexport interface SetupParams<\n  AuthMW extends AuthMiddlewares = AuthMiddlewares,\n  GlobalMW extends Middleware<any, any>[] = any[]\n> {\n  authMiddlewareMap: AuthMW\n  globalMiddlewares: GlobalMW\n  exceptionHandlingMiddleware?: ((next: Function) => Function) | null\n\n  // These improve OpenAPI generation\n  apiName: string\n  productionServerUrl: string\n\n  addOkStatus?: boolean\n\n  shouldValidateResponses?: boolean\n  shouldValidateGetRequestBody?: boolean\n  securitySchemas?: Record<string, SecuritySchemeObject>\n  globalSchemas?: Record<string, z.ZodTypeAny>\n}\n\nconst defaultMiddlewareMap = {\n  none: (next) => next,\n} as const\n\ntype Send<T> = (body: T) => void\ntype NextApiResponseWithoutJsonAndStatusMethods = Omit<\n  NextApiResponse,\n  \"json\" | \"status\"\n>\n\ntype SuccessfulNextApiResponseMethods<T> = {\n  status: (\n    statusCode: 200 | 201\n  ) => NextApiResponseWithoutJsonAndStatusMethods & {\n    json: Send<T>\n  }\n  json: Send<T>\n}\n\ntype ErrorNextApiResponseMethods = {\n  status: (statusCode: number) => NextApiResponseWithoutJsonAndStatusMethods & {\n    json: Send<any>\n  }\n  json: Send<any>\n}\n\nexport type RouteFunction<\n  SP extends SetupParams<AuthMiddlewares>,\n  RS extends RouteSpec\n> = (\n  req: (SP[\"authMiddlewareMap\"] &\n    typeof defaultMiddlewareMap)[RS[\"auth\"]] extends Middleware<\n    infer AuthMWOut,\n    any\n  >\n    ? Omit<NextApiRequest, \"query\" | \"body\"> &\n        AuthMWOut &\n        MiddlewareChainOutput<\n          RS[\"middlewares\"] extends readonly Middleware<any, any>[]\n            ? [...SP[\"globalMiddlewares\"], ...RS[\"middlewares\"]]\n            : SP[\"globalMiddlewares\"]\n        > & {\n          body: RS[\"formData\"] extends z.ZodTypeAny\n            ? z.infer<RS[\"formData\"]>\n            : RS[\"jsonBody\"] extends z.ZodTypeAny\n            ? z.infer<RS[\"jsonBody\"]>\n            : {}\n          query: RS[\"queryParams\"] extends z.ZodTypeAny\n            ? z.infer<RS[\"queryParams\"]>\n            : {}\n          commonParams: RS[\"commonParams\"] extends z.ZodTypeAny\n            ? z.infer<RS[\"commonParams\"]>\n            : {}\n        }\n    : `unknown auth type: ${RS[\"auth\"]}. You should configure this auth type in your auth_middlewares w/ createWithRouteSpec, or maybe you need to add \"as const\" to your route spec definition.`,\n  res: NextApiResponseWithoutJsonAndStatusMethods &\n    SuccessfulNextApiResponseMethods<\n      RS[\"jsonResponse\"] extends z.ZodTypeAny\n        ? z.infer<RS[\"jsonResponse\"]>\n        : any\n    > &\n    ErrorNextApiResponseMethods\n) => Promise<void>\n\nexport type CreateWithRouteSpecFunction = <\n  SP extends SetupParams<AuthMiddlewares, any>\n>(\n  setupParams: SP\n) => <\n  RS extends RouteSpec<\n    string,\n    any,\n    any,\n    any,\n    any,\n    any,\n    z.ZodObject<any, any, any, any, any>,\n    any\n  >\n>(\n  route_spec: RS\n) => (next: RouteFunction<SP, RS>) => any\n"],
  "mappings": "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",
  "names": ["z", "wrappers"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextlove",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "private": false,
   "repository": "https://github.com/seamapi/nextlove",
   "files": [
@@ -15,10 +15,24 @@
     "nextlove": "bin.js"
   },
   "main": "./dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./generators": {
+      "types": "./dist/generators/index.d.ts",
+      "import": "./dist/generators/index.mjs",
+      "require": "./dist/generators/index.js"
+    }
+  },
   "scripts": {
     "test": "npm run typecheck",
     "typecheck": "tsc --noEmit",
-    "build": "tsup --dts --sourcemap inline src",
+    "build": "tsup --dts --sourcemap inline src/index.ts src/generators/index.ts --format cjs,esm",
     "yalc": "npm run build && yalc push"
   },
   "peerDependencies": {
@@ -31,28 +45,26 @@
     "prettier": "^2.0.0 || ^3.0.0"
   },
   "dependencies": {
+    "@anatine/zod-openapi": "^2.0.1",
     "lodash": "^4.17.21",
     "nextjs-exception-middleware": "^2.0.1",
     "nextjs-middleware-wrappers": "^1.3.0",
-    "openapi3-ts": "^3.1.1",
-    "zod-to-ts": "^1.1.1"
+    "openapi3-ts": "^4.1.2",
+    "zod-to-ts": "^1.1.4"
   },
   "devDependencies": {
-    "@anatine/zod-openapi": "^1.10.0",
     "@types/lodash": "^4.14.182",
     "@types/node": "18.0.0",
     "@types/prettier": "^2.7.1",
     "@types/react": "18.0.14",
     "@types/react-dom": "18.0.5",
-    "chalk": "^5.1.2",
+    "chalk": "^5.3.0",
     "esbuild": "^0.14.7",
     "esbuild-register": "^3.3.3",
     "esbuild-runner": "^2.2.1",
     "eslint": "8.18.0",
     "eslint-config-next": "12.2.0",
     "expect-type": "^0.15.0",
-    "globby": "11.1.0",
-    "minimist": "^1.2.7",
     "next": "12.2.0",
     "nextjs-middleware-wrappers": "^1.3.0",
     "nextjs-server-modules": "^2.1.0",
@@ -64,6 +76,6 @@
     "turbo": "^1.3.1",
     "type-fest": "^3.1.0",
     "typescript": "4.7.4",
-    "zod": "^3.17.3"
+    "zod": "^3.21.4"
   }
 }