nextlove 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from 'nextjs-exception-middleware';
+export { checkRouteSpec, createWithRouteSpec } from './with-route-spec/index.js';
+export { wrappers } from 'nextjs-middleware-wrappers';
+export { AuthMiddlewares, CreateWithRouteSpecFunction, Middleware, MiddlewareChainOutput, RouteFunction, RouteSpec, SetupParams } from './types/index.js';
+import './with-route-spec/middlewares/with-methods.js';
+import 'zod';
+import 'next';
+import 'openapi3-ts';

package/dist/index.js

@@ -0,0 +1,154 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  checkRouteSpec: () => checkRouteSpec,
+  createWithRouteSpec: () => createWithRouteSpec,
+  wrappers: () => import_nextjs_middleware_wrappers2.wrappers
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("nextjs-exception-middleware"), module.exports);
+
+// src/with-route-spec/index.ts
+var import_nextjs_exception_middleware3 = require("nextjs-exception-middleware");
+var import_nextjs_middleware_wrappers = __toESM(require("nextjs-middleware-wrappers"));
+
+// src/with-route-spec/middlewares/with-methods.ts
+var import_nextjs_exception_middleware = require("nextjs-exception-middleware");
+var withMethods = (methods) => (next) => (req, res) => {
+  if (!methods.includes(req.method)) {
+    throw new import_nextjs_exception_middleware.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
+var import_nextjs_exception_middleware2 = require("nextjs-exception-middleware");
+var import_lodash = require("lodash");
+var parseCommaSeparateArrays = (schema, input) => {
+  const parsed_input = Object.assign({}, input);
+  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(".")}"`;
+};
+var withValidation = (input) => (next) => async (req, res) => {
+  var _a, _b, _c;
+  if ((req.method === "POST" || req.method === "PATCH") && !((_a = req.headers["content-type"]) == null ? void 0 : _a.includes("application/json")) && !(0, import_lodash.isEmpty)(req.body)) {
+    throw new import_nextjs_exception_middleware2.BadRequestException({
+      type: "invalid_content_type",
+      message: `POST requests must have Content-Type header with "application/json"`
+    });
+  }
+  try {
+    const original_combined_params = { ...req.query, ...req.body };
+    req.body = (_b = input.jsonBody) == null ? void 0 : _b.parse(req.body);
+    req.query = (_c = input.queryParams) == null ? void 0 : _c.parse(req.query);
+    if (input.commonParams) {
+      ;
+      req.commonParams = parseCommaSeparateArrays(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 import_nextjs_exception_middleware2.BadRequestException({
+        type: "invalid_input",
+        message,
+        validation_errors: error.format()
+      });
+    }
+    throw new import_nextjs_exception_middleware2.BadRequestException({
+      type: "invalid_input",
+      message: "Error while parsing input"
+    });
+  }
+  return next(req, res);
+};
+var with_validation_default = withValidation;
+
+// src/with-route-spec/index.ts
+var checkRouteSpec = (spec) => spec;
+var createWithRouteSpec = (setupParams) => {
+  const {
+    authMiddlewareMap = {},
+    globalMiddlewares = [],
+    exceptionHandlingMiddleware = (0, import_nextjs_exception_middleware3.withExceptionHandling)({
+      addOkStatus: true
+    })
+  } = 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 (0, import_nextjs_middleware_wrappers.default)(...exceptionHandlingMiddleware ? [exceptionHandlingMiddleware] : [], ...globalMiddlewares || [], auth_middleware, ...spec.middlewares || [], with_methods_default(spec.methods), with_validation_default({
+          jsonBody: spec.jsonBody,
+          queryParams: spec.queryParams,
+          commonParams: spec.commonParams
+        }), 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
+var import_nextjs_middleware_wrappers2 = require("nextjs-middleware-wrappers");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkRouteSpec,
+  createWithRouteSpec,
+  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"],
  "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  Spec extends RouteSpec<\n    AuthType,\n    Methods,\n    JsonBody,\n    QueryParams,\n    CommonParams,\n    Middlewares\n  > = RouteSpec<\n    AuthType,\n    Methods,\n    JsonBody,\n    QueryParams,\n    CommonParams,\n    Middlewares\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    exceptionHandlingMiddleware = withExceptionHandling({\n      addOkStatus: true,\n    }) as any,\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          }),\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 } from \"zod\"\nimport { BadRequestException } from \"nextjs-exception-middleware\"\nimport { isEmpty } from \"lodash\"\n\nconst parseCommaSeparateArrays = (\n  schema: z.ZodTypeAny,\n  input: Record<string, unknown>\n) => {\n  const parsed_input = Object.assign({}, input)\n\n  // todo: iterate over Zod top level keys, if there's an array, parse it\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> {\n  jsonBody?: JsonBody\n  queryParams?: QueryParams\n  commonParams?: CommonParams\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\nexport const withValidation =\n  <\n    JsonBody extends z.ZodTypeAny,\n    QueryParams extends z.ZodTypeAny,\n    CommonParams extends z.ZodTypeAny\n  >(\n    input: RequestInput<JsonBody, QueryParams, CommonParams>\n  ) =>\n  (next) =>\n  async (req: NextApiRequest, res: NextApiResponse) => {\n    if (\n      (req.method === \"POST\" || req.method === \"PATCH\") &&\n      !req.headers[\"content-type\"]?.includes(\"application/json\") &&\n      !isEmpty(req.body)\n    ) {\n      throw new BadRequestException({\n        type: \"invalid_content_type\",\n        message: `POST requests must have Content-Type header with \"application/json\"`,\n      })\n    }\n\n    try {\n      const original_combined_params = { ...req.query, ...req.body }\n      req.body = input.jsonBody?.parse(req.body)\n      req.query = input.queryParams?.parse(req.query)\n\n      if (input.commonParams) {\n        ;(req as any).commonParams = parseCommaSeparateArrays(\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    return next(req, res)\n  }\n\nexport default withValidation\n"],
  "mappings": "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",
  "names": []
}


package/dist/types/index.d.ts

@@ -0,0 +1,41 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { Middleware as Middleware$1 } from 'nextjs-middleware-wrappers';
+import { z } from 'zod';
+import { HTTPMethods } from '../with-route-spec/middlewares/with-methods.js';
+import { SecuritySchemeObject, SecurityRequirementObject } from 'openapi3-ts';
+
+declare type Middleware<T, Dep = {}> = Middleware$1<T, Dep> & {
+    securitySchema?: SecuritySchemeObject;
+    securityObjects?: SecurityRequirementObject[];
+};
+declare type ParamDef = z.ZodTypeAny | z.ZodEffects<z.ZodTypeAny>;
+interface RouteSpec<Auth extends string = string, Methods extends HTTPMethods[] = any, JsonBody extends ParamDef = z.ZodTypeAny, QueryParams extends ParamDef = z.ZodTypeAny, CommonParams extends ParamDef = z.ZodTypeAny, Middlewares extends readonly Middleware<any, any>[] = any[], JsonResponse extends ParamDef = z.ZodTypeAny> {
+    methods: Methods;
+    auth: Auth;
+    jsonBody?: JsonBody;
+    queryParams?: QueryParams;
+    commonParams?: CommonParams;
+    middlewares?: Middlewares;
+    jsonResponse?: JsonResponse;
+}
+declare type MiddlewareChainOutput<MWChain extends readonly Middleware<any, any>[]> = MWChain extends readonly [] ? {} : MWChain extends readonly [infer First, ...infer Rest] ? First extends Middleware<infer T, any> ? T & (Rest extends readonly Middleware<any, any>[] ? MiddlewareChainOutput<Rest> : never) : never : never;
+declare type AuthMiddlewares = {
+    [auth_type: string]: Middleware<any, any>;
+};
+interface SetupParams<AuthMW extends AuthMiddlewares = AuthMiddlewares, GlobalMW extends Middleware<any, any>[] = any[]> {
+    authMiddlewareMap: AuthMW;
+    globalMiddlewares: GlobalMW;
+    exceptionHandlingMiddleware?: ((next: Function) => Function) | null;
+    apiName: string;
+    productionServerUrl: string;
+}
+declare const defaultMiddlewareMap: {
+    readonly none: (next: any) => any;
+};
+declare type RouteFunction<SP extends SetupParams<AuthMiddlewares>, RS extends RouteSpec> = (req: (SP["authMiddlewareMap"] & typeof defaultMiddlewareMap)[RS["auth"]] extends Middleware<infer AuthMWOut, any> ? Omit<NextApiRequest, "query" | "body"> & AuthMWOut & MiddlewareChainOutput<RS["middlewares"] extends readonly Middleware<any, any>[] ? [...SP["globalMiddlewares"], ...RS["middlewares"]] : SP["globalMiddlewares"]> & {
+    body: (RS["jsonBody"] extends z.ZodTypeAny ? z.infer<RS["jsonBody"]> : {}) & (RS["commonParams"] extends z.ZodTypeAny ? z.infer<RS["commonParams"]> : {});
+    query: (RS["queryParams"] extends z.ZodTypeAny ? z.infer<RS["queryParams"]> : {}) & (RS["commonParams"] extends z.ZodTypeAny ? z.infer<RS["commonParams"]> : {});
+} : `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.`, res: NextApiResponse<RS["jsonResponse"] extends z.ZodTypeAny ? z.infer<RS["jsonResponse"]> : any>) => Promise<void>;
+declare type CreateWithRouteSpecFunction = <SP extends SetupParams<AuthMiddlewares, any>>(setupParams: SP) => <RS extends RouteSpec<any, any, any, any, any, any, any>>(route_spec: RS) => (next: RouteFunction<SP, RS>) => any;
+
+export { AuthMiddlewares, CreateWithRouteSpecFunction, Middleware, MiddlewareChainOutput, RouteFunction, RouteSpec, SetupParams };

package/dist/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/index.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/with-route-spec/index.d.ts

@@ -0,0 +1,12 @@
+import { Middleware } from 'nextjs-middleware-wrappers';
+import { RouteSpec, CreateWithRouteSpecFunction } from '../types/index.js';
+import { HTTPMethods } from './middlewares/with-methods.js';
+import { z } from 'zod';
+import 'next';
+import 'openapi3-ts';
+
+declare type ParamDef = z.ZodTypeAny | z.ZodEffects<z.ZodTypeAny>;
+declare const checkRouteSpec: <AuthType extends string = string, Methods extends HTTPMethods[] = HTTPMethods[], JsonBody extends ParamDef = z.ZodTypeAny, QueryParams extends ParamDef = z.ZodTypeAny, CommonParams extends ParamDef = z.ZodTypeAny, Middlewares extends readonly Middleware<any, any>[] = readonly Middleware<any, any>[], Spec extends RouteSpec<AuthType, Methods, JsonBody, QueryParams, CommonParams, Middlewares, z.ZodTypeAny> = RouteSpec<AuthType, Methods, JsonBody, QueryParams, CommonParams, Middlewares, z.ZodTypeAny>>(spec: Spec) => string extends Spec["auth"] ? "your route spec is underspecified, add \"as const\"" : Spec;
+declare const createWithRouteSpec: CreateWithRouteSpecFunction;
+
+export { checkRouteSpec, createWithRouteSpec };

package/dist/with-route-spec/index.js

@@ -0,0 +1,145 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/with-route-spec/index.ts
+var with_route_spec_exports = {};
+__export(with_route_spec_exports, {
+  checkRouteSpec: () => checkRouteSpec,
+  createWithRouteSpec: () => createWithRouteSpec
+});
+module.exports = __toCommonJS(with_route_spec_exports);
+var import_nextjs_exception_middleware3 = require("nextjs-exception-middleware");
+var import_nextjs_middleware_wrappers = __toESM(require("nextjs-middleware-wrappers"));
+
+// src/with-route-spec/middlewares/with-methods.ts
+var import_nextjs_exception_middleware = require("nextjs-exception-middleware");
+var withMethods = (methods) => (next) => (req, res) => {
+  if (!methods.includes(req.method)) {
+    throw new import_nextjs_exception_middleware.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
+var import_nextjs_exception_middleware2 = require("nextjs-exception-middleware");
+var import_lodash = require("lodash");
+var parseCommaSeparateArrays = (schema, input) => {
+  const parsed_input = Object.assign({}, input);
+  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(".")}"`;
+};
+var withValidation = (input) => (next) => async (req, res) => {
+  var _a, _b, _c;
+  if ((req.method === "POST" || req.method === "PATCH") && !((_a = req.headers["content-type"]) == null ? void 0 : _a.includes("application/json")) && !(0, import_lodash.isEmpty)(req.body)) {
+    throw new import_nextjs_exception_middleware2.BadRequestException({
+      type: "invalid_content_type",
+      message: `POST requests must have Content-Type header with "application/json"`
+    });
+  }
+  try {
+    const original_combined_params = { ...req.query, ...req.body };
+    req.body = (_b = input.jsonBody) == null ? void 0 : _b.parse(req.body);
+    req.query = (_c = input.queryParams) == null ? void 0 : _c.parse(req.query);
+    if (input.commonParams) {
+      ;
+      req.commonParams = parseCommaSeparateArrays(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 import_nextjs_exception_middleware2.BadRequestException({
+        type: "invalid_input",
+        message,
+        validation_errors: error.format()
+      });
+    }
+    throw new import_nextjs_exception_middleware2.BadRequestException({
+      type: "invalid_input",
+      message: "Error while parsing input"
+    });
+  }
+  return next(req, res);
+};
+var with_validation_default = withValidation;
+
+// src/with-route-spec/index.ts
+var checkRouteSpec = (spec) => spec;
+var createWithRouteSpec = (setupParams) => {
+  const {
+    authMiddlewareMap = {},
+    globalMiddlewares = [],
+    exceptionHandlingMiddleware = (0, import_nextjs_exception_middleware3.withExceptionHandling)({
+      addOkStatus: true
+    })
+  } = 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 (0, import_nextjs_middleware_wrappers.default)(...exceptionHandlingMiddleware ? [exceptionHandlingMiddleware] : [], ...globalMiddlewares || [], auth_middleware, ...spec.middlewares || [], with_methods_default(spec.methods), with_validation_default({
+          jsonBody: spec.jsonBody,
+          queryParams: spec.queryParams,
+          commonParams: spec.commonParams
+        }), userDefinedRouteFn)(req, res);
+      };
+      rootRequestHandler._setupParams = setupParams;
+      rootRequestHandler._routeSpec = spec;
+      return rootRequestHandler;
+    };
+    createRouteExport._setupParams = setupParams;
+    createRouteExport._routeSpec = spec;
+    return createRouteExport;
+  };
+  withRouteSpec._setupParams = setupParams;
+  return withRouteSpec;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkRouteSpec,
+  createWithRouteSpec
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/with-route-spec/index.ts", "../../src/with-route-spec/middlewares/with-methods.ts", "../../src/with-route-spec/middlewares/with-validation.ts"],
  "sourcesContent": ["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  Spec extends RouteSpec<\n    AuthType,\n    Methods,\n    JsonBody,\n    QueryParams,\n    CommonParams,\n    Middlewares\n  > = RouteSpec<\n    AuthType,\n    Methods,\n    JsonBody,\n    QueryParams,\n    CommonParams,\n    Middlewares\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    exceptionHandlingMiddleware = withExceptionHandling({\n      addOkStatus: true,\n    }) as any,\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          }),\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 } from \"zod\"\nimport { BadRequestException } from \"nextjs-exception-middleware\"\nimport { isEmpty } from \"lodash\"\n\nconst parseCommaSeparateArrays = (\n  schema: z.ZodTypeAny,\n  input: Record<string, unknown>\n) => {\n  const parsed_input = Object.assign({}, input)\n\n  // todo: iterate over Zod top level keys, if there's an array, parse it\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> {\n  jsonBody?: JsonBody\n  queryParams?: QueryParams\n  commonParams?: CommonParams\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\nexport const withValidation =\n  <\n    JsonBody extends z.ZodTypeAny,\n    QueryParams extends z.ZodTypeAny,\n    CommonParams extends z.ZodTypeAny\n  >(\n    input: RequestInput<JsonBody, QueryParams, CommonParams>\n  ) =>\n  (next) =>\n  async (req: NextApiRequest, res: NextApiResponse) => {\n    if (\n      (req.method === \"POST\" || req.method === \"PATCH\") &&\n      !req.headers[\"content-type\"]?.includes(\"application/json\") &&\n      !isEmpty(req.body)\n    ) {\n      throw new BadRequestException({\n        type: \"invalid_content_type\",\n        message: `POST requests must have Content-Type header with \"application/json\"`,\n      })\n    }\n\n    try {\n      const original_combined_params = { ...req.query, ...req.body }\n      req.body = input.jsonBody?.parse(req.body)\n      req.query = input.queryParams?.parse(req.query)\n\n      if (input.commonParams) {\n        ;(req as any).commonParams = parseCommaSeparateArrays(\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    return next(req, res)\n  }\n\nexport default withValidation\n"],
  "mappings": "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",
  "names": []
}


package/dist/with-route-spec/middlewares/with-methods.d.ts

@@ -0,0 +1,4 @@
+declare type HTTPMethods = "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "HEAD" | "OPTIONS";
+declare const withMethods: (methods: HTTPMethods[]) => (next: any) => (req: any, res: any) => any;
+
+export { HTTPMethods, withMethods as default, withMethods };

package/dist/with-route-spec/middlewares/with-methods.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/with-route-spec/middlewares/with-methods.ts
+var with_methods_exports = {};
+__export(with_methods_exports, {
+  default: () => with_methods_default,
+  withMethods: () => withMethods
+});
+module.exports = __toCommonJS(with_methods_exports);
+var import_nextjs_exception_middleware = require("nextjs-exception-middleware");
+var withMethods = (methods) => (next) => (req, res) => {
+  if (!methods.includes(req.method)) {
+    throw new import_nextjs_exception_middleware.MethodNotAllowedException({
+      type: "method_not_allowed",
+      message: `only ${methods.join(",")} accepted`
+    });
+  }
+  return next(req, res);
+};
+var with_methods_default = withMethods;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withMethods
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3dpdGgtcm91dGUtc3BlYy9taWRkbGV3YXJlcy93aXRoLW1ldGhvZHMudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImltcG9ydCB7IE1ldGhvZE5vdEFsbG93ZWRFeGNlcHRpb24gfSBmcm9tIFwibmV4dGpzLWV4Y2VwdGlvbi1taWRkbGV3YXJlXCJcblxuZXhwb3J0IHR5cGUgSFRUUE1ldGhvZHMgPVxuICB8IFwiR0VUXCJcbiAgfCBcIlBPU1RcIlxuICB8IFwiREVMRVRFXCJcbiAgfCBcIlBVVFwiXG4gIHwgXCJQQVRDSFwiXG4gIHwgXCJIRUFEXCJcbiAgfCBcIk9QVElPTlNcIlxuXG5leHBvcnQgY29uc3Qgd2l0aE1ldGhvZHMgPSAobWV0aG9kczogSFRUUE1ldGhvZHNbXSkgPT4gKG5leHQpID0+IChyZXEsIHJlcykgPT4ge1xuICBpZiAoIW1ldGhvZHMuaW5jbHVkZXMocmVxLm1ldGhvZCkpIHtcbiAgICB0aHJvdyBuZXcgTWV0aG9kTm90QWxsb3dlZEV4Y2VwdGlvbih7XG4gICAgICB0eXBlOiBcIm1ldGhvZF9ub3RfYWxsb3dlZFwiLFxuICAgICAgbWVzc2FnZTogYG9ubHkgJHttZXRob2RzLmpvaW4oXCIsXCIpfSBhY2NlcHRlZGAsXG4gICAgfSlcbiAgfVxuICByZXR1cm4gbmV4dChyZXEsIHJlcylcbn1cblxuZXhwb3J0IGRlZmF1bHQgd2l0aE1ldGhvZHNcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEseUNBQTBDO0FBV25DLElBQU0sY0FBYyxDQUFDLFlBQTJCLENBQUMsU0FBUyxDQUFDLEtBQUssUUFBUTtBQUM3RSxNQUFJLENBQUMsUUFBUSxTQUFTLElBQUksTUFBTSxHQUFHO0FBQ2pDLFVBQU0sSUFBSSw2REFBMEI7QUFBQSxNQUNsQyxNQUFNO0FBQUEsTUFDTixTQUFTLFFBQVEsUUFBUSxLQUFLLEdBQUc7QUFBQSxJQUNuQyxDQUFDO0FBQUEsRUFDSDtBQUNBLFNBQU8sS0FBSyxLQUFLLEdBQUc7QUFDdEI7QUFFQSxJQUFPLHVCQUFROyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/with-route-spec/middlewares/with-validation.d.ts

@@ -0,0 +1,11 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { z } from 'zod';
+
+interface RequestInput<JsonBody extends z.ZodTypeAny, QueryParams extends z.ZodTypeAny, CommonParams extends z.ZodTypeAny> {
+    jsonBody?: JsonBody;
+    queryParams?: QueryParams;
+    commonParams?: CommonParams;
+}
+declare const withValidation: <JsonBody extends z.ZodTypeAny, QueryParams extends z.ZodTypeAny, CommonParams extends z.ZodTypeAny>(input: RequestInput<JsonBody, QueryParams, CommonParams>) => (next: any) => (req: NextApiRequest, res: NextApiResponse) => Promise<any>;
+
+export { RequestInput, withValidation as default, withValidation };

package/dist/with-route-spec/middlewares/with-validation.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/with-route-spec/middlewares/with-validation.ts
+var with_validation_exports = {};
+__export(with_validation_exports, {
+  default: () => with_validation_default,
+  withValidation: () => withValidation
+});
+module.exports = __toCommonJS(with_validation_exports);
+var import_nextjs_exception_middleware = require("nextjs-exception-middleware");
+var import_lodash = require("lodash");
+var parseCommaSeparateArrays = (schema, input) => {
+  const parsed_input = Object.assign({}, input);
+  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(".")}"`;
+};
+var withValidation = (input) => (next) => async (req, res) => {
+  var _a, _b, _c;
+  if ((req.method === "POST" || req.method === "PATCH") && !((_a = req.headers["content-type"]) == null ? void 0 : _a.includes("application/json")) && !(0, import_lodash.isEmpty)(req.body)) {
+    throw new import_nextjs_exception_middleware.BadRequestException({
+      type: "invalid_content_type",
+      message: `POST requests must have Content-Type header with "application/json"`
+    });
+  }
+  try {
+    const original_combined_params = { ...req.query, ...req.body };
+    req.body = (_b = input.jsonBody) == null ? void 0 : _b.parse(req.body);
+    req.query = (_c = input.queryParams) == null ? void 0 : _c.parse(req.query);
+    if (input.commonParams) {
+      ;
+      req.commonParams = parseCommaSeparateArrays(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 import_nextjs_exception_middleware.BadRequestException({
+        type: "invalid_input",
+        message,
+        validation_errors: error.format()
+      });
+    }
+    throw new import_nextjs_exception_middleware.BadRequestException({
+      type: "invalid_input",
+      message: "Error while parsing input"
+    });
+  }
+  return next(req, res);
+};
+var with_validation_default = withValidation;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withValidation
+});
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "nextlove",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "repository": "https://github.com/seamapi/nextlove",
+  "files": ["dist"],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/.eslintrc.json

@@ -1,3 +0,0 @@
-{
-  "extends": "next/core-web-vitals"
-}

package/next-env.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="next" />
-/// <reference types="next/image-types/global" />
-
-// NOTE: This file should not be edited
-// see https://nextjs.org/docs/basic-features/typescript for more information.

package/next.config.js

@@ -1,6 +0,0 @@
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  reactStrictMode: true,
-}
-
-module.exports = nextConfig