@kosmojs/dev 0.0.20 → 0.0.22

package/pkg/index.js

@@ -60,9 +60,6 @@ var pathResolver = ({
     },
     libEntry(...a) {
       return this.lib(defaults.entryDir, ...a);
-    },
-    fetch(...a) {
-      return this.lib(defaults.fetchDir, ...a);
     }
   };
   return {
@@ -96,9 +93,6 @@ var pathResolver = ({
       },
       libPages(...a) {
         return this.lib(defaults.pagesDir, ...a);
-      },
-      fetch(...a) {
-        return this.lib(defaults.fetchDir, ...a);
       }
     },
     createImport,
@@ -175,98 +169,33 @@ var alias_plugin_default = (appRoot, opt) => {
 };
 
 // src/base-plugin/index.ts
+import { writeFile as writeFile3 } from "node:fs/promises";
 import { basename as basename2, join as join5, resolve as resolve5 } from "node:path";
-import { styleText as styleText2 } from "node:util";
+import { styleText as styleText4 } from "node:util";
 import { Worker } from "node:worker_threads";
 import stubGenerator from "@kosmojs/dev/stub-generator";
 
 // 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 as glob2 } 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, context2, options) => {
-  const { noEscape = true, renderer = handlebars } = { ...options };
-  return renderer.compile(template, { noEscape })(context2);
-};
-var renderAsFile = (file, template, context2, options) => {
-  const { formatters, ...renderOpts } = { ...options };
-  const content = render(template, context2, renderOpts);
-  return Array.isArray(formatters) ? formatters.reduce((c, f) => f(c, file), content) : content;
-};
-var renderToFile = async (file, template, context2, options) => {
-  const content = renderAsFile(file, template, context2, 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");
-};
-var renderFactory = (options) => {
-  const renderer = handlebars.create();
-  if (options?.partials) {
-    renderer.registerPartial(options.partials);
-  }
-  if (options?.helpers) {
-    renderer.registerHelper(options.helpers);
-  }
-  return {
-    render(template, context2, selfOoptions) {
-      return render(template, context2, {
-        renderer,
-        ...options,
-        ...selfOoptions
-      });
-    },
-    async renderToFile(file, template, context2, selfOoptions) {
-      return renderToFile(
-        options?.outdir ? join2(options.outdir, file) : file,
-        template,
-        context2,
-        { renderer, ...options, ...selfOoptions }
-      );
-    }
-  };
-};
-
 // 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 {
@@ -278,19 +207,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
   };
 };
@@ -305,22 +227,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 [];
@@ -341,35 +264,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;
@@ -474,12 +535,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 }) => {
   const project = createProject({
@@ -488,7 +544,7 @@ var typeResolverFactory = ({ appRoot }) => {
   });
   const literalTypesResolver = (literalTypes, options) => {
     const sourceFile = project.createSourceFile(
-      `${crc2(literalTypes)}-${Date.now()}.ts`,
+      `${crc(literalTypes)}-${Date.now()}.ts`,
       literalTypes,
       { overwrite: true }
     );
@@ -514,10 +570,23 @@ var typeResolverFactory = ({ appRoot }) => {
 };
 
 // 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,
   sourceFolder,
@@ -526,11 +595,11 @@ var cacheFactory = (route, {
   const cacheFile = pathResolver({
     appRoot,
     sourceFolder
-  }).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) {
       }
@@ -553,8 +622,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) => {
@@ -586,11 +655,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
@@ -601,75 +670,230 @@ 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, context2, options) => {
+  const { noEscape = true, renderer = handlebars } = { ...options };
+  return renderer.compile(template, { noEscape })(context2);
+};
+var renderToFile = async (file, template, context2, options) => {
+  const content = render(template, context2, 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");
+};
+var renderFactory = (options) => {
+  const renderer = handlebars.create();
+  renderer.registerPartial({ ...options?.partials });
+  renderer.registerHelper({ ...options?.helpers });
+  return {
+    render(template, context2, selfOoptions) {
+      return render(template, context2, {
+        renderer,
+        ...options,
+        ...selfOoptions
+      });
+    },
+    async renderToFile(file, template, context2, selfOoptions) {
+      return renderToFile(
+        options?.outdir ? join2(options.outdir, file) : file,
+        template,
+        context2,
+        { renderer, ...options, ...selfOoptions }
+      );
+    }
+  };
+};
+var renderHelpers = {
+  createParamsLiteral: (params) => {
+    return params.schema.map((p) => {
+      return p.kind === "splat" ? `${p.const}?: Array<string | number>` : p.kind === "optional" ? `${p.const}?: string | number` : `${p.const}: string | number`;
+    }).join(", ");
+  }
+};
+
 // 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, "\\\\+");
 };
 var sortRoutes = (a, b) => {
-  const aStaticSegments = staticSegments(a.pathTokens);
-  const bStaticSegments = staticSegments(b.pathTokens);
-  if (aStaticSegments !== bStaticSegments) {
-    return bStaticSegments - aStaticSegments;
+  const aSpecificity = routeSpecificity(a.pathTokens);
+  const bSpecificity = routeSpecificity(b.pathTokens);
+  if (aSpecificity !== bSpecificity) {
+    return bSpecificity - aSpecificity;
   }
   if (a.pathTokens.length !== b.pathTokens.length) {
     return a.pathTokens.length - b.pathTokens.length;
   }
   return a.name.localeCompare(b.name);
 };
-var staticSegments = (pathTokens) => {
-  return pathTokens.reduce((a, e) => a + (e.param ? 0 : 1), 0);
+var paramWeight = (part) => {
+  return {
+    required: 2,
+    optional: 1,
+    splat: 0
+  }[part.kind];
+};
+var mixedSegmentWeight = (parts) => {
+  const hasSplat = parts.some((p) => {
+    return p.type === "param" ? p.kind === "splat" : false;
+  });
+  return hasSplat ? 0.5 : 3;
+};
+var segmentWeight = (token) => {
+  return {
+    static: 4,
+    mixed: mixedSegmentWeight(token.parts),
+    param: paramWeight(token.parts[0])
+  }[token.kind];
+};
+var routeSpecificity = (pathTokens) => {
+  return pathTokens.reduce((sum, token) => sum + segmentWeight(token), 0);
 };
 
 // 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";
@@ -740,15 +964,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) => {
@@ -764,14 +991,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,
@@ -802,28 +1032,33 @@ var apiRouteResolverFactory = (pluginOptions) => {
     appRoot,
     sourceFolder,
     generators = [],
-    formatters = [],
     refineTypeName
   } = pluginOptions;
-  let resolveTypes = false;
-  for (const { options } of generators) {
-    if (options?.resolveTypes) {
-      resolveTypes = true;
-    }
-  }
+  const resolveTypes = generators.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 },
         {
@@ -841,11 +1076,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),
@@ -854,6 +1088,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);
@@ -875,25 +1114,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
+          stripComments: true,
+          overrides: { [refineTypeName]: refineTypeName },
+          withProperties: [
+            params.id,
+            ...validationTypes.flatMap(({ id: id2 }) => id2)
+          ]
         }) : void 0;
         await renderToFile(
           typesFile,
@@ -906,26 +1141,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,
@@ -934,8 +1237,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
@@ -944,7 +1246,7 @@ var apiRouteResolverFactory = (pluginOptions) => {
       };
       return {
         kind: "apiRoute",
-        entry: entry2
+        entry
       };
     };
     return { name, handler };
@@ -1075,32 +1377,29 @@ var routesFactory = async (pluginOptions) => {
 
 // src/base-plugin/api-handler.ts
 import { join as join4, resolve as resolve4 } from "node:path";
-import { styleText } from "node:util";
+import { styleText as styleText3 } from "node:util";
 import { context } from "esbuild";
 var api_handler_default = async (options) => {
   const { appRoot, sourceFolder, baseurl, apiurl } = options;
   const { createPath } = pathResolver({ appRoot, sourceFolder });
   const outDir = join4(options.outDir, defaults.apiDir);
   const esbuildOptions = await import(resolve4(appRoot, "esbuild.json"), { with: { type: "json" } }).then((e) => e.default);
-  let app;
-  let devMiddlewareFactory;
-  let teardownHandler;
+  let devSetup;
   const watcher = async () => {
     const rebuildPlugin = {
       name: "rebuild",
       setup(build) {
         build.onEnd(async () => {
-          if (app) {
-            await teardownHandler?.(app);
+          if (devSetup) {
+            await devSetup.teardownHandler?.();
           }
           try {
-            const exports = await import(`${outDir}/app.js?${Date.now()}`);
-            devMiddlewareFactory = exports.devMiddlewareFactory;
-            teardownHandler = exports.teardownHandler;
-            app = await exports.default();
-            console.debug(`${styleText("green", "\u279C")} Api handler ready`);
+            await import(`${outDir}/dev.js?${Date.now()}`).then((e) => {
+              devSetup = e.default;
+            });
+            console.debug(`${styleText3("green", "\u279C")} Api handler ready`);
           } catch (error) {
-            console.error(`${styleText("red", "\u2717")} Api handler error`);
+            console.error(`${styleText3("red", "\u2717")} Api handler error`);
             console.error(error);
           }
         });
@@ -1108,9 +1407,13 @@ var api_handler_default = async (options) => {
     };
     const ctx = await context({
       ...esbuildOptions,
+      define: {
+        ...esbuildOptions.define,
+        PRODUCTION_BUILD: "false"
+      },
       logLevel: "error",
       bundle: true,
-      entryPoints: [createPath.api("app.ts")],
+      entryPoints: [createPath.api("dev.ts")],
       plugins: [rebuildPlugin],
       outdir: outDir
     });
@@ -1126,16 +1429,20 @@ var api_handler_default = async (options) => {
       }
     };
   };
-  const devMiddleware = async (req, res, viteHandler) => {
-    const next = () => {
-      return viteHandler();
-    };
-    if (devMiddlewareFactory) {
-      const handler = devMiddlewareFactory(app);
-      await handler(req, res, next);
-    } else {
-      !req?.url || !new RegExp(`^${join4(baseurl, apiurl)}($|/)`).test(req.url) ? next() : await app?.callback()(req, res);
+  const devMiddleware = async (req, res, next) => {
+    const {
+      requestMatcher = () => {
+        return new RegExp(`^${join4(baseurl, apiurl)}($|/)`).test(
+          req.url
+        );
+      },
+      requestHandler
+    } = { ...devSetup };
+    if (!requestMatcher(req)) {
+      return next();
     }
+    const handler = requestHandler?.();
+    return handler ? handler(req, res) : next();
   };
   return {
     watcher,
@@ -1144,9 +1451,9 @@ var api_handler_default = async (options) => {
 };
 
 // src/base-plugin/spinner.ts
-import ora from "ora";
+import { Spinner } from "@topcli/spinner";
 var spinnerFactory = (startText) => {
-  const spinner = ora().start(startText);
+  const spinner = new Spinner().start(startText);
   let _text = startText;
   return {
     text(text) {
@@ -1168,7 +1475,7 @@ var spinnerFactory = (startText) => {
       if (text) {
         this.text([_text, text].join("\n"));
       }
-      spinner.fail();
+      spinner.failed();
     }
   };
 };
@@ -1179,19 +1486,13 @@ var base_plugin_default = (apiurl, pluginOptions) => {
   const outDirSuffix = "client";
   const store = {};
   const createWorker = () => {
-    const {
-      generators = [],
-      formatters = [],
-      ...restOptions
-    } = store.resolvedOptions;
+    const { generators = [], ...restOptions } = store.resolvedOptions;
     const generatorModules = generators.map(
       (e) => [e.moduleImport, e.moduleConfig]
     );
-    const formatterModules = pluginOptions?.formatters ? pluginOptions.formatters.map((e) => [e.moduleImport, e.moduleConfig]) : [];
     const workerData = {
       ...restOptions,
-      generatorModules,
-      formatterModules
+      generatorModules
     };
     return new Worker(resolve5(import.meta.dirname, "base-plugin/worker.js"), {
       workerData,
@@ -1230,10 +1531,10 @@ var base_plugin_default = (apiurl, pluginOptions) => {
           const { error } = msg;
           if (error.stack) {
             const [message, ...stack] = error.stack.split("\n");
-            console.error(styleText2("red", message));
+            console.error(styleText4("red", message));
             console.error(stack.join("\n"));
           } else if (error?.message) {
-            console.error(`${styleText2("red", error?.name)}: ${error.message}`);
+            console.error(`${styleText4("red", error?.name)}: ${error.message}`);
           } else {
             console.error(error);
           }
@@ -1275,19 +1576,12 @@ var base_plugin_default = (apiurl, pluginOptions) => {
         ...store.config.server.watch ? { options: store.config.server.watch } : {}
       };
       {
-        const {
-          generators = [],
-          formatters = [],
-          refineTypeName = "TRefine"
-        } = { ...pluginOptions };
-        const apiGenerator = generators.find((e) => e.kind === "api");
-        const fetchGenerator = generators.find((e) => e.kind === "fetch");
-        const ssrGenerator = generators.find((e) => e.kind === "ssr");
-        if (!apiGenerator || !fetchGenerator) {
-          throw new Error(
-            "Some of required generators missing, make sure both `api` and `fetch` generators configured properly"
-          );
-        }
+        const { generators = [], refineTypeName = "TRefine" } = {
+          ...pluginOptions
+        };
+        const apiGenerator = generators.find((e) => e.slot === "api");
+        const fetchGenerator = generators.find((e) => e.slot === "fetch");
+        const ssrGenerator = generators.find((e) => e.slot === "ssr");
         store.resolvedOptions = {
           ...pluginOptions,
           command: store.config.command,
@@ -1296,17 +1590,16 @@ var base_plugin_default = (apiurl, pluginOptions) => {
             // 1. stub generator should run first
             stubGenerator(),
             // 2. then api generator
-            apiGenerator,
-            // 3. then fetch generator
-            fetchGenerator,
+            ...apiGenerator ? [apiGenerator] : [],
+            // 3. then fetch generator, only if api generator also enabled
+            ...fetchGenerator && apiGenerator ? [fetchGenerator] : [],
             // 4. user generators in the order they were added
             ...generators.filter((e) => {
-              return e.kind ? !["api", "fetch", "ssr"].includes(e.kind) : true;
+              return e.slot ? !["api", "fetch", "ssr"].includes(e.slot) : true;
             }),
             // 5. ssr generator should run last
             ...ssrGenerator ? [ssrGenerator] : []
           ],
-          formatters: formatters.map((e) => e.formatter),
           refineTypeName,
           baseurl: store.config.base,
           apiurl,
@@ -1315,6 +1608,52 @@ var base_plugin_default = (apiurl, pluginOptions) => {
           outDir
         };
       }
+      const packageJsonFile = resolve5(appRoot, "package.json");
+      const packageJson = await import(packageJsonFile, {
+        with: { type: "json" }
+      }).then((e) => e.default);
+      const newDependencies = [];
+      for (const generator of store.resolvedOptions.generators) {
+        for (const key of ["dependencies", "devDependencies"]) {
+          for (const [pkg, ver] of Object.entries(generator[key] || {})) {
+            if (!packageJson[key]?.[pkg]) {
+              newDependencies.push([key, pkg, ver]);
+            }
+          }
+        }
+      }
+      if (newDependencies.length) {
+        console.warn();
+        console.warn(
+          [
+            "\u{1F4A1} ",
+            styleText4(["bold", "italic", "red"], "New dependencies added: "),
+            styleText4("dim", newDependencies.map(([, pkg]) => pkg).join(", "))
+          ].join("")
+        );
+        console.warn(
+          "\u{1F4E6}",
+          [
+            styleText4(
+              ["bold", "blueBright"],
+              store.config.command === "build" ? "Install them and run a new build: " : "Install them and restart dev server: "
+            ),
+            styleText4(
+              "dim",
+              ["npm", "pnpm", "yarn"].map((e) => `\`${e} install\``).join(" / ")
+            )
+          ].join("")
+        );
+        console.warn();
+        for (const [key, pkg, ver] of newDependencies) {
+          packageJson[key] = { ...packageJson[key], [pkg]: ver };
+        }
+        await writeFile3(
+          packageJsonFile,
+          JSON.stringify(packageJson, null, 2),
+          "utf8"
+        );
+      }
       if (store.config.command === "build") {
         const { resolvers } = await routesFactory(store.resolvedOptions);
         const resolvedEntries = [];
@@ -1343,6 +1682,10 @@ var base_plugin_default = (apiurl, pluginOptions) => {
       if (store.config.command !== "serve") {
         return;
       }
+      if (!store.resolvedOptions.generators.find((e) => e.slot === "api")) {
+        const stopWorker2 = workerHandler(() => stopWorker2());
+        return;
+      }
       const apiHandler = await api_handler_default(store.resolvedOptions);
       const apiWatcher = await apiHandler.watcher();
       const stopWorker = workerHandler(
@@ -1421,13 +1764,14 @@ export {
   isPageRoute,
   isRouteFile,
   nestedRoutesFactory,
+  normalizeStaticValue,
   pageLayoutResolverFactory,
   pageRouteResolverFactory,
   pathResolver,
   pathTokensFactory,
   render,
-  renderAsFile,
   renderFactory,
+  renderHelpers,
   renderToFile,
   routesFactory,
   scanRoutes,