vite-plugin-ai-mock-generator 1.0.0

package/dist/index.mjs

@@ -0,0 +1,653 @@
+import fs from 'fs';
+import path from 'path';
+
+// src/storage.ts
+var MockStorage = class {
+  constructor(options = {}) {
+    this.storageDir = options.dir || "mock-data";
+    this.persist = options.persist !== false;
+    this.cache = /* @__PURE__ */ new Map();
+    if (this.persist && !fs.existsSync(this.storageDir)) {
+      fs.mkdirSync(this.storageDir, { recursive: true });
+    }
+    this.load();
+  }
+  /**
+   * 生成存储 key
+   */
+  getKey(endpoint, method) {
+    return `${method}:${endpoint}`;
+  }
+  /**
+   * 生成文件名
+   */
+  getFileName(endpoint, method) {
+    const sanitized = endpoint.replace(/^\//, "").replace(/\//g, "_").replace(/:/g, "_");
+    return `${method}_${sanitized}.json`;
+  }
+  /**
+   * 获取数据
+   */
+  get(endpoint, method = "GET") {
+    const key = this.getKey(endpoint, method);
+    const store = this.cache.get(key);
+    return store?.data;
+  }
+  /**
+   * 设置数据
+   */
+  set(endpoint, method, data, metadata) {
+    const key = this.getKey(endpoint, method);
+    const store = {
+      endpoint,
+      method,
+      data,
+      metadata: {
+        count: Array.isArray(data) ? data.length : 1,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "1.0.0",
+        type: typeof data,
+        ...metadata
+      }
+    };
+    this.cache.set(key, store);
+    if (this.persist) {
+      this.save(endpoint, method, store);
+    }
+  }
+  /**
+   * 删除数据
+   */
+  delete(endpoint, method = "GET") {
+    const key = this.getKey(endpoint, method);
+    this.cache.delete(key);
+    if (this.persist) {
+      const fileName = this.getFileName(endpoint, method);
+      const filePath = path.join(this.storageDir, fileName);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    }
+  }
+  /**
+   * 清空所有数据
+   */
+  clear() {
+    this.cache.clear();
+    if (this.persist && fs.existsSync(this.storageDir)) {
+      const files = fs.readdirSync(this.storageDir);
+      for (const file of files) {
+        fs.unlinkSync(path.join(this.storageDir, file));
+      }
+    }
+  }
+  /**
+   * 获取所有端点
+   */
+  getAll() {
+    return Array.from(this.cache.values());
+  }
+  /**
+   * 保存到文件
+   */
+  save(endpoint, method, store) {
+    const fileName = this.getFileName(endpoint, method);
+    const filePath = path.join(this.storageDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(store, null, 2), "utf-8");
+  }
+  /**
+   * 从文件加载
+   */
+  load() {
+    if (!this.persist || !fs.existsSync(this.storageDir)) {
+      return;
+    }
+    const files = fs.readdirSync(this.storageDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const filePath = path.join(this.storageDir, file);
+        const content = fs.readFileSync(filePath, "utf-8");
+        const store = JSON.parse(content);
+        const key = this.getKey(store.endpoint, store.method);
+        this.cache.set(key, store);
+      } catch (error) {
+        console.warn(`Failed to load mock data from ${file}:`, error);
+      }
+    }
+  }
+  /**
+   * 导出所有数据
+   */
+  export(outputPath) {
+    const allData = this.getAll();
+    fs.writeFileSync(outputPath, JSON.stringify(allData, null, 2), "utf-8");
+  }
+  /**
+   * 导入数据
+   */
+  import(inputPath) {
+    const content = fs.readFileSync(inputPath, "utf-8");
+    const allData = JSON.parse(content);
+    for (const store of allData) {
+      const key = this.getKey(store.endpoint, store.method);
+      this.cache.set(key, store);
+      if (this.persist) {
+        this.save(store.endpoint, store.method, store);
+      }
+    }
+  }
+};
+
+// src/generator.ts
+var MockDataGenerator = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.apiUrl = options.apiUrl;
+    this.model = options.model;
+  }
+  /**
+   * 生成 Mock 数据
+   */
+  async generate(context) {
+    const { type, count, locale, quality } = context;
+    const prompt = this.buildPrompt(type, count, locale, quality);
+    const response = await this.callAI(prompt);
+    return this.parseResponse(response, type.isArray);
+  }
+  /**
+   * 构建 AI Prompt
+   */
+  buildPrompt(type, count, locale, quality) {
+    const properties = type.properties.map((p) => this.formatProperty(p)).join("\n");
+    return `
+\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684 Mock \u6570\u636E\u751F\u6210\u5668\u3002\u8BF7\u6839\u636E\u4EE5\u4E0B\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u771F\u5B9E\u3001\u5408\u7406\u7684\u6D4B\u8BD5\u6570\u636E\u3002
+
+\u7C7B\u578B\u540D\u79F0: ${type.name}
+\u6570\u636E\u8BED\u8A00: ${locale === "zh-CN" ? "\u4E2D\u6587" : "\u82F1\u6587"}
+\u6570\u636E\u6570\u91CF: ${count}
+\u8D28\u91CF\u8981\u6C42: ${quality === "high" ? "\u9AD8\u8D28\u91CF\uFF08\u771F\u5B9E\u4E1A\u52A1\u6570\u636E\uFF09" : quality === "fast" ? "\u5FEB\u901F\u751F\u6210" : "\u5E73\u8861\u8D28\u91CF\u548C\u901F\u5EA6"}
+
+\u7C7B\u578B\u5B9A\u4E49:
+${properties}
+
+\u8981\u6C42:
+1. \u751F\u6210 ${count} \u6761\u6570\u636E
+2. \u6570\u636E\u8981\u7B26\u5408\u4E1A\u52A1\u903B\u8F91\u548C\u771F\u5B9E\u573A\u666F
+3. \u5B57\u6BB5\u503C\u8981\u5408\u7406\uFF08\u5982\u4EF7\u683C\u4E0D\u80FD\u4E3A\u8D1F\u6570\uFF0C\u5E74\u9F84\u5728\u5408\u7406\u8303\u56F4\uFF09
+4. \u65E5\u671F\u683C\u5F0F\u4F7F\u7528 ISO 8601
+5. \u8FD4\u56DE JSON \u6570\u7EC4\u683C\u5F0F\uFF0C\u4E0D\u8981\u5305\u542B\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57
+6. \u7406\u89E3\u5B57\u6BB5\u8BED\u4E49\uFF0C\u751F\u6210\u771F\u5B9E\u6570\u636E\uFF08\u5982 userName \u751F\u6210\u771F\u5B9E\u59D3\u540D\uFF09
+
+\u793A\u4F8B\u683C\u5F0F:
+[
+  {
+    "id": 1,
+    "name": "\u5F20\u4E09",
+    ...
+  }
+]
+
+\u8BF7\u751F\u6210\u6570\u636E:
+`.trim();
+  }
+  /**
+   * 格式化属性
+   */
+  formatProperty(prop) {
+    let line = `- ${prop.name}: ${prop.type}`;
+    if (prop.comment) {
+      line += ` // ${prop.comment}`;
+    }
+    if (prop.constraints) {
+      const constraints = [];
+      if (prop.constraints.min !== void 0) {
+        constraints.push(`min: ${prop.constraints.min}`);
+      }
+      if (prop.constraints.max !== void 0) {
+        constraints.push(`max: ${prop.constraints.max}`);
+      }
+      if (prop.constraints.unique) {
+        constraints.push("unique");
+      }
+      if (prop.constraints.enum) {
+        constraints.push(`enum: [${prop.constraints.enum.join(", ")}]`);
+      }
+      if (constraints.length > 0) {
+        line += ` (${constraints.join(", ")})`;
+      }
+    }
+    return line;
+  }
+  /**
+   * 调用 AI API
+   */
+  async callAI(prompt) {
+    try {
+      const response = await fetch(`${this.apiUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: [
+            {
+              role: "user",
+              content: prompt
+            }
+          ],
+          temperature: 0.7
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`AI API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.choices[0].message.content;
+    } catch (error) {
+      console.error("Failed to call AI API:", error);
+      throw error;
+    }
+  }
+  /**
+   * 解析 AI 响应
+   */
+  parseResponse(response, isArray = true) {
+    try {
+      let cleanedResponse = response.trim();
+      cleanedResponse = cleanedResponse.replace(/^```json\s*/i, "");
+      cleanedResponse = cleanedResponse.replace(/^```\s*/, "");
+      cleanedResponse = cleanedResponse.replace(/\s*```$/, "");
+      const jsonMatch = cleanedResponse.match(/(\[[\s\S]*\]|\{[\s\S]*\})/);
+      if (!jsonMatch) {
+        throw new Error("No JSON array or object found in response");
+      }
+      const data = JSON.parse(jsonMatch[0]);
+      return isArray ? data : data[0];
+    } catch (error) {
+      console.error("Failed to parse AI response:", error);
+      console.error("Response:", response);
+      throw error;
+    }
+  }
+  /**
+   * 生成基础数据（不使用 AI）
+   */
+  generateBasic(type, count) {
+    const data = [];
+    for (let i = 0; i < count; i++) {
+      const item = {};
+      for (const prop of type.properties) {
+        item[prop.name] = this.generateBasicValue(prop, i);
+      }
+      data.push(item);
+    }
+    return data;
+  }
+  /**
+   * 生成基础值
+   */
+  generateBasicValue(prop, index) {
+    const { type, constraints } = prop;
+    if (constraints?.enum) {
+      return constraints.enum[index % constraints.enum.length];
+    }
+    switch (type) {
+      case "number":
+        const min = constraints?.min ?? 0;
+        const max = constraints?.max ?? 100;
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+      case "string":
+        return `${prop.name}_${index + 1}`;
+      case "boolean":
+        return Math.random() > 0.5;
+      case "Date":
+        return (/* @__PURE__ */ new Date()).toISOString();
+      default:
+        return null;
+    }
+  }
+};
+
+// src/utils.ts
+function delay(ms) {
+  const delayTime = Array.isArray(ms) ? Math.random() * (ms[1] - ms[0]) + ms[0] : ms;
+  return new Promise((resolve) => setTimeout(resolve, delayTime));
+}
+function matchPathParams(pattern, path2) {
+  const patternParts = pattern.split("/");
+  const pathParts = path2.split("/");
+  if (patternParts.length !== pathParts.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+    const pathPart = pathParts[i];
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = pathPart;
+    } else if (patternPart !== pathPart) {
+      return null;
+    }
+  }
+  return params;
+}
+function parseQueryParams(url) {
+  const queryString = url.split("?")[1];
+  if (!queryString) return {};
+  const params = {};
+  const pairs = queryString.split("&");
+  for (const pair of pairs) {
+    const [key, value] = pair.split("=");
+    params[decodeURIComponent(key)] = decodeURIComponent(value || "");
+  }
+  return params;
+}
+function applyFilters(data, filters) {
+  if (!filters || Object.keys(filters).length === 0) {
+    return data;
+  }
+  return data.filter((item) => {
+    for (const [key, value] of Object.entries(filters)) {
+      if (item[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function applySorting(data, sort) {
+  if (!sort) return data;
+  const sortConfig = typeof sort === "string" ? { field: sort, order: "asc" } : sort;
+  return [...data].sort((a, b) => {
+    const aValue = a[sortConfig.field];
+    const bValue = b[sortConfig.field];
+    if (aValue < bValue) return sortConfig.order === "asc" ? -1 : 1;
+    if (aValue > bValue) return sortConfig.order === "asc" ? 1 : -1;
+    return 0;
+  });
+}
+function applyPagination(data, page = 1, pageSize = 20) {
+  const total = data.length;
+  const totalPages = Math.ceil(total / pageSize);
+  const start = (page - 1) * pageSize;
+  const end = start + pageSize;
+  return {
+    data: data.slice(start, end),
+    pagination: {
+      page,
+      pageSize,
+      total,
+      totalPages
+    }
+  };
+}
+function formatResponse(data, success = true, message) {
+  return {
+    code: success ? 200 : 500,
+    data,
+    message: message || (success ? "Success" : "Error")
+  };
+}
+
+// src/server.ts
+var MockServer = class {
+  constructor(storage, options) {
+    this.storage = storage;
+    this.endpoints = options.endpoints || [];
+    this.options = options;
+  }
+  /**
+   * 配置服务器中间件
+   */
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      const url = req.url || "";
+      const method = req.method;
+      const endpoint = this.matchEndpoint(url, method);
+      if (!endpoint) {
+        return next();
+      }
+      try {
+        const params = this.parseRequest(req, url);
+        const data = await this.getMockData(endpoint, params);
+        if (this.options.server?.delay) {
+          await delay(this.options.server.delay);
+        }
+        res.setHeader("Content-Type", "application/json");
+        if (this.options.server?.cors) {
+          res.setHeader("Access-Control-Allow-Origin", "*");
+          res.setHeader("Access-Control-Allow-Methods", "*");
+          res.setHeader("Access-Control-Allow-Headers", "*");
+        }
+        res.statusCode = 200;
+        res.end(JSON.stringify(data));
+        if (this.options.output?.logs) {
+          console.log(`[Mock] ${method} ${url} \u2192 ${data ? "OK" : "Empty"}`);
+        }
+      } catch (error) {
+        console.error(`[Mock] Error handling ${method} ${url}:`, error);
+        res.statusCode = 500;
+        res.end(
+          JSON.stringify({
+            code: 500,
+            message: error.message
+          })
+        );
+      }
+    });
+    console.log("\n\u{1F3AD} Mock \u670D\u52A1\u5668\u5DF2\u542F\u52A8");
+    console.log(`\u{1F4CD} \u5DF2\u6CE8\u518C ${this.endpoints.length} \u4E2A\u7AEF\u70B9
+`);
+  }
+  /**
+   * 匹配端点
+   */
+  matchEndpoint(url, method) {
+    const path2 = url.split("?")[0];
+    const prefix = this.options.server?.prefix || "";
+    const cleanPath = prefix ? path2.replace(new RegExp(`^${prefix}`), "") : path2;
+    for (const endpoint of this.endpoints) {
+      if (endpoint.enabled === false) continue;
+      if (endpoint.method !== method) continue;
+      if (endpoint.path === cleanPath) {
+        return endpoint;
+      }
+      if (matchPathParams(endpoint.path, cleanPath)) {
+        return endpoint;
+      }
+    }
+    return null;
+  }
+  /**
+   * 解析请求
+   */
+  parseRequest(req, url) {
+    const query = parseQueryParams(url);
+    const path2 = url.split("?")[0];
+    const endpoint = this.matchEndpoint(path2, req.method);
+    const pathParams = endpoint ? matchPathParams(endpoint.path, path2.split("?")[0]) : null;
+    return {
+      query,
+      params: pathParams || {},
+      body: req.body,
+      headers: req.headers
+    };
+  }
+  /**
+   * 获取 Mock 数据
+   */
+  async getMockData(endpoint, params) {
+    let data = this.storage.get(endpoint.path, endpoint.method);
+    if (!data) {
+      console.warn(
+        `[Mock] No data found for ${endpoint.method} ${endpoint.path}`
+      );
+      return formatResponse([], false, "No mock data available");
+    }
+    if (Array.isArray(data)) {
+      if (params.query.filter) {
+        data = applyFilters(data, JSON.parse(params.query.filter));
+      }
+      if (params.query.sort) {
+        data = applySorting(data, params.query.sort);
+      }
+      if (params.query.page || params.query.pageSize) {
+        const page = parseInt(params.query.page) || 1;
+        const pageSize = parseInt(params.query.pageSize) || 20;
+        const result = applyPagination(data, page, pageSize);
+        return formatResponse({
+          list: result.data,
+          pagination: result.pagination
+        });
+      }
+    }
+    if (endpoint.custom) {
+      data = await endpoint.custom(data, params);
+    }
+    return formatResponse(data);
+  }
+  /**
+   * 添加端点
+   */
+  addEndpoint(endpoint) {
+    this.endpoints.push(endpoint);
+  }
+  /**
+   * 移除端点
+   */
+  removeEndpoint(path2, method) {
+    this.endpoints = this.endpoints.filter(
+      (e) => !(e.path === path2 && e.method === method)
+    );
+  }
+  /**
+   * 获取所有端点
+   */
+  getEndpoints() {
+    return this.endpoints;
+  }
+};
+
+// src/index.ts
+function vitePluginAIMockGenerator(options = {}) {
+  const {
+    apiKey = process.env.OPENAI_API_KEY || "",
+    apiUrl = process.env.OPENAI_API_URL || "https://api.openai.com/v1",
+    model = process.env.OPENAI_MODEL || "gpt-4",
+    enabled = true,
+    autoGenerate = false,
+    generation = {
+      locale: "zh-CN",
+      count: 20,
+      quality: "balanced"
+    },
+    storage: storageOptions = {
+      dir: "mock-data",
+      persist: true,
+      cache: true
+    },
+    output = {
+      console: true,
+      logs: false
+    }
+  } = options;
+  if (!enabled) {
+    return {
+      name: "vite-plugin-ai-mock-generator"
+    };
+  }
+  const storage = new MockStorage(storageOptions);
+  const generator = new MockDataGenerator({ apiKey, apiUrl, model });
+  const server = new MockServer(storage, options);
+  return {
+    name: "vite-plugin-ai-mock-generator",
+    enforce: "pre",
+    configResolved(config) {
+      if (output.console) {
+        console.log("\n\u{1F916} AI Mock Generator \u5DF2\u542F\u52A8");
+        console.log(`\u{1F4C2} \u5B58\u50A8\u76EE\u5F55: ${storageOptions.dir}`);
+        console.log(`\u{1F30D} \u6570\u636E\u8BED\u8A00: ${generation.locale}`);
+        console.log(`\u{1F4CA} \u9ED8\u8BA4\u6570\u91CF: ${generation.count}`);
+        console.log(`\u{1F511} API Key: ${apiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+        console.log(
+          `\u{1F4CD} \u7AEF\u70B9\u6570\u91CF: ${options.endpoints?.length || 0}`
+        );
+      }
+    },
+    async buildStart() {
+      if (autoGenerate && options.endpoints) {
+        if (output.console) {
+          console.log("\n\u{1F504} \u5F00\u59CB\u81EA\u52A8\u751F\u6210 Mock \u6570\u636E...\n");
+        }
+        for (const endpoint of options.endpoints) {
+          const existingData = storage.get(endpoint.path, endpoint.method);
+          if (existingData) {
+            if (output.console) {
+              console.log(
+                `\u23ED\uFE0F  \u8DF3\u8FC7 ${endpoint.method} ${endpoint.path} (\u5DF2\u6709\u6570\u636E)`
+              );
+            }
+            continue;
+          }
+          try {
+            if (output.console) {
+              console.log(`\u{1F3B2} \u751F\u6210 ${endpoint.method} ${endpoint.path}...`);
+            }
+            const typeDefinition = parseTypeDefinition(endpoint.response);
+            const count = endpoint.count || generation.count || 20;
+            let data;
+            if (generation.quality === "fast") {
+              data = generator.generateBasic(typeDefinition, count);
+            } else {
+              data = await generator.generate({
+                type: typeDefinition,
+                count,
+                locale: generation.locale || "zh-CN",
+                quality: generation.quality || "balanced"
+              });
+            }
+            storage.set(endpoint.path, endpoint.method, data, {
+              type: endpoint.response
+            });
+            if (output.console) {
+              console.log(
+                `\u2705 \u5DF2\u751F\u6210 ${count} \u6761\u6570\u636E: ${endpoint.method} ${endpoint.path}`
+              );
+            }
+          } catch (error) {
+            console.error(
+              `\u274C \u751F\u6210\u5931\u8D25 ${endpoint.method} ${endpoint.path}:`,
+              error.message
+            );
+          }
+        }
+        if (output.console) {
+          console.log("\n\u2728 Mock \u6570\u636E\u751F\u6210\u5B8C\u6210\n");
+        }
+      }
+    },
+    configureServer(viteServer) {
+      server.configureServer(viteServer);
+    }
+  };
+}
+function parseTypeDefinition(typeStr) {
+  if (typeof typeStr === "object") {
+    return typeStr;
+  }
+  const isArray = typeStr.endsWith("[]");
+  const typeName = isArray ? typeStr.slice(0, -2) : typeStr;
+  return {
+    name: typeName,
+    properties: [],
+    isArray
+  };
+}
+
+export { MockDataGenerator, MockServer, MockStorage, vitePluginAIMockGenerator };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map