@nmtjs/client 0.12.6 → 0.12.8

package/package.json

@@ -19,24 +19,23 @@
     }
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.12.6",
-    "@nmtjs/contract": "0.12.6",
-    "@nmtjs/common": "0.12.6",
-    "@nmtjs/protocol": "0.12.6"
+    "@nmtjs/contract": "0.12.8",
+    "@nmtjs/common": "0.12.8",
+    "@nmtjs/protocol": "0.12.8",
+    "@nmtjs/type": "0.12.8"
   },
   "devDependencies": {
-    "@nmtjs/type": "0.12.6",
-    "@nmtjs/common": "0.12.6",
-    "@nmtjs/contract": "0.12.6",
-    "@nmtjs/protocol": "0.12.6"
+    "@nmtjs/type": "0.12.8",
+    "@nmtjs/contract": "0.12.8",
+    "@nmtjs/common": "0.12.8",
+    "@nmtjs/protocol": "0.12.8"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.6",
+  "version": "0.12.8",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/src/common.ts

@@ -1,105 +0,0 @@
-import type { TAnyAPIContract } from '@nmtjs/contract'
-import {
-  EventEmitter,
-  type ProtocolBaseClientCallOptions,
-  type ProtocolBaseTransformer,
-  ProtocolError,
-  type ProtocolTransport,
-} from '@nmtjs/protocol/client'
-import type {
-  ClientCallers,
-  ResolveAPIContract,
-  ResolveClientEvents,
-  RuntimeInputContractTypeProvider,
-  RuntimeOutputContractTypeProvider,
-} from './types.ts'
-
-export {
-  ErrorCode,
-  ProtocolBlob,
-  type ProtocolBlobMetadata,
-  TransportType,
-} from '@nmtjs/protocol'
-export * from './types.ts'
-
-export class ClientError extends ProtocolError {}
-
-export abstract class BaseClient<
-  APIContract extends TAnyAPIContract = TAnyAPIContract,
-  SafeCall extends boolean = false,
-  API extends ResolveAPIContract<
-    APIContract,
-    RuntimeInputContractTypeProvider,
-    RuntimeOutputContractTypeProvider
-  > = ResolveAPIContract<
-    APIContract,
-    RuntimeInputContractTypeProvider,
-    RuntimeOutputContractTypeProvider
-  >,
-> extends EventEmitter<ResolveClientEvents<API>> {
-  _!: {
-    api: API
-    safe: SafeCall
-  }
-
-  protected abstract transformer: ProtocolBaseTransformer
-  protected callers!: ClientCallers<API, SafeCall>
-  protected auth: any
-
-  constructor(
-    readonly transport: ProtocolTransport,
-    readonly options: {
-      timeout: number
-      autoreconnect?: boolean
-      safe?: SafeCall
-    },
-  ) {
-    super()
-
-    if (this.options.autoreconnect) {
-      this.transport.on('disconnected', () =>
-        setTimeout(this.connect.bind(this), 1000),
-      )
-    }
-  }
-
-  protected async _call(
-    namespace: string,
-    procedure: string,
-    payload: any,
-    options: ProtocolBaseClientCallOptions,
-  ) {
-    const call = await this.transport.call(
-      namespace,
-      procedure,
-      payload,
-      options,
-      this.transformer,
-    )
-    if (this.options.safe) {
-      return await call.promise
-        .then((result) => ({ result }))
-        .catch((error) => ({ error }))
-    } else {
-      return await call.promise.catch((error) => {
-        throw error
-      })
-    }
-  }
-
-  get call() {
-    return this.callers
-  }
-
-  setAuth(auth: any) {
-    this.auth = auth
-  }
-
-  connect() {
-    return this.transport.connect(this.auth, this.transformer)
-  }
-
-  disconnect() {
-    return this.transport.disconnect()
-  }
-}

package/src/runtime.ts

@@ -1,83 +0,0 @@
-import type { TAnyAPIContract } from '@nmtjs/contract'
-import { ErrorCode } from '@nmtjs/protocol'
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client'
-import { NeemataTypeError, t } from '@nmtjs/type'
-import { BaseClient, ClientError } from './common.ts'
-
-export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-  protected contract: TAnyAPIContract
-
-  constructor(contract: TAnyAPIContract) {
-    super()
-
-    this.contract = contract
-  }
-
-  decodeEvent(namespace: string, event: string, payload: any) {
-    const type = this.contract.namespaces[namespace].events[event].payload
-    return type.decode(payload)
-  }
-
-  decodeRPC(namespace: string, procedure: string, payload: any) {
-    const type =
-      this.contract.namespaces[namespace].procedures[procedure].output
-    if (type instanceof t.NeverType) return undefined
-    return type.decode(payload)
-  }
-
-  decodeRPCChunk(namespace: string, procedure: string, payload: any) {
-    const type =
-      this.contract.namespaces[namespace].procedures[procedure].stream
-    if (!type || type instanceof t.NeverType) return undefined
-    return type.decode(payload)
-  }
-
-  encodeRPC(namespace: string, procedure: string, payload: any) {
-    const type = this.contract.namespaces[namespace].procedures[procedure].input
-    if (type instanceof t.NeverType) return undefined
-    try {
-      return type.encode(payload)
-    } catch (error) {
-      if (error instanceof NeemataTypeError) {
-        throw new ClientError(
-          ErrorCode.ValidationError,
-          `Invalid payload for ${namespace}.${procedure}: ${error.message}`,
-          error.issues,
-        )
-      }
-      throw error
-    }
-  }
-}
-
-export class RuntimeClient<
-  APIContract extends TAnyAPIContract,
-  SafeCall extends boolean,
-> extends BaseClient<APIContract, SafeCall> {
-  protected transformer: RuntimeContractTransformer
-
-  constructor(
-    public contract: APIContract,
-    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>
-  ) {
-    super(...args)
-
-    this.transformer = new RuntimeContractTransformer(this.contract)
-    const callers: any = {}
-    const namespaces = Object.entries(this.contract.namespaces)
-    for (const [namespaceKey, namespace] of namespaces) {
-      callers[namespaceKey] = {} as any
-
-      const procedures = Object.entries(namespace.procedures)
-
-      for (const [procedureKey, procedure] of procedures) {
-        callers[namespaceKey][procedureKey] = (payload, options) =>
-          this._call(namespace.name, procedure.name, payload, {
-            timeout: procedure.timeout || namespace.timeout || options.timeout,
-            ...options,
-          })
-      }
-    }
-    this.callers = callers
-  }
-}

package/src/static.ts

@@ -1,40 +0,0 @@
-import type { TAnyAPIContract } from '@nmtjs/contract'
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client'
-import { BaseClient } from './common.ts'
-
-export class StaticClient<
-  APIContract extends TAnyAPIContract,
-  SafeCall extends boolean = false,
-> extends BaseClient<APIContract, SafeCall> {
-  protected transformer: ProtocolBaseTransformer
-
-  constructor(
-    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>
-  ) {
-    super(...args)
-
-    this.transformer = new ProtocolBaseTransformer()
-
-    this.callers = new Proxy(Object(), {
-      get: (target, namespace) => {
-        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`
-        // without explicitly calling a function implicitly calls .then() on target
-        // FIXME: this basically makes "then" a reserved word
-        if (namespace === 'then') return target
-        return new Proxy(Object(), {
-          get: (target, procedure) => {
-            // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`
-            // without explicitly calling a function implicitly calls .then() on target
-            // FIXME: this basically makes "then" a reserved word
-            if (procedure === 'then') return target
-            return (payload, options) =>
-              this._call(namespace as string, procedure as string, payload, {
-                ...options,
-                timeout: options?.timeout ?? this.options.timeout,
-              })
-          },
-        })
-      },
-    })
-  }
-}

package/src/types.ts

@@ -1,151 +0,0 @@
-import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common'
-import type { TAnyAPIContract, TAnyProcedureContract } from '@nmtjs/contract'
-import type {
-  InputType,
-  OutputType,
-  ProtocolBaseClientCallOptions,
-  ProtocolError,
-  ProtocolServerStreamInterface,
-} from '@nmtjs/protocol/client'
-import type { BaseTypeAny, t } from '@nmtjs/type'
-
-export interface StaticInputContractTypeProvider extends TypeProvider {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.encoded.input<this['input']>
-    : never
-}
-
-export interface RuntimeInputContractTypeProvider extends TypeProvider {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.decoded.input<this['input']>
-    : never
-}
-
-export interface StaticOutputContractTypeProvider extends TypeProvider {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.encoded.output<this['input']>
-    : never
-}
-
-export interface RuntimeOutputContractTypeProvider extends TypeProvider {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.decoded.output<this['input']>
-    : never
-}
-
-export type AnyResolvedAPIContract = Record<
-  string,
-  {
-    procedures: Record<
-      string,
-      {
-        contract: TAnyProcedureContract
-        input: any
-        output: any
-      }
-    >
-    events: Record<
-      string,
-      {
-        payload: any
-      }
-    >
-  }
->
-
-export type ResolveAPIContract<
-  C extends TAnyAPIContract = TAnyAPIContract,
-  InputTypeProvider extends TypeProvider = TypeProvider,
-  OutputTypeProvider extends TypeProvider = TypeProvider,
-> = {
-  [N in keyof C['namespaces']]: {
-    procedures: {
-      [P in keyof C['namespaces'][N]['procedures']]: {
-        contract: C['namespaces'][N]['procedures'][P]
-        input: InputType<
-          CallTypeProvider<
-            InputTypeProvider,
-            C['namespaces'][N]['procedures'][P]['input']
-          >
-        >
-        output: C['namespaces'][N]['procedures'][P]['stream'] extends
-          | undefined
-          | t.NeverType
-          ? OutputType<
-              CallTypeProvider<
-                OutputTypeProvider,
-                C['namespaces'][N]['procedures'][P]['output']
-              >
-            >
-          : {
-              result: OutputType<
-                CallTypeProvider<
-                  OutputTypeProvider,
-                  C['namespaces'][N]['procedures'][P]['output']
-                >
-              >
-              stream: ProtocolServerStreamInterface<
-                CallTypeProvider<
-                  OutputTypeProvider,
-                  C['namespaces'][N]['procedures'][P]['stream']
-                >
-              >
-            }
-      }
-    }
-    events: {
-      [KE in keyof C['namespaces'][N]['events']]: {
-        payload: OutputType<
-          CallTypeProvider<
-            OutputTypeProvider,
-            C['namespaces'][N]['events'][KE]['payload']
-          >
-        >
-      }
-    }
-  }
-}
-
-export type ResolveClientEvents<
-  C extends AnyResolvedAPIContract = AnyResolvedAPIContract,
-> = {
-  [N in keyof C]: {
-    [E in keyof C[N]['events'] as `${Extract<N, string>}/${Extract<E, string>}`]: [
-      C[N]['events'][E]['payload'],
-    ]
-  }
-}[keyof C]
-
-export type ClientCallers<
-  Resolved extends AnyResolvedAPIContract,
-  SafeCall extends boolean,
-> = {
-  [N in keyof Resolved]: {
-    [P in keyof Resolved[N]['procedures']]: (
-      ...args: Resolved[N]['procedures'][P]['input'] extends t.NeverType
-        ? [data?: undefined, options?: Partial<ProtocolBaseClientCallOptions>]
-        : undefined extends t.infer.encoded.input<
-              Resolved[N]['procedures'][P]['contract']['input']
-            >
-          ? [
-              data?: Resolved[N]['procedures'][P]['input'],
-              options?: Partial<ProtocolBaseClientCallOptions>,
-            ]
-          : [
-              data: Resolved[N]['procedures'][P]['input'],
-              options?: Partial<ProtocolBaseClientCallOptions>,
-            ]
-    ) => SafeCall extends true
-      ? Promise<
-          OneOf<
-            [
-              {
-                output: Resolved[N]['procedures'][P]['output']
-              },
-              { error: ProtocolError },
-            ]
-          >
-        >
-      : Promise<Resolved[N]['procedures'][P]['output']>
-  }
-}