@cnbcool/cnb-api-generate 1.0.0

package/built/utils/get-swagger-file.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwaggerFile = getSwaggerFile;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const get_config_1 = require("./get-config");
+function isHttpUrl(url) {
+    return url.startsWith('http://') || url.startsWith('https://');
+}
+function fetchRemoteFile(url) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith('https://') ? https_1.default : http_1.default;
+        const req = client.get(url, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP请求失败，状态码: ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                resolve(data);
+            });
+        });
+        req.on('error', (err) => {
+            reject(new Error(`网络请求失败: ${err.message}`));
+        });
+        req.setTimeout(10000, () => {
+            req.destroy();
+            reject(new Error('请求超时'));
+        });
+    });
+}
+async function getSwaggerFile() {
+    const config = (0, get_config_1.getConfig)();
+    if (!config.target) {
+        throw new Error('缺失config.target');
+    }
+    if (isHttpUrl(config.target)) {
+        try {
+            const content = await fetchRemoteFile(config.target);
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`远程文件加载失败: ${error.message}`);
+        }
+    }
+    const fsPath = path_1.default.resolve(process.cwd(), config.target);
+    if (!fs_1.default.existsSync(fsPath)) {
+        throw new Error(`swagger.json文件不存在 ${fsPath}`);
+    }
+    const content = JSON.parse(fs_1.default.readFileSync(fsPath, 'utf8'));
+    return content;
+}

package/built/utils/inject-param-to-path.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectParamToPath = injectParamToPath;
+function injectParamToPath(path, params) {
+    let newPath = path;
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < params.length; i++) {
+        const param = params[i];
+        newPath = newPath.replace(`{${param.name}}`, param.name);
+    }
+    return newPath;
+}

package/built/utils/is-english-only.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnglishOnly = isEnglishOnly;
+function isEnglishOnly(str) {
+    // ^ 和 $ 表示字符串的开始和结束，确保整个字符串都匹配
+    // [A-Za-z]+ 表示一个或多个英文大小写字母
+    return /^[A-Za-z_]+$/.test(str);
+}

package/built/utils/is-skills.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSkills = isSkills;
+function isSkills() {
+    return process.env.CNB_GENERATE_MODE === 'skills';
+}

package/built/utils/lower-first-char.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowerFirstChar = lowerFirstChar;
+function lowerFirstChar(str) {
+    if (!str)
+        return str; // 处理空字符串或非字符串
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}

package/built/utils/path-to-camel-case.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToCamelCase = pathToCamelCase;
+function pathToCamelCase(path) {
+    return path
+        .split('/') // 按斜杠分割
+        .filter((part) => part && part !== '-') // 过滤空字符串和单独的 '-'
+        .map((part) => {
+        // 去掉花括号
+        part = part.replace(/[{}]/g, '');
+        // 按 '-' 分割，转驼峰
+        return part
+            .split('-')
+            .map((word, index) => {
+            word = word.toLowerCase();
+            if (index === 0) {
+                return word;
+            }
+            return word.charAt(0).toUpperCase() + word.slice(1);
+        })
+            .join('');
+    })
+        .map((word, index) => {
+        // 整体首字母小写，后续单词首字母大写
+        if (index === 0) {
+            return word.charAt(0).toLowerCase() + word.slice(1);
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    })
+        .join('');
+}

package/built/utils/progress.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startProgress = startProgress;
+exports.successProgress = successProgress;
+exports.infoProgress = infoProgress;
+exports.createProgressBar = createProgressBar;
+exports.startProgressBar = startProgressBar;
+exports.updateProgressBar = updateProgressBar;
+exports.stopProgressBar = stopProgressBar;
+const ora_1 = __importDefault(require("ora"));
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const tty = process.stdout.isTTY;
+function isOpenCagDebugLogger() {
+    if (process.env.DEBUG) {
+        return process.env.DEBUG.includes('cag:');
+    }
+    return false;
+}
+function startProgress(message = '') {
+    if (isOpenCagDebugLogger())
+        return;
+    if (!tty) {
+        process.stdout.write(`${message}\n`);
+    }
+    else {
+        const spinner = (0, ora_1.default)(message).start();
+        return spinner;
+    }
+}
+function successProgress(message, spinner) {
+    if (isOpenCagDebugLogger())
+        return;
+    if (!tty || !spinner) {
+        process.stdout.write(`${message}\n`);
+    }
+    else {
+        spinner.succeed(message);
+    }
+}
+function infoProgress(message, spinner) {
+    if (isOpenCagDebugLogger())
+        return;
+    if (!tty || !spinner) {
+        process.stdout.write(`${message}\n`);
+    }
+    else {
+        spinner.info(message);
+    }
+}
+function createProgressBar(title) {
+    if (isOpenCagDebugLogger())
+        return;
+    return new cli_progress_1.default.SingleBar({
+        format: `${title} |{bar}| {value}/{total} | {percentage}% | {duration_formatted}`,
+        fps: 30,
+        clearOnComplete: true,
+    }, cli_progress_1.default.Presets.shades_classic);
+}
+function startProgressBar(total, startValue, progressBar) {
+    if (!progressBar)
+        return;
+    progressBar.start(total, startValue);
+}
+function updateProgressBar(value, progressBar) {
+    if (!progressBar)
+        return;
+    progressBar.update(value);
+}
+function stopProgressBar(progressBar) {
+    if (!progressBar)
+        return;
+    progressBar.stop();
+}

package/built/utils/to-camel-case.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+function toCamelCase(str) {
+    return str
+        .toLowerCase()
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''));
+}

package/built/utils/translations-keyworad-to-string.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translationsKeyworadToString = translationsKeyworadToString;
+const ts = __importStar(require("typescript"));
+const constants_1 = require("../constants");
+function translationsKeyworadToString(keyword) {
+    switch (keyword) {
+        case ts.SyntaxKind.StringKeyword:
+            return constants_1.DefinitionsKeywordTypeNodeKey.string;
+        case ts.SyntaxKind.NumberKeyword:
+            return constants_1.DefinitionsKeywordTypeNodeKey.number;
+        case ts.SyntaxKind.BooleanKeyword:
+            return constants_1.DefinitionsKeywordTypeNodeKey.boolean;
+        case ts.SyntaxKind.ObjectKeyword:
+            return constants_1.DefinitionsKeywordTypeNodeKey.object;
+        case ts.SyntaxKind.ArrayType:
+            return constants_1.DefinitionsKeywordTypeNodeKey.array;
+        default:
+            return null;
+    }
+}
+;

package/client/core.ts

@@ -0,0 +1,114 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fetchResponseHandler } from "./fetch-response-handler";
+import { generateUniqueId } from './utils/generate-unique-id';
+
+
+async function formatResponse(data: any, response: any) {
+  const responseData: {
+    status: number;
+    trace: string;
+    header: Record<string, string>;
+    data: Record<string, any> | string | null;
+  } = {
+    status: response.status,
+    trace: response.headers.get('traceparent'),
+    header: {
+      'x-cnb-page': response.headers.get('x-cnb-page'),
+      'x-cnb-page-size': response.headers.get('x-cnb-page-size'),
+      'x-cnb-total': response.headers.get('x-cnb-total'),
+    },
+    data: null,
+  };
+
+  const contentType = response.headers.get('content-type') || '';
+  const isJson = [
+    'application/vnd.cnb.api+json',
+    'application/json',
+    'text/json',
+  ].some((t) => contentType.includes(t));
+  const isText = contentType.startsWith('text/') || contentType.includes('xml');
+  const isImage = contentType.startsWith('image/'); 
+  try {
+    if (isJson) {
+      responseData.data = await response.json();
+    } else if (isText) {
+      responseData.data = await response.text();
+    } else if (isImage) {
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+
+      // 确定文件扩展名
+      let extension = '.bin';
+      if (contentType.includes('png')) extension = '.png';
+      else if (contentType.includes('jpeg') || contentType.includes('jpg')) extension = '.jpg';
+      else if (contentType.includes('gif')) extension = '.gif';
+      else if (contentType.includes('webp')) extension = '.webp';
+      else if (contentType.includes('svg')) extension = '.svg';
+      // 可以根据需要添加更多类型
+
+      // 构建本地保存路径
+      // 注意：请确保 './downloads' 目录存在，或者使用 fs.mkdirSync 创建它
+      const tempDir = os.tmpdir();
+      const uploadDir = path.join(tempDir, 'cnb-skill'); 
+      if (!fs.existsSync(uploadDir)) {
+        fs.mkdirSync(uploadDir, { recursive: true });
+      }
+
+      const fileName = `${generateUniqueId()}${extension}`;
+      const filePath = path.join(uploadDir, fileName);
+
+      fs.writeFileSync(filePath, buffer);
+      responseData.data = filePath;
+    } else {
+      // 其他二进制数据保持原有的 Base64 逻辑，或者也可以按需保存
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      const base64String = buffer.toString('base64');
+      
+      responseData.data = {
+        type: 'base64',
+        data: base64String,
+        mimeType: contentType || 'application/octet-stream',
+      };
+    }
+  } catch (err: any) {
+    responseData.data = err?.message || 'Unknown Error';
+  }
+
+
+  if (responseData.status >= 200 && responseData.status < 300) {
+    return await fetchResponseHandler(data._originParams, responseData);
+  } 
+
+  return responseData;
+}
+
+async function clientFetch(data: any): Promise<any> {
+  const domain = process.env.CNB_API_ENDPOINT || 'https://api.cnb.cool'
+  const url = `${domain}${data.url}`
+  const urlParse = new URL(url);
+  if (data.params) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in data.params) {
+      urlParse.searchParams.append(key, data.params[key]);
+    }
+  }
+
+  const response = await fetch(urlParse.href, {
+    method: data.method.toUpperCase(),
+    body: data.data ? JSON.stringify(data.data) : undefined,
+    headers: {
+      Authorization: `Bearer ${process.env.CNB_TOKEN}`,
+      Accept: 'application/vnd.cnb.api+json',
+      ...(data?.header || {}),
+    },
+  });
+
+  return await formatResponse(data, response);
+}
+
+export default {
+  request: clientFetch,
+};

package/client/fetch-response-handler.ts

@@ -0,0 +1,36 @@
+export async function fetchResponseHandler(fetchOriginParams: Record<string, any>, response: {
+  status: number,
+  trace: string,
+  header: Record<string, string>
+  data: Record<string, any> | string | {                   // 二进制数据标识
+      type: 'base64';
+      data: string;     // base64 字符串
+      mimeType: string; // 原始 MIME type，方便模型知道是什么文件
+    }
+  | null
+}) {
+
+  const config = require('./config/cag.config.js');
+  const responseConverter = config?.skillConfig?.fetchConfig?.responseConverter;
+
+  if (!responseConverter) {
+    return response;
+  }
+
+  const { method, _apiTag } = fetchOriginParams;
+  const requestTag = `${method}@${_apiTag}`;
+  const convertConfig = responseConverter[requestTag];
+  if (convertConfig) {
+    const {converter, handler} = convertConfig;
+    try {
+      const converterExample = require(`./utils/${converter}`).default;
+      if (converterExample && typeof converterExample === 'function') {
+        return handler(converterExample, fetchOriginParams, response.data);
+      }
+    } catch (e) {
+      console.error(`converter ${converter} not found`);
+    }
+  }
+
+  return response;
+}