esa-cli 0.0.5 → 1.0.0

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

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import path from 'path';
+import t from '../../../i18n/index.js';
+import { getRoot } from '../../../utils/fileUtils/base.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) => {
+                    const childMap = new Map();
+                    Object.keys(kvJsonObj[namespace]).forEach((key) => {
+                        childMap.set(key, JSON.stringify(kvJsonObj[namespace][key]));
+                    });
+                    EdgeKV.store.set(namespace, childMap);
+                });
+            }
+            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' }
+      }
+    );
+    // Check if key exists
+    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;
   }
 }
 

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

@@ -8,15 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as http from 'http';
+import chalk from 'chalk';
 import spawn from 'cross-spawn';
+import { HttpProxyAgent } from 'http-proxy-agent';
 import fetch from 'node-fetch';
+import t from '../../../i18n/index.js';
 import logger from '../../../libs/logger.js';
 import { getRoot } from '../../../utils/fileUtils/base.js';
 import { EW2BinPath } from '../../../utils/installEw2.js';
-import { HttpProxyAgent } from 'http-proxy-agent';
-import chalk from 'chalk';
-import t from '../../../i18n/index.js';
 import sleep from '../../../utils/sleep.js';
+import CacheService from './cacheService.js';
+import EdgeKV from './kvService.js';
 const getColorForStatusCode = (statusCode, message) => {
     if (statusCode >= 100 && statusCode < 200) {
         return chalk.blue(`${statusCode} ${message}`);
@@ -40,6 +42,8 @@ const getColorForStatusCode = (statusCode, message) => {
 class Ew2Server {
     constructor(props) {
         this.worker = null;
+        this.cache = null;
+        this.kv = null;
         this.startingWorker = false;
         this.workerStartTimeout = undefined;
         this.server = null;
@@ -57,6 +61,8 @@ class Ew2Server {
         return __awaiter(this, void 0, void 0, function* () {
             this.startingWorker = true;
             const result = yield this.openEdgeWorker();
+            this.cache = new CacheService();
+            this.kv = new EdgeKV();
             if (!result) {
                 throw new Error('Worker start failed');
             }
@@ -81,8 +87,9 @@ class Ew2Server {
                 stdio: ['pipe', 'pipe', 'pipe']
             });
             this.workerStartTimeout = setTimeout(() => {
+                var _a;
                 reject(new Error(t('dev_worker_timeout').d('Worker start timeout')));
-                this.worker && this.worker.kill();
+                (_a = this.worker) === null || _a === void 0 ? void 0 : _a.kill();
             }, 60000);
             const sendToRuntime = () => {
                 return new Promise((resolveStart) => {
@@ -96,7 +103,7 @@ class Ew2Server {
                     const req = http.get(options, (res) => {
                         resolveStart(res.statusCode);
                     });
-                    req.on('error', (err) => {
+                    req.on('error', () => {
                         resolveStart(null);
                     });
                     req.end();
@@ -119,7 +126,8 @@ class Ew2Server {
             this.worker.on('close', this.closeHandler.bind(this));
             this.worker.on('error', this.errorHandler.bind(this));
             process.on('SIGTERM', () => {
-                this.worker && this.worker.kill();
+                var _a;
+                (_a = this.worker) === null || _a === void 0 ? void 0 : _a.kill();
             });
         });
     }
@@ -128,37 +136,60 @@ class Ew2Server {
     }
     createServer() {
         this.server = http.createServer((req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (req.url === '/favicon.ico') {
+                res.writeHead(204, {
+                    'Content-Type': 'image/x-icon',
+                    'Content-Length': 0
+                });
+                return res.end();
+            }
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.includes('/mock_cache')) {
+                const cacheResult = yield this.handleCache(req);
+                return res.end(JSON.stringify(cacheResult));
+            }
+            if ((_b = req.url) === null || _b === void 0 ? void 0 : _b.includes('/mock_kv')) {
+                const kvResult = yield this.handleKV(req);
+                if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.includes('/get')) {
+                    if (kvResult.success) {
+                        return res.end(kvResult.value);
+                    }
+                    else {
+                        res.setHeader('Kv-Get-Empty', 'true');
+                        return res.end();
+                    }
+                }
+                else {
+                    return res.end(JSON.stringify(kvResult));
+                }
+            }
             try {
                 const host = req.headers.host;
                 const url = req.url;
+                const method = req.method;
+                const headers = Object.entries(req.headers).reduce((acc, [key, value]) => {
+                    if (Array.isArray(value)) {
+                        acc[key] = value.join(', ');
+                    }
+                    else {
+                        acc[key] = value;
+                    }
+                    return acc;
+                }, {});
                 // @ts-ignore
                 const ew2Port = global.ew2Port;
                 // @ts-ignore
                 const localUpstream = global.localUpstream;
                 const workerRes = yield fetch(`http://${localUpstream ? localUpstream : host}${url}`, {
-                    method: 'GET',
-                    headers: {
-                        'x-er-context': 'eyJzaXRlX2lkIjogIjYyMjcxODQ0NjgwNjA4IiwgInNpdGVfbmFtZSI6ICJjb21wdXRlbHguYWxpY2RuLXRlc3QuY29tIiwgInNpdGVfcmVjb3JkIjogIm1vY2hlbi1uY2RuLmNvbXB1dGVseC5hbGljZG4tdGVzdC5jb20iLCAiYWxpdWlkIjogIjEzMjI0OTI2ODY2NjU2MDgiLCAic2NoZW1lIjoiaHR0cCIsICAiaW1hZ2VfZW5hYmxlIjogdHJ1ZX0=',
-                        'x-er-id': 'a.bA'
-                    },
+                    method,
+                    headers: Object.assign(Object.assign({}, headers), { 'x-er-context': 'eyJzaXRlX2lkIjogIjYyMjcxODQ0NjgwNjA4IiwgInNpdGVfbmFtZSI6ICJjb21wdXRlbHguYWxpY2RuLXRlc3QuY29tIiwgInNpdGVfcmVjb3JkIjogIm1vY2hlbi1uY2RuLmNvbXB1dGVseC5hbGljZG4tdGVzdC5jb20iLCAiYWxpdWlkIjogIjEzMjI0OTI2ODY2NjU2MDgiLCAic2NoZW1lIjoiaHR0cCIsICAiaW1hZ2VfZW5hYmxlIjogdHJ1ZX0=', 'x-er-id': 'a.bA' }),
+                    body: req.method === 'GET' ? undefined : req,
                     agent: new HttpProxyAgent(`http://127.0.0.1:${ew2Port}`)
                 });
                 const workerHeaders = Object.fromEntries(workerRes.headers.entries());
-                // 解决 gzip 兼容性问题，防止net::ERR_CONTENT_DECODING_FAILED
+                // Solve gzip compatibility issue, prevent net::ERR_CONTENT_DECODING_FAILED
                 workerHeaders['content-encoding'] = 'identity';
                 if (workerRes.body) {
-                    // if (workerRes.headers.get('content-type')?.includes('text/')) {
-                    //   const text = await workerRes.text();
-                    //   // 出现换行符之类会导致 content-length 不一致
-                    //   workerHeaders['content-length'] =
-                    //     Buffer.byteLength(text).toString();
-                    //     console.log(workerHeaders['content-length']);
-                    //   res.writeHead(workerRes.status, workerHeaders);
-                    //   res.end(text);
-                    // } else {
-                    //   res.writeHead(workerRes.status, workerHeaders);
-                    //   workerRes.body.pipe(res);
-                    // }
                     res.writeHead(workerRes.status, workerHeaders);
                     workerRes.body.pipe(res);
                     logger.log(`[ESA Dev] ${req.method} ${url} ${getColorForStatusCode(workerRes.status, workerRes.statusText)}`);
@@ -176,6 +207,65 @@ class Ew2Server {
             logger.log(`listening on port ${this.port}`);
         });
     }
+    handleCache(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const body = yield this.parseCacheBody(req);
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.includes('/put')) {
+                (_b = this.cache) === null || _b === void 0 ? void 0 : _b.put(body.key, body);
+                return { success: true };
+            }
+            if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.includes('/get')) {
+                const res = (_d = this.cache) === null || _d === void 0 ? void 0 : _d.get(body.key);
+                if (!res) {
+                    return { success: false, key: body.key };
+                }
+                return { success: true, key: body.key, data: res === null || res === void 0 ? void 0 : res.serializedResponse };
+            }
+            if ((_e = req.url) === null || _e === void 0 ? void 0 : _e.includes('/delete')) {
+                const res = (_f = this.cache) === null || _f === void 0 ? void 0 : _f.delete(body.key);
+                return { success: !!res };
+            }
+            return { success: false };
+        });
+    }
+    handleKV(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const url = new URL(req.url, 'http://localhost');
+            const key = url.searchParams.get('key');
+            const namespace = url.searchParams.get('namespace');
+            const body = yield this.parseKVBody(req);
+            if (!key || !namespace) {
+                return {
+                    success: false
+                };
+            }
+            if ((_a = req.url) === null || _a === void 0 ? void 0 : _a.includes('/put')) {
+                (_b = this.kv) === null || _b === void 0 ? void 0 : _b.put(key, body, namespace);
+                return {
+                    success: true
+                };
+            }
+            if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.includes('/get')) {
+                const res = (_d = this.kv) === null || _d === void 0 ? void 0 : _d.get(key, namespace);
+                const params = { success: true, value: res };
+                if (!res) {
+                    params.success = false;
+                }
+                return params;
+            }
+            if ((_e = req.url) === null || _e === void 0 ? void 0 : _e.includes('/delete')) {
+                const res = (_f = this.kv) === null || _f === void 0 ? void 0 : _f.delete(key, namespace);
+                return {
+                    success: res
+                };
+            }
+            return {
+                success: false
+            };
+        });
+    }
     stdoutHandler(chunk) {
         logger.log(`${chalk.bgGreen('[Worker]')} ${chunk.toString().trim()}`);
     }
@@ -189,17 +279,60 @@ class Ew2Server {
         }
         this.stop();
     }
-    closeHandler(code, signal) {
+    closeHandler() {
         if (this.restarting) {
             this.restarting = false;
             return;
         }
         this.stop().then(() => {
+            var _a;
             logger.log(t('dev_server_closed').d('Worker server closed'));
             logger.info('Worker server closed');
             // @ts-ignore
             global.port = undefined;
-            this.onClose && this.onClose();
+            (_a = this.onClose) === null || _a === void 0 ? void 0 : _a.call(this);
+        });
+    }
+    parseCacheBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let totalLength = 0;
+            req.on('data', (chunk) => {
+                chunks.push(chunk);
+                totalLength += chunk.length;
+            });
+            req.on('end', () => {
+                try {
+                    const buffer = Buffer.concat(chunks, totalLength);
+                    const rawBody = buffer.toString('utf8');
+                    resolve(rawBody ? JSON.parse(rawBody) : {});
+                }
+                catch (err) {
+                    reject(new Error(`Invalid JSON: ${err.message}`));
+                }
+            });
+            req.on('error', reject);
+        });
+    }
+    parseKVBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let totalLength = 0;
+            req.on('data', (chunk) => {
+                chunks.push(chunk);
+                totalLength += chunk.length;
+            });
+            req.on('end', () => {
+                try {
+                    const buffer = Buffer.concat(chunks, totalLength);
+                    const rawBody = buffer.toString();
+                    resolve(rawBody);
+                }
+                catch (err) {
+                    reject(new Error(`Invalid JSON: ${err.message}`));
+                }
+            });
+            req.on('error', reject);
         });
     }
     runCommand(command) {
@@ -213,7 +346,7 @@ class Ew2Server {
                 resolve(false);
                 return;
             }
-            const onExit = (code, signal) => {
+            const onExit = () => {
                 this.worker = null;
                 resolve(true);
             };
@@ -222,10 +355,12 @@ class Ew2Server {
             (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
         });
     }
-    restart() {
+    restart(devPack) {
         return __awaiter(this, void 0, void 0, function* () {
             this.restarting = true;
+            console.clear();
             yield this.stop();
+            yield devPack();
             this.start();
             logger.log(t('dev_server_restart').d('Worker server restarted'));
             logger.info('Worker server restarted');