nmtjs 0.16.0-beta.9 → 0.16.0

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

package/src/runtime/application/config.ts

@@ -1,82 +0,0 @@
-import type {
-  ConnectionIdentity,
-  GatewayOptions,
-  Transport,
-} from '@nmtjs/gateway'
-import { assertUniqueMetaBindings } from '@nmtjs/core'
-
-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 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 = [],
-    meta = [],
-    plugins = [],
-    api = {} as ApplicationConfig['api'],
-    filters = [] as ApplicationConfig['filters'],
-    hooks = [] as ApplicationConfig['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,
-  } satisfies AnyApplicationConfig) as ApplicationConfig<R, T>
-}
-
-export function isApplicationConfig(value: any): value is ApplicationConfig {
-  return Boolean(value?.[kApplicationConfig])
-}

package/src/runtime/application/constants.ts

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

package/src/runtime/application/hook.ts

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

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