@nmtjs/contract 0.0.1

package/src/schemas/service.ts

@@ -0,0 +1,126 @@
+import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
+import {
+  type ContractSchemaOptions,
+  applyNames,
+  createSchema,
+} from '../utils.ts'
+import type { TEventContract } from './event.ts'
+import type { TProcedureContract } from './procedure.ts'
+import { SubscriptionKind, type TSubscriptionContract } from './subscription.ts'
+
+export const ServiceKind = 'NeemataService'
+
+export interface TServiceContract<
+  Name extends string = string,
+  Transports extends { [K in string]?: true } = {},
+  Procedures extends Record<
+    string,
+    TProcedureContract | TSubscriptionContract
+  > = Record<string, TProcedureContract | TSubscriptionContract>,
+  Events extends Record<string, TEventContract> = Record<
+    string,
+    TEventContract
+  >,
+> extends TSchema {
+  [Kind]: typeof ServiceKind
+  static: {
+    procedures: {
+      [K in keyof Procedures]: Procedures[K]['static']
+    }
+    subscriptions: {
+      [K in keyof Procedures]: Procedures[K]['static']
+    }
+    events: {
+      [K in keyof Events]: Events[K]['static']
+    }
+    transports: Transports
+  }
+  type: 'neemata:service'
+  name: Name
+  transports: Transports
+  procedures: {
+    [K in keyof Procedures]: Procedures[K] extends TProcedureContract<
+      infer Input,
+      infer Output
+    >
+      ? TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>
+      : Procedures[K] extends TSubscriptionContract<
+            infer Input,
+            infer Output,
+            infer Options,
+            infer Events
+          >
+        ? TSubscriptionContract<
+            Input,
+            Output,
+            Options,
+            {
+              [EK in keyof Events]: Events[EK] extends TEventContract<
+                infer Payload
+              >
+                ? TEventContract<
+                    Payload,
+                    Extract<EK, string>,
+                    Name,
+                    Extract<K, string>
+                  >
+                : never
+            },
+            Extract<K, string>,
+            Name,
+            Transports
+          >
+        : never
+  }
+  events: {
+    [K in Extract<keyof Events, string>]: Events[K] extends TEventContract<
+      infer Payload
+    >
+      ? TEventContract<Payload, K, Name>
+      : never
+  }
+  timeout?: number
+}
+
+export const ServiceContract = <
+  Name extends string,
+  Transports extends { [key: string]: true },
+  Procedures extends Record<string, TProcedureContract | TSubscriptionContract>,
+  Events extends Record<string, TEventContract>,
+>(
+  name: Name,
+  transports: Transports,
+  procedures: Procedures = {} as Procedures,
+  events: Events = {} as Events,
+  timeout?: number,
+  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
+) => {
+  if (!TypeRegistry.Has(ServiceKind)) TypeRegistry.Set(ServiceKind, () => true)
+
+  const serviceProcedures = {}
+
+  for (const [procedureName, procedure] of Object.entries(procedures)) {
+    if (procedure[Kind] === SubscriptionKind) {
+      serviceProcedures[procedureName] = {
+        ...procedure,
+        events: applyNames(procedure.events, {
+          serviceName: name,
+          subscriptionName: procedureName,
+        }),
+      }
+    } else {
+      serviceProcedures[procedureName] = procedure
+    }
+  }
+
+  return createSchema<TServiceContract<Name, Transports, Procedures, Events>>({
+    ...schemaOptions,
+    [Kind]: ServiceKind,
+    name: name,
+    type: 'neemata:service',
+    procedures: applyNames(procedures, { serviceName: name }),
+    events: applyNames(events, { serviceName: name }),
+    transports,
+    timeout,
+  })
+}

package/src/schemas/subscription.ts

@@ -0,0 +1,82 @@
+import { Kind, type TSchema, TypeRegistry } from '@sinclair/typebox/type'
+import { type ContractSchemaOptions, createSchema } from '../utils.ts'
+import type { TEventContract } from './event.ts'
+import type { TBaseProcedureContract } from './procedure.ts'
+
+export const SubscriptionKind = 'NeemataSubscription'
+
+export type TSubcriptionOptions = { static: Record<string, string | number> }
+
+export interface TSubscriptionContract<
+  Input extends TSchema = TSchema,
+  Output extends TSchema = TSchema,
+  Options extends TSubcriptionOptions = TSubcriptionOptions,
+  Events extends Record<string, TEventContract> = Record<
+    string,
+    TEventContract
+  >,
+  Name extends string | undefined = string | undefined,
+  ServiceName extends string | undefined = string | undefined,
+  Transports extends { [K in string]?: true } | undefined =
+    | { [K in string]?: true }
+    | undefined,
+> extends TBaseProcedureContract<Input, Output, Name, ServiceName, Transports> {
+  [Kind]: typeof SubscriptionKind
+  type: 'neemata:subscription'
+  static: {
+    input: Input['static']
+    output: Output['static']
+    options: Options['static']
+    events: {
+      [K in keyof Events]: Events[K]['static']
+    }
+  }
+  options: Options
+  events: Events
+}
+
+export const SubscriptionContract = <
+  Input extends TSchema = TSchema,
+  Output extends TSchema = TSchema,
+  Options extends TSubcriptionOptions = TSubcriptionOptions,
+  Events extends Record<string, TEventContract> = Record<
+    string,
+    TEventContract
+  >,
+  Name extends string | undefined = string | undefined,
+  ServiceName extends string | undefined = string | undefined,
+  Transports extends { [K in string]?: true } | undefined =
+    | { [K in string]?: true }
+    | undefined,
+>(
+  input: Input,
+  output: Output,
+  options: Options,
+  events: Events,
+  timeout?: number,
+  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
+) => {
+  if (!TypeRegistry.Has(SubscriptionKind))
+    TypeRegistry.Set(SubscriptionKind, () => true)
+
+  return createSchema<
+    TSubscriptionContract<
+      Input,
+      Output,
+      Options,
+      Events,
+      Name,
+      ServiceName,
+      Transports
+    >
+  >({
+    ...schemaOptions,
+    [Kind]: SubscriptionKind,
+    type: 'neemata:subscription',
+    input,
+    output,
+    events,
+    options,
+    timeout,
+  })
+}

package/src/schemas/union-enum.ts

@@ -0,0 +1,43 @@
+import {
+  Kind,
+  type SchemaOptions,
+  type TSchema,
+  TypeRegistry,
+} from '@sinclair/typebox/type'
+
+export const UnionEnumKind = 'UnionEnum'
+
+// Ref: https://github.com/sinclairzx81/typebox/blob/master/example/prototypes/union-enum.ts
+
+// -------------------------------------------------------------------------------------
+// TUnionEnum
+// -------------------------------------------------------------------------------------
+export interface TUnionEnum<T extends (string | number)[]> extends TSchema {
+  [Kind]: typeof UnionEnumKind
+  static: T[number]
+  enum: T
+}
+
+// -------------------------------------------------------------------------------------
+// UnionEnum
+// -------------------------------------------------------------------------------------
+/** `[Experimental]` Creates a Union type with a `enum` schema representation  */
+export function UnionEnum<T extends (string | number)[]>(
+  values: [...T],
+  options: SchemaOptions = {},
+) {
+  function UnionEnumCheck(
+    schema: TUnionEnum<(string | number)[]>,
+    value: unknown,
+  ) {
+    return (
+      (typeof value === 'string' || typeof value === 'number') &&
+      schema.enum.includes(value)
+    )
+  }
+
+  if (!TypeRegistry.Has(UnionEnumKind))
+    TypeRegistry.Set(UnionEnumKind, UnionEnumCheck)
+
+  return { ...options, [Kind]: UnionEnumKind, enum: values } as TUnionEnum<T>
+}

package/src/utils.ts

@@ -0,0 +1,16 @@
+import type { SchemaOptions, TSchema } from '@sinclair/typebox'
+
+export type ContractSchemaOptions = Pick<SchemaOptions, 'title' | 'description'>
+
+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 extends TSchema>(
+  schema: Omit<T, 'static' | 'params'>,
+) => schema as T

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}