@kosmojs/dev 0.0.20 → 0.0.22

package/pkg/base-plugin/worker.js

@@ -53,9 +53,6 @@ var pathResolver = ({
     },
     libEntry(...a) {
       return this.lib(defaults.entryDir, ...a);
-    },
-    fetch(...a) {
-      return this.lib(defaults.fetchDir, ...a);
     }
   };
   return {
@@ -89,9 +86,6 @@ var pathResolver = ({
       },
       libPages(...a) {
         return this.lib(defaults.pagesDir, ...a);
-      },
-      fetch(...a) {
-        return this.lib(defaults.fetchDir, ...a);
       }
     },
     createImport,
@@ -103,65 +97,25 @@ var pathResolver = ({
 
 // src/routes-factory/resolve.ts
 import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
+import { styleText as styleText2 } from "node:util";
 import crc5 from "crc/crc32";
+import mimeTypes from "mime-types";
 import picomatch from "picomatch";
 import { glob } from "tinyglobby";
 
-// src/render.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join as join2 } from "node:path";
-import crc from "crc/crc32";
-import handlebars from "handlebars";
-
-// src/fs.ts
-import { access, constants } from "node:fs/promises";
-var pathExists = async (path) => {
-  try {
-    await access(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// src/render.ts
-var render = (template, context, options) => {
-  const { noEscape = true, renderer = handlebars } = { ...options };
-  return renderer.compile(template, { noEscape })(context);
-};
-var renderAsFile = (file, template, context, options) => {
-  const { formatters: formatters2, ...renderOpts } = { ...options };
-  const content = render(template, context, renderOpts);
-  return Array.isArray(formatters2) ? formatters2.reduce((c, f) => f(c, file), content) : content;
-};
-var renderToFile = async (file, template, context, options) => {
-  const content = renderAsFile(file, template, context, options);
-  if (await pathExists(file)) {
-    const { overwrite = true } = { ...options };
-    if (overwrite === false) {
-      return;
-    }
-    const fileContent = await readFile(file, "utf8");
-    if (typeof overwrite === "function" && !overwrite(fileContent)) {
-      return;
-    }
-    if (crc(content) === crc(fileContent)) {
-      return;
-    }
-  }
-  await mkdir(dirname(file), { recursive: true });
-  await writeFile(file, content, "utf8");
-};
-
 // src/ast.ts
 import { resolve } from "node:path";
-import crc2 from "crc/crc32";
+import { styleText } from "node:util";
+import crc from "crc/crc32";
 import { flattener } from "tfusion";
 import {
   Project,
   SyntaxKind
 } from "ts-morph";
-import { HTTPMethods } from "@kosmojs/api";
+import {
+  HTTPMethods,
+  RequestValidationTargets
+} from "@kosmojs/api";
 var createProject = (opts) => new Project(opts);
 var resolveRouteSignature = async (route, opts) => {
   const {
@@ -173,19 +127,12 @@ var resolveRouteSignature = async (route, opts) => {
   );
   const defaultExport = extractDefaultExport(sourceFile);
   const paramsRefinements = defaultExport ? extractParamsRefinements(defaultExport) : void 0;
-  const methods = defaultExport ? extractRouteMethods(defaultExport, route) : [];
-  const payloadTypes = methods.flatMap((e) => {
-    return e.payloadType ? [e.payloadType] : [];
-  });
-  const responseTypes = methods.flatMap((e) => {
-    return e.responseType ? [e.responseType] : [];
-  });
+  const methods = defaultExport ? extractRouteMethods(route, defaultExport) : [];
   return {
     typeDeclarations,
     paramsRefinements,
     methods: methods.map((e) => e.method),
-    payloadTypes,
-    responseTypes,
+    validationDefinitions: methods.flatMap((e) => e.validationDefinitions),
     referencedFiles
   };
 };
@@ -200,22 +147,23 @@ var extractDefaultExport = (sourceFile) => {
   return defaultExport;
 };
 var extractParamsRefinements = (callExpression) => {
-  const [firstGeneric] = extractGenerics(callExpression);
-  if (!firstGeneric?.node.isKind(SyntaxKind.TupleType)) {
-    return;
-  }
-  const tupleElements = firstGeneric.node.getElements();
-  if (!tupleElements?.length) {
+  const [
+    _routeName,
+    // first generic - the route name
+    paramsGeneric
+    // second generic - params refinements
+  ] = extractGenerics(callExpression);
+  if (!paramsGeneric?.isKind(SyntaxKind.TupleType)) {
     return;
   }
-  return tupleElements.map((node, index) => {
+  return paramsGeneric.getElements().map((node, index) => {
     return {
       index,
       text: node.getText()
     };
   });
 };
-var extractRouteMethods = (callExpression, route) => {
+var extractRouteMethods = (route, callExpression) => {
   const funcDeclaration = callExpression.getFirstChildByKind(SyntaxKind.ArrowFunction) || callExpression.getFirstChildByKind(SyntaxKind.FunctionExpression);
   if (!funcDeclaration) {
     return [];
@@ -236,35 +184,173 @@ var extractRouteMethods = (callExpression, route) => {
     }
   }
   const methods = [];
-  const skipValidationFilter = (e) => /@skip-validation/.test(e);
   for (const [callExpression2, method] of callExpressions) {
-    const [payloadGeneric, responseGeneric] = extractGenerics(callExpression2);
-    const payloadText = payloadGeneric?.node ? payloadGeneric.node.getChildren().length === 0 ? "{}" : payloadGeneric.node.getFullText() : void 0;
-    const responseText = responseGeneric?.node.getText();
-    const responseType = responseText ? {
-      id: ["ResponseT", crc2(route.id + method)].join(""),
-      method,
-      skipValidation: responseGeneric?.comments ? responseGeneric.comments.some(skipValidationFilter) : false,
-      text: ["never", "object"].includes(responseText) ? "{}" : responseText,
-      resolvedType: void 0
-    } : void 0;
-    const payloadType = payloadText ? {
-      id: ["PayloadT", crc2(route.id + method)].join(""),
-      responseTypeId: responseType?.id,
-      method,
-      skipValidation: payloadGeneric?.comments ? payloadGeneric.comments.some(skipValidationFilter) : false,
-      isOptional: payloadText ? payloadText === "{}" || route.optionalParams : true,
-      text: payloadText,
-      resolvedType: void 0
-    } : void 0;
+    const [vDefs, vOpts] = extractGenerics(callExpression2);
     methods.push({
       method,
-      payloadType,
-      responseType
+      validationDefinitions: extractValidationDefinitions(
+        route,
+        method,
+        vDefs,
+        vOpts
+      )
     });
   }
   return methods;
 };
+var parseRuntimeValidation = (typeNode) => {
+  if (typeNode.isKind(SyntaxKind.LiteralType)) {
+    const literal = typeNode.getFirstChild();
+    if (literal?.isKind(SyntaxKind.TrueKeyword)) {
+      return true;
+    } else if (literal?.isKind(SyntaxKind.FalseKeyword)) {
+      return false;
+    }
+  }
+  return void 0;
+};
+var extractResponseVariant = (typeNode) => {
+  if (!typeNode.isKind(SyntaxKind.TupleType)) {
+    return;
+  }
+  let status = 200;
+  let contentType;
+  let body;
+  const [statusNode, contentTypeNode, bodyNode] = typeNode.getElements();
+  if (statusNode?.isKind(SyntaxKind.LiteralType)) {
+    const literal = statusNode.getFirstChildByKind(SyntaxKind.NumericLiteral);
+    if (literal) {
+      status = Number(literal.getText());
+    }
+  }
+  if (contentTypeNode) {
+    contentType = extractStringLiteral(contentTypeNode);
+  }
+  if (bodyNode) {
+    body = bodyNode.getText();
+    if (["object"].includes(body)) {
+      body = "{}";
+    }
+  }
+  return { status, contentType, body };
+};
+var parseValidationOptions = (typeNode) => {
+  const opts = {};
+  if (!typeNode?.isKind(SyntaxKind.TypeLiteral)) {
+    return opts;
+  }
+  for (const prop of typeNode.getMembers()) {
+    if (!prop.isKind(SyntaxKind.PropertySignature)) {
+      continue;
+    }
+    const target = prop.getName();
+    const typeNode2 = prop.getTypeNodeOrThrow();
+    if (!typeNode2.isKind(SyntaxKind.TypeLiteral)) {
+      continue;
+    }
+    let contentType;
+    let runtimeValidation;
+    const customErrors = {};
+    for (const member of typeNode2.getMembers()) {
+      if (!member.isKind(SyntaxKind.PropertySignature)) {
+        continue;
+      }
+      const nameNode = member.getNameNode();
+      const valueNode = member.getTypeNodeOrThrow();
+      const name = nameNode.isKind(SyntaxKind.StringLiteral) ? nameNode.getLiteralText() : nameNode.getText();
+      if (name === "contentType") {
+        contentType = extractStringLiteral(valueNode);
+      } else if (name === "runtimeValidation") {
+        runtimeValidation = parseRuntimeValidation(valueNode);
+      } else if (name.startsWith("error")) {
+        const literal = extractStringLiteral(valueNode);
+        if (literal) {
+          customErrors[name] = literal;
+        }
+      }
+    }
+    opts[target] = {
+      contentType,
+      runtimeValidation,
+      customErrors
+    };
+  }
+  return opts;
+};
+var extractStringLiteral = (typeNode) => {
+  const literal = typeNode.isKind(SyntaxKind.LiteralType) ? typeNode.getFirstChildByKind(SyntaxKind.StringLiteral) : void 0;
+  return literal ? literal.getLiteralText() : void 0;
+};
+var extractValidationDefinitions = (route, method, defsNode, optsNode) => {
+  const definitions = [];
+  if (!defsNode?.isKind(SyntaxKind.TypeLiteral)) {
+    return definitions;
+  }
+  const optsMap = parseValidationOptions(optsNode);
+  const createId = (target, hash) => {
+    return [
+      target.replace(/^./, (c) => c.toUpperCase()),
+      "T",
+      method,
+      crc(route.id + hash)
+    ].join("");
+  };
+  for (const prop of defsNode.getMembers()) {
+    if (!prop.isKind(SyntaxKind.PropertySignature)) {
+      continue;
+    }
+    const target = prop.getName();
+    const typeNode = prop.getTypeNodeOrThrow();
+    if (target === "response") {
+      const variants = typeNode.isKind(SyntaxKind.UnionType) ? typeNode.getChildrenOfKind(SyntaxKind.TupleType) : [typeNode];
+      definitions.push({
+        ...optsMap[target],
+        method,
+        target,
+        variants: variants.flatMap((e, i) => {
+          const { status, contentType, body } = extractResponseVariant(e) || {};
+          if (!status) {
+            return [];
+          }
+          if (contentType && typeof contentType !== "string") {
+            console.warn(
+              styleText(
+                ["bold", "red"],
+                `\u2717 The second element of a response variant should specify the Response Content Type`
+              )
+            );
+            console.warn(
+              styleText(["blue"], `  Example: [200, "json", Schema]`)
+            );
+            console.warn(
+              `  Route: ${route.name}; Method: ${method}; Response Variant: #${i}`
+            );
+            console.warn();
+          }
+          return [
+            {
+              id: createId(target, JSON.stringify([status, contentType, body])),
+              status,
+              contentType,
+              body
+            }
+          ];
+        })
+      });
+    } else if (Object.keys(RequestValidationTargets).includes(target)) {
+      definitions.push({
+        ...optsMap[target],
+        method,
+        target,
+        schema: {
+          id: createId(target),
+          text: typeNode.getText()
+        }
+      });
+    }
+  }
+  return definitions;
+};
 var extractTypeDeclarations = (sourceFile, opts) => {
   const declarations = [];
   const referencedFiles = opts?.withReferencedFiles ? [] : void 0;
@@ -369,12 +455,7 @@ var getReferencedFiles = (importIdentifier) => {
   });
 };
 var extractGenerics = (callExpression) => {
-  return callExpression.getTypeArguments().map((node) => {
-    return {
-      node,
-      comments: node.getLeadingCommentRanges().map((range) => range.getText().trim())
-    };
-  });
+  return callExpression.getTypeArguments();
 };
 var typeResolverFactory = ({ appRoot: appRoot2 }) => {
   const project = createProject({
@@ -383,7 +464,7 @@ var typeResolverFactory = ({ appRoot: appRoot2 }) => {
   });
   const literalTypesResolver = (literalTypes, options) => {
     const sourceFile = project.createSourceFile(
-      `${crc2(literalTypes)}-${Date.now()}.ts`,
+      `${crc(literalTypes)}-${Date.now()}.ts`,
       literalTypes,
       { overwrite: true }
     );
@@ -409,10 +490,23 @@ var typeResolverFactory = ({ appRoot: appRoot2 }) => {
 };
 
 // src/cache.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, resolve as resolve2 } from "node:path";
-import crc3 from "crc/crc32";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve as resolve2 } from "node:path";
+import crc2 from "crc/crc32";
 import self from "@kosmojs/dev/package.json" with { type: "json" };
+
+// src/fs.ts
+import { access, constants } from "node:fs/promises";
+var pathExists = async (path) => {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/cache.ts
 var cacheFactory = (route, {
   appRoot: appRoot2,
   sourceFolder: sourceFolder2,
@@ -421,11 +515,11 @@ var cacheFactory = (route, {
   const cacheFile = pathResolver({
     appRoot: appRoot2,
     sourceFolder: sourceFolder2
-  }).createPath.libApi(dirname2(route.file), "cache.json");
+  }).createPath.libApi(dirname(route.file), "cache.json");
   const getCache = async (opt) => {
     if (await pathExists(cacheFile)) {
       try {
-        const cache = JSON.parse(await readFile2(cacheFile, "utf8"));
+        const cache = JSON.parse(await readFile(cacheFile, "utf8"));
         return opt?.validate ? validateCache(cache) : cache;
       } catch (_e) {
       }
@@ -448,8 +542,8 @@ var cacheFactory = (route, {
       ] = await generateFileHash(file);
     }
     const cache = { ...rest, hash, referencedFiles };
-    await mkdir2(dirname2(cacheFile), { recursive: true });
-    await writeFile2(cacheFile, JSON.stringify(cache, null, 2), "utf8");
+    await mkdir(dirname(cacheFile), { recursive: true });
+    await writeFile(cacheFile, JSON.stringify(cache, null, 2), "utf8");
     return cache;
   };
   const validateCache = async (cache) => {
@@ -481,11 +575,11 @@ var cacheFactory = (route, {
 var generateFileHash = async (file, extraContext) => {
   let fileContent;
   try {
-    fileContent = await readFile2(file, "utf8");
+    fileContent = await readFile(file, "utf8");
   } catch (_e) {
     return 0;
   }
-  return fileContent ? crc3(
+  return fileContent ? crc2(
     JSON.stringify({
       ...extraContext,
       [self.cacheVersion]: fileContent
@@ -496,61 +590,167 @@ var identicalHashSum = (a, b) => {
   return a === b;
 };
 
+// src/render.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+import crc3 from "crc/crc32";
+import handlebars from "handlebars";
+var render = (template, context, options) => {
+  const { noEscape = true, renderer = handlebars } = { ...options };
+  return renderer.compile(template, { noEscape })(context);
+};
+var renderToFile = async (file, template, context, options) => {
+  const content = render(template, context, options);
+  if (await pathExists(file)) {
+    const { overwrite = true } = { ...options };
+    if (overwrite === false) {
+      return;
+    }
+    const fileContent = await readFile2(file, "utf8");
+    if (typeof overwrite === "function" && !overwrite(fileContent)) {
+      return;
+    }
+    if (crc3(content) === crc3(fileContent)) {
+      return;
+    }
+  }
+  await mkdir2(dirname2(file), { recursive: true });
+  await writeFile2(file, content, "utf8");
+};
+
 // src/routes-factory/base.ts
 import crc4 from "crc/crc32";
-var pathTokensFactory = (path) => {
-  const requiredParamRegex = /^\[([^\]]+)\]$/;
-  const optionalParamRegex = /^\[\[([^\]]+)\]\]$/;
-  const restParamRegex = /^\[\.\.\.([^\]]+)\]$/;
-  return path.split("/").map((orig, i) => {
-    const [base, ext = ""] = orig.split(/(\.([\w\d-]+)$)/);
-    const paramBase = (regex) => {
-      const name = base.replace(regex, "$1") || base;
-      return {
-        name,
-        const: /\W/.test(name) ? [name.replace(/\W/g, "_"), crc4(orig)].join("_") : name
-      };
-    };
-    let param;
-    if (base.startsWith("[")) {
-      if (restParamRegex.test(base)) {
-        param = {
-          ...paramBase(restParamRegex),
-          isRequired: false,
-          isOptional: false,
-          isRest: true
-        };
-      } else if (optionalParamRegex.test(base)) {
-        param = {
-          ...paramBase(optionalParamRegex),
-          isRequired: false,
-          isOptional: true,
-          isRest: false
-        };
-      } else if (requiredParamRegex.test(base)) {
-        param = {
-          ...paramBase(requiredParamRegex),
-          isRequired: true,
-          isOptional: false,
-          isRest: false
-        };
+import { parse } from "path-to-regexp";
+var pathTokensFactory = (path, {
+  transformStaticValue = normalizeStaticValue
+} = {}) => {
+  const extractParts = (tokens2, createConst, insideGroup = false) => {
+    const parts = [];
+    for (const token of tokens2) {
+      switch (token.type) {
+        case "text":
+          if (token.value !== "/") {
+            parts.push({
+              type: "static",
+              value: transformStaticValue(token.value)
+            });
+          }
+          break;
+        case "param":
+          parts.push({
+            type: "param",
+            kind: insideGroup ? "optional" : "required",
+            name: token.name,
+            const: createConst(token.name)
+          });
+          break;
+        case "wildcard":
+          parts.push({
+            type: "param",
+            kind: "splat",
+            name: token.name,
+            const: createConst(token.name)
+          });
+          break;
+        case "group":
+          parts.push(...extractParts(token.tokens, createConst, true));
+          break;
       }
     }
-    return {
-      orig,
-      base,
-      path: i === 0 ? orig.replace(/^index$/, "/") : orig,
-      ext,
-      ...param ? { param } : {}
-    };
+    return parts;
+  };
+  const patternTransforms = [
+    // Transform required params: [id] => :id
+    // Only pure \w param names,
+    // [some-id] used as is, not treated as param,
+    // use [some_id] instead.
+    (s) => s.replace(/\[(\w+)\]/g, ":$1"),
+    // Transform optional params: {id} => {:id}
+    // Only pure \w param names,
+    // anything else treated as a path-to-regexp pattern and used as is.
+    // {some-id} treated as an optional static segment.
+    // use {some_id} for simple param syntax
+    // or {:some-id} pattern where :some is the param name and -id is a static segment.
+    (s) => s.replace(/\{(\w+)\}/g, "{:$1}"),
+    // Transform splat params: {...param} => {*param}
+    (s) => s.replace(/\{\.\.\./g, "{*"),
+    // Insert leading slash inside optional/splat groups.
+    // {:name} => {/:name}
+    // {*name} => {/*name}
+    (s) => {
+      return s.startsWith("{") ? s.replace(/^\{/, "{/") : s;
+    }
+  ];
+  const detectBareParams = (s) => {
+    let depth = 0;
+    for (const [i, ch] of [...s].entries()) {
+      if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+      } else if (ch === ":" && depth === 0) {
+        const match = s.slice(i + 1).match(/^\w+/);
+        return match?.[0] || ":";
+      }
+    }
+    return;
+  };
+  const tokens = path.replace(/^index\/?/, "").split("/").flatMap((orig) => {
+    if (!orig.length) {
+      return [];
+    }
+    const bareParam = detectBareParams(orig);
+    if (bareParam === ":") {
+      throw new Error(
+        `${path} contains colons outside braces, use : only within {}`
+      );
+    } else if (bareParam) {
+      throw new Error(
+        `${path} contains bare params, use [${bareParam}] instead of :${bareParam}`
+      );
+    }
+    const pattern = patternTransforms.reduce((src, fn) => fn(src), orig);
+    const { tokens: tokens2 } = parse(pattern);
+    const parts = extractParts(tokens2, (val) => {
+      return /\W/.test(val) || /^\d/.test(val) ? [val.replace(/^\d+|\W/g, "_"), crc4(orig)].join("_") : val;
+    });
+    const isStatic = parts.length === 1 ? parts[0].type === "static" : false;
+    const isParam = parts.length === 1 ? parts[0].type === "param" : false;
+    const kind = isStatic ? "static" : isParam ? "param" : "mixed";
+    return [
+      {
+        kind,
+        orig,
+        pattern,
+        parts
+      }
+    ];
   });
+  return [
+    tokens,
+    tokens.map(({ pattern }, i) => {
+      const next = tokens[i + 1];
+      if (!next || next.pattern.includes("/")) {
+        return pattern;
+      }
+      const slashRequired = tokens.slice(i + 1).some((e) => {
+        return e.parts.some((e2) => {
+          return e2.type === "static" || e2.kind === "required";
+        });
+      });
+      return slashRequired ? `${pattern}/` : pattern;
+    }).join("")
+  ];
+};
+var normalizeStaticValue = (value) => {
+  return value.replace(/\+/g, "\\\\+");
 };
 
 // src/routes-factory/templates/resolved-types.hbs
 var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
 
 // src/routes-factory/templates/types.hbs
-var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}:{{#if isRest}} Array<{{/if}}\n    {{#if refinement}}{{refinement.text}}{{else}}string{{/if}}\n  {{#if isRest}}>{{/if}}\n  {{/each}}\n};\n\n{{#each payloadTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n\n{{#each responseTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n';
+var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}: {{#if refinement}}\n    {{refinement.text}},\n  {{else}}\n    {{#if isSplat}}Array<string>{{else}}string{{/if}},\n  {{/if}}\n  {{/each}}\n};\n\n{{#each validationTypes}}export type {{id}} = {{text}};\n{{/each}}\n';
 
 // src/routes-factory/resolve.ts
 var API_INDEX_BASENAME = "index";
@@ -621,15 +821,18 @@ var createRouteEntry = (fileFullpath, {
     return;
   }
   const [folder, file] = resolvedPaths;
-  const pathTokens = pathTokensFactory(dirname3(file));
-  return {
-    id: `${file.replace(/\W+/g, "_")}_${crc5(file)}`,
-    name: pathTokens.map((e) => e.orig).join("/"),
-    folder,
-    file,
-    fileFullpath,
-    pathTokens
-  };
+  const id = `${file.replace(/\W+/g, "_")}_${crc5(file)}`;
+  const name = dirname3(file);
+  try {
+    const [pathTokens, pathPattern] = pathTokensFactory(dirname3(file));
+    return { id, name, folder, file, fileFullpath, pathTokens, pathPattern };
+  } catch (error) {
+    console.error(
+      `\u2757${styleText2("red", "ERROR")}: Failed parsing path for "${styleText2("cyan", file)}"`
+    );
+    console.error(error);
+    return;
+  }
 };
 var pageLayoutResolverFactory = () => {
   return (entry) => {
@@ -645,14 +848,17 @@ var pageLayoutResolverFactory = () => {
 };
 var pageRouteResolverFactory = () => {
   return (entry) => {
-    const { id, name, folder, file, fileFullpath, pathTokens } = entry;
+    const { id, name, folder, file, fileFullpath, pathTokens, pathPattern } = entry;
     const handler = async () => {
       const entry2 = {
         id,
         name,
         pathTokens,
+        pathPattern,
         params: {
-          schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
+          schema: pathTokens.flatMap((e) => {
+            return e.parts.filter((p) => p.type === "param");
+          })
         },
         folder,
         file,
@@ -683,28 +889,33 @@ var apiRouteResolverFactory = (pluginOptions) => {
     appRoot: appRoot2,
     sourceFolder: sourceFolder2,
     generators: generators2 = [],
-    formatters: formatters2 = [],
     refineTypeName
   } = pluginOptions;
-  let resolveTypes = false;
-  for (const { options } of generators2) {
-    if (options?.resolveTypes) {
-      resolveTypes = true;
-    }
-  }
+  const resolveTypes = generators2.some((e) => e.options?.resolveTypes);
   const {
     //
     literalTypesResolver,
     getSourceFile,
     refreshSourceFile
   } = typeResolverFactory(pluginOptions);
-  return (entry) => {
-    const { id, name, file, folder, fileFullpath, pathTokens } = entry;
+  return ({
+    id,
+    name,
+    file,
+    folder,
+    fileFullpath,
+    pathTokens,
+    pathPattern
+  }) => {
     const handler = async (updatedFile) => {
-      const paramsSchema = pathTokens.flatMap((e) => {
-        return e.param ? [e.param] : [];
-      });
-      const optionalParams = paramsSchema.length ? !paramsSchema.some((e) => e.isRequired) : true;
+      const paramsSchema = pathTokens.flatMap(
+        (e) => {
+          return e.parts.flatMap((p) => {
+            return p.type === "param" ? [p] : [];
+          });
+        }
+      );
+      const optionalParams = paramsSchema.length ? paramsSchema.filter((e) => e.kind === "required").length === 0 : true;
       const { getCache, persistCache } = cacheFactory(
         { id, file, fileFullpath },
         {
@@ -722,11 +933,10 @@ var apiRouteResolverFactory = (pluginOptions) => {
           typeDeclarations,
           paramsRefinements,
           methods,
-          payloadTypes,
-          responseTypes,
+          validationDefinitions: validationDefinitions2,
           referencedFiles = []
         } = await resolveRouteSignature(
-          { id, fileFullpath, optionalParams },
+          { id, name, fileFullpath, optionalParams },
           {
             withReferencedFiles: true,
             sourceFile: getSourceFile(fileFullpath),
@@ -735,6 +945,11 @@ var apiRouteResolverFactory = (pluginOptions) => {
             }
           }
         );
+        const validationTypes = validationDefinitions2.flatMap((def) => {
+          return def.target === "response" ? def.variants.flatMap(({ id: id2, body }) => {
+            return body ? [{ id: id2, text: body }] : [];
+          }) : [def.schema];
+        });
         const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
           if (text === "number") {
             const param = paramsSchema.at(index);
@@ -756,25 +971,21 @@ var apiRouteResolverFactory = (pluginOptions) => {
           paramsSchema: paramsSchema.map((param, index) => {
             return {
               ...param,
+              isRequired: param.kind === "required",
+              isSplat: param.kind === "splat",
               refinement: paramsRefinements?.at(index)
             };
           }),
           typeDeclarations,
-          payloadTypes,
-          responseTypes
+          validationTypes
         });
         const resolvedTypes = resolveTypes ? literalTypesResolver(typesFileContent, {
-          overrides: [...payloadTypes, ...responseTypes].reduce(
-            (map, { id: id2, skipValidation }) => {
-              if (skipValidation) {
-                map[id2] = "never";
-              }
-              return map;
-            },
-            { [refineTypeName]: refineTypeName }
-          ),
-          withProperties: [params.id, ...payloadTypes.map((e) => e.id)],
-          formatters: formatters2
+          stripComments: true,
+          overrides: { [refineTypeName]: refineTypeName },
+          withProperties: [
+            params.id,
+            ...validationTypes.flatMap(({ id: id2 }) => id2)
+          ]
         }) : void 0;
         await renderToFile(
           typesFile,
@@ -787,26 +998,94 @@ var apiRouteResolverFactory = (pluginOptions) => {
           methods,
           typeDeclarations,
           numericParams,
-          // text was needed at writing types.ts file, dropping from cache
-          payloadTypes: payloadTypes.map(({ text, ...rest }) => {
-            return {
-              ...rest,
-              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
-            };
-          }),
-          responseTypes: responseTypes.map(({ text, ...rest }) => {
+          referencedFiles,
+          validationDefinitions: validationDefinitions2.map((def) => {
             return {
-              ...rest,
-              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
+              ...def,
+              ...def.target === "response" ? {
+                variants: def.variants.map((variant) => {
+                  return {
+                    ...variant,
+                    resolvedType: resolvedTypes?.find(
+                      (e) => e.name === variant.id
+                    )
+                  };
+                })
+              } : {
+                schema: {
+                  ...def.schema,
+                  resolvedType: resolvedTypes?.find(
+                    (e) => e.name === def.schema.id
+                  )
+                }
+              }
             };
-          }),
-          referencedFiles
+          })
         });
       }
-      const entry2 = {
+      const validationDefinitions = cache.validationDefinitions.flatMap(
+        (def) => {
+          let augmentedDef = def;
+          if (def.target === "response") {
+            augmentedDef = {
+              ...def,
+              variants: def.variants.flatMap((variant, i) => {
+                if (typeof variant.contentType !== "string") {
+                  return [variant];
+                }
+                if (variant.contentType.includes("/")) {
+                  return [variant];
+                }
+                const contentType = mimeTypes.lookup(variant.contentType);
+                if (contentType === false) {
+                  console.warn(
+                    styleText2(
+                      ["bold", "red"],
+                      "\u2717 Failed resolving Response Content Type"
+                    )
+                  );
+                  console.warn(
+                    `  Invalid value provided for mime-types lookup - ${variant.contentType}`
+                  );
+                  console.warn(
+                    styleText2(
+                      ["cyan"],
+                      `  Response variant #${i} excluded from route schemas`
+                    )
+                  );
+                  console.warn(`  Route: ${name}; Method: ${def.method}`);
+                  console.warn();
+                  return [];
+                }
+                return [{ ...variant, contentType }];
+              })
+            };
+          } else if (def.contentType && !def.contentType.includes("/")) {
+            const contentType = mimeTypes.lookup(def.contentType);
+            if (contentType === false) {
+              console.warn(
+                styleText2(
+                  ["bold", "red"],
+                  "\u2717 Failed resolving Response Content Type"
+                )
+              );
+              console.warn(
+                `  Invalid value provided for mime-types lookup - ${def.contentType}`
+              );
+              console.warn(`  Route: ${name}; Method: ${def.method}`);
+              console.warn();
+            } else {
+              augmentedDef = { ...def, contentType };
+            }
+          }
+          return augmentedDef ? [augmentedDef] : [];
+        }
+      );
+      const entry = {
         id,
         name,
         pathTokens,
+        pathPattern,
         params: cache.params,
         numericParams: cache.numericParams,
         optionalParams,
@@ -815,8 +1094,7 @@ var apiRouteResolverFactory = (pluginOptions) => {
         fileFullpath,
         methods: cache.methods,
         typeDeclarations: cache.typeDeclarations,
-        payloadTypes: cache.payloadTypes,
-        responseTypes: cache.responseTypes,
+        validationDefinitions,
         referencedFiles: Object.keys(cache.referencedFiles).map(
           // expand referenced files path,
           // they are stored as relative in cache
@@ -825,7 +1103,7 @@ var apiRouteResolverFactory = (pluginOptions) => {
       };
       return {
         kind: "apiRoute",
-        entry: entry2
+        entry
       };
     };
     return { name, handler };
@@ -870,24 +1148,14 @@ var routesFactory = async (pluginOptions) => {
 };
 
 // src/base-plugin/worker.ts
-var {
-  //
-  generatorModules,
-  formatterModules,
-  ...restOptions
-} = workerData;
+var { generatorModules, ...restOptions } = workerData;
 var generators = [];
-var formatters = [];
 for (const [path, opts] of generatorModules) {
   generators.push(await import(path).then((m) => m.default(opts)));
 }
-for (const [path, opts] of formatterModules) {
-  formatters.push(await import(path).then((m) => m.default(opts).formatter));
-}
 var resolvedOptions = {
   ...restOptions,
-  generators,
-  formatters
+  generators
 };
 var { appRoot, sourceFolder } = resolvedOptions;
 var watchHandlers = [];