use get-ready to refactor

README.md

@@ -142,6 +142,7 @@ It can be overridden by child class, but should not be called directly. It must
 
 - Drop `.awaitFirst(events)` support
 - Drop generator function support
+- Don't catch event listener inside error
 
 ### License
 

package.json

@@ -20,7 +20,8 @@
     "node": ">= 18.19.0"
   },
   "dependencies": {
-    "get-ready": "^3.3.0",
+    "gals": "^1.0.2",
+    "get-ready": "^3.4.0",
     "is-type-of": "^2.2.0",
     "utility": "^2.3.0"
   },
@@ -32,17 +33,16 @@
     "egg-bin": "6",
     "eslint": "8",
     "eslint-config-egg": "14",
-    "runscript": "^2.0.1",
     "tshy": "3",
     "tshy-after": "1",
     "typescript": "5"
   },
   "scripts": {
     "lint": "eslint --cache src test --ext .ts",
     "pretest": "npm run lint -- --fix && npm run prepublishOnly",
-    "test": "egg-bin test",
+    "test": "egg-bin test -p --timeout 5000",
     "preci": "npm run lint && npm run prepublishOnly && attw --pack",
-    "ci": "egg-bin cov",
+    "ci": "egg-bin cov -p",
     "prepublishOnly": "tshy && tshy-after"
   },
   "type": "module",
@@ -70,5 +70,6 @@
     "src"
   ],
   "types": "./dist/commonjs/index.d.ts",
-  "main": "./dist/commonjs/index.js"
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js"
 }

src/index.ts

@@ -2,6 +2,7 @@ import util from 'node:util';
 import assert from 'node:assert';
 import { once } from 'node:events';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { getAsyncLocalStorage } from 'gals';
 import { ReadyEventEmitter } from 'get-ready';
 import { isPromise, isGeneratorFunction } from 'is-type-of';
 import { promiseTimeout } from 'utility';
@@ -12,28 +13,38 @@ export interface BaseOptions<T = any> {
   [key: string]: any;
 }
 
-export class Base<T = any> extends ReadyEventEmitter {
+export abstract class Base<T = any> extends ReadyEventEmitter {
   options: BaseOptions<T>;
   #closed = false;
+  #localStorage: AsyncLocalStorage<T>;
 
   constructor(options?: BaseOptions<T>) {
     super();
 
     if (options?.initMethod) {
-      const initMethod = Reflect.get(this, options.initMethod);
+      const initMethod = Reflect.get(this, options.initMethod) as () => Promise<void>;
       assert(typeof initMethod === 'function',
         `[sdk-base] this.${options.initMethod} should be a function`);
       assert(!isGeneratorFunction(initMethod),
-        `[sdk-base] this.${options.initMethod} generator function is not support`);
+        `[sdk-base] this.${options.initMethod} should not be generator function`);
 
       process.nextTick(() => {
         const ret = initMethod.apply(this);
         assert(isPromise(ret), `[sdk-base] this.${options.initMethod} should return a promise`);
-        ret.then(() => this.ready(true))
-          .catch(err => this.ready(err));
+        ret.then(() => {
+          this.ready(true);
+        }).catch(err => {
+          const hasReadyCallbacks = this.hasReadyCallbacks;
+          this.ready(err);
+          // no ready callbacks, should emit error event instead
+          if (!hasReadyCallbacks) {
+            this.emit('error', err);
+          }
+        });
       });
     }
     this.options = options ?? {};
+    this.#localStorage = this.options.localStorage ?? getAsyncLocalStorage<T>();
     this.on('error', err => {
       this._defaultErrorHandler(err);
     });
@@ -42,16 +53,17 @@ export class Base<T = any> extends ReadyEventEmitter {
   /**
    * support `await this.await('event')`
    */
-  await(event: string) {
-    return once(this, event);
+  async await(event: string) {
+    const values = await once(this, event);
+    return values[0];
   }
 
   /**
    * get AsyncLocalStorage from options
    * @return {AsyncLocalStorage} asyncLocalStorage instance or undefined
    */
   get localStorage() {
-    return this.options.localStorage;
+    return this.#localStorage;
   }
 
   async readyOrTimeout(milliseconds: number) {
@@ -87,15 +99,19 @@ export class Base<T = any> extends ReadyEventEmitter {
       return;
     }
     this.#closed = true;
-    const closeFunc = Reflect.get(this, '_close');
-    if (typeof closeFunc !== 'function') {
+    const closeMethod = Reflect.get(this, '_close') as () => Promise<void>;
+    if (typeof closeMethod !== 'function') {
       return;
     }
 
     try {
-      await closeFunc.apply(this);
+      await closeMethod.apply(this);
     } catch (err) {
       this.emit('error', err);
     }
   }
+
+  get isClosed() {
+    return this.#closed;
+  }
 }

test/fixtures/ts/index.ts

@@ -1,4 +1,4 @@
-import Base, { BaseOptions } from '../../..';
+import { Base, BaseOptions } from '../../../src/index.js';
 
 class FooContext {
   traceId?: string;
@@ -47,8 +47,7 @@ export async function test() {
     console.log('localStorage should be undefined: %o', client.localStorage?.getStore());
   });
   await client.await('someEvent');
-  await client.awaitFirst([ 'one', 'two' ]);
+  // await client.awaitFirst([ 'one', 'two' ]);
 
   return client.isReady;
-
 }