@kosmojs/dev 0.0.7 → 0.0.9

package/pkg/base-plugin/worker.js

@@ -7,6 +7,11 @@ import {
 } from "@kosmojs/devlib";
 
 // src/base-plugin/routes.ts
+import {
+  defaults as defaults2
+} from "@kosmojs/devlib";
+
+// src/base-plugin/routes/resolve.ts
 import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
 import crc3 from "crc/crc32";
 import picomatch from "picomatch";
@@ -288,7 +293,7 @@ var cacheFactory = (route, {
   const cacheFile = pathResolver({
     appRoot: appRoot2,
     sourceFolder: sourceFolder2
-  }).resolve("apiLibDir", route.importPath, "cache.json");
+  }).resolve("apiLibDir", dirname(route.file), "cache.json");
   const getCache = async (opt) => {
     if (await pathExists(cacheFile)) {
       try {
@@ -369,8 +374,120 @@ var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{
 // 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/base-plugin/routes.ts
-var routes_default = async (pluginOptions) => {
+// src/base-plugin/routes/resolve.ts
+var API_INDEX_BASENAME = "index";
+var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
+var PAGE_INDEX_BASENAME = "index";
+var PAGE_INDEX_PATTERN = `${PAGE_INDEX_BASENAME}.{tsx,vue}`;
+var PAGE_LAYOUT_BASENAME = "layout";
+var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue}`;
+var ROUTE_FILE_PATTERNS = [
+  // match index files in api dir
+  `${defaults.apiDir}/**/${API_INDEX_PATTERN}`,
+  // match index files in pages dir
+  `${defaults.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
+  // match layout files in pages dir
+  `${defaults.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
+];
+var scanRoutes = async ({
+  appRoot: appRoot2,
+  sourceFolder: sourceFolder2
+}) => {
+  return glob(ROUTE_FILE_PATTERNS, {
+    cwd: resolve3(appRoot2, sourceFolder2),
+    absolute: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: [
+      // ignore top-level matches, routes resides in folders, even index route
+      `${defaults.apiDir}/${API_INDEX_PATTERN}`,
+      `${defaults.pagesDir}/${PAGE_INDEX_PATTERN}`,
+      `${defaults.pagesDir}/${PAGE_LAYOUT_PATTERN}`
+    ]
+  });
+};
+var isRouteFile = (file, {
+  appRoot: appRoot2,
+  sourceFolder: sourceFolder2
+}) => {
+  const [_sourceFolder, folder, ...rest] = resolve3(appRoot2, file).replace(`${appRoot2}/`, "").split("/");
+  if (!folder || _sourceFolder !== sourceFolder2 || rest.length < 2) {
+    return;
+  }
+  return picomatch.isMatch(join(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : void 0;
+};
+var isPageFile = (file) => {
+  return picomatch.matchBase(file, `**/${PAGE_INDEX_PATTERN}`) ? { kind: "index" } : picomatch.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`) ? { kind: "layout" } : void 0;
+};
+var createRouteEntry = (_file, {
+  appRoot: appRoot2,
+  sourceFolder: sourceFolder2
+}) => {
+  const resolvedPaths = isRouteFile(_file, { 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
+  };
+};
+var pageLayoutResolverFactory = () => {
+  return (entry) => {
+    const { name } = entry;
+    const handler = async () => {
+      return {
+        kind: "pageLayout",
+        entry
+      };
+    };
+    return { name, handler };
+  };
+};
+var pageRouteResolverFactory = () => {
+  return (entry) => {
+    const {
+      name,
+      folder,
+      file,
+      fileFullpath,
+      pathTokens,
+      importFile,
+      importName
+    } = entry;
+    const handler = async () => {
+      const entry2 = {
+        name,
+        pathTokens,
+        params: {
+          schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
+        },
+        folder,
+        file,
+        fileFullpath,
+        importFile,
+        importName
+      };
+      return {
+        kind: "pageRoute",
+        entry: entry2
+      };
+    };
+    return { name, handler };
+  };
+};
+var apiRouteResolverFactory = (pluginOptions) => {
   const {
     appRoot: appRoot2,
     sourceFolder: sourceFolder2,
@@ -390,235 +507,185 @@ var routes_default = async (pluginOptions) => {
     getSourceFile,
     refreshSourceFile
   } = typeResolverFactory(pluginOptions);
-  const routeFilePatterns = [
-    `${defaults.apiDir}/**/index.ts`,
-    `${defaults.pagesDir}/**/index.{ts,tsx,vue,svelte}`
-  ];
-  const resolveRouteFile2 = (file) => {
-    const [_sourceFolder, folder, ...rest] = resolve3(appRoot2, file).replace(`${appRoot2}/`, "").split("/");
-    if (!folder || _sourceFolder !== sourceFolder2 || rest.length < 2) {
-      return;
-    }
-    return picomatch.isMatch(join(folder, ...rest), routeFilePatterns) ? [folder, rest.join("/")] : void 0;
-  };
-  const resolversFactory2 = (routeFiles2) => {
-    const resolvers2 = /* @__PURE__ */ new Map();
-    const entries = routeFiles2.flatMap((_file) => {
-      const resolvedPaths = resolveRouteFile2(_file);
-      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 importPath = dirname2(file);
-      const importName = [
-        importPath.split(/\[/)[0].replace(/^\W+|\W+$/g, "").replace(/\W+/g, "_"),
-        crc3(importPath)
-      ].join("_");
-      return [
+  return (entry) => {
+    const {
+      name,
+      file,
+      folder,
+      fileFullpath,
+      pathTokens,
+      importFile,
+      importName
+    } = entry;
+    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 { getCache, persistCache } = cacheFactory(
+        { file, fileFullpath, importName },
         {
-          name,
-          folder,
-          file,
-          fileFullpath,
-          pathTokens,
-          importPath,
-          importName
+          appRoot: appRoot2,
+          sourceFolder: sourceFolder2,
+          extraContext: { resolveTypes }
         }
-      ];
-    });
-    for (const entry of entries.filter((e) => e.folder === defaults.apiDir)) {
-      const {
-        name,
-        file,
-        folder,
-        fileFullpath,
-        pathTokens,
-        importPath,
-        importName
-      } = entry;
-      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 { getCache, persistCache } = cacheFactory(
-          { file, fileFullpath, importName, importPath },
+      );
+      let cache = await getCache({ validate: true });
+      if (!cache) {
+        if (updatedFile === fileFullpath) {
+          await refreshSourceFile(fileFullpath);
+        }
+        const {
+          typeDeclarations,
+          paramsRefinements,
+          methods,
+          payloadTypes,
+          responseTypes,
+          referencedFiles = []
+        } = await resolveRouteSignature(
+          { importName, fileFullpath, optionalParams },
           {
-            appRoot: appRoot2,
-            sourceFolder: sourceFolder2,
-            extraContext: { resolveTypes }
+            withReferencedFiles: true,
+            sourceFile: getSourceFile(fileFullpath),
+            relpathResolver(path) {
+              return join(sourceFolder2, defaults.apiDir, dirname2(file), path);
+            }
           }
         );
-        let cache = await getCache({ validate: true });
-        if (!cache) {
-          if (updatedFile === fileFullpath) {
-            await refreshSourceFile(fileFullpath);
+        const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
+          if (text === "number") {
+            const param = paramsSchema.at(index);
+            return param ? [param.name] : [];
           }
-          const {
-            typeDeclarations,
-            paramsRefinements,
-            methods,
-            payloadTypes,
-            responseTypes,
-            referencedFiles = []
-          } = await resolveRouteSignature(
-            { importName, fileFullpath, optionalParams },
-            {
-              withReferencedFiles: true,
-              sourceFile: getSourceFile(fileFullpath),
-              relpathResolver(path) {
-                return join(sourceFolder2, defaults.apiDir, dirname2(file), path);
-              }
-            }
-          );
-          const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
-            if (text === "number") {
-              const param = paramsSchema.at(index);
-              return param ? [param.name] : [];
-            }
-            return [];
-          }) : [];
-          const typesFile = pathResolver2({ appRoot: appRoot2, sourceFolder: sourceFolder2 }).resolve(
-            "apiLibDir",
-            importPath,
-            "types.ts"
-          );
-          const params = {
-            id: ["ParamsT", crc3(name)].join(""),
-            schema: paramsSchema,
-            resolvedType: void 0
-          };
-          const typesFileContent = render(types_default, {
-            params,
-            paramsSchema: paramsSchema.map((param, index) => {
-              return {
-                ...param,
-                refinement: paramsRefinements?.at(index)
-              };
-            }),
-            typeDeclarations,
-            payloadTypes,
-            responseTypes
-          });
-          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
-          }) : void 0;
-          await renderToFile(
-            typesFile,
-            resolvedTypes ? resolved_types_default : typesFileContent,
-            { resolvedTypes }
-          );
-          params.resolvedType = resolvedTypes?.find(
-            (e) => e.name === params.id
-          );
-          cache = await persistCache({
-            params,
-            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 }) => {
-              return {
-                ...rest,
-                resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
-              };
-            }),
-            referencedFiles
-          });
-        }
-        const route = {
-          name,
-          pathTokens,
-          params: cache.params,
-          numericParams: cache.numericParams,
-          optionalParams,
-          importName,
-          importPath,
-          folder,
-          file,
-          fileFullpath,
-          methods: cache.methods,
-          typeDeclarations: cache.typeDeclarations,
-          payloadTypes: cache.payloadTypes,
-          responseTypes: cache.responseTypes,
-          referencedFiles: Object.keys(cache.referencedFiles).map(
-            // expand referenced files path,
-            // they are stored as relative in cache
-            (e) => resolve3(appRoot2, e)
-          )
-        };
-        return {
-          kind: "api",
-          route
+          return [];
+        }) : [];
+        const typesFile = pathResolver2({ appRoot: appRoot2, sourceFolder: sourceFolder2 }).resolve(
+          "apiLibDir",
+          dirname2(file),
+          "types.ts"
+        );
+        const params = {
+          id: ["ParamsT", crc3(name)].join(""),
+          schema: paramsSchema,
+          resolvedType: void 0
         };
-      };
-      resolvers2.set(fileFullpath, { name, handler });
-    }
-    for (const entry of entries.filter((e) => e.folder === defaults.pagesDir)) {
-      const {
-        //
+        const typesFileContent = render(types_default, {
+          params,
+          paramsSchema: paramsSchema.map((param, index) => {
+            return {
+              ...param,
+              refinement: paramsRefinements?.at(index)
+            };
+          }),
+          typeDeclarations,
+          payloadTypes,
+          responseTypes
+        });
+        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
+        }) : void 0;
+        await renderToFile(
+          typesFile,
+          resolvedTypes ? resolved_types_default : typesFileContent,
+          { resolvedTypes }
+        );
+        params.resolvedType = resolvedTypes?.find((e) => e.name === params.id);
+        cache = await persistCache({
+          params,
+          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 }) => {
+            return {
+              ...rest,
+              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
+            };
+          }),
+          referencedFiles
+        });
+      }
+      const entry2 = {
         name,
+        pathTokens,
+        params: cache.params,
+        numericParams: cache.numericParams,
+        optionalParams,
+        importName,
+        importFile,
         folder,
         file,
         fileFullpath,
-        pathTokens,
-        importPath,
-        importName
-      } = entry;
-      const handler = async () => {
-        const route = {
-          name,
-          pathTokens,
-          params: {
-            schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
-          },
-          folder,
-          file,
-          fileFullpath,
-          importPath,
-          importName
-        };
-        return {
-          kind: "page",
-          route
-        };
+        methods: cache.methods,
+        typeDeclarations: cache.typeDeclarations,
+        payloadTypes: cache.payloadTypes,
+        responseTypes: cache.responseTypes,
+        referencedFiles: Object.keys(cache.referencedFiles).map(
+          // expand referenced files path,
+          // they are stored as relative in cache
+          (e) => resolve3(appRoot2, e)
+        )
+      };
+      return {
+        kind: "apiRoute",
+        entry: entry2
       };
-      resolvers2.set(fileFullpath, { name, handler });
+    };
+    return { name, handler };
+  };
+};
+
+// src/base-plugin/routes/nesting.ts
+import {
+  sortRoutes
+} from "@kosmojs/devlib";
+
+// src/base-plugin/routes.ts
+var routes_default = async (pluginOptions) => {
+  const { appRoot: appRoot2, sourceFolder: sourceFolder2 } = pluginOptions;
+  const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
+  const pageRouteResolver = pageRouteResolverFactory(pluginOptions);
+  const pageLayoutResolver = pageLayoutResolverFactory(pluginOptions);
+  const resolversFactory2 = (routeFiles2) => {
+    const resolvers2 = /* @__PURE__ */ new Map();
+    const entries = routeFiles2.flatMap((file) => {
+      const entry = createRouteEntry(file, pluginOptions);
+      return entry ? [entry] : [];
+    });
+    for (const entry of entries) {
+      if (entry.folder === defaults2.apiDir) {
+        resolvers2.set(entry.fileFullpath, apiRouteResolver(entry));
+      } else if (entry.folder === defaults2.pagesDir) {
+        const pageFile = isPageFile(entry.file);
+        if (pageFile?.kind === "index") {
+          resolvers2.set(entry.fileFullpath, pageRouteResolver(entry));
+        } else if (pageFile?.kind === "layout") {
+          resolvers2.set(entry.fileFullpath, pageLayoutResolver(entry));
+        }
+      }
     }
     return resolvers2;
   };
-  const routeFiles = await glob(routeFilePatterns, {
-    cwd: resolve3(appRoot2, sourceFolder2),
-    absolute: true,
-    onlyFiles: true,
-    ignore: [
-      `${defaults.apiDir}/index.ts`,
-      `${defaults.pagesDir}/index.ts{x,}`
-    ]
-  });
+  const routeFiles = await scanRoutes({ appRoot: appRoot2, sourceFolder: sourceFolder2 });
   return {
     resolvers: resolversFactory2(routeFiles),
-    resolversFactory: resolversFactory2,
-    resolveRouteFile: resolveRouteFile2
+    resolversFactory: resolversFactory2
   };
 };
 
@@ -644,13 +711,8 @@ var resolvedOptions = {
 };
 var { appRoot, sourceFolder } = resolvedOptions;
 var watchHandlers = [];
-var resolvedRoutes = /* @__PURE__ */ new Map();
-var {
-  //
-  resolvers,
-  resolversFactory,
-  resolveRouteFile
-} = await routes_default(resolvedOptions);
+var resolvedEntries = /* @__PURE__ */ new Map();
+var { resolvers, resolversFactory } = await routes_default(resolvedOptions);
 var { resolve: resolve4 } = pathResolver3({ appRoot, sourceFolder });
 var spinnerFactory = (startText) => {
   const id = [startText, Date.now().toString()].map(crc4).join(":");
@@ -684,9 +746,9 @@ var createEventHandler = async (file) => {
   if (resolver) {
     const spinner = spinnerFactory(`Resolving ${resolver.name} Route`);
     try {
-      const resolvedRoute = await resolver.handler();
+      const resolvedEntry = await resolver.handler();
       resolvers.set(file, resolver);
-      resolvedRoutes.set(resolvedRoute.route.fileFullpath, resolvedRoute);
+      resolvedEntries.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
       spinner.succeed();
     } catch (error) {
       spinner.failed(error);
@@ -695,16 +757,16 @@ var createEventHandler = async (file) => {
 };
 var updateEventHandler = async (file) => {
   const relatedResolvers = /* @__PURE__ */ new Map();
-  if (resolvedRoutes.has(file)) {
+  if (resolvedEntries.has(file)) {
     const resolver = resolvers.get(file);
     if (resolver) {
       relatedResolvers.set(file, resolver);
     }
   } else {
-    const referencedRoutes = resolvedRoutes.values().filter(({ kind, route }) => {
-      return kind === "api" ? route.referencedFiles.includes(file) : false;
+    const referencedRoutes = resolvedEntries.values().flatMap(({ kind, entry }) => {
+      return kind === "apiRoute" ? entry.referencedFiles.includes(file) ? [entry] : [] : [];
     });
-    for (const { route } of referencedRoutes) {
+    for (const route of referencedRoutes) {
       const resolver = resolvers.get(route.fileFullpath);
       if (resolver) {
         relatedResolvers.set(route.fileFullpath, resolver);
@@ -715,8 +777,8 @@ var updateEventHandler = async (file) => {
   for (const resolver of relatedResolvers.values()) {
     spinner.append(resolver.name);
     try {
-      const route = await resolver.handler(file);
-      resolvedRoutes.set(route.route.fileFullpath, route);
+      const resolvedEntry = await resolver.handler(file);
+      resolvedEntries.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
     } catch (error) {
       spinner.failed(error);
       spinner = spinnerFactory(`Updating ${relatedResolvers.size} Routes`);
@@ -728,11 +790,11 @@ var deleteEventHandler = async () => {
 };
 var runWatchHandlers = async (event) => {
   let spinner = spinnerFactory("Running Generators");
-  const routes = Array.from(resolvedRoutes.values());
+  const entries = Array.from(resolvedEntries.values());
   for (const { name, handler } of watchHandlers) {
     spinner.append(name);
     try {
-      await handler(structuredClone(routes), event);
+      await handler(structuredClone(entries), event);
     } catch (error) {
       spinner.failed(error);
       spinner = spinnerFactory("Running Generators");
@@ -762,7 +824,7 @@ watcher.on("all", async (event, file) => {
   if (event.endsWith("Dir")) {
     return;
   }
-  if (!resolveRouteFile(file)) {
+  if (!isRouteFile(file, { appRoot, sourceFolder })) {
     return;
   }
   const match = {
@@ -780,11 +842,11 @@ watcher.on("all", async (event, file) => {
   let spinner = spinnerFactory("Resolving Routes");
   for (const { name, handler } of resolvers.values()) {
     spinner.append(
-      `[ ${resolvedRoutes.size + 1} of ${resolvers.size} ] ${name}`
+      `[ ${resolvedEntries.size + 1} of ${resolvers.size} ] ${name}`
     );
     try {
       const resolvedEntry = await handler();
-      resolvedRoutes.set(resolvedEntry.route.fileFullpath, resolvedEntry);
+      resolvedEntries.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
     } catch (error) {
       spinner.failed(error);
       spinner = spinnerFactory("Resolving Routes");