node-cnb 1.0.0

package/.ide/Dockerfile

@@ -0,0 +1,20 @@
+# .ide/Dockerfile
+FROM node:20
+
+# 以及按需安装其他软件
+RUN apt-get update && apt-get install -y git
+
+# 安装 code-server 和 vscode 常用插件
+RUN curl -fsSL https://code-server.dev/install.sh | sh \
+  && code-server --install-extension redhat.vscode-yaml \
+  && code-server --install-extension dbaeumer.vscode-eslint \
+  && code-server --install-extension eamodio.gitlens \
+  && code-server --install-extension tencent-cloud.coding-copilot \
+  && echo done
+
+# 安装 ssh 服务，用于支持 VSCode 客户端通过 Remote-SSH 访问开发环境
+RUN apt-get update && apt-get install -y wget unzip openssh-server
+
+# 指定字符集支持命令行输入中文（根据需要选择字符集）
+ENV LANG C.UTF-8
+ENV LANGUAGE C.UTF-8

package/README.md

@@ -0,0 +1,57 @@
+node-cnb 是一个用于访问 [CNB API]((https://api.cnb.cool/)) 的 node 编写的 SDK。
+
+# 实现原理
+
+cnb 会编译出 open api 的 swagger json，并生成 api 页面。
+
+该 sdk 依据 swagger json 编译生成对应的 typescript 代码。
+
+sdk 内部采用 ES6 新增的语法 Proxy ，在方法调用时按属性路径获取对应的 api 声明，
+组装 api url 和 参数，用 axios 发起 http(s) 请求调用服务端 api。
+
+# 安装
+
+`npm install node-cnb`
+
+# 使用
+
+```typescript
+import { getClient  } from "node-cnb";
+
+const client = getClient('https://api.cnb.cool', 'xxx');
+
+client.users.pinnedRepos.list({
+  username: 'xxx'
+}).then((res) => {
+  console.log(res);
+})
+
+```
+
+```javascript
+const sdk = require('node-cnb');
+
+const client = sdk.getClient('https://api.cnb.cool', 'xxx');
+
+client.users.pinnedRepos.list({
+  username: 'xxx'
+}).then((res) => {
+  console.log(res);
+})
+```
+
+# 方法路径
+
+方法路径为由如下几个元素组成： 
+
+1. 第一个 `/-/` 前的参数名
+2. 其他非参数名
+3. http method（若 method 为 get 且返回结果为数组则为 list）
+
+例如：
+
+`/{repo}/-/git/branches` 的路径下 get 请求的方法名为 `repo.git.branches.list`
+
+`'/{repo}/-/git/branches/{branch}'` 的路径下 get 请求方法名为 `repo.git.branches.get`
+
+对于此规则下方法路径仍然重复的 api，则单独定义在 [pathMethodMap.json](./pathMethodMap.json)

package/build.js

@@ -0,0 +1,148 @@
+const fs = require('fs');
+const cp = require('child_process');
+const _ = require('lodash');
+const apiSwagger = require('./openapi_swagger.json');
+const { definitions } = apiSwagger;
+const pathMethodNameMap = require('./pathMethodMap.json');
+
+const pathMethodsMap = {}
+
+const buildPathMethods = () => {
+    Object.keys(apiSwagger.paths).forEach(path => {
+        const pathValue = apiSwagger.paths[path];
+        Object.keys(pathValue).forEach(method => {
+            const methodValue = pathValue[method];
+            methodValue.path = path;
+            methodValue.method = method;
+
+            const pathMethod = method === 'get' && methodValue.responses['200']?.schema?.type === 'array' ? 'list' : method;
+            const methodPath = pathMethodNameMap[path] ? pathMethodNameMap[path] : [...path.replace(/\/\{([^\}]+)\}\/-\//g, '/$1/').replace(/\/\{[^\}]+\}/g, '/').split('/').map(item => _.camelCase(item)).filter(Boolean), pathMethod].join('.');
+            const methodValues = pathMethodsMap[methodPath] || []
+            methodValues.push(methodValue)
+            pathMethodsMap[methodPath] = methodValues;
+            if (methodValues.length > 1) {
+                console.log('重复的path', methodPath, methodValues.map(item => item.path))
+            }
+        })
+    })
+
+    fs.writeFileSync('./src/paths.json', JSON.stringify(pathMethodsMap, null, 2));
+}
+
+const convertTypeName = (type) => {
+    let typeName = _.camelCase(type.split('.').join('-'));
+    typeName = typeName.charAt(0).toUpperCase() + typeName.slice(1);
+    return typeName;
+}
+
+const typeMap = {
+    'integer': 'number',
+}
+
+function convertSchemaToType(schema) {
+    if (schema.type === 'object') {
+        let properties = '';
+        if (!schema.properties) {
+            return 'any'
+        }
+        for (const [key, value] of Object.entries(schema.properties)) {
+            const typeName = key.includes('-')?`'${key}'`: key;
+            if(typeName !== key){
+                console.log('typeName',key,typeName)
+            }
+            
+            if (value.description) {
+                properties += `\n  /**${value.description}*/\n`
+            }
+            properties += `  ${typeName}: ${convertSchemaToType(value)};\n`;
+        }
+
+        return `{\n${properties}}`;
+    } else if (schema.type === 'array') {
+        return `${convertSchemaToType(schema.items)}[]`;
+    } else if (schema['$ref']) {
+        return convertTypeName(schema['$ref'].replace('#/definitions/', ''))
+    } else {
+        return typeMap[schema.type] || schema.type || 'any';
+    }
+}
+
+const buildDefinitions = () => {
+    function convertDefinitionsToTypes(definitions) {
+        let types = '';
+
+        for (const [key, value] of Object.entries(definitions)) {
+
+            const convetValue = convertSchemaToType(value);
+            if (!convetValue) {
+                continue;
+            }
+            types += `export type ${convertTypeName(key)} = ${convetValue};\n\n`;
+        }
+
+        return types;
+    }
+
+    // 提取 definitions 并转换为类型声明
+    const types = convertDefinitionsToTypes(definitions);
+
+    // 将类型声明写入 TypeScript 文件
+    fs.writeFileSync('./src/types.d.ts', types, 'utf8');
+}
+const importTypes = [];
+const buildClientInterface = () => {
+    const pathTree = {};
+    Object.keys(pathMethodsMap).forEach(methodPath => {
+        let currentSub = pathTree;
+        const methodList = methodPath.split('.');
+        methodList.forEach((method) => {
+            currentSub[method] = currentSub[method] || {};
+            currentSub = currentSub[method];
+        })
+    });
+    
+    const getMethodContent = (tree, path) => {
+        let content = '';
+        Object.keys(tree).forEach(method => {
+            content += `
+${_.camelCase(method)}: ${getMethodContent(tree[method], [path, method].filter(Boolean).join('.'))}
+            `;
+        })
+        if(!content){
+            const methodValue = pathMethodsMap[path]?.[0]||{};
+            const resultType = convertSchemaToType(methodValue.responses?.['200']?.schema || {});
+            importTypes.push(resultType.replace('[]',''))
+            
+            content = `(params: {${(methodValue.parameters||[]).map(param=>{
+
+                    return  param.name + (param.required?'':'?') + ': '+convertSchemaToType(param)
+})}}) => Promise<${resultType}>`
+        }else {
+            content = `{
+                ${content}
+            }`
+        }
+        return content;
+    }
+    
+    let interfaceContent = `
+export interface Client ${getMethodContent(pathTree, '')}
+    `;
+    const distinctImportTypes = _.uniq(importTypes.filter(item => !/^[a-z]+$/.test(item))).join(', ');
+    interfaceContent = `import {${distinctImportTypes}} from './types';
+${interfaceContent}`
+    fs.writeFileSync('./src/client.d.ts', interfaceContent, 'utf8');
+
+}
+
+const prettier = ()=>{
+    cp.execSync('npx prettier --write ./src/*.ts');
+}
+
+buildPathMethods();
+
+buildDefinitions();
+
+buildClientInterface();
+
+prettier();