@kosmojs/dev 0.0.11 → 0.0.21

package/pkg/base-plugin/worker.js

@@ -1,38 +1,121 @@
 // src/base-plugin/worker.ts
 import { parentPort, workerData } from "node:worker_threads";
 import chokidar from "chokidar";
-import crc4 from "crc/crc32";
-import {
-  pathResolver as pathResolver3
-} from "@kosmojs/devlib";
+import crc6 from "crc/crc32";
 
-// src/base-plugin/routes.ts
-import {
-  defaults as defaults2
-} from "@kosmojs/devlib";
+// src/paths.ts
+import { join } from "node:path";
 
-// src/base-plugin/routes/resolve.ts
-import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
-import crc3 from "crc/crc32";
+// src/defaults.ts
+var defaults = {
+  appPrefix: "~",
+  srcPrefix: "@",
+  libPrefix: "_",
+  coreDir: "core",
+  srcDir: "src",
+  libDir: "lib",
+  configDir: "config",
+  apiDir: "api",
+  pagesDir: "pages",
+  entryDir: "entry",
+  fetchDir: "fetch"
+};
+
+// src/paths.ts
+var pathResolver = ({
+  appRoot: appRoot2,
+  sourceFolder: sourceFolder2
+}) => {
+  const createPath2 = (...a) => {
+    return appRoot2 ? join(appRoot2, ...a) : join(...a);
+  };
+  const createImport = {
+    coreApi(...a) {
+      return join(defaults.appPrefix, defaults.coreDir, defaults.apiDir, ...a);
+    },
+    src(...a) {
+      return join(defaults.srcPrefix, sourceFolder2, ...a);
+    },
+    config(...a) {
+      return this.src(defaults.configDir, ...a);
+    },
+    api(...a) {
+      return this.src(defaults.apiDir, ...a);
+    },
+    pages(...a) {
+      return this.src(defaults.pagesDir, ...a);
+    },
+    lib(...a) {
+      return join(defaults.libPrefix, sourceFolder2, ...a);
+    },
+    libApi(...a) {
+      return this.lib(defaults.apiDir, ...a);
+    },
+    libEntry(...a) {
+      return this.lib(defaults.entryDir, ...a);
+    }
+  };
+  return {
+    createPath: {
+      coreApi(...a) {
+        return createPath2(defaults.coreDir, defaults.apiDir, ...a);
+      },
+      src(...a) {
+        return createPath2(defaults.srcDir, sourceFolder2, ...a);
+      },
+      api(...a) {
+        return this.src(defaults.apiDir, ...a);
+      },
+      pages(...a) {
+        return this.src(defaults.pagesDir, ...a);
+      },
+      config(...a) {
+        return this.src(defaults.configDir, ...a);
+      },
+      entry(...a) {
+        return this.src(defaults.entryDir, ...a);
+      },
+      lib(...a) {
+        return createPath2(defaults.libDir, defaults.srcDir, sourceFolder2, ...a);
+      },
+      libApi(...a) {
+        return this.lib(defaults.apiDir, ...a);
+      },
+      libEntry(...a) {
+        return this.lib(defaults.entryDir, ...a);
+      },
+      libPages(...a) {
+        return this.lib(defaults.pagesDir, ...a);
+      }
+    },
+    createImport,
+    createImportHelper: (key, ...a) => {
+      return createImport[key](...a.slice(0, -1));
+    }
+  };
+};
+
+// 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";
-import {
-  defaults,
-  pathResolver as pathResolver2,
-  pathTokensFactory,
-  render,
-  renderToFile
-} from "@kosmojs/devlib";
 
-// src/base-plugin/ast.ts
+// src/ast.ts
 import { resolve } from "node:path";
+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 {
@@ -44,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
   };
 };
@@ -71,22 +147,23 @@ var extractDefaultExport = (sourceFile) => {
   return defaultExport;
 };
 var extractParamsRefinements = (callExpression) => {
-  const [firstGeneric] = extractGenerics(callExpression);
-  if (!firstGeneric?.node.isKind(SyntaxKind.TupleType)) {
+  const [
+    _routeName,
+    // first generic - the route name
+    paramsGeneric
+    // second generic - params refinements
+  ] = extractGenerics(callExpression);
+  if (!paramsGeneric?.isKind(SyntaxKind.TupleType)) {
     return;
   }
-  const tupleElements = firstGeneric.node.getElements();
-  if (!tupleElements?.length) {
-    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 [];
@@ -107,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", crc(route.importName + 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", crc(route.importName + 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;
@@ -240,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({
@@ -279,12 +489,24 @@ var typeResolverFactory = ({ appRoot: appRoot2 }) => {
   };
 };
 
-// src/base-plugin/cache.ts
+// src/cache.ts
 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" };
-import { pathExists, pathResolver } from "@kosmojs/devlib";
+
+// 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,
@@ -293,7 +515,7 @@ var cacheFactory = (route, {
   const cacheFile = pathResolver({
     appRoot: appRoot2,
     sourceFolder: sourceFolder2
-  }).resolve("apiLibDir", dirname(route.file), "cache.json");
+  }).createPath.libApi(dirname(route.file), "cache.json");
   const getCache = async (opt) => {
     if (await pathExists(cacheFile)) {
       try {
@@ -368,13 +590,169 @@ var identicalHashSum = (a, b) => {
   return a === b;
 };
 
-// src/base-plugin/templates/resolved-types.hbs
+// 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";
+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 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/base-plugin/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';
+// 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 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/base-plugin/routes/resolve.ts
+// src/routes-factory/resolve.ts
 var API_INDEX_BASENAME = "index";
 var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
 var API_USE_BASENAME = "use";
@@ -397,8 +775,9 @@ var scanRoutes = async ({
   appRoot: appRoot2,
   sourceFolder: sourceFolder2
 }) => {
+  const { createPath: createPath2 } = pathResolver({ appRoot: appRoot2, sourceFolder: sourceFolder2 });
   return glob(ROUTE_FILE_PATTERNS, {
-    cwd: resolve3(appRoot2, sourceFolder2),
+    cwd: createPath2.src(),
     absolute: true,
     onlyFiles: true,
     followSymbolicLinks: false,
@@ -415,11 +794,11 @@ var isRouteFile = (file, {
   appRoot: appRoot2,
   sourceFolder: sourceFolder2
 }) => {
-  const [_sourceFolder, folder, ...rest] = resolve3(appRoot2, file).replace(`${appRoot2}/`, "").split("/");
+  const [_sourceFolder, folder, ...rest] = resolve3(appRoot2, file).replace(`${appRoot2}/${defaults.srcDir}/`, "").split("/");
   if (!folder || _sourceFolder !== sourceFolder2 || rest.length < 2) {
-    return;
+    return false;
   }
-  return picomatch.isMatch(join(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : void 0;
+  return picomatch.isMatch(join3(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : false;
 };
 var isApiRoute = (file) => {
   return picomatch.matchBase(file, `**/${API_INDEX_PATTERN}`);
@@ -433,29 +812,27 @@ var isPageRoute = (file) => {
 var isPageLayout = (file) => {
   return picomatch.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`);
 };
-var createRouteEntry = (_file, {
+var createRouteEntry = (fileFullpath, {
   appRoot: appRoot2,
   sourceFolder: sourceFolder2
 }) => {
-  const resolvedPaths = isRouteFile(_file, { appRoot: appRoot2, sourceFolder: sourceFolder2 });
+  const resolvedPaths = isRouteFile(fileFullpath, { appRoot: appRoot2, sourceFolder: sourceFolder2 });
   if (!resolvedPaths) {
     return;
   }
   const [folder, file] = resolvedPaths;
-  const fileFullpath = join(appRoot2, sourceFolder2, folder, file);
-  const pathTokens = pathTokensFactory(dirname2(file));
-  const name = pathTokens.map((e) => e.orig).join("/");
-  const importFile = file;
-  const importName = `${importFile.replace(/\W+/g, "_")}_${crc3(importFile)}`;
-  return {
-    name,
-    folder,
-    file,
-    fileFullpath,
-    pathTokens,
-    importFile,
-    importName
-  };
+  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) => {
@@ -471,27 +848,21 @@ var pageLayoutResolverFactory = () => {
 };
 var pageRouteResolverFactory = () => {
   return (entry) => {
-    const {
-      name,
-      folder,
-      file,
-      fileFullpath,
-      pathTokens,
-      importFile,
-      importName
-    } = 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,
-        fileFullpath,
-        importFile,
-        importName
+        fileFullpath
       };
       return {
         kind: "pageRoute",
@@ -518,38 +889,35 @@ 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 {
-      name,
-      file,
-      folder,
-      fileFullpath,
-      pathTokens,
-      importFile,
-      importName
-    } = 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(
-        { file, fileFullpath, importName },
+        { id, file, fileFullpath },
         {
           appRoot: appRoot2,
           sourceFolder: sourceFolder2,
@@ -565,19 +933,23 @@ var apiRouteResolverFactory = (pluginOptions) => {
           typeDeclarations,
           paramsRefinements,
           methods,
-          payloadTypes,
-          responseTypes,
+          validationDefinitions: validationDefinitions2,
           referencedFiles = []
         } = await resolveRouteSignature(
-          { importName, fileFullpath, optionalParams },
+          { id, name, fileFullpath, optionalParams },
           {
             withReferencedFiles: true,
             sourceFile: getSourceFile(fileFullpath),
             relpathResolver(path) {
-              return join(sourceFolder2, defaults.apiDir, dirname2(file), path);
+              return join3(sourceFolder2, defaults.apiDir, dirname3(file), path);
             }
           }
         );
+        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);
@@ -585,13 +957,12 @@ var apiRouteResolverFactory = (pluginOptions) => {
           }
           return [];
         }) : [];
-        const typesFile = pathResolver2({ appRoot: appRoot2, sourceFolder: sourceFolder2 }).resolve(
-          "apiLibDir",
-          dirname2(file),
-          "types.ts"
-        );
+        const typesFile = pathResolver({
+          appRoot: appRoot2,
+          sourceFolder: sourceFolder2
+        }).createPath.libApi(dirname3(file), "types.ts");
         const params = {
-          id: ["ParamsT", crc3(name)].join(""),
+          id: ["ParamsT", crc5(name)].join(""),
           schema: paramsSchema,
           resolvedType: void 0
         };
@@ -600,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, skipValidation }) => {
-              if (skipValidation) {
-                map[id] = "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,
@@ -631,37 +998,103 @@ 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,
-        importName,
-        importFile,
         folder,
         file,
         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
@@ -670,20 +1103,15 @@ var apiRouteResolverFactory = (pluginOptions) => {
       };
       return {
         kind: "apiRoute",
-        entry: entry2
+        entry
       };
     };
     return { name, handler };
   };
 };
 
-// src/base-plugin/routes/nesting.ts
-import {
-  sortRoutes
-} from "@kosmojs/devlib";
-
-// src/base-plugin/routes.ts
-var routes_default = async (pluginOptions) => {
+// src/routes-factory/index.ts
+var routesFactory = async (pluginOptions) => {
   const { appRoot: appRoot2, sourceFolder: sourceFolder2 } = pluginOptions;
   const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
   const apiUseResolver = apiUseResolverFactory(pluginOptions);
@@ -696,13 +1124,13 @@ var routes_default = async (pluginOptions) => {
       return entry ? [entry] : [];
     });
     for (const entry of entries) {
-      if (entry.folder === defaults2.apiDir) {
+      if (entry.folder === defaults.apiDir) {
         if (isApiRoute(entry.file)) {
           resolvers2.set(entry.fileFullpath, apiRouteResolver(entry));
         } else if (isApiUse(entry.file)) {
           resolvers2.set(entry.fileFullpath, apiUseResolver(entry));
         }
-      } else if (entry.folder === defaults2.pagesDir) {
+      } else if (entry.folder === defaults.pagesDir) {
         if (isPageRoute(entry.file)) {
           resolvers2.set(entry.fileFullpath, pageRouteResolver(entry));
         } else if (isPageLayout(entry.file)) {
@@ -720,32 +1148,21 @@ var routes_default = 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 = [];
 var resolvedEntries = /* @__PURE__ */ new Map();
-var { resolvers, resolversFactory } = await routes_default(resolvedOptions);
-var { resolve: resolve4 } = pathResolver3({ appRoot, sourceFolder });
+var { resolvers, resolversFactory } = await routesFactory(resolvedOptions);
 var spinnerFactory = (startText) => {
-  const id = [startText, Date.now().toString()].map(crc4).join(":");
+  const id = [startText, Date.now().toString()].map(crc6).join(":");
   const postMessage = (method, text) => {
     const spinner = { id, startText, method, text };
     parentPort?.postMessage({ spinner });
@@ -832,11 +1249,12 @@ var runWatchHandlers = async (event) => {
   }
   spinner.succeed();
 };
+var { createPath } = pathResolver({ appRoot, sourceFolder });
 var watcher = chokidar.watch(
   [
     // watching for changes in sourceFolder's apiDir and pagesDir
-    resolve4("apiDir"),
-    resolve4("pagesDir")
+    createPath.api(),
+    createPath.pages()
   ],
   {
     ...resolvedOptions.watcher.options,
@@ -889,8 +1307,8 @@ watcher.on("all", async (event, file) => {
   for (const { name, factory } of generators) {
     spinner.append(name);
     try {
-      const { watchHandler } = await factory(resolvedOptions);
-      watchHandlers.push({ name, handler: watchHandler });
+      const { watch } = await factory(resolvedOptions);
+      watchHandlers.push({ name, handler: watch });
     } catch (error) {
       spinner.failed(error);
       spinner = spinnerFactory("Initializing Generators");