esa-cli 0.0.2-beta.2 → 0.0.2-beta.21

package/dist/commands/dev/ew2/cacheService.js

@@ -0,0 +1,33 @@
+class CacheService {
+    constructor() {
+        this.store = new Map();
+        this.maxQuota = 100 * 1024 * 1024;
+    }
+    put(key, serializedResponse) {
+        const expires = serializedResponse.ttl === 0
+            ? Infinity
+            : Date.now() + serializedResponse.ttl * 1000;
+        this.store.set(key, {
+            serializedResponse,
+            expires: expires,
+            lastUsed: Date.now()
+        });
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry || Date.now() > entry.expires) {
+            return null;
+        }
+        entry.lastUsed = Date.now();
+        return entry;
+    }
+    delete(key) {
+        return this.deleteEntry(key);
+    }
+    deleteEntry(key) {
+        if (!this.store.has(key))
+            return false;
+        return this.store.delete(key);
+    }
+}
+export default CacheService;

package/dist/commands/dev/ew2/devEntry.js

@@ -2,8 +2,9 @@ import worker from '$userPath';
 import Cache from './mock/cache.js';
 import mockKV from './mock/kv.js';
 
-var mock_cache = await Cache.init('mock');
+var mock_cache = new Cache($userPort);
 globalThis.mockCache = mock_cache;
+mockKV.port = $userPort;
 globalThis.mockKV = mockKV;
 
 export default worker;

package/dist/commands/dev/ew2/devPack.js

@@ -7,15 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import path from 'path';
 import fs from 'fs';
-import logger from '../../../libs/logger.js';
-import devBuild from '../build.js';
+import path from 'path';
 import t from '../../../i18n/index.js';
-import { getDevConf } from '../../../utils/fileUtils/index.js';
-import { getRoot, getDirName } from '../../../utils/fileUtils/base.js';
+import logger from '../../../libs/logger.js';
 import { checkPort } from '../../../utils/checkDevPort.js';
+import { getRoot, getDirName } from '../../../utils/fileUtils/base.js';
+import { getDevConf } from '../../../utils/fileUtils/index.js';
 import { EW2Path } from '../../../utils/installEw2.js';
+import devBuild from '../build.js';
 // 生成可用的Ew2端口
 const generateEw2Port = () => __awaiter(void 0, void 0, void 0, function* () {
     let ew2port = 3322;
@@ -61,7 +61,7 @@ conf_path = "${erConfPath}"
     ]);
 };
 // 生成入口文件
-const generateEntry = (id, projectEntry, userRoot) => __awaiter(void 0, void 0, void 0, function* () {
+const generateEntry = (id, projectEntry, userRoot, port) => __awaiter(void 0, void 0, void 0, function* () {
     const __dirname = getDirName(import.meta.url);
     const devDir = path.resolve(userRoot, '.dev');
     const devEntry = path.resolve(devDir, `devEntry-${id}.js`);
@@ -81,7 +81,9 @@ const generateEntry = (id, projectEntry, userRoot) => __awaiter(void 0, void 0,
         const destPath = path.resolve(mockDevDir, file);
         yield fs.promises.copyFile(srcPath, destPath);
     }
-    return fs.promises.writeFile(devEntry, devEntryTempFile.replace(/'\$userPath'/g, `'${projectEntry}'`));
+    return fs.promises.writeFile(devEntry, devEntryTempFile
+        .replace(/'\$userPath'/g, `'${projectEntry.replace(/\\/g, '/')}'`)
+        .replace(/\$userPort/g, `${port}`));
 });
 // 前期准备
 const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(void 0, void 0, void 0, function* () {
@@ -92,7 +94,7 @@ const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(
     // @ts-ignore
     global.id = id;
     // 生成入口文件
-    yield generateEntry(id, entry, userRoot);
+    yield generateEntry(id, entry, userRoot, port);
     // 生成 Ew2 配置
     const ew2port = yield generateEw2Port();
     yield writeEw2config(id, ew2port, userRoot);
@@ -106,27 +108,13 @@ const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(
         if (currentIds[0] && /^\d+$/.test(currentIds[0])) {
             // 删除没有用到的入口
             for (let currentId of currentIds) {
-                const useful = yield checkPort(currentConfigObj[currentId].port);
-                if (useful) {
-                    const unusedEntry = path.resolve(userRoot, `.dev/index-${currentId}.js`);
-                    const unusedTemp = path.resolve(userRoot, `.dev/devEntry-${currentId}.js`);
-                    const unusedConfig = path.resolve(userRoot, `.dev/config-${currentId}.toml`);
-                    if (fs.existsSync(unusedEntry)) {
-                        fs.rmSync(unusedEntry, {
-                            force: true,
-                            recursive: true,
-                            maxRetries: 5
-                        });
-                    }
-                    if (fs.existsSync(unusedTemp)) {
-                        fs.rmSync(unusedTemp, {
-                            force: true,
-                            recursive: true,
-                            maxRetries: 5
-                        });
-                    }
-                    if (fs.existsSync(unusedConfig)) {
-                        fs.rmSync(unusedConfig, {
+                const unused = yield checkPort(currentConfigObj[currentId].port);
+                if (unused) {
+                    const devDir = path.resolve(userRoot, '.dev');
+                    const files = fs.readdirSync(devDir);
+                    const filesToDelete = files.filter((file) => file.includes(currentId));
+                    for (const file of filesToDelete) {
+                        fs.rmSync(path.resolve(devDir, file), {
                             force: true,
                             recursive: true,
                             maxRetries: 5
@@ -141,13 +129,22 @@ const prepare = (configPath, entry, port, localUpstream, userRoot) => __awaiter(
     }
     return fs.promises.writeFile(configPath, `export default ${JSON.stringify(Object.assign(options, { [id]: currentOptions }))}`);
 });
-const devPack = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (restarting = false) {
+const devPack = () => __awaiter(void 0, void 0, void 0, function* () {
     logger.ora.start('Processing...\n');
     const userRoot = getRoot();
-    const configPath = path.resolve(userRoot, 'esa.toml');
+    // Try to find config file in order of preference: .jsonc, .toml
+    const configFormats = ['esa.jsonc', 'esa.toml'];
+    let configPath = null;
+    for (const format of configFormats) {
+        const testPath = path.resolve(userRoot, format);
+        if (fs.existsSync(testPath)) {
+            configPath = testPath;
+            break;
+        }
+    }
     let port, minify, localUpstream, entry;
     let projectEntry = path.resolve(userRoot, 'src/index.js');
-    if (fs.existsSync(configPath)) {
+    if (configPath) {
         port = getDevConf('port', 'dev', 18080);
         minify = getDevConf('minify', 'dev', false);
         localUpstream = getDevConf('localUpstream', 'dev', '');
@@ -164,8 +161,7 @@ const devPack = (...args_1) => __awaiter(void 0, [...args_1], void 0, function*
         .then(() => {
         logger.ora.succeed(t('dev_pack_config_success').d('Config created successfully'));
         return devBuild({
-            minify,
-            isNode: true
+            minify
         });
     })
         .then(() => {

package/dist/commands/dev/ew2/kvService.js

@@ -0,0 +1,46 @@
+import path from 'path';
+import fs from 'fs';
+import { getRoot } from '../../../utils/fileUtils/base.js';
+import t from '../../../i18n/index.js';
+class EdgeKV {
+    constructor() {
+        const root = getRoot();
+        const kvPath = path.join(root, 'kv.json');
+        if (fs.existsSync(kvPath)) {
+            try {
+                const kvJson = fs.readFileSync(kvPath, 'utf8');
+                const kvJsonObj = JSON.parse(kvJson);
+                Object.keys(kvJsonObj).forEach((namespace) => {
+                    EdgeKV.store.set(namespace, new Map(Object.entries(kvJsonObj[namespace])));
+                });
+            }
+            catch (err) {
+                console.log(t('kv_parse_failed').d('kv.json parse failed, use empty local kv store.'));
+            }
+        }
+    }
+    get(key, namespace) {
+        const store = EdgeKV.store.get(namespace);
+        if (!store || !store.has(key)) {
+            return;
+        }
+        return store.get(key);
+    }
+    put(key, value, namespace) {
+        let store = EdgeKV.store.get(namespace);
+        if (!store) {
+            EdgeKV.store.set(namespace, new Map([[key, value]]));
+        }
+        else {
+            store.set(key, value);
+        }
+    }
+    delete(key, namespace) {
+        const store = EdgeKV.store.get(namespace);
+        if (!store)
+            return false;
+        return store.delete(key);
+    }
+}
+EdgeKV.store = new Map();
+export default EdgeKV;

package/dist/commands/dev/ew2/mock/cache.js

@@ -1,31 +1,115 @@
 class MockCache {
-  constructor() {
-    this.cache = new Map();
+  constructor(port) {
+    this.port = port;
   }
 
-  static async init(cacheName) {
-    const instance = await MockCache.open(cacheName);
-    return new MockCache(instance);
-  }
+  async put(reqOrUrl, response) {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to execute 'put' on 'cache': 2 arguments required, but only ${arguments.length} present.`
+      );
+    }
+    if (!reqOrUrl) {
+      throw new TypeError(
+        "Failed to execute 'put' on 'cache': 2 arguments required, but only 0 present."
+      );
+    }
+    if (!(response instanceof Response)) {
+      throw new TypeError(
+        "Failed to execute 'put' on 'cache': Argument 2 is not of type Response."
+      );
+    }
+
+    try {
+      const body = await response.clone().text();
+      const headers = {};
+      response.headers.forEach((v, k) => (headers[k] = v));
+
+      const cacheControl = response.headers.get('Cache-Control') || '';
+      const ttl = this.parseTTL(cacheControl);
 
-  static async open(cacheName) {
-    return new Map();
+      const key = this.normalizeKey(reqOrUrl);
+      const fetchRes = await fetch(
+        `http://localhost:${this.port}/mock_cache/put`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            key,
+            response: {
+              status: response.status,
+              headers,
+              body
+            },
+            ttl
+          })
+        }
+      );
+      if (!fetchRes.ok) {
+        const error = await fetchRes.json();
+        throw new Error(error.error);
+      }
+      return undefined;
+    } catch (err) {
+      throw new Error(`Cache put failed: ${err.message}`);
+    }
   }
 
-  async match(reqOrUrl) {
-    return this.cache.get(reqOrUrl) || null;
+  async get(reqOrUrl) {
+    const key = this.normalizeKey(reqOrUrl);
+    const fetchRes = await fetch(
+      `http://localhost:${this.port}/mock_cache/get`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          key
+        })
+      }
+    );
+    if (!fetchRes.ok) {
+      const error = await fetchRes.json();
+      throw new Error(error.error);
+    }
+    const res = await fetchRes.json();
+    if (res && res.success) {
+      return new Response(res.data.response.body, {
+        status: res.data.response.status,
+        headers: new Headers(res.data.response.headers)
+      });
+    } else {
+      return undefined;
+    }
   }
 
   async delete(reqOrUrl) {
-    return this.cache.delete(reqOrUrl);
+    const key = this.normalizeKey(reqOrUrl);
+    const fetchRes = await fetch(
+      `http://localhost:${this.port}/mock_cache/delete`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          key
+        })
+      }
+    );
+    if (!fetchRes.ok) {
+      const error = await fetchRes.json();
+      throw new Error(error.error);
+    }
+    const res = await fetchRes.json();
+    return res.success;
   }
 
-  async put(reqOrUrl, response) {
-    this.cache.set(reqOrUrl, response);
+  normalizeKey(input) {
+    const url = input instanceof Request ? input.url : input;
+    return url.replace(/^https:/i, 'http:');
   }
 
-  async get(reqOrUrl) {
-    return this.match(reqOrUrl);
+  parseTTL(cacheControl) {
+    const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+    return maxAgeMatch ? parseInt(maxAgeMatch[1]) : 3600;
   }
 }
 

package/dist/commands/dev/ew2/mock/kv.js

@@ -1,44 +1,165 @@
 class EdgeKV {
+  static port = 0;
+  JS_RESPONSE_BUFFER_THRESHOLD = 64 * 1024;
   constructor(options) {
+    if (!options || (!options.namespace && !options.namespaceId)) {
+      throw new TypeError(
+        'The argument to `EdgeKV` must be an object with a `namespace` or `namespaceId` field'
+      );
+    }
     this.namespace = options.namespace;
-    this.allData = {};
   }
 
-  async get(key, options) {
-    const namespaceData = this.allData[this.namespace] || {};
-    if (!(key in namespaceData)) {
+  async put(key, value) {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to execute 'put' on 'EdgeKV': 2 arguments required, but only ${arguments.length} present.`
+      );
+    }
+    if (!key) {
+      throw new TypeError(
+        "Failed to execute 'put' on 'EdgeKV': 2 arguments required, but only 0 present."
+      );
+    }
+    if (typeof key !== 'string') {
+      throw new TypeError(
+        `Failed to execute 'put' on 'EdgeKV': 1th argument must be a string.`
+      );
+    }
+
+    try {
+      let body;
+      if (typeof value === 'string') {
+        if (value.length > this.JS_RESPONSE_BUFFER_THRESHOLD) {
+          const encoder = new TextEncoder();
+          const encodedValue = encoder.encode(value);
+
+          body = new ReadableStream({
+            start(controller) {
+              controller.enqueue(encodedValue);
+              controller.close();
+            }
+          });
+        } else {
+          body = value;
+        }
+      } else if (value instanceof Response) {
+        const resBody = await value.clone().text();
+        const headers = {};
+        value.headers.forEach((v, k) => (headers[k] = v));
+        body = JSON.stringify({
+          body: resBody,
+          headers,
+          status: value.status
+        });
+      } else if (
+        value instanceof ReadableStream ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value)
+      ) {
+        body = value;
+      } else {
+        throw new TypeError(
+          `Failed to execute 'put' on 'EdgeKV': 2nd argument should be one of string/Response/ArrayBuffer/ArrayBufferView/ReadableStream`
+        );
+      }
+
+      const fetchRes = await fetch(
+        `http://localhost:${EdgeKV.port}/mock_kv/put?key=${key}&namespace=${this.namespace}`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body
+        }
+      );
+      if (!fetchRes.ok) {
+        const error = await fetchRes.json();
+        throw new Error(error.error);
+      }
       return undefined;
+    } catch (err) {
+      throw new Error(`Cache put failed: ${err.message}`);
+    }
+  }
+
+  async get(key, options) {
+    const isTypeValid = (ty) =>
+      typeof ty === 'string' &&
+      (ty === 'text' ||
+        ty === 'json' ||
+        ty === 'stream' ||
+        ty === 'arrayBuffer');
+
+    if (options && !isTypeValid(options?.type)) {
+      throw new TypeError(
+        "EdgeKV.get: 2nd optional argument must be an object with a 'type' field. The 'type' field specifies the format of the return value and must be a string of 'text', 'json', 'stream' or 'arrayBuffer'"
+      );
     }
-    const value = namespaceData[key];
     const type = options?.type || 'text';
+    const fetchRes = await fetch(
+      `http://localhost:${EdgeKV.port}/mock_kv/get?key=${key}&namespace=${this.namespace}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      }
+    );
+    // 判断是否存在key
+    let isGetFailed = false;
+    fetchRes.headers.forEach((v, k) => {
+      if (k === 'kv-get-empty') {
+        isGetFailed = true;
+      }
+    });
+    if (isGetFailed) {
+      return undefined;
+    }
     switch (type) {
       case 'text':
-        return value;
+        return fetchRes.text();
       case 'json':
         try {
-          return JSON.parse(value);
+          const value = await fetchRes.text();
+          const userObject = JSON.parse(value);
+          return userObject;
         } catch (error) {
-          throw new Error('Failed to parse JSON');
+          throw new TypeError(`Invalid JSON: ${err.message}`);
         }
       case 'arrayBuffer':
-        const encoder = new TextEncoder();
-        const uint8Array = encoder.encode(value);
-        return uint8Array.buffer;
+        try {
+          const buffer = await fetchRes.arrayBuffer();
+          return buffer;
+        } catch (error) {
+          throw new TypeError(
+            `Failed to read the response body into an ArrayBuffer: ${error.message}`
+          );
+        }
+      case 'stream':
+        const value = await fetchRes.text();
+        return new ReadableStream({
+          start(controller) {
+            controller.enqueue(new TextEncoder().encode(value));
+            controller.close();
+          }
+        });
       default:
-        throw new Error('Invalid type option');
+        throw new Error(`Unsupported type: ${type}`);
     }
   }
 
-  async put(key, value) {
-    const namespaceData = this.allData[this.namespace] || {};
-    namespaceData[key] = value;
-    this.allData[this.namespace] = namespaceData;
-  }
-
   async delete(key) {
-    const namespaceData = this.allData[this.namespace] || {};
-    delete namespaceData[key];
-    this.allData[this.namespace] = namespaceData;
+    const fetchRes = await fetch(
+      `http://localhost:${EdgeKV.port}/mock_kv/delete?key=${key}&namespace=${this.namespace}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      }
+    );
+    if (!fetchRes.ok) {
+      const error = await fetchRes.json();
+      throw new Error(error.error);
+    }
+    const res = await fetchRes.json();
+    return res.success;
   }
 }