@kosmojs/dev 0.0.8 → 0.0.10

package/pkg/base-plugin/routes.js

@@ -1,4 +1,9 @@
 // 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";
@@ -280,7 +285,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 {
@@ -361,22 +366,70 @@ 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 API_INDEX_PATTERN = "index.ts";
-var PAGE_INDEX_PATTERN = "index.{tsx,vue}";
+// src/base-plugin/routes/resolve.ts
+var API_INDEX_BASENAME = "index";
+var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
+var API_USE_BASENAME = "use";
+var API_USE_PATTERN = `${API_USE_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}`,
-  `${defaults.pagesDir}/**/${PAGE_INDEX_PATTERN}`
+  // match use files in api dir
+  `${defaults.apiDir}/**/${API_USE_PATTERN}`,
+  // match index files in pages dir
+  `${defaults.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
+  // match layout files in pages dir
+  `${defaults.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
 ];
-var resolveRouteFile = (file, { appRoot, sourceFolder }) => {
+var scanRoutes = async ({
+  appRoot,
+  sourceFolder
+}) => {
+  return glob(ROUTE_FILE_PATTERNS, {
+    cwd: resolve3(appRoot, sourceFolder),
+    absolute: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: [
+      // ignore top-level matches, routes resides in folders, even index route
+      `${defaults.apiDir}/${API_INDEX_PATTERN}`,
+      `${defaults.apiDir}/${API_USE_PATTERN}`,
+      `${defaults.pagesDir}/${PAGE_INDEX_PATTERN}`,
+      `${defaults.pagesDir}/${PAGE_LAYOUT_PATTERN}`
+    ]
+  });
+};
+var isRouteFile = (file, {
+  appRoot,
+  sourceFolder
+}) => {
   const [_sourceFolder, folder, ...rest] = resolve3(appRoot, file).replace(`${appRoot}/`, "").split("/");
   if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
     return;
   }
   return picomatch.isMatch(join(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : void 0;
 };
-var resolveRouteEntry = (_file, { appRoot, sourceFolder }) => {
-  const resolvedPaths = resolveRouteFile(_file, { appRoot, sourceFolder });
+var isApiRoute = (file) => {
+  return picomatch.matchBase(file, `**/${API_INDEX_PATTERN}`);
+};
+var isApiUse = (file) => {
+  return picomatch.matchBase(file, `**/${API_USE_PATTERN}`);
+};
+var isPageRoute = (file) => {
+  return picomatch.matchBase(file, `**/${PAGE_INDEX_PATTERN}`);
+};
+var isPageLayout = (file) => {
+  return picomatch.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`);
+};
+var createRouteEntry = (_file, {
+  appRoot,
+  sourceFolder
+}) => {
+  const resolvedPaths = isRouteFile(_file, { appRoot, sourceFolder });
   if (!resolvedPaths) {
     return;
   }
@@ -384,22 +437,75 @@ var resolveRouteEntry = (_file, { appRoot, sourceFolder }) => {
   const fileFullpath = join(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("_");
+  const importFile = file;
+  const importName = `${importFile.replace(/\W+/g, "_")}_${crc3(importFile)}`;
   return {
     name,
     folder,
     file,
     fileFullpath,
     pathTokens,
-    importPath,
+    importFile,
     importName
   };
 };
-var routes_default = async (pluginOptions) => {
+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 apiUseResolverFactory = () => {
+  return (entry) => {
+    const { name } = entry;
+    const handler = async () => {
+      return {
+        kind: "apiUse",
+        entry
+      };
+    };
+    return { name, handler };
+  };
+};
+var apiRouteResolverFactory = (pluginOptions) => {
   const {
     appRoot,
     sourceFolder,
@@ -419,206 +525,295 @@ var routes_default = async (pluginOptions) => {
     getSourceFile,
     refreshSourceFile
   } = typeResolverFactory(pluginOptions);
-  const resolversFactory = (routeFiles2) => {
-    const resolvers = /* @__PURE__ */ new Map();
-    const entries = routeFiles2.flatMap((file) => {
-      const entry = resolveRouteEntry(file, pluginOptions);
-      return entry ? [entry] : [];
-    });
-    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 },
+  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 },
+        {
+          appRoot,
+          sourceFolder,
+          extraContext: { resolveTypes }
+        }
+      );
+      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 join(sourceFolder, 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(sourceFolder, 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, 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) => resolve3(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 === 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
+        }) : 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(appRoot, e)
+        )
       };
-      resolvers.set(fileFullpath, { name, handler });
+      return {
+        kind: "apiRoute",
+        entry: entry2
+      };
+    };
+    return { name, handler };
+  };
+};
+
+// src/base-plugin/routes/nesting.ts
+import { basename } from "node:path";
+import {
+  sortRoutes
+} from "@kosmojs/devlib";
+var nestedRoutesFactory = (routeEntries) => {
+  const entryStack = structuredClone(routeEntries).sort(sortRoutes);
+  const transformEntries = (entries, parent) => {
+    return [...new Set(entries.map((e) => e.name))].flatMap((name) => {
+      const nameEntries = entryStack.flatMap(({ fileFullpath, ...entry }) => {
+        return entry.name === name ? [entry] : [];
+      });
+      const index = nameEntries.find(
+        (e) => basename(e.file).startsWith(PAGE_INDEX_BASENAME)
+      );
+      const layout = nameEntries.find(
+        (e) => basename(e.file).startsWith(PAGE_LAYOUT_BASENAME)
+      );
+      if (index || layout) {
+        return [
+          {
+            index: index ? {
+              ...index,
+              pathTokens: index.pathTokens.slice(
+                parent?.pathTokens.length || 0
+              )
+            } : void 0,
+            layout: layout ? {
+              ...layout,
+              pathTokens: layout.pathTokens.slice(
+                parent?.pathTokens.length || 0
+              )
+            } : void 0,
+            parent: parent?.name,
+            children: transformEntries(
+              findDescendantEntries(index || layout),
+              index || layout
+            )
+          }
+        ];
+      }
+      return [];
+    });
+  };
+  const findDescendantEntries = ({
+    name,
+    pathTokens
+  }) => {
+    const potentialChildren = entryStack.filter((entry) => {
+      if (entry.pathTokens.length <= pathTokens.length) {
+        return false;
+      }
+      if (!entry.name.startsWith(`${name}/`)) {
+        return false;
+      }
+      return true;
+    });
+    return potentialChildren.filter((child) => {
+      const hasIntermediateRoute = potentialChildren.some((intermediate) => {
+        if (intermediate === child) {
+          return false;
+        }
+        if (intermediate.pathTokens.length <= pathTokens.length) {
+          return false;
+        }
+        if (intermediate.pathTokens.length >= child.pathTokens.length) {
+          return false;
+        }
+        return child.name.startsWith(`${intermediate.name}/`);
+      });
+      return !hasIntermediateRoute;
+    });
+  };
+  const rootEntries = entryStack.filter((entry) => {
+    const hasParent = entryStack.some((potential) => {
+      if (potential === entry) {
+        return false;
+      }
+      if (potential.pathTokens.length >= entry.pathTokens.length) {
+        return false;
+      }
+      return entry.name.startsWith(`${potential.name}/`);
+    });
+    return !hasParent;
+  });
+  return transformEntries(rootEntries);
+};
+
+// src/base-plugin/routes.ts
+var routes_default = async (pluginOptions) => {
+  const { appRoot, sourceFolder } = pluginOptions;
+  const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
+  const apiUseResolver = apiUseResolverFactory(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 === defaults2.apiDir) {
+        if (isApiRoute(entry.file)) {
+          resolvers.set(entry.fileFullpath, apiRouteResolver(entry));
+        } else if (isApiUse(entry.file)) {
+          resolvers.set(entry.fileFullpath, apiUseResolver(entry));
+        }
+      } else if (entry.folder === defaults2.pagesDir) {
+        if (isPageRoute(entry.file)) {
+          resolvers.set(entry.fileFullpath, pageRouteResolver(entry));
+        } else if (isPageLayout(entry.file)) {
+          resolvers.set(entry.fileFullpath, pageLayoutResolver(entry));
+        }
+      }
     }
     return resolvers;
   };
-  const routeFiles = await glob(ROUTE_FILE_PATTERNS, {
-    cwd: resolve3(appRoot, sourceFolder),
-    absolute: true,
-    onlyFiles: true,
-    ignore: [
-      `${defaults.apiDir}/${API_INDEX_PATTERN}`,
-      `${defaults.pagesDir}/${PAGE_INDEX_PATTERN}`
-    ]
-  });
+  const routeFiles = await scanRoutes({ appRoot, sourceFolder });
   return {
     resolvers: resolversFactory(routeFiles),
     resolversFactory
   };
 };
 export {
+  API_INDEX_BASENAME,
+  API_INDEX_PATTERN,
+  API_USE_BASENAME,
+  API_USE_PATTERN,
+  PAGE_INDEX_BASENAME,
+  PAGE_INDEX_PATTERN,
+  PAGE_LAYOUT_BASENAME,
+  PAGE_LAYOUT_PATTERN,
+  apiRouteResolverFactory,
+  apiUseResolverFactory,
+  createRouteEntry,
   routes_default as default,
-  resolveRouteEntry,
-  resolveRouteFile
+  isApiRoute,
+  isApiUse,
+  isPageLayout,
+  isPageRoute,
+  isRouteFile,
+  nestedRoutesFactory,
+  pageLayoutResolverFactory,
+  pageRouteResolverFactory,
+  scanRoutes
 };
 //# sourceMappingURL=routes.js.map