nmtjs 0.15.0-beta.2 → 0.15.0-beta.21

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

@@ -0,0 +1,229 @@
+import type { MaybePromise } from '@nmtjs/common'
+import type { TAnyProcedureContract, TProcedureContract } from '@nmtjs/contract'
+import type {
+  Dependant,
+  Dependencies,
+  DependencyContext,
+  Metadata,
+} from '@nmtjs/core'
+import type { InputType } from '@nmtjs/protocol/server'
+import type { BaseType } from '@nmtjs/type'
+import type * as zod from 'zod/mini'
+import { c } from '@nmtjs/contract'
+import { MetadataStore } from '@nmtjs/core'
+import { t } from '@nmtjs/type'
+
+import type { AnyGuard } from './guards.ts'
+import type { AnyMiddleware } from './middlewares.ts'
+import type { JsonPrimitive } from './types.ts'
+import { kProcedure } from './constants.ts'
+
+export interface BaseProcedure<
+  ProcedureContract extends TAnyProcedureContract,
+  ProcedureDeps extends Dependencies,
+> extends Dependant<ProcedureDeps> {
+  contract: ProcedureContract
+  handler: (...args: any[]) => any
+  metadata: MetadataStore
+  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<
+    InputType<t.infer.decodeRaw.output<ProcedureContract['input']>>,
+    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[]
+      metadata?: Metadata[]
+      streamTimeout?: number
+      handler: ProcedureHandlerType<
+        InputType<t.infer.decodeRaw.output<ProcedureContract['input']>>,
+        ProcedureContract['stream'] extends undefined
+          ? t.infer.encode.input<ProcedureContract['output']>
+          : AsyncIterable<
+              Exclude<ProcedureContract['stream'], undefined | boolean>
+            >,
+        ProcedureDeps
+      >
+    }
+  | ProcedureHandlerType<
+      InputType<t.infer.decodeRaw.output<ProcedureContract['input']>>,
+      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[]
+    metadata?: Metadata[]
+    streamTimeout?: number
+  },
+) {
+  const dependencies = params.dependencies ?? ({} as ProcedureDeps)
+  const metadata = new MetadataStore()
+  const middlewares = new Set(params.middlewares ?? [])
+  const guards = new Set(params.guards ?? [])
+  const streamTimeout = params.streamTimeout
+
+  if (typeof streamTimeout !== 'undefined' && streamTimeout <= 0) {
+    throw new Error('Stream timeout must be a positive integer')
+  }
+
+  for (const meta of params.metadata ?? []) {
+    metadata.set(meta.key, meta.value)
+  }
+
+  return {
+    contract,
+    dependencies,
+    middlewares,
+    guards,
+    metadata,
+    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[]
+        metadata?: Metadata[]
+        timeout?: number
+        handler: ProcedureHandlerType<
+          TInput extends BaseType
+            ? InputType<t.infer.decodeRaw.output<TInput>>
+            : never,
+          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<
+        TInput extends BaseType
+          ? InputType<t.infer.decodeRaw.output<TInput>>
+          : never,
+        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 = [],
+    metadata = [],
+    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,
+      metadata,
+      streamTimeout: typeof stream === 'number' ? stream : undefined,
+    },
+  )
+}
+
+export const isProcedure = (value: any): value is AnyProcedure =>
+  Boolean(value?.[kProcedure])

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

@@ -0,0 +1,193 @@
+import type { Callback } from '@nmtjs/common'
+import type {
+  TAnyProcedureContract,
+  TAnyRouterContract,
+  TProcedureContract,
+  TRouteContract,
+  TRouterContract,
+} from '@nmtjs/contract'
+import type { AnyType } from '@nmtjs/type/any'
+import { c, IsRouterContract } from '@nmtjs/contract'
+
+import type { AnyGuard } from './guards.ts'
+import type { AnyMiddleware } from './middlewares.ts'
+import type { AnyProcedure } from './procedure.ts'
+import { kRootRouter, kRouter } from './constants.ts'
+
+export interface AnyRouter {
+  contract: TAnyRouterContract
+  routes: Record<string, AnyProcedure<any> | AnyRouter>
+  guards: Set<AnyGuard>
+  middlewares: Set<AnyMiddleware>
+  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>
+  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>
+  : {}
+
+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 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({ name: undefined, routes: routes })
+  return Object.freeze({
+    ...router,
+    default: defaultProcedure,
+    [kRootRouter]: true,
+  }) as any
+}
+
+export function createRouter<
+  const Options extends {
+    name?: string
+    routes?: Record<string, AnyProcedure<any> | AnyRouter>
+    guards?: AnyGuard[]
+    middlewares?: AnyMiddleware[]
+    hooks?: Record<string, Callback[]>
+    timeout?: number
+  },
+>(
+  params: Options,
+): Router<
+  TRouterContract<
+    Options['routes'] extends Record<string, AnyProcedure<any> | AnyRouter>
+      ? {
+          [K in keyof Options['routes']]: Options['routes'][K] extends AnyRouter
+            ? Options['routes'][K]['contract']
+            : Options['routes'][K] extends AnyProcedure<any>
+              ? Options['routes'][K]['contract']
+              : never
+        }
+      : {},
+    null extends Options['name'] ? undefined : Options['name']
+  >
+> {
+  const { name, guards, middlewares, timeout } = params
+  const routes: Record<string, any> = params.routes || {}
+
+  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,
+    timeout,
+  })
+}
+
+export function createContractRouter<Contract extends TAnyRouterContract>(
+  contract: Contract,
+  params: {
+    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[]
+    timeout?: number
+  },
+): Router<Contract> {
+  const guards = new Set(params.guards ?? [])
+  const middlewares = new Set(params.middlewares ?? [])
+
+  return {
+    contract,
+    routes: params.routes,
+    guards,
+    middlewares,
+    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

@@ -0,0 +1,124 @@
+import type { Container } from '@nmtjs/core'
+import type { GatewayConnection } from '@nmtjs/gateway'
+
+import type { AnyProcedure } from './procedure.ts'
+import type { AnyRouter } from './router.ts'
+
+export type ApiCallContext = Readonly<{
+  connection: GatewayConnection
+  container: Container
+  path: AnyRouter[]
+  procedure: AnyProcedure
+}>
+
+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
+}

package/src/runtime/application/config.ts

@@ -0,0 +1,69 @@
+import type { ConnectionIdentity, Transport } from '@nmtjs/gateway'
+
+import type { LifecycleHooks } from '../core/hooks.ts'
+import type { RuntimePlugin } from '../core/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 } 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'>
+  transports: Transports
+  identity?: ConnectionIdentity
+  plugins: RuntimePlugin[]
+  filters: AnyFilter[]
+  middlewares: AnyMiddleware[]
+  guards: AnyGuard[]
+  hooks: AnyHook[]
+  lifecycleHooks: LifecycleHooks['_']['config']
+}
+
+export 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'>>,
+) {
+  const {
+    router,
+    transports = {},
+    guards = [],
+    middlewares = [],
+    plugins = [],
+    api = {} as ApplicationConfig['api'],
+    filters = [] as ApplicationConfig['filters'],
+    hooks = [] as ApplicationConfig['hooks'],
+    lifecycleHooks = {},
+    identity: identityResolver,
+  } = options
+
+  return Object.freeze({
+    [kApplicationConfig]: true,
+    router,
+    transports,
+    api,
+    filters,
+    plugins,
+    guards,
+    middlewares,
+    hooks,
+    lifecycleHooks,
+    identity: identityResolver,
+  } satisfies AnyApplicationConfig) as ApplicationConfig<R, T>
+}
+
+export function isApplicationConfig(value: any): value is ApplicationConfig {
+  return Boolean(value?.[kApplicationConfig])
+}

package/src/runtime/application/constants.ts

@@ -0,0 +1,4 @@
+export const kApplicationConfig: unique symbol = Symbol.for(
+  'neemata:ApplicationConfig',
+)
+export type kApplicationConfig = typeof kApplicationConfig

package/src/runtime/application/hook.ts

@@ -0,0 +1,51 @@
+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 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> {
+  const { name, handler, dependencies = {} as Deps } = params
+  return Object.freeze({ [kHook]: true, name, handler, dependencies }) as any
+}
+
+export function createApplicationHookFactory<Types extends HookTypes>() {
+  return <
+    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> => {
+    return createHook<Types, Name, Deps>(params)
+  }
+}

package/src/runtime/application/hooks.ts

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

package/src/runtime/application/index.ts

@@ -0,0 +1,5 @@
+export * from './api/index.ts'
+export * from './config.ts'
+export * from './constants.ts'
+export * from './hook.ts'
+export * from './hooks.ts'

package/src/runtime/constants.ts

@@ -0,0 +1,13 @@
+export const kServerConfig: unique symbol = Symbol.for(
+  'neemata:ServerConfigKey',
+)
+export type kServerConfig = typeof kServerConfig
+
+export const kCommand: unique symbol = Symbol.for('neemata:CommandKey')
+export type kCommand = typeof kCommand
+
+export const kJobKey: unique symbol = Symbol.for('neemata:JobKey')
+export type kJobKey = typeof kJobKey
+
+export const kJobStepKey: unique symbol = Symbol.for('neemata:JobStepKey')
+export type kJobStepKey = typeof kJobStepKey

package/src/runtime/core/hooks.ts

@@ -0,0 +1,5 @@
+import { Hooks } from '@nmtjs/core'
+
+import type { LifecycleHookTypes } from '../types.ts'
+
+export class LifecycleHooks extends Hooks<LifecycleHookTypes> {}