@nmtjs/client 0.5.3 → 0.6.0

package/dist/common.js

@@ -0,0 +1,5 @@
+import { ProtocolError } from '@nmtjs/protocol/client';
+export * from "./types.js";
+export class ClientError extends ProtocolError {
+}
+export { ProtocolBlob, ErrorCode, TransportType } from '@nmtjs/protocol/common';

package/dist/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../lib/common.ts"],"sourcesContent":["import { ProtocolError } from '@nmtjs/protocol/client'\n\nexport * from './types.ts'\n\nexport class ClientError extends ProtocolError {}\n\nexport {\n  ProtocolBlob,\n  ErrorCode,\n  TransportType,\n  type ProtocolBlobMetadata,\n} from '@nmtjs/protocol/common'\n"],"names":["ProtocolError","ClientError","ProtocolBlob","ErrorCode","TransportType"],"mappings":"AAAA,SAASA,aAAa,QAAQ,yBAAwB;AAEtD,cAAc,aAAY;AAE1B,OAAO,MAAMC,oBAAoBD;AAAe;AAEhD,SACEE,YAAY,EACZC,SAAS,EACTC,aAAa,QAER,yBAAwB"}

package/dist/runtime.js

@@ -0,0 +1,92 @@
+import { ProtocolBaseClient, ProtocolBaseTransformer } from '@nmtjs/protocol/client';
+import { ErrorCode } from '@nmtjs/protocol/common';
+import { NeverType } from '@nmtjs/type';
+import { compile } from '@nmtjs/type/compiler';
+import { ClientError } from "./common.js";
+export class RuntimeContractTransformer extends ProtocolBaseTransformer {
+    #contract;
+    #types = new Set();
+    #compiled = new Map();
+    constructor(contract){
+        super();
+        this.#contract = contract;
+        for (const namespace of Object.values(contract.namespaces)){
+            for (const procedure of Object.values(namespace.procedures)){
+                const { input, output, stream } = procedure;
+                this.#registerType(input);
+                this.#registerType(output);
+                this.#registerType(stream);
+            }
+            for (const subscription of Object.values(namespace.subscriptions)){
+                const { input, output } = subscription;
+                this.#registerType(input);
+                this.#registerType(output);
+                for (const event of Object.values(subscription.events)){
+                    this.#registerType(event.payload);
+                }
+            }
+            for (const event of Object.values(namespace.events)){
+                this.#registerType(event.payload);
+            }
+        }
+        this.#compile();
+    }
+    decodeEvent(namespace, event, payload) {
+        const type = this.#contract.namespaces[namespace].events[event].payload;
+        if (type instanceof NeverType) return undefined;
+        const compiled = this.#compiled.get(type);
+        return compiled.decode(payload);
+    }
+    decodeRPC(namespace, procedure, payload) {
+        const type = this.#contract.namespaces[namespace].procedures[procedure].output;
+        if (type instanceof NeverType) return undefined;
+        const compiled = this.#compiled.get(type);
+        return compiled.decode(payload);
+    }
+    decodeRPCChunk(namespace, procedure, payload) {
+        const type = this.#contract.namespaces[namespace].procedures[procedure].stream;
+        if (type instanceof NeverType) return undefined;
+        const compiled = this.#compiled.get(type);
+        return compiled.decode(payload);
+    }
+    encodeRPC(namespace, procedure, payload) {
+        const type = this.#contract.namespaces[namespace].procedures[procedure].input;
+        if (type instanceof NeverType) return undefined;
+        const compiled = this.#compiled.get(type);
+        if (!compiled.check(payload)) {
+            const errors = compiled.errors(payload);
+            throw new ClientError(ErrorCode.ValidationError, 'Invalid RPC payload', errors);
+        }
+        return compiled.encode(payload);
+    }
+    #registerType(type) {
+        this.#types.add(type);
+    }
+    #compile() {
+        for (const type of this.#types){
+            this.#compiled.set(type, compile(type));
+        }
+    }
+}
+export class RuntimeClient extends ProtocolBaseClient {
+    _;
+    #callers = {};
+    constructor(contract, transport, format){
+        super(transport, format, new RuntimeContractTransformer(contract));
+        const callers = {};
+        for (const [namespaceKey, namespace] of Object.entries(contract.namespaces)){
+            namespace.procedures;
+            callers[namespaceKey] = {};
+            for (const [procedureKey, procedure] of Object.entries(namespace.procedures)){
+                callers[namespaceKey][procedureKey] = (payload, options)=>this._call(namespace.name, procedure.name, payload, {
+                        timeout: namespace.timeout,
+                        ...options
+                    });
+            }
+        }
+        this.#callers = callers;
+    }
+    get call() {
+        return this.#callers;
+    }
+}

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../lib/runtime.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport {\n  ProtocolBaseClient,\n  ProtocolBaseTransformer,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\nimport type { BaseClientFormat } from '@nmtjs/protocol/client'\nimport { ErrorCode } from '@nmtjs/protocol/common'\nimport { type BaseTypeAny, NeverType } from '@nmtjs/type'\nimport { type Compiled, compile } from '@nmtjs/type/compiler'\nimport { ClientError } from './common.ts'\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  RuntimeContractTypeProvider,\n} from './types.ts'\n\nexport class RuntimeContractTransformer extends ProtocolBaseTransformer {\n  #contract: TAnyAPIContract\n  #types = new Set<BaseTypeAny>()\n  #compiled = new Map<BaseTypeAny, Compiled>()\n\n  constructor(contract: TAnyAPIContract) {\n    super()\n\n    this.#contract = contract\n\n    for (const namespace of Object.values(contract.namespaces)) {\n      for (const procedure of Object.values(namespace.procedures)) {\n        const { input, output, stream } = procedure\n        this.#registerType(input)\n        this.#registerType(output)\n        this.#registerType(stream)\n      }\n\n      for (const subscription of Object.values(namespace.subscriptions)) {\n        const { input, output } = subscription\n        this.#registerType(input)\n        this.#registerType(output)\n\n        for (const event of Object.values(subscription.events)) {\n          this.#registerType(event.payload)\n        }\n      }\n\n      for (const event of Object.values(namespace.events)) {\n        this.#registerType(event.payload)\n      }\n    }\n\n    this.#compile()\n  }\n\n  decodeEvent(namespace: string, event: string, payload: any) {\n    const type = this.#contract.namespaces[namespace].events[event].payload\n    if (type instanceof NeverType) return undefined\n    const compiled = this.#compiled.get(type)!\n    return compiled.decode(payload)\n  }\n\n  decodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].output\n    if (type instanceof NeverType) return undefined\n    const compiled = this.#compiled.get(type)!\n    return compiled.decode(payload)\n  }\n\n  decodeRPCChunk(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].stream\n    if (type instanceof NeverType) return undefined\n\n    const compiled = this.#compiled.get(type)!\n    return compiled.decode(payload)\n  }\n\n  encodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].input\n    if (type instanceof NeverType) return undefined\n\n    const compiled = this.#compiled.get(type)!\n    if (!compiled.check(payload)) {\n      const errors = compiled.errors(payload)\n      throw new ClientError(\n        ErrorCode.ValidationError,\n        'Invalid RPC payload',\n        errors,\n      )\n    }\n\n    return compiled.encode(payload)\n  }\n\n  #registerType(type: BaseTypeAny) {\n    this.#types.add(type)\n  }\n\n  #compile() {\n    for (const type of this.#types) {\n      this.#compiled.set(type, compile(type))\n    }\n  }\n}\n\nexport class RuntimeClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    RuntimeContractTypeProvider\n  > = ResolveAPIContract<APIContract, RuntimeContractTypeProvider>,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n  #callers = {} as ClientCallers<ResolvedAPIContract>\n\n  constructor(\n    contract: APIContract,\n    transport: ProtocolTransport,\n    format: BaseClientFormat,\n  ) {\n    super(transport, format, new RuntimeContractTransformer(contract))\n\n    const callers = {} as any\n\n    for (const [namespaceKey, namespace] of Object.entries(\n      contract.namespaces,\n    )) {\n      namespace.procedures\n\n      callers[namespaceKey] = {} as any\n\n      for (const [procedureKey, procedure] of Object.entries(\n        namespace.procedures,\n      )) {\n        callers[namespaceKey][procedureKey] = (payload, options) =>\n          this._call(namespace.name, procedure.name, payload, {\n            timeout: namespace.timeout,\n            ...options,\n          })\n      }\n    }\n    this.#callers = callers\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"names":["ProtocolBaseClient","ProtocolBaseTransformer","ErrorCode","NeverType","compile","ClientError","RuntimeContractTransformer","Set","Map","constructor","contract","namespace","Object","values","namespaces","procedure","procedures","input","output","stream","subscription","subscriptions","event","events","payload","decodeEvent","type","undefined","compiled","get","decode","decodeRPC","decodeRPCChunk","encodeRPC","check","errors","ValidationError","encode","add","set","RuntimeClient","_","transport","format","callers","namespaceKey","entries","procedureKey","options","_call","name","timeout","call"],"mappings":"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"}

package/dist/static.js

@@ -0,0 +1,22 @@
+import { ProtocolBaseClient } from '@nmtjs/protocol/client';
+export class StaticClient extends ProtocolBaseClient {
+    _;
+    #callers;
+    constructor(transport, format){
+        super(transport, format);
+        this.#callers = new Proxy(Object(), {
+            get: (target, namespaceProp, receiver)=>{
+                if (namespaceProp === 'then') return target;
+                return new Proxy(Object(), {
+                    get: (target, procedureProp, receiver)=>{
+                        if (procedureProp === 'then') return target;
+                        return (payload, options)=>this._call(namespaceProp, procedureProp, payload);
+                    }
+                });
+            }
+        });
+    }
+    get call() {
+        return this.#callers;
+    }
+}

package/dist/static.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../lib/static.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport {\n  type BaseClientFormat,\n  ProtocolBaseClient,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\n\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  StaticContractTypeProvider,\n} from './types.ts'\n\nexport class StaticClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    StaticContractTypeProvider\n  > = ResolveAPIContract<APIContract, StaticContractTypeProvider>,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n\n  #callers: ClientCallers<ResolvedAPIContract>\n\n  constructor(transport: ProtocolTransport, format: BaseClientFormat) {\n    super(transport, format)\n\n    this.#callers = new Proxy(Object(), {\n      get: (target, namespaceProp, receiver) => {\n        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n        // without explicitly calling a function implicitly calls .then() on target\n        // FIXME: this basically makes \"then\" a reserved word\n        if (namespaceProp === 'then') return target\n        return new Proxy(Object(), {\n          get: (target, procedureProp, receiver) => {\n            // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n            // without explicitly calling a function implicitly calls .then() on target\n            // FIXME: this basically makes \"then\" a reserved word\n            if (procedureProp === 'then') return target\n            return (payload, options) =>\n              this._call(\n                namespaceProp as string,\n                procedureProp as string,\n                payload,\n              )\n          },\n        })\n      },\n    })\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"names":["ProtocolBaseClient","StaticClient","_","constructor","transport","format","Proxy","Object","get","target","namespaceProp","receiver","procedureProp","payload","options","_call","call"],"mappings":"AACA,SAEEA,kBAAkB,QAEb,yBAAwB;AAS/B,OAAO,MAAMC,qBAMHD;IACRE,EAAuB;IAEvB,CAAA,OAAQ,CAAoC;IAE5CC,YAAYC,SAA4B,EAAEC,MAAwB,CAAE;QAClE,KAAK,CAACD,WAAWC;QAEjB,IAAI,CAAC,CAAA,OAAQ,GAAG,IAAIC,MAAMC,UAAU;YAClCC,KAAK,CAACC,QAAQC,eAAeC;gBAI3B,IAAID,kBAAkB,QAAQ,OAAOD;gBACrC,OAAO,IAAIH,MAAMC,UAAU;oBACzBC,KAAK,CAACC,QAAQG,eAAeD;wBAI3B,IAAIC,kBAAkB,QAAQ,OAAOH;wBACrC,OAAO,CAACI,SAASC,UACf,IAAI,CAACC,KAAK,CACRL,eACAE,eACAC;oBAEN;gBACF;YACF;QACF;IACF;IAEA,IAAIG,OAAO;QACT,OAAO,IAAI,CAAC,CAAA,OAAQ;IACtB;AACF"}

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../lib/types.ts"],"sourcesContent":["import type { CallTypeProvider, TypeProvider } from '@nmtjs/common'\nimport type { TAnyAPIContract } from '@nmtjs/contract'\nimport type { ProtocolServerStream } from '@nmtjs/protocol/client'\nimport type { InputType, OutputType } from '@nmtjs/protocol/common'\nimport type { BaseTypeAny, NeverType, t } from '@nmtjs/type'\n\nexport interface StaticContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.input.decoded<this['input']>\n    : never\n}\n\nexport interface RuntimeContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded<this['input']>\n    : never\n}\n\nexport type ResolveAPIContract<\n  C extends TAnyAPIContract = TAnyAPIContract,\n  T extends TypeProvider = TypeProvider,\n> = {\n  [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {\n    procedures: {\n      [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {\n        contract: C['namespaces'][N]['procedures'][P]\n        input: InputType<\n          CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['input']>\n        >\n        output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType\n          ? OutputType<\n              CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['output']>\n            >\n          : [\n              result: OutputType<\n                CallTypeProvider<\n                  T,\n                  C['namespaces'][N]['procedures'][P]['output']\n                >\n              >,\n              stream: ProtocolServerStream<\n                CallTypeProvider<\n                  T,\n                  C['namespaces'][N]['procedures'][P]['stream']\n                >\n              >,\n            ]\n      }\n    }\n    events: {\n      [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {\n        payload: OutputType<\n          CallTypeProvider<T, C['namespaces'][N]['events'][KE]['payload']>\n        >\n      }\n    }\n  }\n}\n\nexport type ResolveClientEvents<\n  C extends ResolveAPIContract = ResolveAPIContract,\n> = {\n  [N in keyof C]: {\n    [KE in keyof C[N]['events']]: C[N]['events'][KE]['payload']\n  }\n}\n\nexport type ClientCallOptions = {\n  signal?: AbortSignal\n}\n\nexport type ClientCallers<Resolved extends ResolveAPIContract> = {\n  [N in keyof Resolved]: {\n    [P in keyof Resolved[N]['procedures']]: (\n      ...args: Resolved[N]['procedures'][P]['input'] extends NeverType\n        ? [options?: ClientCallOptions]\n        : t.infer.input.encoded<\n              Resolved[N]['procedures'][P]['contract']['input']\n            > extends undefined\n          ? [\n              data?: Resolved[N]['procedures'][P]['input'],\n              options?: ClientCallOptions,\n            ]\n          : [\n              data: Resolved[N]['procedures'][P]['input'],\n              options?: ClientCallOptions,\n            ]\n    ) => Promise<Resolved[N]['procedures'][P]['output']>\n  }\n}\n"],"names":[],"mappings":"AAuEA,WAkBC"}

package/lib/common.ts

@@ -1,9 +1,12 @@
-export class ClientError extends Error {
-  constructor(
-    public code: string,
-    message?: string,
-    public data?: any,
-  ) {
-    super(message)
-  }
-}
+import { ProtocolError } from '@nmtjs/protocol/client'
+
+export * from './types.ts'
+
+export class ClientError extends ProtocolError {}
+
+export {
+  ProtocolBlob,
+  ErrorCode,
+  TransportType,
+  type ProtocolBlobMetadata,
+} from '@nmtjs/protocol/common'

package/lib/runtime.ts

@@ -0,0 +1,150 @@
+import type { TAnyAPIContract } from '@nmtjs/contract'
+import {
+  ProtocolBaseClient,
+  ProtocolBaseTransformer,
+  type ProtocolTransport,
+} from '@nmtjs/protocol/client'
+import type { BaseClientFormat } from '@nmtjs/protocol/client'
+import { ErrorCode } from '@nmtjs/protocol/common'
+import { type BaseTypeAny, NeverType } from '@nmtjs/type'
+import { type Compiled, compile } from '@nmtjs/type/compiler'
+import { ClientError } from './common.ts'
+import type {
+  ClientCallers,
+  ResolveAPIContract,
+  ResolveClientEvents,
+  RuntimeContractTypeProvider,
+} from './types.ts'
+
+export class RuntimeContractTransformer extends ProtocolBaseTransformer {
+  #contract: TAnyAPIContract
+  #types = new Set<BaseTypeAny>()
+  #compiled = new Map<BaseTypeAny, Compiled>()
+
+  constructor(contract: TAnyAPIContract) {
+    super()
+
+    this.#contract = contract
+
+    for (const namespace of Object.values(contract.namespaces)) {
+      for (const procedure of Object.values(namespace.procedures)) {
+        const { input, output, stream } = procedure
+        this.#registerType(input)
+        this.#registerType(output)
+        this.#registerType(stream)
+      }
+
+      for (const subscription of Object.values(namespace.subscriptions)) {
+        const { input, output } = subscription
+        this.#registerType(input)
+        this.#registerType(output)
+
+        for (const event of Object.values(subscription.events)) {
+          this.#registerType(event.payload)
+        }
+      }
+
+      for (const event of Object.values(namespace.events)) {
+        this.#registerType(event.payload)
+      }
+    }
+
+    this.#compile()
+  }
+
+  decodeEvent(namespace: string, event: string, payload: any) {
+    const type = this.#contract.namespaces[namespace].events[event].payload
+    if (type instanceof NeverType) return undefined
+    const compiled = this.#compiled.get(type)!
+    return compiled.decode(payload)
+  }
+
+  decodeRPC(namespace: string, procedure: string, payload: any) {
+    const type =
+      this.#contract.namespaces[namespace].procedures[procedure].output
+    if (type instanceof NeverType) return undefined
+    const compiled = this.#compiled.get(type)!
+    return compiled.decode(payload)
+  }
+
+  decodeRPCChunk(namespace: string, procedure: string, payload: any) {
+    const type =
+      this.#contract.namespaces[namespace].procedures[procedure].stream
+    if (type instanceof NeverType) return undefined
+
+    const compiled = this.#compiled.get(type)!
+    return compiled.decode(payload)
+  }
+
+  encodeRPC(namespace: string, procedure: string, payload: any) {
+    const type =
+      this.#contract.namespaces[namespace].procedures[procedure].input
+    if (type instanceof NeverType) return undefined
+
+    const compiled = this.#compiled.get(type)!
+    if (!compiled.check(payload)) {
+      const errors = compiled.errors(payload)
+      throw new ClientError(
+        ErrorCode.ValidationError,
+        'Invalid RPC payload',
+        errors,
+      )
+    }
+
+    return compiled.encode(payload)
+  }
+
+  #registerType(type: BaseTypeAny) {
+    this.#types.add(type)
+  }
+
+  #compile() {
+    for (const type of this.#types) {
+      this.#compiled.set(type, compile(type))
+    }
+  }
+}
+
+export class RuntimeClient<
+  APIContract extends TAnyAPIContract,
+  ResolvedAPIContract extends ResolveAPIContract<
+    APIContract,
+    RuntimeContractTypeProvider
+  > = ResolveAPIContract<APIContract, RuntimeContractTypeProvider>,
+> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {
+  _!: ResolvedAPIContract
+  #callers = {} as ClientCallers<ResolvedAPIContract>
+
+  constructor(
+    contract: APIContract,
+    transport: ProtocolTransport,
+    format: BaseClientFormat,
+  ) {
+    super(transport, format, new RuntimeContractTransformer(contract))
+
+    const callers = {} as any
+
+    for (const [namespaceKey, namespace] of Object.entries(
+      contract.namespaces,
+    )) {
+      namespace.procedures
+
+      callers[namespaceKey] = {} as any
+
+      for (const [procedureKey, procedure] of Object.entries(
+        namespace.procedures,
+      )) {
+        callers[namespaceKey][procedureKey] = (payload, options) =>
+          this._call(namespace.name, procedure.name, payload, {
+            timeout: namespace.timeout,
+            ...options,
+          })
+      }
+    }
+    this.#callers = callers
+  }
+
+  get call() {
+    return this.#callers
+  }
+}

package/lib/static.ts

@@ -0,0 +1,56 @@
+import type { TAnyAPIContract } from '@nmtjs/contract'
+import {
+  type BaseClientFormat,
+  ProtocolBaseClient,
+  type ProtocolTransport,
+} from '@nmtjs/protocol/client'
+
+import type {
+  ClientCallers,
+  ResolveAPIContract,
+  ResolveClientEvents,
+  StaticContractTypeProvider,
+} from './types.ts'
+
+export class StaticClient<
+  APIContract extends TAnyAPIContract,
+  ResolvedAPIContract extends ResolveAPIContract<
+    APIContract,
+    StaticContractTypeProvider
+  > = ResolveAPIContract<APIContract, StaticContractTypeProvider>,
+> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {
+  _!: ResolvedAPIContract
+
+  #callers: ClientCallers<ResolvedAPIContract>
+
+  constructor(transport: ProtocolTransport, format: BaseClientFormat) {
+    super(transport, format)
+
+    this.#callers = new Proxy(Object(), {
+      get: (target, namespaceProp, receiver) => {
+        // `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 (namespaceProp === 'then') return target
+        return new Proxy(Object(), {
+          get: (target, procedureProp, receiver) => {
+            // `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 (procedureProp === 'then') return target
+            return (payload, options) =>
+              this._call(
+                namespaceProp as string,
+                procedureProp as string,
+                payload,
+              )
+          },
+        })
+      },
+    })
+  }
+
+  get call() {
+    return this.#callers
+  }
+}

package/lib/types.ts

@@ -1,22 +1,90 @@
-import type { ApiBlob, ApiBlobInterface } from '@nmtjs/common'
-import type { ClientDownStreamBlob } from './stream.ts'
+import type { CallTypeProvider, TypeProvider } from '@nmtjs/common'
+import type { TAnyAPIContract } from '@nmtjs/contract'
+import type { ProtocolServerStream } from '@nmtjs/protocol/client'
+import type { InputType, OutputType } from '@nmtjs/protocol/common'
+import type { BaseTypeAny, NeverType, t } from '@nmtjs/type'
+
+export interface StaticContractTypeProvider extends TypeProvider {
+  output: this['input'] extends BaseTypeAny
+    ? t.infer.input.decoded<this['input']>
+    : never
+}
+
+export interface RuntimeContractTypeProvider extends TypeProvider {
+  output: this['input'] extends BaseTypeAny
+    ? t.infer.decoded<this['input']>
+    : never
+}
+
+export type ResolveAPIContract<
+  C extends TAnyAPIContract = TAnyAPIContract,
+  T extends TypeProvider = TypeProvider,
+> = {
+  [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {
+    procedures: {
+      [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {
+        contract: C['namespaces'][N]['procedures'][P]
+        input: InputType<
+          CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['input']>
+        >
+        output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType
+          ? OutputType<
+              CallTypeProvider<T, C['namespaces'][N]['procedures'][P]['output']>
+            >
+          : [
+              result: OutputType<
+                CallTypeProvider<
+                  T,
+                  C['namespaces'][N]['procedures'][P]['output']
+                >
+              >,
+              stream: ProtocolServerStream<
+                CallTypeProvider<
+                  T,
+                  C['namespaces'][N]['procedures'][P]['stream']
+                >
+              >,
+            ]
+      }
+    }
+    events: {
+      [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {
+        payload: OutputType<
+          CallTypeProvider<T, C['namespaces'][N]['events'][KE]['payload']>
+        >
+      }
+    }
+  }
+}
+
+export type ResolveClientEvents<
+  C extends ResolveAPIContract = ResolveAPIContract,
+> = {
+  [N in keyof C]: {
+    [KE in keyof C[N]['events']]: C[N]['events'][KE]['payload']
+  }
+}
 
 export type ClientCallOptions = {
   signal?: AbortSignal
 }
 
-export type InputType<T> = T extends any[]
-  ? InputType<T[number]>[]
-  : T extends ApiBlobInterface
-    ? ApiBlob
-    : T extends object
-      ? { [K in keyof T]: InputType<T[K]> }
-      : T
-
-export type OutputType<T> = T extends any[]
-  ? OutputType<T[number]>[]
-  : T extends ApiBlobInterface
-    ? ClientDownStreamBlob
-    : T extends object
-      ? { [K in keyof T]: OutputType<T[K]> }
-      : T
+export type ClientCallers<Resolved extends ResolveAPIContract> = {
+  [N in keyof Resolved]: {
+    [P in keyof Resolved[N]['procedures']]: (
+      ...args: Resolved[N]['procedures'][P]['input'] extends NeverType
+        ? [options?: ClientCallOptions]
+        : t.infer.input.encoded<
+              Resolved[N]['procedures'][P]['contract']['input']
+            > extends undefined
+          ? [
+              data?: Resolved[N]['procedures'][P]['input'],
+              options?: ClientCallOptions,
+            ]
+          : [
+              data: Resolved[N]['procedures'][P]['input'],
+              options?: ClientCallOptions,
+            ]
+    ) => Promise<Resolved[N]['procedures'][P]['output']>
+  }
+}

package/package.json

@@ -3,25 +3,26 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./index.ts",
-      "default": "./dist/index.js",
-      "types": "./index.ts"
+      "bun": "./lib/common.ts",
+      "default": "./dist/common.js",
+      "types": "./lib/common.ts"
     },
     "./runtime": {
-      "bun": "./lib/client-runtime.ts",
-      "default": "./dist/lib/client-runtime.js",
-      "types": "./lib/client-runtime.ts"
+      "bun": "./lib/runtime.ts",
+      "default": "./dist/runtime.js",
+      "types": "./lib/runtime.ts"
     },
     "./static": {
-      "bun": "./lib/client-static.ts",
-      "default": "./dist/lib/client-static.js",
-      "types": "./lib/client-static.ts"
+      "bun": "./lib/static.ts",
+      "default": "./dist/static.js",
+      "types": "./lib/static.ts"
     }
   },
   "dependencies": {
-    "@nmtjs/type": "0.5.3",
-    "@nmtjs/common": "0.5.3",
-    "@nmtjs/contract": "0.5.3"
+    "@nmtjs/contract": "0.6.0",
+    "@nmtjs/common": "0.6.0",
+    "@nmtjs/type": "0.6.0",
+    "@nmtjs/protocol": "0.6.0"
   },
   "files": [
     "index.ts",
@@ -31,9 +32,9 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.5.3",
+  "version": "0.6.0",
   "scripts": {
-    "build": "neemata-build -p neutral ./index.ts './lib/**/*.ts'",
+    "build": "neemata-build -p neutral --root=./lib './**/*.ts'",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/index.js

@@ -1,6 +0,0 @@
-export * from "./lib/client.js";
-export * from "./lib/common.js";
-export * from "./lib/stream.js";
-export * from "./lib/subscription.js";
-export * from "./lib/transport.js";
-export * from "./lib/utils.js";

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../index.ts"],"sourcesContent":["export * from './lib/client.ts'\nexport * from './lib/common.ts'\nexport * from './lib/stream.ts'\nexport * from './lib/subscription.ts'\nexport * from './lib/transport.ts'\nexport * from './lib/utils.ts'\n"],"names":[],"mappings":"AAAA,cAAc,kBAAiB;AAC/B,cAAc,kBAAiB;AAC/B,cAAc,kBAAiB;AAC/B,cAAc,wBAAuB;AACrC,cAAc,qBAAoB;AAClC,cAAc,iBAAgB"}

package/dist/lib/client-runtime.js

@@ -1,87 +0,0 @@
-import { NeverType } from '@nmtjs/type';
-import { compile } from '@nmtjs/type/compiler';
-import { Client } from "./client.js";
-export class RuntimeClient extends Client {
-    contracts;
-    $types;
-    #callers;
-    constructor(contracts, options){
-        super(options, Object.values(contracts).map((s)=>s.contract.name));
-        this.contracts = contracts;
-        const callers = {};
-        for (const [serviceKey, service] of Object.entries(contracts)){
-            service.contract.procedures;
-            callers[serviceKey] = {};
-            for(const procedureName in service.contract.procedures){
-                const { input, output } = service.contract.procedures[procedureName];
-                function decodeOutput(data) {
-                    if (output instanceof NeverType) return undefined;
-                    const compiled = service.compiled.get(output);
-                    const result = compiled.decodeSafe(data);
-                    if (result.success) {
-                        return result.value;
-                    } else {
-                        console.dir(result.error);
-                        throw new Error('Failed to decode output', {
-                            cause: result.error
-                        });
-                    }
-                }
-                callers[serviceKey][procedureName] = this.createCaller(service.contract.name, procedureName, {
-                    timeout: service.contract.timeout,
-                    transformInput: (data)=>{
-                        if (input instanceof NeverType) return undefined;
-                        const compiled = service.compiled.get(input);
-                        const result = compiled.encodeSafe(data);
-                        if (result.success) {
-                            return result.value;
-                        } else {
-                            console.dir(result.error);
-                            throw new Error('Failed to encode input', {
-                                cause: result.error
-                            });
-                        }
-                    },
-                    transformOutput: (data)=>{
-                        if (service.contract.procedures[procedureName].type === 'neemata:subscription') {
-                            data.payload = decodeOutput(data.payload);
-                            return data;
-                        } else {
-                            return decodeOutput(data);
-                        }
-                    }
-                });
-            }
-        }
-        this.#callers = callers;
-    }
-    get call() {
-        return this.#callers;
-    }
-    checkTransport(transport) {
-        for (const { contract } of Object.values(this.contracts)){
-            if (!contract.transports[transport.type]) throw new Error(`Transport [${transport.type}] not supported for service [${contract.name}]`);
-        }
-    }
-}
-export const compileContract = (contract)=>{
-    const compiled = new Map();
-    for (const procedure of Object.values(contract.procedures)){
-        const { input, output } = procedure;
-        if (procedure.type === 'neemata:subscription') {
-            const { events } = procedure;
-            for (const event of Object.values(events)){
-                compiled.set(event.payload, compile(event.payload));
-            }
-        }
-        compiled.set(input, compile(input));
-        compiled.set(output, compile(output));
-    }
-    for (const event of Object.values(contract.events)){
-        compiled.set(event.payload, compile(event.payload));
-    }
-    return {
-        compiled,
-        contract
-    };
-};