@nmtjs/contract 0.12.6 → 0.12.8

package/package.json

@@ -9,16 +9,15 @@
     }
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.12.6",
-    "@nmtjs/type": "0.12.6"
+    "@nmtjs/protocol": "0.12.8",
+    "@nmtjs/type": "0.12.8"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.6",
+  "version": "0.12.8",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/src/constants.ts

@@ -1 +0,0 @@
-export const Kind = Symbol.for('neemata:kind')

package/src/index.ts

@@ -1,28 +0,0 @@
-// biome-ignore lint/correctness/noUnusedImports: TSC wants it
-import t from '@nmtjs/type'
-
-import { APIContract } from './schemas/api.ts'
-import { EventContract } from './schemas/event.ts'
-import { NamespaceContract } from './schemas/namespace.ts'
-import { ProcedureContract } from './schemas/procedure.ts'
-import { SubscriptionContract } from './schemas/subscription.ts'
-import { BlobType } from './types/blob.ts'
-
-export * from './schemas/api.ts'
-export * from './schemas/event.ts'
-export * from './schemas/namespace.ts'
-export * from './schemas/procedure.ts'
-export * from './schemas/subscription.ts'
-
-export namespace contract {
-  export const procedure = ProcedureContract
-  export const event = EventContract
-  export const subscription = SubscriptionContract
-  export const namespace = NamespaceContract
-  export const api = APIContract
-  export const blob = BlobType
-}
-
-export { contract as c }
-
-export default contract

package/src/schemas/api.ts

@@ -1,104 +0,0 @@
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TEventContract } from './event.ts'
-import type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts'
-import type { TProcedureContract } from './procedure.ts'
-
-export const APIKind = Symbol('NeemataAPI')
-
-export type TAnyAPIContract = TAPIContract<
-  Record<string, TAnyNamespaceContract>
->
-
-export interface TAPIContract<
-  Namespaces extends Record<string, TAnyNamespaceContract> = {},
-> {
-  readonly [Kind]: typeof APIKind
-  readonly type: 'neemata:api'
-  readonly namespaces: {
-    [K in keyof Namespaces]: TNamespaceContract<
-      Namespaces[K]['procedures'],
-      Namespaces[K]['events'],
-      Extract<K, string>
-    >
-  }
-  readonly timeout?: number
-}
-
-export const APIContract = <
-  const Options extends {
-    namespaces: Record<string, TAnyNamespaceContract>
-    timeout?: number
-    schemaOptions?: ContractSchemaOptions
-  },
->(
-  options: Options,
-) => {
-  const { timeout, schemaOptions } = options
-
-  const _namespaces = {} as any
-
-  for (const namespaceKey in options.namespaces) {
-    const namespace = options.namespaces[namespaceKey]
-    const _procedures = {} as any
-    for (const procedureKey in namespace.procedures) {
-      const procedure = namespace.procedures[procedureKey]
-      _procedures[procedureKey] = createSchema<
-        TProcedureContract<
-          (typeof procedure)['input'],
-          (typeof procedure)['output'],
-          (typeof procedure)['stream'],
-          Extract<typeof procedureKey, string>,
-          Extract<typeof namespaceKey, string>
-        >
-      >({
-        ...procedure,
-        name: procedureKey,
-        namespace: namespaceKey,
-      })
-    }
-
-    const _events = {} as any
-    for (const eventKey in namespace.events) {
-      const event = namespace.events[eventKey]
-      _events[eventKey] = createSchema<
-        TEventContract<
-          (typeof event)['payload'],
-          Extract<typeof eventKey, string>,
-          undefined,
-          Extract<typeof namespaceKey, string>
-        >
-      >({
-        ...event,
-        subscription: undefined,
-        name: eventKey,
-        namespace: namespaceKey,
-      })
-    }
-
-    _namespaces[namespaceKey] = createSchema<
-      TNamespaceContract<
-        typeof _procedures,
-        typeof _events,
-        Extract<typeof namespaceKey, string>
-      >
-    >({
-      ...namespace,
-      procedures: _procedures,
-      events: _events,
-      name: namespaceKey,
-    })
-  }
-
-  return createSchema<TAPIContract<Options['namespaces']>>({
-    ...schemaOptions,
-    [Kind]: APIKind,
-    type: 'neemata:api',
-    namespaces: _namespaces,
-    timeout,
-  })
-}
-
-export function IsAPIContract(value: any): value is TAnyAPIContract {
-  return Kind in value && value[Kind] === APIKind
-}

package/src/schemas/event.ts

@@ -1,54 +0,0 @@
-import { type BaseType, t } from '@nmtjs/type'
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-
-export const EventKind = Symbol('NeemataEvent')
-
-export type TAnyEventContract = TEventContract<
-  BaseType,
-  string | undefined,
-  string | undefined,
-  string | undefined
->
-
-export interface TEventContract<
-  Payload extends BaseType = t.NeverType,
-  Name extends string | undefined = undefined,
-  Subscription extends string | undefined = undefined,
-  Namespace extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof EventKind
-  readonly type: 'neemata:event'
-  readonly name: Name
-  readonly subscription: Subscription
-  readonly namespace: Namespace
-  readonly payload: Payload
-}
-
-export const EventContract = <
-  Payload extends BaseType,
-  Name extends string | undefined = undefined,
->(options?: {
-  payload?: Payload
-  schemaOptions?: ContractSchemaOptions
-  name?: Name
-}) => {
-  const {
-    payload = t.never() as unknown as Payload,
-    schemaOptions = {},
-    name,
-  } = options ?? {}
-  return createSchema<TEventContract<Payload, Name>>({
-    ...schemaOptions,
-    [Kind]: EventKind,
-    type: 'neemata:event',
-    payload,
-    name: name as Name,
-    subscription: undefined,
-    namespace: undefined,
-  })
-}
-
-export function IsEventContract(value: any): value is TAnyEventContract {
-  return Kind in value && value[Kind] === EventKind
-}

package/src/schemas/namespace.ts

@@ -1,118 +0,0 @@
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TAnyEventContract, TEventContract } from './event.ts'
-import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'
-
-export const NamespaceKind = Symbol('NeemataNamespace')
-
-export type TAnyNamespaceContract<
-  Procedures extends Record<string, TAnyProcedureContract> = Record<
-    string,
-    TAnyProcedureContract
-  >,
-> = TNamespaceContract<
-  Procedures,
-  Record<string, TAnyEventContract>,
-  string | undefined
->
-
-export interface TNamespaceContract<
-  Procedures extends Record<string, TAnyProcedureContract> = {},
-  Events extends Record<string, TAnyEventContract> = {},
-  Name extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof NamespaceKind
-  readonly type: 'neemata:namespace'
-  readonly name: Name
-  readonly procedures: {
-    [K in keyof Procedures]: TProcedureContract<
-      Procedures[K]['input'],
-      Procedures[K]['output'],
-      Procedures[K]['stream'],
-      Extract<K, string>,
-      Name
-    >
-  }
-  readonly events: {
-    [K in keyof Events]: TEventContract<
-      Events[K]['payload'],
-      Extract<K, string>,
-      undefined,
-      Name
-    >
-  }
-  readonly timeout?: number
-}
-
-export const NamespaceContract = <
-  const Options extends {
-    procedures: Record<string, TAnyProcedureContract>
-    events: Record<string, TAnyEventContract>
-    name?: string
-    timeout?: number
-    schemaOptions?: ContractSchemaOptions
-  },
->(
-  options: Options,
-) => {
-  const { name, timeout, schemaOptions = {} as ContractSchemaOptions } = options
-  const events: Record<string, any> = {}
-
-  for (const name in options.events) {
-    const event = options.events[name]
-    events[name] = createSchema<
-      TEventContract<
-        (typeof event)['payload'],
-        Extract<typeof name, string>,
-        undefined,
-        Options['name'] extends string ? Options['name'] : undefined
-      >
-    >({
-      ...event,
-      subscription: undefined,
-      name: name as any,
-      namespace: options?.name as any,
-    })
-  }
-
-  const procedures: Record<string, any> = {}
-
-  for (const name in options.procedures) {
-    const procedure: any = options.procedures[name]
-    procedures[name] = createSchema<
-      TProcedureContract<
-        (typeof procedure)['input'],
-        (typeof procedure)['output'],
-        (typeof procedure)['stream'],
-        Extract<typeof name, string>,
-        Options['name'] extends string ? Options['name'] : undefined
-      >
-    >({
-      ...procedure,
-      name: name as any,
-      namespace: options?.name as any,
-    })
-  }
-
-  return createSchema<
-    TNamespaceContract<
-      Options['procedures'],
-      Options['events'],
-      Options['name'] extends string ? Options['name'] : undefined
-    >
-  >({
-    ...schemaOptions,
-    [Kind]: NamespaceKind,
-    type: 'neemata:namespace',
-    name: name as any,
-    procedures: procedures as any,
-    events: events as any,
-    timeout,
-  })
-}
-
-export function IsNamespaceContract(
-  value: any,
-): value is TAnyNamespaceContract {
-  return Kind in value && value[Kind] === NamespaceKind
-}

package/src/schemas/procedure.ts

@@ -1,82 +0,0 @@
-import { type BaseType, t } from '@nmtjs/type'
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-
-export type TAnyProcedureContract = TProcedureContract<
-  BaseType,
-  BaseType,
-  BaseType | undefined,
-  string | undefined,
-  string | undefined
->
-
-export const ProcedureKind = Symbol('NeemataProcedure')
-
-export interface TProcedureContract<
-  Input extends BaseType,
-  Output extends BaseType,
-  Stream extends BaseType | undefined,
-  Name extends string | undefined = undefined,
-  Namespace extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof ProcedureKind
-  readonly type: 'neemata:procedure'
-  readonly name: Name
-  readonly namespace: Namespace
-  readonly input: Input
-  readonly output: Output
-  readonly stream: Stream
-  readonly timeout?: number
-}
-
-export const ProcedureContract = <
-  const Options extends {
-    input?: BaseType
-    output?: BaseType
-    stream?: BaseType | undefined
-    timeout?: number
-    schemaOptions?: ContractSchemaOptions
-    name?: string
-  },
->(
-  options: Options,
-) => {
-  const {
-    input = t.never() as any,
-    output = t.never() as any,
-    stream = undefined as any,
-    name = undefined as any,
-    timeout,
-    schemaOptions = {},
-  } = options
-  return createSchema<
-    TProcedureContract<
-      Options['input'] extends BaseType ? Options['input'] : t.NeverType,
-      Options['output'] extends BaseType ? Options['output'] : t.NeverType,
-      Options['stream'] extends BaseType ? Options['stream'] : undefined,
-      Options['name'] extends string ? Options['name'] : undefined
-    >
-  >({
-    ...schemaOptions,
-    [Kind]: ProcedureKind,
-    type: 'neemata:procedure',
-    input,
-    output,
-    stream,
-    name,
-    timeout,
-    namespace: undefined,
-  })
-}
-
-export function IsProcedureContract(
-  contract: any,
-): contract is TAnyProcedureContract {
-  return Kind in contract && contract[Kind] === ProcedureKind
-}
-
-export function IsStreamProcedureContract(
-  contract: any,
-): contract is TAnyProcedureContract {
-  return IsProcedureContract(contract) && typeof contract.stream !== 'undefined'
-}

package/src/schemas/subscription.ts

@@ -1,96 +0,0 @@
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TAnyEventContract, TEventContract } from './event.ts'
-
-export const SubscriptionKind = Symbol('NeemataSubscription')
-
-export type SubcriptionOptions = Record<
-  string,
-  string | number | boolean
-> | null
-
-export type TAnySubscriptionContract = TSubscriptionContract<
-  SubcriptionOptions,
-  Record<string, TAnyEventContract>,
-  string | undefined
->
-
-export interface TSubscriptionContract<
-  Options extends SubcriptionOptions = null,
-  Events extends Record<string, unknown> = {},
-  Name extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof SubscriptionKind
-  readonly type: 'neemata:subscription'
-  readonly name: Name
-  readonly options: Options
-  readonly events: {
-    [K in keyof Events]: Events[K] extends TAnyEventContract
-      ? TEventContract<Events[K]['payload'], Extract<K, string>, Name>
-      : never
-  }
-}
-
-const _SubscriptionContract = <
-  const Options extends {
-    events: Record<string, TAnyEventContract>
-    name?: string
-    schemaOptions?: ContractSchemaOptions
-  },
-  SubOpt extends SubcriptionOptions = null,
->(
-  options: Options,
-) => {
-  const { schemaOptions = {}, name } = options
-  const _events = {} as any
-  for (const key in options.events) {
-    const event = options.events[key]
-    _events[key] = createSchema<
-      TEventContract<
-        (typeof event)['payload'],
-        Extract<typeof key, string>,
-        undefined,
-        Options['name'] extends string ? Options['name'] : undefined
-      >
-    >({
-      ...event,
-      name: key,
-      namespace: undefined,
-      subscription: name as any,
-    })
-  }
-  return createSchema<
-    TSubscriptionContract<
-      SubOpt,
-      Options['events'],
-      Options['name'] extends string ? Options['name'] : undefined
-    >
-  >({
-    ...schemaOptions,
-    [Kind]: SubscriptionKind,
-    type: 'neemata:subscription',
-    events: _events,
-    name: name as any,
-    options: undefined as unknown as SubOpt,
-  })
-}
-
-export const SubscriptionContract = Object.assign(_SubscriptionContract, {
-  withOptions: <Options extends SubcriptionOptions>() => {
-    return <
-      T extends {
-        events: Record<string, TAnyEventContract>
-        name?: string
-        schemaOptions?: ContractSchemaOptions
-      },
-    >(
-      options: T,
-    ) => _SubscriptionContract<T, Options>(options)
-  },
-})
-
-export function IsSubscriptionContract(
-  contract: any,
-): contract is TAnySubscriptionContract {
-  return Kind in contract && contract[Kind] === SubscriptionKind
-}

package/src/types/blob.ts

@@ -1,26 +0,0 @@
-import type { ProtocolBlobInterface } from '@nmtjs/protocol'
-import { t } from '@nmtjs/type'
-
-export interface BlobOptions {
-  maxSize?: number
-  contentType?: string
-}
-
-export const BlobType = (
-  options: BlobOptions = {},
-): t.CustomType<ProtocolBlobInterface> =>
-  t.custom<ProtocolBlobInterface>({
-    decode: (value) => {
-      // TODO: here should be some validation logic to check if the value is an actual blob
-      if ('metadata' in value) {
-        if (options.maxSize) {
-          const size = (value as ProtocolBlobInterface).metadata.size
-          if (typeof size !== 'undefined' && size > options.maxSize) {
-            throw new Error('Blob size unknown or exceeds maximum allowed size')
-          }
-        }
-      }
-      return value
-    },
-    encode: (value) => value,
-  })

package/src/utils.ts

@@ -1,15 +0,0 @@
-export type ContractSchemaOptions = {
-  title?: string
-  description?: string
-}
-
-export const applyNames = <T extends Record<string, { serviceName?: string }>>(
-  params: T,
-  opts: { serviceName?: string; subscriptionName?: string },
-) => {
-  return Object.fromEntries(
-    Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]),
-  )
-}
-
-export const createSchema = <T>(schema: T) => Object.freeze(schema) as T