refactor: store promise in handleStore via reference (#157)

Author: toyobayashi

packages/emnapi/src/promise.ts

@@ -10,15 +10,14 @@ export function napi_create_promise (env: napi_env, deferred: Pointer<napi_defer
     $CHECK_ARG!(envObject, deferred)
     $CHECK_ARG!(envObject, promise)
 
-    const p = new Promise<any>((resolve, reject) => {
-      const deferredObject = emnapiCtx.createDeferred({ resolve, reject })
-      deferredObjectId = deferredObject.id
-      from64('deferred')
-      makeSetValue('deferred', 0, 'deferredObjectId', '*')
-    })
-    from64('promise')
+    const resolver = emnapiCtx.createResolver()
+    deferredObjectId = emnapiCtx.createReference(undefined, resolver, 1, ReferenceOwnership.kUserland as any).id
+
+    from64('deferred')
+    makeSetValue('deferred', 0, 'deferredObjectId', '*')
 
-    value = emnapiCtx.napiValueFromJsValue(p)
+    value = emnapiCtx.napiValueFromJsValue(resolver.promise)
+    from64('promise')
     makeSetValue('promise', 0, 'value', '*')
     return $GET_RETURN_STATUS!(envObject)
   })
@@ -29,8 +28,10 @@ export function napi_resolve_deferred (env: napi_env, deferred: napi_deferred, r
   return $PREAMBLE!(env, (envObject) => {
     $CHECK_ARG!(envObject, deferred)
     $CHECK_ARG!(envObject, resolution)
-    const deferredObject = emnapiCtx.getDeferred(deferred)!
-    deferredObject.resolve(emnapiCtx.jsValueFromNapiValue(resolution)!)
+    const deferredRef = emnapiCtx.getRef(deferred)!
+    const resolver = deferredRef.deref() as Resolver<any>
+    resolver.resolve(emnapiCtx.jsValueFromNapiValue(resolution)!)
+    deferredRef.dispose()
     return $GET_RETURN_STATUS!(envObject)
   })
 }
@@ -40,8 +41,10 @@ export function napi_reject_deferred (env: napi_env, deferred: napi_deferred, re
   return $PREAMBLE!(env, (envObject) => {
     $CHECK_ARG!(envObject, deferred)
     $CHECK_ARG!(envObject, resolution)
-    const deferredObject = emnapiCtx.getDeferred(deferred)!
-    deferredObject.reject(emnapiCtx.jsValueFromNapiValue(resolution)!)
+    const deferredRef = emnapiCtx.getRef(deferred)!
+    const resolver = deferredRef.deref() as Resolver<any>
+    resolver.reject(emnapiCtx.jsValueFromNapiValue(resolution)!)
+    deferredRef.dispose()
     return $GET_RETURN_STATUS!(envObject)
   })
 }

packages/emnapi/src/typings/emnapi.d.ts

@@ -3,6 +3,7 @@ declare type NodeEnv = import('../../../runtime/dist/types/index').NodeEnv
 // declare type Handle<S> = import('../../../runtime/dist/types/index').Handle<S>
 declare type Context = import('../../../runtime/dist/types/index').Context
 declare type Reference = import('../../../runtime/dist/types/index').Reference
+declare type Resolver<T> = import('../../../runtime/dist/types/index').Resolver<T>
 declare type FunctionTemplate = import('../../../runtime/dist/types/index').FunctionTemplate
 
 declare type NodeBinding = typeof import('../../../node/index')

packages/runtime/src/Context.ts

@@ -9,12 +9,12 @@ import {
   NODE_API_DEFAULT_MODULE_API_VERSION,
   NODE_MODULE_VERSION,
   detectFeatures,
-  Features
+  Features,
+  type Resolver
 } from './util'
 import { TryCatch } from './TryCatch'
 import { NotSupportWeakRefError, NotSupportBufferError } from './errors'
 import { Reference, ReferenceOwnership, ReferenceWithData, ReferenceWithFinalizer } from './Reference'
-import { type IDeferrdValue, Deferred } from './Deferred'
 import { ArrayStore } from './Store'
 import { TrackedFinalizer } from './TrackedFinalizer'
 import { External, isExternal, getExternalValue } from './External'
@@ -139,11 +139,10 @@ export class Context {
 
   private envStore = new ArrayStore<Env>()
   private scopeStore = new ScopeStore()
-  private deferredStore = new ArrayStore<Deferred>()
   private readonly refCounter?: NodejsWaitingRequestCounter
   private readonly cleanupQueue: CleanupQueue
 
-  public readonly features: Features = detectFeatures()
+  public readonly features: Features
 
   private handleStore: HandleStore
 
@@ -258,8 +257,8 @@ export class Context {
     )
   }
 
-  public createDeferred<T = any> (value: IDeferrdValue<T>): Deferred<T> {
-    return new Deferred(this.deferredStore, value)
+  public createResolver<T> (): Resolver<T> {
+    return this.features.withResolvers.call<PromiseConstructor, [], Resolver<T>>(Promise)
   }
 
   public createEnv (
@@ -475,10 +474,6 @@ export class Context {
     return this.scopeStore.deref(info)!.callbackInfo
   }
 
-  public getDeferred<T = any> (deferred: napi_deferred): Deferred<T> | undefined {
-    return this.deferredStore.deref(deferred)
-  }
-
   public napiValueFromJsValue (value: unknown): number | bigint {
     switch (value) {
       case undefined: return GlobalHandle.UNDEFINED

packages/runtime/src/Deferred.ts

@@ -1,5 +1,4 @@
 export { createContext, getDefaultContext, Context, type CleanupHookCallbackFunction, type ContextOptions } from './Context'
-export { Deferred, type IDeferrdValue } from './Deferred'
 export { Disposable } from './Disaposable'
 export { Env, NodeEnv, type IReferenceBinding } from './env'
 export { EmnapiError, NotSupportWeakRefError, NotSupportBufferError } from './errors'
@@ -17,7 +16,7 @@ export { Reference, ReferenceWithData, ReferenceWithFinalizer, ReferenceOwnershi
 export { RefTracker } from './RefTracker'
 export { ScopeStore } from './ScopeStore'
 export * from './Store'
-export { type Features } from './util'
+export { type Features, type Resolver } from './util'
 
 export {
   isReferenceType,

packages/runtime/src/index.ts

@@ -8,6 +8,12 @@ export function detectFinalizer () {
 
 export const supportFinalizer = /*#__PURE__*/ detectFinalizer()
 
+export interface Resolver<T> {
+  promise: Promise<T>
+  resolve: (value: T | PromiseLike<T>) => void
+  reject: (reason?: any) => void
+}
+
 export interface Features {
   makeDynamicFunction: ((...args: any[]) => Function) | undefined
   getGlobalThis: () => typeof globalThis
@@ -19,6 +25,7 @@ export interface Features {
   MessageChannel: typeof MessageChannel | undefined
   Buffer: BufferCtor | undefined
   setImmediate: (callback: () => void) => any
+  withResolvers: <T>(this: PromiseConstructor) => Resolver<T>
 }
 
 export function detectFeatures (features?: Partial<Features>): Features {
@@ -90,10 +97,26 @@ export function detectFeatures (features?: Partial<Features>): Features {
     throw new Error('Unable to get globalThis')
   }
 
+  function defaultWithResolvers<T> (this: PromiseConstructor) {
+    let ok: (value: T | PromiseLike<T>) => void
+    let err: (reason?: any) => void
+    const promise = new this<T>((resolve, reject) => {
+      ok = resolve
+      err = reject
+    })
+    return { promise, resolve: ok!, reject: err! }
+  }
+
   const getGlobalThis = features && 'getGlobalThis' in features
     ? (features.getGlobalThis ?? defaultGetGlobalThis)
     : defaultGetGlobalThis
 
+  const withResolvers = (features && 'withResolvers' in features)
+    ? (features.withResolvers ?? defaultWithResolvers)
+    : typeof Promise.withResolvers === 'function'
+      ? Promise.withResolvers
+      : defaultWithResolvers
+
   const getBuiltinModule: (id: string) => any = getGlobalThis?.().process?.getBuiltinModule ?? _require
 
   const ret: Features = {
@@ -146,6 +169,7 @@ export function detectFeatures (features?: Partial<Features>): Features {
         })(),
     ...features,
     getGlobalThis,
+    withResolvers
   }
 
   return ret

packages/runtime/src/util.ts

@@ -12,6 +12,7 @@
     "lib": [
       "ES2021",
       "ESNext.Disposable",
+      "ES2024.Promise",
       "DOM"
     ]
   },