@zimi/remote 0.1.0 → 0.1.1-alpha.0

package/src/remoteValue/index.ts

@@ -0,0 +1,129 @@
+import { RemoteError, RemoteTimeoutError, response } from '../response'
+import { Adaptor, AdaptorCallback, AdaptorPackageData } from '../adaptor'
+import type { ToFunc } from './type'
+
+function noop() {
+  // pass
+}
+
+type RemoteValueProps = Pick<
+  AdaptorPackageData,
+  'deviceId' | 'targetDeviceId'
+> & {
+  globalName: string
+  adaptor: Adaptor
+  timeoutMs?: number
+}
+
+function geneProxy<T extends object>(paths: string[], props: RemoteValueProps) {
+  return new Proxy<ToFunc<T>>(noop as unknown as ToFunc<T>, {
+    apply(target, thisArg, argArray) {
+      const { adaptor, globalName, timeoutMs = 30000, ...restProps } = props
+      const randomStr = Math.random().toString(36).slice(2)
+      const name = `__REMOTE_VALUE_REQ__${globalName}`
+      const responseName = `__REMOTE_VALUE_RES__${[globalName, ...paths].join('.')}-${randomStr}`
+
+      return new Promise((resolve, reject) => {
+        let timer: NodeJS.Timeout | undefined
+        const callback: AdaptorCallback = (e) => {
+          clearTimeout(timer)
+          if (RemoteError.isRemoteError(e.data)) {
+            reject(RemoteError.fromError(e.data))
+          } else {
+            resolve((e.data as ReturnType<typeof response.success>)?.data)
+          }
+        }
+        adaptor.once(responseName, callback)
+        timer = setTimeout(() => {
+          adaptor.off(responseName, callback)
+          reject(
+            new RemoteTimeoutError(
+              `timeout: ${[globalName, ...paths].join('.')}`
+            )
+          )
+        }, timeoutMs)
+        adaptor.emit({
+          name,
+          callbackName: responseName,
+          ...restProps,
+          data: {
+            paths,
+            args: argArray,
+          },
+        })
+      })
+    },
+    get(target, prop) {
+      return geneProxy([...paths, prop as string], props)
+    },
+  })
+}
+
+/**
+ * @example
+ * ```
+ * const obj = remoteValue<{
+ *   a: number;
+ *   b: {
+ *     c: string;
+ *   };
+ *   funcD: () => number
+ * }>()
+ *
+ * const val_1 = await obj.a()      // number
+ * const val_2 = await obj.b()      // { c: string }
+ * const val_3 = await obj.b.c()    // string
+ * const val_4 = await obj.funcD()  // number
+ * ```
+ */
+export function remoteValue<T extends object>(props: RemoteValueProps) {
+  return geneProxy<T>([], props)
+}
+
+interface ExposeProps {
+  globalName: string
+  adaptor: Adaptor
+  /**
+   * ['*'] or ['device_id_1', 'device_id_2']
+   */
+  exposeTo: string[]
+}
+
+export function exposeToRemote<T extends object>(obj: T, options: ExposeProps) {
+  const { globalName, adaptor, exposeTo } = options
+  const callback = async (e: AdaptorPackageData) => {
+    try {
+      if (!exposeTo.includes(e.deviceId) && !exposeTo.includes('*')) {
+        throw new RemoteError('permission denied')
+      }
+      const { paths, args } = e.data as { paths: string[]; args: unknown[] }
+      let target = obj
+      for (let i = 0; i < paths.length - 1; i += 1) {
+        target = target[paths[i] as keyof typeof target] as typeof target
+      }
+      let res: unknown
+      if (target instanceof Function) {
+        res = await target(...args)
+      } else {
+        res = target
+      }
+      adaptor.emit({
+        name: e.callbackName ?? 'IMPOSSIBLE_NO_CALLBACK_NAME',
+        deviceId: e.targetDeviceId,
+        targetDeviceId: e.deviceId,
+        data: response.success(res),
+      })
+    } catch (error) {
+      adaptor.emit({
+        name: e.callbackName ?? 'IMPOSSIBLE_NO_CALLBACK_NAME',
+        deviceId: e.targetDeviceId,
+        targetDeviceId: e.deviceId,
+        data: response.error(RemoteError.fromError(error)),
+      })
+    }
+  }
+  adaptor.on(`__REMOTE_VALUE_REQ__${globalName}`, callback)
+  return () => {
+    adaptor.off(`__REMOTE_VALUE_REQ__${globalName}`, callback)
+  }
+}

package/src/remoteValue/type.d.ts

@@ -0,0 +1,113 @@
+type HasFunc<T> = T extends (...args: unknown[]) => unknown
+  ? true
+  : T extends unknown[]
+    ? { [K in keyof T]: HasFunc<T[K]> }[number] extends false
+      ? false
+      : true
+    : T extends object
+      ? { [K in keyof T]: HasFunc<T[K]> }[keyof T] extends false
+        ? false
+        : true
+      : false
+
+export type ToFunc<T extends object> = {
+  [K in keyof T]: T[K] extends (...args: infer Args) => infer Ret
+    ? (...args: Args) => Promise<Awaited<Ret>>
+    : HasFunc<T[K]> extends false
+      ? () => Promise<T[K]>
+      : T[K] extends object
+        ? ToFunc<T[K]>
+        : never
+}
+
+type Assert<T extends true> = T
+
+interface TestObj {
+  a1: number
+  a2: number[]
+  a3: [number, string]
+  a4: {
+    b: number
+    c: [string]
+  }
+  a5: () => Promise<number>
+  a6: () => Promise<number[]>
+  a7: () => Promise<[number, string]>
+  b: {
+    b1: number
+    b2: number[]
+    b3: [number, string]
+    b4: () => {
+      b: number
+      c: [string]
+    }
+    b5: () => Promise<number>
+    b6: () => Promise<number[]>
+    b7: () => Promise<[number, string]>
+  }
+  f: {
+    b: number
+    c: {
+      d: () => number
+    }
+  }
+}
+
+export type TestA1 = Assert<
+  ToFunc<TestObj>['a1'] extends () => Promise<number> ? true : false
+>
+export type TestA2 = Assert<
+  ToFunc<TestObj>['a2'] extends () => Promise<number[]> ? true : false
+>
+export type TestA3 = Assert<
+  ToFunc<TestObj>['a3'] extends () => Promise<[number, string]> ? true : false
+>
+export type TestA4 = Assert<
+  ToFunc<TestObj>['a4'] extends () => Promise<{
+    b: number
+    c: [string]
+  }>
+    ? true
+    : false
+>
+export type TestA5 = Assert<
+  ToFunc<TestObj>['a5'] extends () => Promise<number> ? true : false
+>
+export type TestA6 = Assert<
+  ToFunc<TestObj>['a6'] extends () => Promise<number[]> ? true : false
+>
+export type TestA7 = Assert<
+  ToFunc<TestObj>['a7'] extends () => Promise<[number, string]> ? true : false
+>
+export type TestB1 = Assert<
+  ToFunc<TestObj>['b']['b1'] extends () => Promise<number> ? true : false
+>
+export type TestB2 = Assert<
+  ToFunc<TestObj>['b']['b2'] extends () => Promise<number[]> ? true : false
+>
+export type TestB3 = Assert<
+  ToFunc<TestObj>['b']['b3'] extends () => Promise<[number, string]> ? true : false
+>
+export type TestB4 = Assert<
+  ToFunc<TestObj>['b']['b4'] extends () => Promise<{
+    b: number
+    c: [string]
+  }>
+    ? true
+    : false
+>
+export type TestB5 = Assert<
+  ToFunc<TestObj>['b']['b5'] extends () => Promise<number> ? true : false
+>
+export type TestB6 = Assert<
+  ToFunc<TestObj>['b']['b6'] extends () => Promise<number[]> ? true : false
+>
+export type TestB7 = Assert<
+  ToFunc<TestObj>['b']['b7'] extends () => Promise<[number, string]> ? true : false
+>
+export type TestF = Assert<
+  ToFunc<TestObj>['f']['b'] extends () => Promise<number> ? true : false
+>
+export type TestF2 = Assert<
+  ToFunc<TestObj>['f']['c']['d'] extends () => Promise<number> ? true : false
+>