nmtjs 0.16.0-beta.9 → 0.16.1

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])

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

@@ -1,247 +0,0 @@
-import type { Callback } from '@nmtjs/common'
-import type {
-  TAnyProcedureContract,
-  TAnyRouterContract,
-  TProcedureContract,
-  TRouteContract,
-  TRouterContract,
-} from '@nmtjs/contract'
-import type { BaseTypeAny, t } from '@nmtjs/type'
-import type { AnyType } from '@nmtjs/type/any'
-import { c, IsRouterContract } from '@nmtjs/contract'
-import { assertUniqueMetaBindings } from '@nmtjs/core'
-
-import type { AnyGuard } from './guards.ts'
-import type { AnyCompatibleMetaBinding, CompatibleMetaBinding } from './meta.ts'
-import type { AnyMiddleware } from './middlewares.ts'
-import type { AnyProcedure } from './procedure.ts'
-import { kRootRouter, kRouter } from './constants.ts'
-
-export type RouterMetaBinding<Input> = CompatibleMetaBinding<Input>
-export type AnyRouterMetaBinding = AnyCompatibleMetaBinding
-
-export type AnyRouterRoutes = Record<string, AnyProcedure<any> | AnyRouter>
-export type AnyRouterContractRoutes = Record<
-  string,
-  TAnyProcedureContract | TAnyRouterContract
->
-
-export interface AnyRouter {
-  contract: TAnyRouterContract
-  routes: AnyRouterRoutes
-  guards: Set<AnyGuard>
-  middlewares: Set<AnyMiddleware>
-  meta: readonly AnyRouterMetaBinding[]
-  timeout?: number
-  [kRouter]: any
-}
-
-export interface AnyRootRouter extends AnyRouter {
-  [kRootRouter]: any
-  contract: TAnyRouterContract<Record<string, TRouteContract>, undefined>
-  default?: AnyProcedure<any>
-}
-
-export interface Router<Contract extends TAnyRouterContract> extends AnyRouter {
-  contract: Contract
-  routes: {
-    [K in keyof Contract['routes']]: Contract['routes'][K] extends TAnyRouterContract
-      ? Router<Contract['routes'][K]>
-      : Contract['routes'][K] extends TAnyProcedureContract
-        ? AnyProcedure<
-            TProcedureContract<
-              Contract['routes'][K]['input'],
-              Contract['routes'][K]['output'],
-              Contract['routes'][K]['stream'],
-              Contract['routes'][K]['name']
-            >
-          >
-        : never
-  }
-  guards: Set<AnyGuard>
-  middlewares: Set<AnyMiddleware>
-  meta: readonly AnyRouterMetaBinding[]
-  timeout?: number
-  [kRouter]: any
-}
-
-export interface RootRouter<
-  Contract extends TAnyRouterContract<
-    Record<string, TRouteContract>,
-    undefined
-  >,
-> extends Router<Contract> {
-  [kRootRouter]: any
-  default?: AnyProcedure<any>
-}
-
-export type MergeRoutersRoutesContracts<
-  Routers extends readonly TAnyRouterContract[],
-> = Routers extends [
-  infer First extends TAnyRouterContract,
-  ...infer Rest extends TAnyRouterContract[],
-]
-  ? {
-      [K in keyof First['routes']]: First['routes'][K]
-    } & MergeRoutersRoutesContracts<Rest>
-  : Routers extends [infer First extends TAnyRouterContract]
-    ? {
-        [K in keyof First['routes']]: First['routes'][K]
-      }
-    : {}
-
-export type ExtractRouterContracts<
-  Routers extends readonly { contract: TAnyRouterContract }[],
-> = Routers extends [
-  infer First extends { contract: TAnyRouterContract },
-  ...infer Rest extends { contract: TAnyRouterContract }[],
-]
-  ? [First['contract'], ...ExtractRouterContracts<Rest>]
-  : []
-
-export type RouterContractsFromRoutes<Routes extends AnyRouterRoutes> = {
-  [K in keyof Routes]: Routes[K] extends AnyRouter
-    ? Routes[K]['contract']
-    : Routes[K] extends AnyProcedure<any>
-      ? Routes[K]['contract']
-      : never
-}
-
-export type RouterContractFromRoutes<
-  Routes extends AnyRouterRoutes,
-  Name extends string | undefined = undefined,
-> = TRouterContract<RouterContractsFromRoutes<Routes>, Name>
-
-export function createRootRouter<Routers extends readonly AnyRouter[]>(
-  routers: Routers,
-  defaultProcedure?: AnyProcedure<
-    TProcedureContract<AnyType, AnyType, true | undefined, string | undefined>
-  >,
-): RootRouter<
-  TRouterContract<
-    MergeRoutersRoutesContracts<ExtractRouterContracts<[...Routers]>>,
-    undefined
-  >
-> {
-  const routes: Record<string, any> = {}
-  for (const router of routers) Object.assign(routes, router.routes)
-  const router = createRouter({ routes, name: undefined })
-  return Object.freeze({
-    ...router,
-    default: defaultProcedure,
-    [kRootRouter]: true,
-  }) as any
-}
-
-export type FlattenRouterContractInput<Routes extends AnyRouterContractRoutes> =
-  {
-    [K in keyof Routes]: Routes[K] extends TAnyRouterContract
-      ? FlattenRouterContractInput<Routes[K]['routes']>
-      : Routes[K] extends TAnyProcedureContract
-        ? Routes[K]['input']
-        : never
-  }[keyof Routes]
-
-export type FlattenRouterDecodedInput<Routes extends AnyRouterContractRoutes> =
-  t.infer.decode.output<
-    Extract<FlattenRouterContractInput<Routes>, BaseTypeAny>
-  >
-
-export type RouterDecodedInput<Routes extends AnyRouterRoutes> =
-  FlattenRouterDecodedInput<RouterContractsFromRoutes<Routes>>
-
-export type RouterContractDecodedInput<Contract extends TAnyRouterContract> =
-  FlattenRouterDecodedInput<Contract['routes']>
-
-export interface CreateRouterParams<
-  Routes extends AnyRouterRoutes,
-  Name extends string | undefined = undefined,
-> {
-  routes: Routes
-  name?: Name
-  guards?: AnyGuard[]
-  middlewares?: AnyMiddleware[]
-  meta?: RouterMetaBinding<RouterDecodedInput<Routes>>[]
-  hooks?: Record<string, Callback[]>
-  timeout?: number
-}
-
-export interface CreateContractRouterParams<
-  Contract extends TAnyRouterContract,
-> {
-  routes: {
-    [K in keyof Contract['routes']]: Contract['routes'][K] extends TAnyRouterContract
-      ? Router<Contract['routes'][K]>
-      : Contract['routes'][K] extends TAnyProcedureContract
-        ? AnyProcedure<Contract['routes'][K]>
-        : never
-  }
-  guards?: AnyGuard[]
-  middlewares?: AnyMiddleware[]
-  meta?: RouterMetaBinding<RouterContractDecodedInput<Contract>>[]
-  timeout?: number
-}
-
-export function createRouter<
-  const Routes extends AnyRouterRoutes,
-  const Name extends string | undefined = undefined,
->(
-  params: CreateRouterParams<Routes, Name>,
-): Router<RouterContractFromRoutes<Routes, Name>> {
-  const { routes, name, guards, middlewares, meta, timeout } = params
-
-  const routesContracts: any = {}
-  for (const [name, route] of Object.entries(routes)) {
-    routesContracts[name] = route.contract
-  }
-
-  const contract = c.router({ routes: routesContracts, timeout, name })
-
-  assignRouteContracts(routes, contract)
-
-  return createContractRouter(contract, {
-    routes: routes as any,
-    guards,
-    middlewares,
-    meta,
-    timeout,
-  }) as any
-}
-
-export function createContractRouter<Contract extends TAnyRouterContract>(
-  contract: Contract,
-  params: CreateContractRouterParams<Contract>,
-): Router<Contract> {
-  const guards = new Set(params.guards ?? [])
-  const middlewares = new Set(params.middlewares ?? [])
-  const meta = Object.freeze([...(params.meta ?? [])])
-
-  assertUniqueMetaBindings(meta, 'router config')
-
-  return {
-    contract,
-    routes: params.routes,
-    guards,
-    middlewares,
-    meta,
-    timeout: params.timeout,
-    [kRouter]: true,
-  }
-}
-
-export const isRouter = (value: any): value is AnyRouter =>
-  Boolean(value?.[kRouter])
-
-export const isRootRouter = (value: any): value is AnyRootRouter =>
-  Boolean(value?.[kRootRouter])
-
-function assignRouteContracts(
-  routes: Record<string, any>,
-  contract: TAnyRouterContract,
-) {
-  for (const [key, routeContract] of Object.entries(contract.routes)) {
-    routes[key] = { ...routes[key], contract: routeContract }
-    if (IsRouterContract(routeContract))
-      assignRouteContracts(routes[key].routes, routeContract)
-  }
-}

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

@@ -1,138 +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
-}