nmtjs 0.16.0-beta.9 → 0.16.1

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>
-}

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

@@ -1,33 +0,0 @@
-import type { MaybePromise } from '@nmtjs/common'
-import type { Dependant, Dependencies, DependencyContext } from '@nmtjs/core'
-
-import type { ApiGuardContext } from './types.ts'
-import { kGuard } from './constants.ts'
-
-export type GuardCanFn<Deps extends Dependencies> = (
-  ctx: DependencyContext<Deps>,
-  call: ApiGuardContext,
-) => MaybePromise<boolean>
-
-export type GuardParams<Deps extends Dependencies> =
-  | { dependencies?: Deps; can: GuardCanFn<Deps> }
-  | GuardCanFn<Deps>
-
-export interface Guard<Deps extends Dependencies = Dependencies>
-  extends Dependant<Deps> {
-  [kGuard]: true
-  can: GuardCanFn<Deps>
-}
-
-export type AnyGuard = Guard<any>
-
-export function createGuard<Deps extends Dependencies = {}>(
-  paramsOrHandler: GuardParams<Deps>,
-): Guard<Deps> {
-  const { dependencies = {} as Deps, can } =
-    typeof paramsOrHandler === 'function'
-      ? { can: paramsOrHandler }
-      : paramsOrHandler
-
-  return Object.freeze({ dependencies, can, [kGuard]: true }) as Guard<Deps>
-}

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

@@ -1,69 +0,0 @@
-import type {
-  AnyMeta,
-  AfterDecodeMetaBinding as CoreAfterDecodeMetaBinding,
-  AnyFactoryMetaBinding as CoreAnyFactoryMetaBinding,
-  BeforeDecodeMetaBinding as CoreBeforeDecodeMetaBinding,
-  Meta as CoreMeta,
-  MetaFactoryBinding as CoreMetaFactoryBinding,
-  Dependencies,
-  MetaPhase,
-  StaticMetaBinding,
-} from '@nmtjs/core'
-import { createMeta as createCoreMeta, MetadataKind } from '@nmtjs/core'
-
-import type { ApiMetaContext } from './meta.ts'
-
-export type { AnyMeta, MetaPhase, StaticMetaBinding }
-export { MetadataKind }
-
-export type Meta<Value, Kind extends MetadataKind = MetadataKind> = CoreMeta<
-  Value,
-  Kind,
-  ApiMetaContext
->
-
-export type BeforeDecodeMetaBinding<
-  T extends AnyMeta = AnyMeta,
-  Deps extends Dependencies = {},
-> = CoreBeforeDecodeMetaBinding<T, Deps, ApiMetaContext>
-
-export type AfterDecodeMetaBinding<
-  T extends AnyMeta = AnyMeta,
-  Deps extends Dependencies = {},
-  Input = unknown,
-> = CoreAfterDecodeMetaBinding<T, Deps, ApiMetaContext, Input>
-
-export type MetaFactoryBinding<
-  T extends AnyMeta = AnyMeta,
-  Deps extends Dependencies = {},
-  Phase extends MetaPhase = MetaPhase,
-  Input = unknown,
-> = CoreMetaFactoryBinding<T, Deps, Phase, ApiMetaContext, Input>
-
-export type AnyFactoryMetaBinding<
-  T extends AnyMeta = AnyMeta,
-  Deps extends Dependencies = Dependencies,
-  Phase extends MetaPhase = MetaPhase,
-  Input = unknown,
-> = CoreAnyFactoryMetaBinding<T, Deps, Phase, ApiMetaContext, Input>
-
-export type AnyMetaBinding = StaticMetaBinding | AnyFactoryMetaBinding
-
-export function createMeta<
-  Value,
-  Kind extends MetadataKind = MetadataKind,
->(): Meta<Value, Kind> {
-  return createCoreMeta<Value, Kind, ApiMetaContext>() as Meta<Value, Kind>
-}
-
-export * from './api.ts'
-export * from './config.ts'
-export * from './constants.ts'
-export * from './filters.ts'
-export * from './guards.ts'
-export * from './logging.ts'
-export * from './meta.ts'
-export * from './middlewares.ts'
-export * from './procedure.ts'
-export * from './router.ts'
-export * from './types.ts'

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

@@ -1,110 +0,0 @@
-import type { MaybePromise } from '@nmtjs/common'
-import { IsStreamProcedureContract } from '@nmtjs/contract'
-import { CoreInjectables, loggerLocalStorage } from '@nmtjs/core'
-
-import type { ApiCallContext } from './types.ts'
-import { createMiddleware } from './middlewares.ts'
-
-const defaultContext = (options: ApiCallContext, payload: unknown) => {
-  return {
-    callId: options.callId,
-    connection: {
-      id: options.connection.id,
-      type: options.connection.type,
-      transport: options.connection.transport,
-      protocol: options.connection.protocol,
-      identity: options.connection.identity,
-    },
-  }
-}
-
-export const LoggingCallContextMiddleware = (
-  cb: (
-    options: ApiCallContext,
-    payload: unknown,
-  ) => MaybePromise<object> = defaultContext,
-) =>
-  createMiddleware({
-    handle: async (_, call, next, payload) => {
-      const loggingContext = await cb(call, payload)
-      return loggerLocalStorage.run(loggingContext, async () => {
-        return next()
-      })
-    },
-  })
-
-export const LoggingCallMiddleware = (
-  options: {
-    level?: 'info' | 'debug' | 'trace'
-    errorLevel?: 'warn' | 'error' | 'fatal'
-    includePayload?: boolean
-    includeResponse?: boolean
-    includeStreamChunks?: boolean
-  } = {},
-) =>
-  createMiddleware({
-    dependencies: { logger: CoreInjectables.logger('RPC') },
-    handle: async ({ logger }, call, next, payload) => {
-      const {
-        includePayload,
-        includeResponse,
-        includeStreamChunks,
-        level,
-        errorLevel,
-      } = {
-        level: 'info' as const,
-        errorLevel: 'error' as const,
-        includePayload: true,
-        includeResponse: true,
-        includeStreamChunks: true,
-        ...options,
-      }
-
-      const logFn = logger[level].bind(logger)
-      const errorLogFn = logger[errorLevel].bind(logger)
-
-      logFn(
-        includePayload
-          ? { procedure: call.procedure.contract.name, payload: payload }
-          : { procedure: call.procedure.contract.name },
-        'RPC call',
-      )
-
-      const isIterableProcedure = IsStreamProcedureContract(
-        call.procedure.contract,
-      )
-
-      try {
-        const response = await next()
-        if (includeResponse) {
-          if (isIterableProcedure) {
-            logFn({ result: 'success', response: 'Stream' }, 'RPC response')
-          } else {
-            logFn({ result: 'success', response }, 'RPC response')
-          }
-        } else {
-          logFn({ result: 'success' }, 'RPC response')
-        }
-
-        if (isIterableProcedure && includeStreamChunks) {
-          return async function* (...args: any[]) {
-            try {
-              for await (const chunk of response(...args)) {
-                logFn({ callId: call.callId, chunk }, 'RPC stream chunk')
-                yield chunk
-              }
-              logFn({ callId: call.callId }, 'RPC stream end')
-            } catch (error) {
-              errorLogFn({ callId: call.callId, error }, 'RPC stream error')
-              throw error
-            }
-          }
-        }
-
-        return response
-      } catch (error) {
-        errorLogFn({ error }, 'RPC error')
-        throw error
-      }
-    },
-  })