nmtjs 0.16.0-beta.8 → 0.16.0

package/dist/runtime/application/api/types.d.ts

@@ -1,38 +0,0 @@
-import type { TProcedureContract } from '@nmtjs/contract';
-import type { Container } from '@nmtjs/core';
-import type { GatewayConnection } from '@nmtjs/gateway';
-import type { AnyCompatibleType, BaseTypeAny } from '@nmtjs/type';
-import type { Procedure } from './procedure.ts';
-import type { AnyRouter } from './router.ts';
-export type ApiCallContext<Payload = unknown> = Readonly<{
-    callId: string;
-    connection: GatewayConnection;
-    container: Container;
-    path: AnyRouter[];
-    procedure: Procedure<TProcedureContract<AnyCompatibleType<any, Payload>, BaseTypeAny, true | undefined, string | undefined>, any>;
-}>;
-export type ApiGuardContext<Payload = unknown> = ApiCallContext<Payload> & Readonly<{
-    payload: Payload;
-}>;
-export type JsonPrimitive<T> = Equal<T, JsonPrimitiveMain<T>> extends true ? T : JsonPrimitiveMain<T>;
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-type JsonPrimitiveMain<Instance, InArray extends boolean = false> = Instance extends [never] ? never : ValueOf<Instance> extends bigint ? never : ValueOf<Instance> extends boolean | number | string ? ValueOf<Instance> : Instance extends Function ? InArray extends true ? null : never : ValueOf<Instance> extends object ? Instance extends object ? Instance extends NativeClass ? {} : Instance extends IJsonable<infer Raw> ? ValueOf<Raw> extends object ? Raw extends object ? PrimitiveObject<Raw> : never : ValueOf<Raw> : PrimitiveObject<Instance> : never : ValueOf<Instance>;
-type PrimitiveObject<Instance extends object> = Instance extends Array<infer T> ? IsTuple<Instance> extends true ? PrimitiveTuple<Instance> : JsonPrimitiveMain<T, true>[] : {
-    -readonly [P in keyof Instance as JsonPrimitiveMain<Instance[P]> extends never ? never : P]: JsonPrimitiveMain<Instance[P]>;
-};
-type PrimitiveTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [JsonPrimitiveMain<F, true>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [JsonPrimitiveMain<F, true>, ...PrimitiveTuple<Rest>] : T extends [(infer F)?] ? [JsonPrimitiveMain<F, true>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [JsonPrimitiveMain<F, true>?, ...PrimitiveTuple<Rest>] : [];
-type ValueOf<Instance> = IsValueOf<Instance, boolean> extends true ? boolean : IsValueOf<Instance, number> extends true ? number : IsValueOf<Instance, string> extends true ? string : Instance;
-type NativeClass = Set<any> | Map<any, any> | WeakSet<any> | WeakMap<any, any> | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array | ArrayBuffer | SharedArrayBuffer | DataView;
-type IsTuple<T extends readonly any[] | {
-    length: number;
-}> = [T] extends [
-    never
-] ? false : T extends readonly any[] ? number extends T['length'] ? false : true : false;
-type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object ? Object extends IValueOf<infer U> ? Instance extends U ? false : true : false : false;
-interface IValueOf<T> {
-    valueOf(): T;
-}
-interface IJsonable<T> {
-    toJSON(): T;
-}
-export {};

package/dist/runtime/application/api/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/runtime/application/api/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/runtime/application/api/types.ts"],"names":[],"mappings":""}

package/dist/runtime/application/config.d.ts

@@ -1,28 +0,0 @@
-import type { ConnectionIdentity, GatewayOptions, Transport } from '@nmtjs/gateway';
-import type { LifecycleHooks } from '../hooks.ts';
-import type { RuntimePlugin } from '../plugin.ts';
-import type { ApiOptions } from './api/api.ts';
-import type { AnyFilter } from './api/filters.ts';
-import type { AnyGuard } from './api/guards.ts';
-import type { AnyMiddleware } from './api/middlewares.ts';
-import type { AnyRootRouter, AnyRouterMetaBinding } from './api/router.ts';
-import type { AnyHook } from './hook.ts';
-import { kApplicationConfig } from './constants.ts';
-export type AnyApplicationConfig = ApplicationConfig<AnyRootRouter>;
-export interface ApplicationConfig<Router extends AnyRootRouter = AnyRootRouter, Transports extends Record<string, Transport> = Record<string, Transport>> {
-    [kApplicationConfig]: any;
-    router: Router;
-    api: Pick<ApiOptions, 'timeout'>;
-    gateway: Pick<GatewayOptions, 'streamTimeouts' | 'heartbeat'>;
-    transports: Transports;
-    identity?: ConnectionIdentity;
-    plugins: RuntimePlugin[];
-    filters: AnyFilter[];
-    middlewares: AnyMiddleware[];
-    guards: AnyGuard[];
-    meta: AnyRouterMetaBinding[];
-    hooks: AnyHook[];
-    lifecycleHooks: LifecycleHooks['_']['config'];
-}
-export declare function defineApplication<R extends AnyRootRouter, T extends Record<string, Transport> = Record<string, Transport>>(options: Pick<ApplicationConfig<R, T>, 'router'> & Partial<Omit<ApplicationConfig<R, T>, 'router'>>): ApplicationConfig<R, T>;
-export declare function isApplicationConfig(value: any): value is ApplicationConfig;

package/dist/runtime/application/config.js

@@ -1,25 +0,0 @@
-import { assertUniqueMetaBindings } from '@nmtjs/core';
-import { kApplicationConfig } from './constants.js';
-export function defineApplication(options) {
-    const { router, transports = {}, guards = [], middlewares = [], meta = [], plugins = [], api = {}, filters = [], hooks = [], lifecycleHooks = {}, gateway = {}, identity: identityResolver, } = options;
-    assertUniqueMetaBindings(meta, 'application config');
-    return Object.freeze({
-        [kApplicationConfig]: true,
-        router,
-        transports,
-        api,
-        gateway,
-        filters,
-        plugins,
-        guards,
-        middlewares,
-        meta,
-        hooks,
-        lifecycleHooks,
-        identity: identityResolver,
-    });
-}
-export function isApplicationConfig(value) {
-    return Boolean(value?.[kApplicationConfig]);
-}
-//# sourceMappingURL=config.js.map

package/dist/runtime/application/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/runtime/application/config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAUtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAuBnD,MAAM,UAAU,iBAAiB,CAI/B,OACkD;IAElD,MAAM,EACJ,MAAM,EACN,UAAU,GAAG,EAAE,EACf,MAAM,GAAG,EAAE,EACX,WAAW,GAAG,EAAE,EAChB,IAAI,GAAG,EAAE,EACT,OAAO,GAAG,EAAE,EACZ,GAAG,GAAG,EAA8B,EACpC,OAAO,GAAG,EAAkC,EAC5C,KAAK,GAAG,EAAgC,EACxC,cAAc,GAAG,EAAE,EACnB,OAAO,GAAG,EAAE,EACZ,QAAQ,EAAE,gBAAgB,GAC3B,GAAG,OAAO,CAAA;IAEX,wBAAwB,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAA;IAEpD,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,CAAC,kBAAkB,CAAC,EAAE,IAAI;QAC1B,MAAM;QACN,UAAU;QACV,GAAG;QACH,OAAO;QACP,OAAO;QACP,OAAO;QACP,MAAM;QACN,WAAW;QACX,IAAI;QACJ,KAAK;QACL,cAAc;QACd,QAAQ,EAAE,gBAAgB;KACI,CAA4B,CAAA;AAC9D,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAU;IAC5C,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAA;AAC7C,CAAC"}

package/dist/runtime/application/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const kApplicationConfig: unique symbol;
-export type kApplicationConfig = typeof kApplicationConfig;

package/dist/runtime/application/constants.js

@@ -1,2 +0,0 @@
-export const kApplicationConfig = Symbol.for('neemata:ApplicationConfig');
-//# sourceMappingURL=constants.js.map

package/dist/runtime/application/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/runtime/application/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAkB,MAAM,CAAC,GAAG,CACzD,2BAA2B,CAC5B,CAAA"}

package/dist/runtime/application/hook.d.ts

@@ -1,19 +0,0 @@
-import type { MaybePromise } from '@nmtjs/common';
-import type { Dependant, Dependencies, DependencyContext, HookTypes } from '@nmtjs/core';
-import { kHook } from '@nmtjs/core';
-export type AnyHook = Hook<HookTypes, string, any>;
-export interface Hook<T extends HookTypes = HookTypes, H extends string = string, Deps extends Dependencies = {}> extends Dependant<Deps> {
-    [kHook]: any;
-    name: H;
-    handler: (ctx: DependencyContext<Deps>, ...args: H extends keyof T ? Parameters<T[H]> : unknown[]) => MaybePromise<any>;
-}
-export declare function createHook<Types extends HookTypes = HookTypes, Name extends Extract<keyof Types, string> | (object & string) = object & string, Deps extends Dependencies = {}>(params: {
-    name: Name;
-    dependencies?: Deps;
-    handler: Hook<Types, Name, Deps>['handler'];
-}): Hook<Types, Name, Deps>;
-export declare function createApplicationHookFactory<Types extends HookTypes>(): <Name extends Extract<keyof Types, string> | (object & string) = object & string, Deps extends Dependencies = {}>(params: {
-    name: Name;
-    dependencies?: Deps;
-    handler: Hook<Types, Name, Deps>['handler'];
-}) => Hook<Types, Name, Deps>;

package/dist/runtime/application/hook.js

@@ -1,11 +0,0 @@
-import { kHook } from '@nmtjs/core';
-export function createHook(params) {
-    const { name, handler, dependencies = {} } = params;
-    return Object.freeze({ [kHook]: true, name, handler, dependencies });
-}
-export function createApplicationHookFactory() {
-    return (params) => {
-        return createHook(params);
-    };
-}
-//# sourceMappingURL=hook.js.map

package/dist/runtime/application/hook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../../src/runtime/application/hook.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAiBnC,MAAM,UAAU,UAAU,CAKxB,MAID;IACC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,GAAG,EAAU,EAAE,GAAG,MAAM,CAAA;IAC3D,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,CAAQ,CAAA;AAC7E,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO,CAIL,MAID,EAA2B,EAAE;QAC5B,OAAO,UAAU,CAAoB,MAAM,CAAC,CAAA;IAC9C,CAAC,CAAA;AACH,CAAC"}

package/dist/runtime/application/hooks.d.ts

@@ -1,3 +0,0 @@
-import { Hooks } from '@nmtjs/core';
-export declare class ApplicationHooks extends Hooks {
-}

package/dist/runtime/application/hooks.js

@@ -1,4 +0,0 @@
-import { Hooks } from '@nmtjs/core';
-export class ApplicationHooks extends Hooks {
-}
-//# sourceMappingURL=hooks.js.map

package/dist/runtime/application/hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../src/runtime/application/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC,MAAM,OAAO,gBAAiB,SAAQ,KAAK;CAAG"}

package/src/runtime/application/api/api.ts

@@ -1,406 +0,0 @@
-import assert from 'node:assert'
-import { randomUUID } from 'node:crypto'
-import { inspect } from 'node:util'
-
-import type {
-  AnyFactoryMetaBinding,
-  AnyMetaBinding,
-  Container,
-  Logger,
-  StaticMetaBinding,
-} from '@nmtjs/core'
-import type {
-  GatewayApi,
-  GatewayApiCallOptions,
-  GatewayApiCallResult,
-  GatewayConnection,
-  GatewayResolvedProcedure,
-  GatewayResolveOptions,
-} from '@nmtjs/gateway'
-import { withTimeout } from '@nmtjs/common'
-import { IsStreamProcedureContract } from '@nmtjs/contract'
-import {
-  getMetaBindingMeta,
-  getStaticMetaValue,
-  isStaticMetaBinding,
-  Scope,
-} from '@nmtjs/core'
-import {
-  createGatewayStaticMetaView,
-  isAsyncIterable,
-  rpcStreamAbortSignal,
-} from '@nmtjs/gateway'
-import { ErrorCode } from '@nmtjs/protocol'
-import { ProtocolError } from '@nmtjs/protocol/server'
-import { NeemataTypeError, registerDefaultLocale, type } from '@nmtjs/type'
-import { prettifyError } from 'zod/mini'
-
-import type { RuntimeConfig } from './config.ts'
-import type { kDefaultProcedure as kDefaultProcedureKey } from './constants.ts'
-import type { AnyFilter } from './filters.ts'
-import type { AnyGuard } from './guards.ts'
-import type { ApiMetaContext } from './meta.ts'
-import type { AnyMiddleware } from './middlewares.ts'
-import type { AnyProcedure } from './procedure.ts'
-import type { AnyRouter } from './router.ts'
-import type { ApiCallContext } from './types.ts'
-import { config, defaultRuntimeConfig } from './config.ts'
-import { kDefaultProcedure } from './constants.ts'
-
-registerDefaultLocale()
-
-export type ApiCallOptions<T extends AnyProcedure = AnyProcedure> = Readonly<{
-  callId: string
-  connection: GatewayConnection
-  path: AnyRouter[]
-  procedure: T
-  container: Container
-  payload: any
-  signal: AbortSignal
-}>
-
-export type ApiOptions = {
-  timeout?: number
-  container: Container
-  logger: Logger
-  procedures: Map<
-    string | kDefaultProcedureKey,
-    { procedure: AnyProcedure; path: AnyRouter[] }
-  >
-  meta: readonly AnyMetaBinding[]
-  guards: Set<AnyGuard>
-  middlewares: Set<AnyMiddleware>
-  filters: Set<AnyFilter>
-}
-
-type ResolvedMetaBindings = Readonly<{
-  static: readonly StaticMetaBinding[]
-  beforeDecode: readonly AnyFactoryMetaBinding[]
-  afterDecode: readonly AnyFactoryMetaBinding[]
-  config: Required<RuntimeConfig>
-}>
-
-export class ApiError extends ProtocolError {
-  toString() {
-    return `${this.code} ${this.message}: \n${inspect(this.data, true, 10, false)}`
-  }
-}
-
-const NotFound = () => new ApiError(ErrorCode.NotFound, 'Procedure not found')
-
-export class ApplicationApi implements GatewayApi {
-  constructor(public options: ApiOptions) {}
-
-  find(procedureName: string) {
-    const procedure = this.options.procedures.get(procedureName)
-    if (procedure) return procedure
-
-    const fallback = this.options.procedures.get(kDefaultProcedure)
-    if (fallback) return fallback
-
-    throw NotFound()
-  }
-
-  async resolve(
-    options: GatewayResolveOptions,
-  ): Promise<GatewayResolvedProcedure> {
-    const { procedure, path } = this.find(options.procedure)
-
-    const metaBindings = this.resolveMetaBindings(path, procedure)
-
-    return Object.freeze({
-      stream: IsStreamProcedureContract(procedure.contract),
-      meta: createGatewayStaticMetaView(metaBindings.static),
-    }) satisfies GatewayResolvedProcedure
-  }
-
-  async call(options: GatewayApiCallOptions): Promise<GatewayApiCallResult> {
-    const callId = randomUUID()
-
-    const { payload, container, signal, connection } = options
-
-    assert(
-      container.scope === Scope.Call,
-      'Invalid container scope, expected to be Scope.Call',
-    )
-
-    const { procedure, path } = this.find(options.procedure)
-
-    const metaBindings = this.resolveMetaBindings(path, procedure)
-
-    const callOptions: ApiCallOptions = Object.freeze({
-      callId,
-      payload,
-      container,
-      signal,
-      connection,
-      procedure,
-      path,
-    })
-
-    const timeout = procedure.contract.timeout ?? this.options.timeout
-    const streamTimeoutSignal = procedure.streamTimeout
-      ? AbortSignal.timeout(procedure.streamTimeout)
-      : undefined
-
-    if (streamTimeoutSignal) {
-      container.provide(rpcStreamAbortSignal, streamTimeoutSignal)
-    }
-
-    try {
-      const handle = await this.createProcedureHandler(
-        callOptions,
-        metaBindings,
-      )
-      return timeout
-        ? await this.withTimeout(handle(payload), timeout)
-        : await handle(payload)
-    } catch (error) {
-      const handled = await this.handleFilters(callOptions, error)
-      if (handled === error && error instanceof ProtocolError === false) {
-        const logError = new Error('Unhandled error', { cause: error })
-        this.options.logger.error(logError)
-        throw new ApiError(
-          ErrorCode.InternalServerError,
-          'Internal Server Error',
-        )
-      }
-      throw handled
-    }
-  }
-
-  private async createProcedureHandler(
-    callOptions: ApiCallOptions,
-    metaBindings: ResolvedMetaBindings,
-  ) {
-    const { callId, connection, procedure, container, path } = callOptions
-
-    const callCtx: ApiCallContext = Object.freeze({
-      callId,
-      connection,
-      container,
-      path,
-      procedure,
-    })
-
-    const isIterableProcedure = IsStreamProcedureContract(procedure.contract)
-
-    this.applyStaticMetaBindings(container, metaBindings.static)
-
-    const middlewares = this.resolveMiddlewares(callOptions)
-
-    const handleProcedure = async (payload: any) => {
-      const middleware = (await middlewares).next().value
-      if (middleware) {
-        const next = (...args: any[]) =>
-          handleProcedure(args.length === 0 ? payload : args[0])
-        return middleware.handle(middleware.ctx, callCtx, next, payload)
-      } else {
-        await this.applyFactoryMetaBindings(
-          container,
-          metaBindings.beforeDecode,
-          callCtx,
-          payload,
-        )
-        const input = this.handleInput(procedure, payload)
-        await this.applyFactoryMetaBindings(
-          container,
-          metaBindings.afterDecode,
-          callCtx,
-          input,
-        )
-        await this.handleGuards(callOptions, callCtx, input)
-        const { dependencies, handler } = procedure
-        const context = await container.createContext(dependencies)
-        const result = await handler(context, input)
-        if (isIterableProcedure) {
-          return this.handleIterableOutput(
-            procedure,
-            result,
-            metaBindings.config,
-          )
-        } else {
-          return this.handleOutput(procedure, result, metaBindings.config)
-        }
-      }
-    }
-
-    return handleProcedure
-  }
-
-  private resolveMetaBindings(
-    path: AnyRouter[],
-    procedure: AnyProcedure,
-  ): ResolvedMetaBindings {
-    const bindings = [
-      ...this.options.meta,
-      ...path.flatMap((router) => router.meta),
-      ...procedure.meta,
-    ]
-
-    const staticBindings: StaticMetaBinding[] = []
-    const beforeDecode: AnyFactoryMetaBinding[] = []
-    const afterDecode: AnyFactoryMetaBinding[] = []
-
-    for (const binding of bindings) {
-      if (isStaticMetaBinding(binding)) {
-        staticBindings.push(binding)
-      } else if (binding.phase === 'afterDecode') {
-        afterDecode.push(binding)
-      } else {
-        beforeDecode.push(binding)
-      }
-    }
-
-    const runtimeConfig = getStaticMetaValue(staticBindings, config)
-
-    return Object.freeze({
-      static: Object.freeze(staticBindings),
-      beforeDecode: Object.freeze(beforeDecode),
-      afterDecode: Object.freeze(afterDecode),
-      config: Object.freeze({ ...defaultRuntimeConfig, ...runtimeConfig }),
-    })
-  }
-
-  private applyStaticMetaBindings(
-    container: Container,
-    bindings: readonly StaticMetaBinding[],
-  ) {
-    for (const binding of bindings) {
-      container.provide(getMetaBindingMeta(binding), binding.value)
-    }
-  }
-
-  private async applyFactoryMetaBindings(
-    container: Container,
-    bindings: readonly AnyFactoryMetaBinding[],
-    callCtx: ApiMetaContext,
-    input: unknown,
-  ) {
-    for (const binding of bindings) {
-      const context = await container.createContext(binding.dependencies)
-      const value = await binding.resolve(context, callCtx, input)
-      container.provide(getMetaBindingMeta(binding), value)
-    }
-  }
-
-  private async resolveMiddlewares(callOptions: ApiCallOptions) {
-    const { path, procedure, container } = callOptions
-    const middlewares = [
-      ...this.options.middlewares,
-      ...path.flatMap((router) => [...router.middlewares]),
-      ...procedure.middlewares,
-    ]
-    const result = await Promise.all(
-      middlewares.map(async (middleware) => {
-        const ctx = await container.createContext(middleware.dependencies)
-        return { handle: middleware.handle, ctx }
-      }),
-    )
-    return result[Symbol.iterator]()
-  }
-
-  private withTimeout(response: any, timeout: number): unknown {
-    const applyTimeout = response instanceof Promise && timeout > 0
-    if (!applyTimeout) return response
-    return withTimeout(
-      response,
-      timeout,
-      new ApiError(ErrorCode.RequestTimeout, 'Request Timeout'),
-    )
-  }
-
-  private async handleGuards(
-    callOptions: ApiCallOptions,
-    callCtx: ApiCallContext,
-    payload: any,
-  ) {
-    const { path, procedure, container } = callOptions
-    const guards = [
-      ...this.options.guards,
-      ...path.flatMap((router) => [...router.guards]),
-      ...procedure.guards,
-    ]
-    for (const guard of guards) {
-      const ctx = await container.createContext(guard.dependencies)
-      const result = await guard.can(
-        ctx,
-        Object.freeze({ ...callCtx, payload }),
-      )
-      if (result === false) throw new ApiError(ErrorCode.Forbidden)
-    }
-  }
-
-  private async handleFilters({ container }: ApiCallOptions, error: any) {
-    if (this.options.filters.size) {
-      for (const filter of this.options.filters) {
-        if (error instanceof filter.errorClass) {
-          const ctx = await container.createContext(filter.dependencies)
-          const handledError = await filter.catch(ctx, error)
-          if (!handledError || handledError instanceof ApiError === false)
-            continue
-          return handledError
-        }
-      }
-    }
-    return error
-  }
-
-  private handleInput(procedure: AnyProcedure, payload: any) {
-    if (procedure.contract.input instanceof type.NeverType === false) {
-      const type = procedure.contract.input
-      try {
-        return type.decode(payload)
-      } catch (error) {
-        if (error instanceof NeemataTypeError)
-          throw new ApiError(
-            ErrorCode.ValidationError,
-            `Input validation error: \n${prettifyError(error)}`,
-            error.issues,
-          )
-        throw error
-      }
-    }
-  }
-
-  private handleIterableOutput(
-    procedure: AnyProcedure,
-    response: any,
-    runtimeConfig: Required<RuntimeConfig>,
-  ) {
-    if (!isAsyncIterable(response))
-      throw new Error('Response is an async iterable')
-    const chunkType = procedure.contract.output
-    if (chunkType instanceof type.NeverType)
-      throw new Error('Stream procedure must have a defined output type')
-
-    return async function* (onDone?: () => void) {
-      try {
-        if (runtimeConfig.serializeOutput === false) {
-          yield* response
-        } else if (chunkType instanceof type.AnyType === false) {
-          for await (const chunk of response) {
-            yield chunkType.encode(chunk)
-          }
-        } else {
-          yield* response
-        }
-      } finally {
-        onDone?.()
-      }
-    }
-  }
-
-  private handleOutput(
-    procedure: AnyProcedure,
-    response: any,
-    runtimeConfig: Required<RuntimeConfig>,
-  ) {
-    if (procedure.contract.output instanceof type.NeverType === false) {
-      if (runtimeConfig.serializeOutput === false) return response
-      const type = procedure.contract.output
-      return type.encode(response)
-    }
-    return undefined
-  }
-}

package/src/runtime/application/api/config.ts

@@ -1,18 +0,0 @@
-import type { MetadataKind } from '@nmtjs/core'
-import { createMeta } from '@nmtjs/core'
-
-import type { ApiMetaContext } from './meta.ts'
-
-export interface RuntimeConfig {
-  serializeOutput?: boolean
-}
-
-export const config = createMeta<
-  RuntimeConfig,
-  MetadataKind.STATIC,
-  ApiMetaContext
->()
-
-export const defaultRuntimeConfig = Object.freeze({
-  serializeOutput: true,
-} satisfies Required<RuntimeConfig>)

package/src/runtime/application/api/constants.ts

@@ -1,22 +0,0 @@
-export const kProcedure: unique symbol = Symbol.for('neemata:ProcedureKey')
-export type kProcedure = typeof kProcedure
-
-export const kDefaultProcedure: unique symbol = Symbol.for(
-  'neemata:DefaultProcedureKey',
-)
-export type kDefaultProcedure = typeof kDefaultProcedure
-
-export const kRouter: unique symbol = Symbol.for('neemata:RouterKey')
-export type kRouter = typeof kRouter
-
-export const kRootRouter: unique symbol = Symbol.for('neemata:RootRouterKey')
-export type kRootRouter = typeof kRootRouter
-
-export const kMiddleware: unique symbol = Symbol.for('neemata:MiddlewareKey')
-export type kMiddleware = typeof kMiddleware
-
-export const kGuard: unique symbol = Symbol.for('neemata:GuardKey')
-export type kGuard = typeof kGuard
-
-export const kFilter: unique symbol = Symbol.for('neemata:FilterKey')
-export type kFilter = typeof kFilter

package/src/runtime/application/api/filters.ts

@@ -1,39 +0,0 @@
-import type { ErrorClass, MaybePromise } from '@nmtjs/common'
-import type { Dependant, Dependencies, DependencyContext } from '@nmtjs/core'
-
-import { kFilter } from './constants.ts'
-
-export interface Filter<
-  FilterError extends ErrorClass = ErrorClass,
-  Deps extends Dependencies = Dependencies,
-> extends Dependant<Deps> {
-  [kFilter]: true
-  errorClass: FilterError
-  catch: (
-    ctx: DependencyContext<Deps>,
-    error: InstanceType<FilterError>,
-  ) => MaybePromise<Error>
-}
-
-export type AnyFilter<Error extends ErrorClass = ErrorClass> = Filter<
-  Error,
-  any
->
-
-export function createFilter<
-  FilterError extends ErrorClass,
-  Deps extends Dependencies = {},
->(params: {
-  errorClass: FilterError
-  dependencies?: Deps
-  catch: Filter<FilterError, Deps>['catch']
-}): Filter<FilterError, Deps> {
-  const { errorClass, catch: handler, dependencies = {} as Deps } = params
-
-  return Object.freeze({
-    errorClass,
-    dependencies,
-    catch: handler,
-    [kFilter]: true,
-  }) as Filter<FilterError, Deps>
-}