@kosmojs/dev 0.0.0

package/package.json

@@ -0,0 +1,57 @@
+{
+  "type": "module",
+  "name": "@kosmojs/dev",
+  "version": "0.0.0",
+  "cacheVersion": "001",
+  "author": "Slee Woo",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "pkg/*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./pkg/src/index.d.ts",
+      "default": "./pkg/index.js"
+    },
+    "./routes": {
+      "types": "./pkg/src/base-plugin/routes.d.ts",
+      "default": "./pkg/base-plugin/routes.js"
+    },
+    "./stub-generator": {
+      "types": "./pkg/src/stub-generator/index.d.ts",
+      "default": "./pkg/stub-generator/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "crc": "^4.3.2",
+    "dotenv": "^17.2.3",
+    "esbuild": "^0.25.12",
+    "fs-extra": "^11.3.2",
+    "ora": "^9.0.0",
+    "picomatch": "^4.0.3",
+    "tfusion": "^0.0.23",
+    "tinyglobby": "^0.2.15",
+    "ts-morph": "^27.0.2",
+    "typescript": "^5.9.3",
+    "@kosmojs/api": "^0.0.0",
+    "@kosmojs/api-generator": "^0.0.0",
+    "@kosmojs/config": "^0.0.0",
+    "@kosmojs/devlib": "^0.0.0",
+    "@kosmojs/fetch-generator": "^0.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/koa": "^3.0.1",
+    "@types/picomatch": "^4.0.2",
+    "vite": "^7.2.2"
+  },
+  "scripts": {
+    "build": "esbuilder src/index.ts src/base-plugin/routes.ts src/base-plugin/worker.ts src/stub-generator/index.ts",
+    "test": "vitest --root ../../.. --project core/dev"
+  }
+}

package/pkg/base-plugin/routes.js

@@ -0,0 +1,618 @@
+// src/base-plugin/routes.ts
+import { dirname, join, resolve as resolve3 } from "node:path";
+import crc3 from "crc/crc32";
+import picomatch from "picomatch";
+import { glob } from "tinyglobby";
+import {
+  defaults,
+  pathResolver as pathResolver2,
+  pathTokensFactory,
+  render,
+  renderToFile
+} from "@kosmojs/devlib";
+
+// src/base-plugin/ast.ts
+import { resolve } from "node:path";
+import crc from "crc/crc32";
+import { flattener } from "tfusion";
+import {
+  Project,
+  SyntaxKind
+} from "ts-morph";
+import { HTTPMethods } from "@kosmojs/api";
+var createProject = (opts) => new Project(opts);
+var resolveRouteSignature = async (route, opts) => {
+  const {
+    sourceFile = createProject().addSourceFileAtPath(route.fileFullpath)
+  } = { ...opts };
+  const [typeDeclarations, referencedFiles] = extractTypeDeclarations(
+    sourceFile,
+    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] : [];
+  });
+  return {
+    typeDeclarations,
+    paramsRefinements,
+    methods: methods.map((e) => e.method),
+    payloadTypes,
+    responseTypes,
+    referencedFiles
+  };
+};
+var extractDefaultExport = (sourceFile) => {
+  const [defaultExport] = sourceFile.getExportAssignments().flatMap((exportAssignment) => {
+    if (exportAssignment.isExportEquals()) {
+      return [];
+    }
+    const callExpression = exportAssignment.getExpression();
+    return callExpression.isKind(SyntaxKind.CallExpression) ? [callExpression] : [];
+  });
+  return defaultExport;
+};
+var extractParamsRefinements = (callExpression) => {
+  const [firstGeneric] = extractGenerics(callExpression);
+  if (!firstGeneric?.node.isKind(SyntaxKind.TupleType)) {
+    return;
+  }
+  const tupleElements = firstGeneric.node.getElements();
+  if (!tupleElements?.length) {
+    return;
+  }
+  return tupleElements.map((node, index) => {
+    return {
+      index,
+      text: node.getText()
+    };
+  });
+};
+var extractRouteMethods = (callExpression, route) => {
+  const funcDeclaration = callExpression.getFirstChildByKind(SyntaxKind.ArrowFunction) || callExpression.getFirstChildByKind(SyntaxKind.FunctionExpression);
+  if (!funcDeclaration) {
+    return [];
+  }
+  const arrayLiteralExpression = funcDeclaration.getFirstChildByKind(
+    SyntaxKind.ArrayLiteralExpression
+  );
+  if (!arrayLiteralExpression) {
+    return [];
+  }
+  const callExpressions = [];
+  for (const e of arrayLiteralExpression.getChildrenOfKind(
+    SyntaxKind.CallExpression
+  )) {
+    const name = e.getExpression().getText();
+    if (HTTPMethods[name]) {
+      callExpressions.push([e, name]);
+    }
+  }
+  const methods = [];
+  const skipValidationFilter = (e) => /@skip-validation/.test(e);
+  for (const [callExpression2, method] of callExpressions) {
+    const [payloadGeneric, responseGeneric] = extractGenerics(callExpression2);
+    const payloadText = payloadGeneric?.node ? payloadGeneric.node.getChildren().length === 0 ? "{}" : payloadGeneric.node.getFullText() : void 0;
+    const responseText = responseGeneric?.node.getText();
+    const responseType = responseText ? {
+      id: ["ResponseT", crc(route.importName + method)].join(""),
+      method,
+      skipValidation: responseGeneric?.comments ? responseGeneric.comments.some(skipValidationFilter) : false,
+      text: ["never", "object"].includes(responseText) ? "{}" : responseText,
+      resolvedType: void 0
+    } : void 0;
+    const payloadType = payloadText ? {
+      id: ["PayloadT", crc(route.importName + method)].join(""),
+      responseTypeId: responseType?.id,
+      method,
+      skipValidation: payloadGeneric?.comments ? payloadGeneric.comments.some(skipValidationFilter) : false,
+      isOptional: payloadText ? payloadText === "{}" || route.optionalParams : true,
+      text: payloadText,
+      resolvedType: void 0
+    } : void 0;
+    methods.push({
+      method,
+      payloadType,
+      responseType
+    });
+  }
+  return methods;
+};
+var extractTypeDeclarations = (sourceFile, opts) => {
+  const declarations = [];
+  const referencedFiles = opts?.withReferencedFiles ? [] : void 0;
+  for (const declaration of sourceFile.getImportDeclarations()) {
+    const modulePath = declaration.getModuleSpecifierValue();
+    const path = /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath;
+    const typeOnlyDeclaration = declaration.isTypeOnly();
+    const defaultImport = typeOnlyDeclaration ? declaration.getDefaultImport() : void 0;
+    if (defaultImport) {
+      const name = defaultImport.getText();
+      const text = `import type ${name} from "${path}";`;
+      declarations.push({
+        importDeclaration: {
+          name,
+          path
+        },
+        text
+      });
+      if (referencedFiles) {
+        referencedFiles.push(...getReferencedFiles(defaultImport));
+      }
+    }
+    for (const namedImport of declaration.getNamedImports()) {
+      if (namedImport.isTypeOnly() || typeOnlyDeclaration) {
+        const nameNode = namedImport.getNameNode();
+        const name = nameNode.getText();
+        const alias = namedImport.getAliasNode()?.getText();
+        const nameText = alias ? `${name} as ${alias}` : name;
+        declarations.push({
+          importDeclaration: {
+            name,
+            alias,
+            path
+          },
+          text: `import type { ${nameText} } from "${path}";`
+        });
+        if (referencedFiles) {
+          if (nameNode.isKind(SyntaxKind.Identifier)) {
+            referencedFiles.push(...getReferencedFiles(nameNode));
+          }
+        }
+      }
+    }
+  }
+  for (const declaration of sourceFile.getTypeAliases()) {
+    const name = declaration.getName();
+    const text = declaration.getFullText().trim();
+    declarations.push({
+      typeAliasDeclaration: { name },
+      text
+    });
+  }
+  for (const declaration of sourceFile.getInterfaces()) {
+    const name = declaration.getName();
+    const text = declaration.getFullText().trim();
+    declarations.push({
+      interfaceDeclaration: { name },
+      text
+    });
+  }
+  for (const declaration of sourceFile.getEnums()) {
+    const name = declaration.getName();
+    const text = declaration.getFullText().trim();
+    declarations.push({
+      enumDeclaration: { name },
+      text
+    });
+  }
+  for (const declaration of sourceFile.getExportDeclarations()) {
+    const typeOnlyDeclaration = declaration.isTypeOnly();
+    const modulePath = declaration.getModuleSpecifierValue();
+    const path = modulePath ? /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath : void 0;
+    for (const namedExport of declaration.getNamedExports()) {
+      if (namedExport.isTypeOnly() || typeOnlyDeclaration) {
+        const nameNode = namedExport.getNameNode();
+        const name = nameNode.getText();
+        const alias = namedExport.getAliasNode()?.getText();
+        const nameText = alias ? `${name} as ${alias}` : name;
+        declarations.push({
+          exportDeclaration: {
+            name,
+            alias: alias ?? name,
+            path
+          },
+          text: path ? `export type { ${nameText} } from "${path}";` : `export type { ${nameText} };`
+        });
+        if (referencedFiles) {
+          if (nameNode.isKind(SyntaxKind.Identifier)) {
+            referencedFiles.push(...getReferencedFiles(nameNode));
+          }
+        }
+      }
+    }
+  }
+  return referencedFiles ? [declarations, [...new Set(referencedFiles)]] : [declarations];
+};
+var getReferencedFiles = (importIdentifier) => {
+  const declarations = importIdentifier?.getSymbol()?.getAliasedSymbol()?.getDeclarations() || [];
+  return declarations.flatMap((e) => {
+    const sourceFile = e.getSourceFile();
+    return sourceFile ? [sourceFile.getFilePath()] : [];
+  });
+};
+var extractGenerics = (callExpression) => {
+  return callExpression.getTypeArguments().map((node) => {
+    return {
+      node,
+      comments: node.getLeadingCommentRanges().map((range) => range.getText().trim())
+    };
+  });
+};
+var typeResolverFactory = ({ appRoot }) => {
+  const project = createProject({
+    tsConfigFilePath: resolve(appRoot, "tsconfig.json"),
+    skipAddingFilesFromTsConfig: true
+  });
+  const literalTypesResolver = (literalTypes, options) => {
+    const sourceFile = project.createSourceFile(
+      `${crc(literalTypes)}-${Date.now()}.ts`,
+      literalTypes,
+      { overwrite: true }
+    );
+    const resolvedTypes = flattener(project, sourceFile, {
+      ...options,
+      stripComments: true
+    });
+    project.removeSourceFile(sourceFile);
+    return resolvedTypes;
+  };
+  return {
+    getSourceFile: (fileFullpath) => {
+      return project.getSourceFile(fileFullpath) || project.addSourceFileAtPath(fileFullpath);
+    },
+    refreshSourceFile: async (fileFullpath) => {
+      const sourceFile = project.getSourceFile(fileFullpath);
+      if (sourceFile) {
+        await sourceFile.refreshFromFileSystem();
+      }
+    },
+    literalTypesResolver
+  };
+};
+
+// src/base-plugin/cache.ts
+import { resolve as resolve2 } from "node:path";
+import crc2 from "crc/crc32";
+import fsx from "fs-extra";
+import pkg from "@kosmojs/dev/package.json" with { type: "json" };
+import { pathResolver } from "@kosmojs/devlib";
+var cacheFactory = (route, {
+  appRoot,
+  sourceFolder,
+  extraContext
+}) => {
+  const cacheFile = pathResolver({
+    appRoot,
+    sourceFolder
+  }).resolve("apiLibDir", route.importPath, "cache.json");
+  const getCache = async (opt) => {
+    if (await fsx.exists(cacheFile)) {
+      try {
+        const cache = JSON.parse(await fsx.readFile(cacheFile, "utf8"));
+        return opt?.validate ? validateCache(cache) : cache;
+      } catch (_e) {
+      }
+    }
+    return void 0;
+  };
+  const persistCache = async ({
+    referencedFiles: _referencedFiles,
+    ...rest
+  }) => {
+    const hash = await generateFileHash(route.fileFullpath, {
+      ...extraContext
+    });
+    const referencedFiles = {};
+    for (const file of _referencedFiles) {
+      referencedFiles[
+        // Strip project root to ensure cached paths are relative
+        // and portable across environments (CI, local, etc.)
+        file.replace(`${appRoot}/`, "")
+      ] = await generateFileHash(file);
+    }
+    const cache = { ...rest, hash, referencedFiles };
+    await fsx.outputJson(cacheFile, cache, { spaces: 2 });
+    return cache;
+  };
+  const validateCache = async (cache) => {
+    if (!cache?.hash) {
+      return;
+    }
+    if (!cache.typeDeclarations || !cache.referencedFiles) {
+      return;
+    }
+    const hash = await generateFileHash(route.fileFullpath, {
+      ...extraContext
+    });
+    if (!identicalHashSum(cache.hash, hash)) {
+      return;
+    }
+    for (const [file, hash2] of Object.entries(cache.referencedFiles)) {
+      if (!identicalHashSum(hash2, await generateFileHash(resolve2(appRoot, file)))) {
+        return;
+      }
+    }
+    return cache;
+  };
+  return {
+    getCache,
+    validateCache,
+    persistCache
+  };
+};
+var generateFileHash = async (file, extraContext) => {
+  let fileContent;
+  try {
+    fileContent = await fsx.readFile(file, "utf8");
+  } catch (_e) {
+    return 0;
+  }
+  return fileContent ? crc2(
+    JSON.stringify({
+      ...extraContext,
+      [pkg.cacheVersion]: fileContent
+    })
+  ) : 0;
+};
+var identicalHashSum = (a, b) => {
+  return a === b;
+};
+
+// src/base-plugin/templates/resolved-types.hbs
+var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
+
+// src/base-plugin/templates/types.hbs
+var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}:{{#if isRest}} Array<{{/if}}\n    {{#if refinement}}{{refinement.text}}{{else}}string{{/if}}\n  {{#if isRest}}>{{/if}}\n  {{/each}}\n};\n\n{{#each payloadTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n\n{{#each responseTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n';
+
+// src/base-plugin/routes.ts
+var routes_default = async (pluginOptions) => {
+  const {
+    appRoot,
+    sourceFolder,
+    generators = [],
+    formatters = [],
+    refineTypeName
+  } = pluginOptions;
+  let resolveTypes = false;
+  for (const { options } of generators) {
+    if (options?.resolveTypes) {
+      resolveTypes = true;
+    }
+  }
+  const {
+    //
+    literalTypesResolver,
+    getSourceFile,
+    refreshSourceFile
+  } = typeResolverFactory(pluginOptions);
+  const routeFilePatterns = [
+    `${defaults.apiDir}/**/index.ts`,
+    `${defaults.pagesDir}/**/index.{ts,tsx,vue,svelte}`
+  ];
+  const resolveRouteFile = (file) => {
+    const [_sourceFolder, folder, ...rest] = resolve3(appRoot, file).replace(`${appRoot}/`, "").split("/");
+    if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
+      return;
+    }
+    return picomatch.isMatch(join(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 = join(appRoot, sourceFolder, folder, file);
+      const pathTokens = pathTokensFactory(dirname(file));
+      const name = pathTokens.map((e) => e.orig).join("/");
+      const importPath = dirname(file);
+      const importName = [
+        importPath.split(/\[/)[0].replace(/^\W+|\W+$/g, "").replace(/\W+/g, "_"),
+        crc3(importPath)
+      ].join("_");
+      return [
+        {
+          name,
+          folder,
+          file,
+          fileFullpath,
+          pathTokens,
+          importPath,
+          importName
+        }
+      ];
+    });
+    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 },
+          {
+            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 },
+            {
+              withReferencedFiles: true,
+              sourceFile: getSourceFile(fileFullpath),
+              relpathResolver(path) {
+                return join(sourceFolder, defaults.apiDir, dirname(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
+        };
+      };
+      resolvers.set(fileFullpath, { name, handler });
+    }
+    for (const entry of entries.filter((e) => e.folder === defaults.pagesDir)) {
+      const {
+        //
+        name,
+        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
+        };
+      };
+      resolvers.set(fileFullpath, { name, handler });
+    }
+    return resolvers;
+  };
+  const routeFiles = await glob(routeFilePatterns, {
+    cwd: resolve3(appRoot, sourceFolder),
+    absolute: true,
+    onlyFiles: true,
+    ignore: [
+      `${defaults.apiDir}/index.ts`,
+      `${defaults.pagesDir}/index.ts{x,}`
+    ]
+  });
+  return {
+    resolvers: resolversFactory(routeFiles),
+    resolversFactory,
+    resolveRouteFile
+  };
+};
+export {
+  routes_default as default
+};
+//# sourceMappingURL=routes.js.map