nmtjs 0.16.0-beta.9 → 0.16.0

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

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

@@ -1,37 +0,0 @@
-import type { TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract'
-import type {
-  AfterDecodeMetaBinding,
-  AnyMeta,
-  BeforeDecodeMetaBinding,
-  Container,
-  StaticMetaBinding,
-} from '@nmtjs/core'
-import type { GatewayConnection } from '@nmtjs/gateway'
-
-export type ApiMetaRouteContext = Readonly<{
-  contract: TAnyRouterContract
-  timeout?: number
-}>
-
-export type ApiMetaProcedureContext = Readonly<{
-  contract: TAnyProcedureContract
-  streamTimeout?: number
-}>
-
-export type ApiMetaContext = Readonly<{
-  callId: string
-  connection: GatewayConnection
-  container: Container
-  path: readonly ApiMetaRouteContext[]
-  procedure: ApiMetaProcedureContext
-}>
-
-export type StaticOrBeforeDecodeMetaBinding =
-  | StaticMetaBinding
-  | BeforeDecodeMetaBinding<AnyMeta, any, ApiMetaContext>
-
-export type CompatibleMetaBinding<Input> =
-  | StaticOrBeforeDecodeMetaBinding
-  | AfterDecodeMetaBinding<AnyMeta, any, ApiMetaContext, Input>
-
-export type AnyCompatibleMetaBinding = CompatibleMetaBinding<any>

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

@@ -1,37 +0,0 @@
-import type { MaybePromise } from '@nmtjs/common'
-import type { Dependant, Dependencies, DependencyContext } from '@nmtjs/core'
-
-import type { ApiCallContext } from './types.ts'
-import { kMiddleware } from './constants.ts'
-
-export type MiddlewareNext = (payload?: any) => any
-
-export interface Middleware<Deps extends Dependencies = Dependencies>
-  extends Dependant<Deps> {
-  [kMiddleware]: true
-  handle: (
-    ctx: DependencyContext<Deps>,
-    call: ApiCallContext,
-    next: MiddlewareNext,
-    payload: any,
-  ) => MaybePromise<any>
-}
-
-export type AnyMiddleware = Middleware<any>
-
-export function createMiddleware<Deps extends Dependencies = {}>(
-  paramsOrHandler:
-    | { dependencies?: Deps; handle: Middleware<Deps>['handle'] }
-    | Middleware<Deps>['handle'],
-): Middleware<Deps> {
-  const { dependencies = {} as Deps, handle } =
-    typeof paramsOrHandler === 'function'
-      ? { handle: paramsOrHandler }
-      : paramsOrHandler
-
-  return Object.freeze({
-    dependencies,
-    handle,
-    [kMiddleware]: true,
-  }) as Middleware<Deps>
-}

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

@@ -1,224 +0,0 @@
-import type { MaybePromise } from '@nmtjs/common'
-import type { TAnyProcedureContract, TProcedureContract } from '@nmtjs/contract'
-import type { Dependant, Dependencies, DependencyContext } from '@nmtjs/core'
-import type { BaseType } from '@nmtjs/type'
-import type * as zod from 'zod/mini'
-import { c } from '@nmtjs/contract'
-import { assertUniqueMetaBindings } from '@nmtjs/core'
-import { t } from '@nmtjs/type'
-
-import type { AnyGuard } from './guards.ts'
-import type { AnyCompatibleMetaBinding, CompatibleMetaBinding } from './meta.ts'
-import type { AnyMiddleware } from './middlewares.ts'
-import type { JsonPrimitive } from './types.ts'
-import { kProcedure } from './constants.ts'
-
-export type {
-  AnyCompatibleMetaBinding,
-  CompatibleMetaBinding,
-  StaticOrBeforeDecodeMetaBinding,
-} from './meta.ts'
-export type ProcedureMetaBinding<Input> = CompatibleMetaBinding<Input>
-export type AnyProcedureMetaBinding = AnyCompatibleMetaBinding
-
-export type ProcedureDecodedInput<Input extends BaseType | undefined> =
-  Input extends BaseType ? t.infer.decode.output<Input> : never
-
-export type ProcedureContractDecodedInput<
-  ProcedureContract extends TAnyProcedureContract,
-> = t.infer.decode.output<ProcedureContract['input']>
-
-export interface BaseProcedure<
-  ProcedureContract extends TAnyProcedureContract,
-  ProcedureDeps extends Dependencies,
-> extends Dependant<ProcedureDeps> {
-  contract: ProcedureContract
-  handler: (...args: any[]) => any
-  meta: readonly AnyProcedureMetaBinding[]
-  dependencies: ProcedureDeps
-  guards: Set<AnyGuard>
-  middlewares: Set<AnyMiddleware>
-  streamTimeout?: number
-  [kProcedure]: any
-}
-
-export type ProcedureHandlerType<Input, Output, Deps extends Dependencies> = (
-  ctx: DependencyContext<Deps>,
-  data: Input,
-) => MaybePromise<Output>
-
-export interface Procedure<
-  ProcedureContract extends TAnyProcedureContract,
-  ProcedureDeps extends Dependencies,
-> extends BaseProcedure<ProcedureContract, ProcedureDeps> {
-  handler: ProcedureHandlerType<
-    ProcedureContractDecodedInput<ProcedureContract>,
-    ProcedureContract['stream'] extends true
-      ? AsyncIterable<t.infer.encode.input<ProcedureContract['output']>>
-      : t.infer.encode.input<ProcedureContract['output']>,
-    ProcedureDeps
-  >
-}
-
-export type AnyProcedure<
-  Contract extends TAnyProcedureContract = TAnyProcedureContract,
-> = BaseProcedure<Contract, Dependencies>
-
-export type CreateProcedureParams<
-  ProcedureContract extends TAnyProcedureContract,
-  ProcedureDeps extends Dependencies,
-> =
-  | {
-      dependencies?: ProcedureDeps
-      guards?: AnyGuard[]
-      middlewares?: AnyMiddleware[]
-      meta?: ProcedureMetaBinding<
-        ProcedureContractDecodedInput<ProcedureContract>
-      >[]
-      streamTimeout?: number
-      handler: ProcedureHandlerType<
-        ProcedureContractDecodedInput<ProcedureContract>,
-        ProcedureContract['stream'] extends undefined
-          ? t.infer.encode.input<ProcedureContract['output']>
-          : AsyncIterable<
-              Exclude<ProcedureContract['stream'], undefined | boolean>
-            >,
-        ProcedureDeps
-      >
-    }
-  | ProcedureHandlerType<
-      ProcedureContractDecodedInput<ProcedureContract>,
-      ProcedureContract['stream'] extends undefined
-        ? t.infer.decode.input<ProcedureContract['output']>
-        : AsyncIterable<
-            Exclude<ProcedureContract['stream'], undefined | boolean>
-          >,
-      ProcedureDeps
-    >
-
-export function _createBaseProcedure<
-  ProcedureContract extends TAnyProcedureContract,
-  ProcedureDeps extends Dependencies,
->(
-  contract: ProcedureContract,
-  params: {
-    dependencies?: ProcedureDeps
-    middlewares?: AnyMiddleware[]
-    guards?: AnyGuard[]
-    meta?: AnyProcedureMetaBinding[]
-    streamTimeout?: number
-  },
-) {
-  const dependencies = params.dependencies ?? ({} as ProcedureDeps)
-  const middlewares = new Set(params.middlewares ?? [])
-  const guards = new Set(params.guards ?? [])
-  const meta = Object.freeze([...(params.meta ?? [])])
-  const streamTimeout = params.streamTimeout
-
-  if (typeof streamTimeout !== 'undefined' && streamTimeout <= 0) {
-    throw new Error('Stream timeout must be a positive integer')
-  }
-
-  assertUniqueMetaBindings(meta, 'procedure config')
-
-  return { contract, dependencies, middlewares, guards, meta, streamTimeout }
-}
-
-export function createContractProcedure<
-  ProcedureContract extends TAnyProcedureContract,
-  ProcedureDeps extends Dependencies,
->(
-  contract: ProcedureContract,
-  paramsOrHandler: CreateProcedureParams<ProcedureContract, ProcedureDeps>,
-): Procedure<ProcedureContract, ProcedureDeps> {
-  const { handler, ...params } =
-    typeof paramsOrHandler === 'function'
-      ? { handler: paramsOrHandler }
-      : paramsOrHandler
-
-  return Object.assign(_createBaseProcedure(contract, params), {
-    handler,
-    [kProcedure]: true,
-  }) as any
-}
-
-export function createProcedure<
-  Return,
-  TInput extends BaseType | undefined = undefined,
-  TOutput extends BaseType | undefined = undefined,
-  TStream extends true | number | undefined = undefined,
-  Deps extends Dependencies = {},
->(
-  paramsOrHandler:
-    | {
-        input?: TInput
-        output?: TOutput
-        /**
-         * Whether the procedure is a stream procedure.
-         * If set to `true`, the procedure handler should return an `AsyncIterable` of output items.
-         * If set to a number, it specifies an explicit stream timeout in milliseconds.
-         */
-        stream?: TStream
-        dependencies?: Deps
-        guards?: AnyGuard[]
-        middlewares?: AnyMiddleware[]
-        meta?: ProcedureMetaBinding<ProcedureDecodedInput<TInput>>[]
-        timeout?: number
-        handler: ProcedureHandlerType<
-          ProcedureDecodedInput<TInput>,
-          TStream extends true | number
-            ? AsyncIterable<
-                TOutput extends BaseType
-                  ? t.infer.encode.input<TOutput>
-                  : Return
-              >
-            : TOutput extends BaseType
-              ? t.infer.encode.input<TOutput>
-              : Return,
-          Deps
-        >
-      }
-    | ProcedureHandlerType<ProcedureDecodedInput<TInput>, Return, Deps>,
-): Procedure<
-  TProcedureContract<
-    TInput extends undefined ? t.NeverType : TInput,
-    TOutput extends undefined
-      ? t.CustomType<
-          JsonPrimitive<Return>,
-          zod.ZodMiniCustom<JsonPrimitive<Return>, JsonPrimitive<Return>>
-        >
-      : TOutput,
-    TStream extends true | number ? true : undefined
-  >,
-  Deps
-> {
-  const {
-    input = t.never() as any,
-    output = t.any() as any,
-    stream = undefined as any,
-    dependencies = {} as Deps,
-    guards = [],
-    middlewares = [],
-    meta = [],
-    handler,
-    timeout,
-  } = typeof paramsOrHandler === 'function'
-    ? { handler: paramsOrHandler }
-    : paramsOrHandler
-
-  // @ts-expect-error
-  return createContractProcedure(
-    c.procedure({ input, output, stream, timeout }),
-    {
-      dependencies,
-      handler: handler as any,
-      guards,
-      middlewares,
-      meta,
-      streamTimeout: typeof stream === 'number' ? stream : undefined,
-    },
-  )
-}
-
-export const isProcedure = (value: any): value is AnyProcedure =>
-  Boolean(value?.[kProcedure])