fix: 重新打包时无法生成.d.ts

Author: geekact

.gitignore

@@ -2,6 +2,7 @@ node_modules/
 .idea/
 TODO
 dist/
+backup/
 .npmrc
 coverage/
 .DS_Store

package.json

@@ -7,7 +7,7 @@
     "generate": "aomex openapi-yaml && aomex openapi-json",
     "build": "tsup",
     "prepare": "husky",
-    "prepublishOnly": "tsup",
+    "prepublishOnly": "pnpm build",
     "deploy:main": "sh scripts/develop-deploy-main.sh",
     "sync:main": "sh scripts/develop-sync-main.sh"
   },
@@ -37,7 +37,7 @@
     "access": "public"
   },
   "files": [
-    "src",
+    "backup",
     "adapters",
     "dist",
     "LICENSE",
@@ -62,9 +62,9 @@
     "lodash-es": "^4.17.21",
     "object-to-formdata": "^4.5.1",
     "openapi-types": "^12.1.3",
+    "prettier": "^3.2.5",
     "qs": "^6.12.3",
-    "tsup": "^8.1.0",
-    "tsx": "^4.15.6",
+    "tsx": "^4.16.2",
     "yaml": "^2.4.5"
   },
   "devDependencies": {
@@ -83,9 +83,8 @@
     "axios": "^1.7.2",
     "husky": "^9.0.11",
     "only-allow": "^1.2.1",
-    "prettier": "^3.2.5",
     "release-it": "^17.6.0",
-    "tsx": "^4.16.2",
+    "tsup": "^8.1.0",
     "typescript": "^5.5.3",
     "vitest": "^2.0.3"
   }

pnpm-lock.yaml

@@ -17,7 +17,7 @@ const sleep = () => new Promise((resolve) => setTimeout(resolve, 300));
 const spinner = new Listr<{
   configs: OpenapiClientConfig[];
   docs: OpenAPIV3.Document[];
-  projects: Record<string, string>;
+  projects: Record<string, { dts: string; js: string }>;
 }>([]);
 
 spinner.add({
@@ -71,12 +71,15 @@ spinner.add({
   task: async (ctx) => {
     ctx.projects = {};
 
-    ctx.configs.forEach((config, i) => {
-      ctx.projects = {
-        ...ctx.projects,
-        ...generateTemplate(ctx.docs[i]!, config.projectName),
-      };
-    });
+    await Promise.all(
+      ctx.configs.map(async (config, i) => {
+        const result = await generateTemplate(ctx.docs[i]!, config.projectName);
+        ctx.projects = {
+          ...ctx.projects,
+          ...result,
+        };
+      }),
+    );
 
     await sleep();
   },
@@ -85,9 +88,14 @@ spinner.add({
 spinner.add({
   title: '写入@aomex/openapi-client',
   task: async (ctx) => {
-    const dist = path.dirname(fileURLToPath(import.meta.url));
-    const content = Object.values(ctx.projects).join('\n');
-    await rebuildDist(dist, content);
+    const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    const jsContent = Object.values(ctx.projects)
+      .map(({ js }) => js)
+      .join('\n');
+    const dtsContent = Object.values(ctx.projects)
+      .map(({ dts }) => dts)
+      .join('\n');
+    await rebuildDist(root, jsContent, dtsContent, Object.keys(ctx.projects));
   },
 });
 

src/bin.ts

@@ -1,4 +1,3 @@
 export * from './lib/adapter';
 export * from './base-openapi-client';
-export * from './openapi-runtime';
 export * from './define-config';

src/index.ts

@@ -2,26 +2,36 @@ import type { OpenAPIV3 } from 'openapi-types';
 import { upperFirst, camelCase } from 'lodash-es';
 import { documentToMeta, type Metas } from './document-to-meta';
 import { methods } from './adapter';
+import prettier from 'prettier';
 
-export const generateTemplate = (docs: OpenAPIV3.Document, projectName: string = '') => {
-  projectName = upperFirst(camelCase(projectName));
-  const className = `OpenapiClient${projectName}`;
+export const generateTemplate = async (
+  docs: OpenAPIV3.Document,
+  projectName: string = '',
+) => {
+  const className = `OpenapiClient${upperFirst(camelCase(projectName))}`;
   const metas = documentToMeta(docs);
-  const tpl = `
-    import { BaseOpenapiClient } from './base-openapi-client';
-
+  const dts = `
     ${generateNamespaceTpl(className, metas)}
-    ${generateClassTpl(className, metas)}
-    ${generateContentTypeTpl(metas)}
+    ${generateClassForDTS(className, metas)}
     ${generatePathRelationTpl(className, metas)}
 `;
 
-  return { [projectName]: tpl };
+  const js = `
+  ${generateClassForJS(className)}
+  ${generateContentTypeTpl(className, metas)}
+  `;
+
+  return {
+    [className]: {
+      dts: await prettier.format(dts, { parser: 'typescript' }),
+      js: await prettier.format(js, { parser: 'typescript' }),
+    },
+  };
 };
 
 export const generateNamespaceTpl = (className: string, metas: Metas) => {
   return `
-export namespace ${className} {
+declare namespace ${className} {
   ${methods
     .flatMap((method) => {
       let content = metas[method].flatMap((meta) => {
@@ -30,7 +40,7 @@ export namespace ${className} {
         (<const>['query', 'params']).forEach((key) => {
           const interfaceName = upperFirst(camelCase(meta.key + '_' + key));
           if (meta[key].types.length) {
-            opts.push(`export interface ${interfaceName} ${meta[key].types[0]}\n`);
+            opts.push(`interface ${interfaceName} ${meta[key].types[0]}\n`);
           }
         });
 
@@ -39,8 +49,8 @@ export namespace ${className} {
           if (meta[key].types.length) {
             opts.push(
               meta[key].types.length === 1
-                ? `export interface ${interfaceName} ${meta[key].types}\n`
-                : `export type ${interfaceName} =  ${meta[key].types.join(' | ')}\n`,
+                ? `interface ${interfaceName} ${meta[key].types}\n`
+                : `type ${interfaceName} =  ${meta[key].types.join(' | ')}\n`,
             );
           }
         });
@@ -53,9 +63,9 @@ export namespace ${className} {
 }`;
 };
 
-export const generateClassTpl = (className: string, metas: Metas) => {
+export const generateClassForDTS = (className: string, metas: Metas) => {
   return `
-export class ${className} extends BaseOpenapiClient {
+declare class ${className} extends BaseOpenapiClient {
   ${methods
     .map((method) => {
       if (!metas[method].length) return '';
@@ -78,22 +88,43 @@ export class ${className} extends BaseOpenapiClient {
 
       return `${method}<K extends keyof ${className}_${method}_paths>(
         uri: K, ...rest: ${opts}
-      ): Promise<${className}_${method}_paths[K]['response']> {
-          return this.request(uri, '${method}', rest[0] || {});
-      }`;
+      ): Promise<${className}_${method}_paths[K]['response']>`;
     })
     .join('\n')}
     
-    protected override getContentTypes(uri: string, method: string) {
-      return defaultContentTypes[uri + ' ' + method] || [void 0, void 0];
-    }
+    protected getContentTypes(uri: string, method: string) : [
+      BaseOpenapiClient.UserInputOpts['requestBodyType'],
+      BaseOpenapiClient.UserInputOpts['responseType'],
+    ];
 }
   `;
 };
 
-export const generateContentTypeTpl = (metas: Metas) => {
+export const generateClassForJS = (className: string) => {
+  return `
+var ${className} = class extends BaseOpenapiClient {
+  get(uri, ...rest) {
+    return this.request(uri, "get", rest[0] || {});
+  }
+  post(uri, ...rest) {
+    return this.request(uri, "post", rest[0] || {});
+  }
+  put(uri, ...rest) {
+    return this.request(uri, "put", rest[0] || {});
+  }
+  delete(uri, ...rest) {
+    return this.request(uri, "delete", rest[0] || {});
+  }
+  getContentTypes(uri, method) {
+    return contentTypes${className}[uri + " " + method] || [void 0, void 0];
+  }
+};
+  `;
+};
+
+export const generateContentTypeTpl = (className: string, metas: Metas) => {
   return `
-  const defaultContentTypes: Record<string, [BaseOpenapiClient.UserInputOpts['requestBodyType'], BaseOpenapiClient.UserInputOpts['responseType']]> = {
+  const contentTypes${className} = {
   ${methods
     .map((method) => {
       if (!metas[method].length) return '';

src/lib/generate-template.ts

@@ -1,26 +1,43 @@
-import fs from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import * as tsup from 'tsup';
 
-export const rebuildDist = async (distDir: string, content: string) => {
-  const src = path.normalize(path.join(distDir, '..', 'src'));
-  const packageJson = await fs.readFile(path.join(distDir, '..', 'package.json'), 'utf8');
-  const deps = Object.keys(JSON.parse(packageJson).dependencies);
+export const rebuildDist = async (
+  root: string,
+  jsContent: string,
+  dtsContent: string,
+  classNames: string[],
+) => {
+  const distDir = path.join(root, 'dist');
+  const backupDir = path.join(root, 'backup');
 
-  await fs.writeFile(path.join(src, 'openapi-runtime.ts'), content);
-  await tsup.build({
-    entry: [path.join(src, 'index.ts')],
-    outDir: distDir,
-    splitting: true,
-    sourcemap: true,
-    clean: false,
-    format: ['cjs', 'esm'],
-    platform: 'node',
-    target: 'es2020',
-    shims: false,
-    dts: true,
-    legacyOutput: true,
-    silent: true,
-    external: deps,
-  });
+  {
+    let backupDTS = await readFile(path.join(backupDir, 'index.d.ts'), 'utf8');
+    backupDTS = backupDTS.replace(
+      `export {`,
+      `${dtsContent}\nexport {${classNames.join(',')},`,
+    );
+    await writeFile(path.join(distDir, 'index.d.ts'), backupDTS);
+  }
+
+  {
+    let backupCJS = await readFile(path.join(backupDir, 'index.js'), 'utf8');
+    backupCJS = backupCJS.replace(
+      '0 && (module.exports = {',
+      `${jsContent}\n0 && (module.exports = {\n${classNames.join(',')},`,
+    );
+    backupCJS = backupCJS.replace(
+      /(__export\(.+?_exports, {)/,
+      `$1\n${classNames.map((className) => `${className}: () => ${className},`)}`,
+    );
+    await writeFile(path.join(distDir, 'index.js'), backupCJS);
+  }
+
+  {
+    let backupESM = await readFile(path.join(backupDir, 'esm', 'index.js'), 'utf8');
+    backupESM = backupESM.replace(
+      'export {',
+      `${jsContent}\nexport {\n${classNames.join(',')},`,
+    );
+    await writeFile(path.join(distDir, 'esm', 'index.js'), backupESM);
+  }
 };