@kosmojs/dev 0.0.7 → 0.0.9

package/pkg/index.js

@@ -147,6 +147,11 @@ var api_handler_default = async (options) => {
 };
 
 // src/base-plugin/routes.ts
+import {
+  defaults as defaults3
+} from "@kosmojs/devlib";
+
+// src/base-plugin/routes/resolve.ts
 import { dirname as dirname2, join as join2, resolve as resolve4 } from "node:path";
 import crc3 from "crc/crc32";
 import picomatch from "picomatch";
@@ -428,7 +433,7 @@ var cacheFactory = (route, {
   const cacheFile = pathResolver({
     appRoot,
     sourceFolder
-  }).resolve("apiLibDir", route.importPath, "cache.json");
+  }).resolve("apiLibDir", dirname(route.file), "cache.json");
   const getCache = async (opt) => {
     if (await pathExists(cacheFile)) {
       try {
@@ -509,8 +514,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
+  `${defaults2.apiDir}/**/${API_INDEX_PATTERN}`,
+  // match index files in pages dir
+  `${defaults2.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
+  // match layout files in pages dir
+  `${defaults2.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
+];
+var scanRoutes = async ({
+  appRoot,
+  sourceFolder
+}) => {
+  return glob2(ROUTE_FILE_PATTERNS, {
+    cwd: resolve4(appRoot, sourceFolder),
+    absolute: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: [
+      // ignore top-level matches, routes resides in folders, even index route
+      `${defaults2.apiDir}/${API_INDEX_PATTERN}`,
+      `${defaults2.pagesDir}/${PAGE_INDEX_PATTERN}`,
+      `${defaults2.pagesDir}/${PAGE_LAYOUT_PATTERN}`
+    ]
+  });
+};
+var isRouteFile = (file, {
+  appRoot,
+  sourceFolder
+}) => {
+  const [_sourceFolder, folder, ...rest] = resolve4(appRoot, file).replace(`${appRoot}/`, "").split("/");
+  if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
+    return;
+  }
+  return picomatch.isMatch(join2(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,
+  sourceFolder
+}) => {
+  const resolvedPaths = isRouteFile(_file, { appRoot, sourceFolder });
+  if (!resolvedPaths) {
+    return;
+  }
+  const [folder, file] = resolvedPaths;
+  const fileFullpath = join2(appRoot, sourceFolder, 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,
     sourceFolder,
@@ -530,235 +647,185 @@ var routes_default = async (pluginOptions) => {
     getSourceFile,
     refreshSourceFile
   } = typeResolverFactory(pluginOptions);
-  const routeFilePatterns = [
-    `${defaults2.apiDir}/**/index.ts`,
-    `${defaults2.pagesDir}/**/index.{ts,tsx,vue,svelte}`
-  ];
-  const resolveRouteFile = (file) => {
-    const [_sourceFolder, folder, ...rest] = resolve4(appRoot, file).replace(`${appRoot}/`, "").split("/");
-    if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
-      return;
-    }
-    return picomatch.isMatch(join2(folder, ...rest), routeFilePatterns) ? [folder, rest.join("/")] : void 0;
-  };
-  const resolversFactory = (routeFiles2) => {
-    const resolvers = /* @__PURE__ */ new Map();
-    const entries = routeFiles2.flatMap((_file) => {
-      const resolvedPaths = resolveRouteFile(_file);
-      if (!resolvedPaths) {
-        return [];
-      }
-      const [folder, file] = resolvedPaths;
-      const fileFullpath = join2(appRoot, sourceFolder, 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,
+          sourceFolder,
+          extraContext: { resolveTypes }
         }
-      ];
-    });
-    for (const entry of entries.filter((e) => e.folder === defaults2.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,
-            sourceFolder,
-            extraContext: { resolveTypes }
+            withReferencedFiles: true,
+            sourceFile: getSourceFile(fileFullpath),
+            relpathResolver(path) {
+              return join2(sourceFolder, defaults2.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 join2(sourceFolder, defaults2.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, sourceFolder }).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
-          }) : 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) => resolve4(appRoot, e)
-          )
-        };
-        return {
-          kind: "api",
-          route
+          return [];
+        }) : [];
+        const typesFile = pathResolver2({ appRoot, sourceFolder }).resolve(
+          "apiLibDir",
+          dirname2(file),
+          "types.ts"
+        );
+        const params = {
+          id: ["ParamsT", crc3(name)].join(""),
+          schema: paramsSchema,
+          resolvedType: void 0
         };
-      };
-      resolvers.set(fileFullpath, { name, handler });
-    }
-    for (const entry of entries.filter((e) => e.folder === defaults2.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
+        }) : 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) => resolve4(appRoot, e)
+        )
       };
-      resolvers.set(fileFullpath, { name, handler });
+      return {
+        kind: "apiRoute",
+        entry: entry2
+      };
+    };
+    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, sourceFolder } = pluginOptions;
+  const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
+  const pageRouteResolver = pageRouteResolverFactory(pluginOptions);
+  const pageLayoutResolver = pageLayoutResolverFactory(pluginOptions);
+  const resolversFactory = (routeFiles2) => {
+    const resolvers = /* @__PURE__ */ new Map();
+    const entries = routeFiles2.flatMap((file) => {
+      const entry = createRouteEntry(file, pluginOptions);
+      return entry ? [entry] : [];
+    });
+    for (const entry of entries) {
+      if (entry.folder === defaults3.apiDir) {
+        resolvers.set(entry.fileFullpath, apiRouteResolver(entry));
+      } else if (entry.folder === defaults3.pagesDir) {
+        const pageFile = isPageFile(entry.file);
+        if (pageFile?.kind === "index") {
+          resolvers.set(entry.fileFullpath, pageRouteResolver(entry));
+        } else if (pageFile?.kind === "layout") {
+          resolvers.set(entry.fileFullpath, pageLayoutResolver(entry));
+        }
+      }
     }
     return resolvers;
   };
-  const routeFiles = await glob2(routeFilePatterns, {
-    cwd: resolve4(appRoot, sourceFolder),
-    absolute: true,
-    onlyFiles: true,
-    ignore: [
-      `${defaults2.apiDir}/index.ts`,
-      `${defaults2.pagesDir}/index.ts{x,}`
-    ]
-  });
+  const routeFiles = await scanRoutes({ appRoot, sourceFolder });
   return {
     resolvers: resolversFactory(routeFiles),
-    resolversFactory,
-    resolveRouteFile
+    resolversFactory
   };
 };
 
@@ -931,14 +998,14 @@ var base_plugin_default = (apiurl, pluginOptions) => {
       }
       if (store.config.command === "build") {
         const { resolvers } = await routes_default(store.resolvedOptions);
-        const resolvedRoutes = [];
+        const resolvedEntries = [];
         {
           const spinner = spinnerFactory("Resolving Routes");
           for (const { name, handler } of resolvers.values()) {
             spinner.append(
-              `[ ${resolvedRoutes.length + 1} of ${resolvers.size} ] ${name}`
+              `[ ${resolvedEntries.length + 1} of ${resolvers.size} ] ${name}`
             );
-            resolvedRoutes.push(await handler());
+            resolvedEntries.push(await handler());
           }
           spinner.succeed();
         }
@@ -947,7 +1014,7 @@ var base_plugin_default = (apiurl, pluginOptions) => {
           for (const { name, factory } of store.resolvedOptions.generators) {
             spinner.append(name);
             const { watchHandler } = await factory(store.resolvedOptions);
-            await watchHandler(resolvedRoutes);
+            await watchHandler(resolvedEntries);
           }
           spinner.succeed();
         }