@nmtjs/contract 0.11.9 → 0.12.1

package/dist/schemas/api.js

@@ -1,50 +1,35 @@
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const APIKind = "NeemataAPI";
+export const APIKind = Symbol("NeemataAPI");
 export const APIContract = (options) => {
-	const { namespaces = {}, timeout = 1e3, schemaOptions = {} } = options || {};
+	const { timeout, schemaOptions } = options;
 	const _namespaces = {};
-	for (const namespaceKey in namespaces) {
-		const namespace = namespaces[namespaceKey];
+	for (const namespaceKey in options.namespaces) {
+		const namespace = options.namespaces[namespaceKey];
 		const _procedures = {};
 		for (const procedureKey in namespace.procedures) {
 			const procedure = namespace.procedures[procedureKey];
-			_procedures[procedureKey] = Object.assign({}, procedure, {
+			_procedures[procedureKey] = createSchema({
+				...procedure,
 				name: procedureKey,
 				namespace: namespaceKey
 			});
 		}
-		const _subscriptions = {};
-		for (const subscriptionKey in namespace.subscriptions) {
-			const subscription = namespace.subscriptions[subscriptionKey];
-			const _events = {};
-			for (const eventKey in subscription.events) {
-				const event = subscription.events[eventKey];
-				_events[eventKey] = Object.assign({}, event, {
-					name: eventKey,
-					namespace: namespaceKey,
-					subscription: subscriptionKey
-				});
-			}
-			_subscriptions[subscriptionKey] = Object.assign({}, subscription, {
-				name: subscriptionKey,
-				namespace: namespaceKey,
-				events: _events
-			});
-		}
 		const _events = {};
 		for (const eventKey in namespace.events) {
 			const event = namespace.events[eventKey];
-			_events[eventKey] = Object.assign({}, event, {
+			_events[eventKey] = createSchema({
+				...event,
+				subscription: undefined,
 				name: eventKey,
 				namespace: namespaceKey
 			});
 		}
-		_namespaces[namespaceKey] = Object.assign({}, namespace, {
-			name: namespaceKey,
+		_namespaces[namespaceKey] = createSchema({
+			...namespace,
 			procedures: _procedures,
-			subscriptions: _subscriptions,
-			events: _events
+			events: _events,
+			name: namespaceKey
 		});
 	}
 	return createSchema({

package/dist/schemas/api.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAGtE,OAAO,MAAM,UAAU;AAoBvB,OAAO,MAAM,cAAc,CAEzBA,YAII;CACJ,MAAM,EAAE,aAAa,CAAE,GAAE,UAAU,KAAM,gBAAgB,CAAE,GAAE,GAAG,WAAW,CAAE;CAE7E,MAAM,cAAc,CAAE;AAEtB,MAAK,MAAM,gBAAgB,YAAY;EACrC,MAAM,YAAY,WAAW;EAC7B,MAAM,cAAc,CAAE;AACtB,OAAK,MAAM,gBAAgB,UAAU,YAAY;GAC/C,MAAM,YAAY,UAAU,WAAW;AACvC,eAAY,gBAAgB,OAAO,OAAO,CAAE,GAAE,WAAW;IACvD,MAAM;IACN,WAAW;GACZ,EAAC;EACH;EAED,MAAM,iBAAiB,CAAE;AACzB,OAAK,MAAM,mBAAmB,UAAU,eAAe;GACrD,MAAM,eAAe,UAAU,cAAc;GAC7C,MAAM,UAAU,CAAE;AAClB,QAAK,MAAM,YAAY,aAAa,QAAQ;IAC1C,MAAM,QAAQ,aAAa,OAAO;AAClC,YAAQ,YAAY,OAAO,OAAO,CAAE,GAAE,OAAO;KAC3C,MAAM;KACN,WAAW;KACX,cAAc;IACf,EAAC;GACH;AACD,kBAAe,mBAAmB,OAAO,OAAO,CAAE,GAAE,cAAc;IAChE,MAAM;IACN,WAAW;IACX,QAAQ;GACT,EAAC;EACH;EAED,MAAM,UAAU,CAAE;AAClB,OAAK,MAAM,YAAY,UAAU,QAAQ;GACvC,MAAM,QAAQ,UAAU,OAAO;AAC/B,WAAQ,YAAY,OAAO,OAAO,CAAE,GAAE,OAAO;IAC3C,MAAM;IACN,WAAW;GACZ,EAAC;EACH;AAED,cAAY,gBAAgB,OAAO,OAAO,CAAE,GAAE,WAAW;GACvD,MAAM;GACN,YAAY;GACZ,eAAe;GACf,QAAQ;EACT,EAAC;CACH;AAED,QAAO,aAAuC;EAC5C,GAAG;GACF,OAAO;EACR,MAAM;EACN,YAAY;EACZ;CACD,EAAC;AACH;AAED,OAAO,SAAS,cAAcC,OAAsC;AAClE,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options?: {\n  namespaces?: Namespaces\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n}","value: any"],"sources":["../../src/schemas/api.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts'\n\nexport const APIKind = 'NeemataAPI'\n\nexport type TAnyAPIContract = TAPIContract<Record<string, any>>\n\nexport interface TAPIContract<Namespaces extends Record<string, unknown> = {}> {\n  [Kind]: typeof APIKind\n  type: 'neemata:api'\n  namespaces: {\n    [K in keyof Namespaces]: Namespaces[K] extends TAnyNamespaceContract\n      ? TNamespaceContract<\n          Namespaces[K]['procedures'],\n          // Namespaces[K]['subscriptions'],\n          Namespaces[K]['events'],\n          Extract<K, string>\n        >\n      : never\n  }\n  timeout?: number\n}\n\nexport const APIContract = <\n  Namespaces extends Record<string, unknown> = {},\n>(options?: {\n  namespaces?: Namespaces\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n}) => {\n  const { namespaces = {}, timeout = 1000, schemaOptions = {} } = options || {}\n\n  const _namespaces = {} as any\n\n  for (const namespaceKey in namespaces) {\n    const namespace = namespaces[namespaceKey]\n    const _procedures = {} as any\n    for (const procedureKey in namespace.procedures) {\n      const procedure = namespace.procedures[procedureKey]\n      _procedures[procedureKey] = Object.assign({}, procedure, {\n        name: procedureKey,\n        namespace: namespaceKey,\n      })\n    }\n\n    const _subscriptions = {} as any\n    for (const subscriptionKey in namespace.subscriptions) {\n      const subscription = namespace.subscriptions[subscriptionKey]\n      const _events = {} as any\n      for (const eventKey in subscription.events) {\n        const event = subscription.events[eventKey]\n        _events[eventKey] = Object.assign({}, event, {\n          name: eventKey,\n          namespace: namespaceKey,\n          subscription: subscriptionKey,\n        })\n      }\n      _subscriptions[subscriptionKey] = Object.assign({}, subscription, {\n        name: subscriptionKey,\n        namespace: namespaceKey,\n        events: _events,\n      })\n    }\n\n    const _events = {} as any\n    for (const eventKey in namespace.events) {\n      const event = namespace.events[eventKey]\n      _events[eventKey] = Object.assign({}, event, {\n        name: eventKey,\n        namespace: namespaceKey,\n      })\n    }\n\n    _namespaces[namespaceKey] = Object.assign({}, namespace, {\n      name: namespaceKey,\n      procedures: _procedures,\n      subscriptions: _subscriptions,\n      events: _events,\n    })\n  }\n\n  return createSchema<TAPIContract<Namespaces>>({\n    ...schemaOptions,\n    [Kind]: APIKind,\n    type: 'neemata:api',\n    namespaces: _namespaces,\n    timeout,\n  })\n}\n\nexport function IsAPIContract(value: any): value is TAnyAPIContract {\n  return Kind in value && value[Kind] === APIKind\n}\n"],"version":3,"file":"api.js"}
+{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAKtE,OAAO,MAAM,UAAU,OAAO,aAAa;AAqB3C,OAAO,MAAM,cAAc,CAOzBA,YACG;CACH,MAAM,EAAE,SAAS,eAAe,GAAG;CAEnC,MAAM,cAAc,CAAE;AAEtB,MAAK,MAAM,gBAAgB,QAAQ,YAAY;EAC7C,MAAM,YAAY,QAAQ,WAAW;EACrC,MAAM,cAAc,CAAE;AACtB,OAAK,MAAM,gBAAgB,UAAU,YAAY;GAC/C,MAAM,YAAY,UAAU,WAAW;AACvC,eAAY,gBAAgB,aAQ1B;IACA,GAAG;IACH,MAAM;IACN,WAAW;GACZ,EAAC;EACH;EAED,MAAM,UAAU,CAAE;AAClB,OAAK,MAAM,YAAY,UAAU,QAAQ;GACvC,MAAM,QAAQ,UAAU,OAAO;AAC/B,WAAQ,YAAY,aAOlB;IACA,GAAG;IACH,cAAc;IACd,MAAM;IACN,WAAW;GACZ,EAAC;EACH;AAED,cAAY,gBAAgB,aAM1B;GACA,GAAG;GACH,YAAY;GACZ,QAAQ;GACR,MAAM;EACP,EAAC;CACH;AAED,QAAO,aAAkD;EACvD,GAAG;GACF,OAAO;EACR,MAAM;EACN,YAAY;EACZ;CACD,EAAC;AACH;AAED,OAAO,SAAS,cAAcC,OAAsC;AAClE,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options: Options","value: any"],"sources":["../../src/schemas/api.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts'\nimport type { TProcedureContract } from './procedure.ts'\n\nexport const APIKind = Symbol('NeemataAPI')\n\nexport type TAnyAPIContract = TAPIContract<\n  Record<string, TAnyNamespaceContract>\n>\n\nexport interface TAPIContract<\n  Namespaces extends Record<string, TAnyNamespaceContract> = {},\n> {\n  readonly [Kind]: typeof APIKind\n  readonly type: 'neemata:api'\n  readonly namespaces: {\n    [K in keyof Namespaces]: TNamespaceContract<\n      Namespaces[K]['procedures'],\n      Namespaces[K]['events'],\n      Extract<K, string>\n    >\n  }\n  readonly timeout?: number\n}\n\nexport const APIContract = <\n  const Options extends {\n    namespaces: Record<string, TAnyNamespaceContract>\n    timeout?: number\n    schemaOptions?: ContractSchemaOptions\n  },\n>(\n  options: Options,\n) => {\n  const { timeout, schemaOptions } = options\n\n  const _namespaces = {} as any\n\n  for (const namespaceKey in options.namespaces) {\n    const namespace = options.namespaces[namespaceKey]\n    const _procedures = {} as any\n    for (const procedureKey in namespace.procedures) {\n      const procedure = namespace.procedures[procedureKey]\n      _procedures[procedureKey] = createSchema<\n        TProcedureContract<\n          (typeof procedure)['input'],\n          (typeof procedure)['output'],\n          (typeof procedure)['stream'],\n          Extract<typeof procedureKey, string>,\n          Extract<typeof namespaceKey, string>\n        >\n      >({\n        ...procedure,\n        name: procedureKey,\n        namespace: namespaceKey,\n      })\n    }\n\n    const _events = {} as any\n    for (const eventKey in namespace.events) {\n      const event = namespace.events[eventKey]\n      _events[eventKey] = createSchema<\n        TEventContract<\n          (typeof event)['payload'],\n          Extract<typeof eventKey, string>,\n          undefined,\n          Extract<typeof namespaceKey, string>\n        >\n      >({\n        ...event,\n        subscription: undefined,\n        name: eventKey,\n        namespace: namespaceKey,\n      })\n    }\n\n    _namespaces[namespaceKey] = createSchema<\n      TNamespaceContract<\n        typeof _procedures,\n        typeof _events,\n        Extract<typeof namespaceKey, string>\n      >\n    >({\n      ...namespace,\n      procedures: _procedures,\n      events: _events,\n      name: namespaceKey,\n    })\n  }\n\n  return createSchema<TAPIContract<Options['namespaces']>>({\n    ...schemaOptions,\n    [Kind]: APIKind,\n    type: 'neemata:api',\n    namespaces: _namespaces,\n    timeout,\n  })\n}\n\nexport function IsAPIContract(value: any): value is TAnyAPIContract {\n  return Kind in value && value[Kind] === APIKind\n}\n"],"version":3,"file":"api.js"}

package/dist/schemas/event.js

@@ -1,7 +1,7 @@
 import { t } from "@nmtjs/type";
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const EventKind = "NeemataEvent";
+export const EventKind = Symbol("NeemataEvent");
 export const EventContract = (options) => {
 	const { payload = t.never(), schemaOptions = {}, name } = options ?? {};
 	return createSchema({

package/dist/schemas/event.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAwB,SAAS,aAAa;AAC9C,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAEtE,OAAO,MAAM,YAAY;AAuBzB,OAAO,MAAM,gBAAgB,CAG3BA,YAII;CACJ,MAAM,EACJ,UAAU,EAAE,OAAO,EACnB,gBAAgB,CAAE,GAClB,MACD,GAAG,WAAW,CAAE;AACjB,QAAO,aAA4C;EACjD,GAAG;GACF,OAAO;EACR,MAAM;EACN;EACM;EACN,cAAc;EACd,WAAW;CACZ,EAAC;AACH;AAED,OAAO,SAAS,gBAAgBC,OAAwC;AACtE,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options?: {\n  payload?: Payload\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}","value: any"],"sources":["../../src/schemas/event.ts"],"sourcesContent":["import { type BaseType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const EventKind = 'NeemataEvent'\n\nexport type TAnyEventContract = TEventContract<\n  BaseType,\n  string | undefined,\n  string | undefined,\n  string | undefined\n>\n\nexport interface TEventContract<\n  Payload extends BaseType = t.NeverType,\n  Name extends string | undefined = undefined,\n  Subscription extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  [Kind]: typeof EventKind\n  type: 'neemata:event'\n  name: Name\n  subscription: Subscription\n  namespace: Namespace\n  payload: Payload\n}\n\nexport const EventContract = <\n  Payload extends BaseType,\n  Name extends string | undefined = undefined,\n>(options?: {\n  payload?: Payload\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}) => {\n  const {\n    payload = t.never() as unknown as Payload,\n    schemaOptions = {},\n    name,\n  } = options ?? {}\n  return createSchema<TEventContract<Payload, Name>>({\n    ...schemaOptions,\n    [Kind]: EventKind,\n    type: 'neemata:event',\n    payload,\n    name: name as Name,\n    subscription: undefined,\n    namespace: undefined,\n  })\n}\n\nexport function IsEventContract(value: any): value is TAnyEventContract {\n  return Kind in value && value[Kind] === EventKind\n}\n"],"version":3,"file":"event.js"}
+{"mappings":"AAAA,SAAwB,SAAS,aAAa;AAC9C,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAEtE,OAAO,MAAM,YAAY,OAAO,eAAe;AAuB/C,OAAO,MAAM,gBAAgB,CAG3BA,YAII;CACJ,MAAM,EACJ,UAAU,EAAE,OAAO,EACnB,gBAAgB,CAAE,GAClB,MACD,GAAG,WAAW,CAAE;AACjB,QAAO,aAA4C;EACjD,GAAG;GACF,OAAO;EACR,MAAM;EACN;EACM;EACN,cAAc;EACd,WAAW;CACZ,EAAC;AACH;AAED,OAAO,SAAS,gBAAgBC,OAAwC;AACtE,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options?: {\n  payload?: Payload\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}","value: any"],"sources":["../../src/schemas/event.ts"],"sourcesContent":["import { type BaseType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const EventKind = Symbol('NeemataEvent')\n\nexport type TAnyEventContract = TEventContract<\n  BaseType,\n  string | undefined,\n  string | undefined,\n  string | undefined\n>\n\nexport interface TEventContract<\n  Payload extends BaseType = t.NeverType,\n  Name extends string | undefined = undefined,\n  Subscription extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof EventKind\n  readonly type: 'neemata:event'\n  readonly name: Name\n  readonly subscription: Subscription\n  readonly namespace: Namespace\n  readonly payload: Payload\n}\n\nexport const EventContract = <\n  Payload extends BaseType,\n  Name extends string | undefined = undefined,\n>(options?: {\n  payload?: Payload\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}) => {\n  const {\n    payload = t.never() as unknown as Payload,\n    schemaOptions = {},\n    name,\n  } = options ?? {}\n  return createSchema<TEventContract<Payload, Name>>({\n    ...schemaOptions,\n    [Kind]: EventKind,\n    type: 'neemata:event',\n    payload,\n    name: name as Name,\n    subscription: undefined,\n    namespace: undefined,\n  })\n}\n\nexport function IsEventContract(value: any): value is TAnyEventContract {\n  return Kind in value && value[Kind] === EventKind\n}\n"],"version":3,"file":"event.js"}

package/dist/schemas/namespace.js

@@ -1,21 +1,24 @@
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const NamespaceKind = "NeemataNamespace";
+export const NamespaceKind = Symbol("NeemataNamespace");
 export const NamespaceContract = (options) => {
-	const { procedures = {}, events = {}, name, timeout, schemaOptions = {} } = options ?? {};
-	const _events = {};
-	for (const eventKey in events) {
-		const event = events[eventKey];
-		_events[eventKey] = Object.assign({}, event, {
-			name: eventKey,
+	const { name, timeout, schemaOptions = {} } = options;
+	const events = {};
+	for (const name in options.events) {
+		const event = options.events[name];
+		events[name] = createSchema({
+			...event,
+			subscription: undefined,
+			name,
 			namespace: options?.name
 		});
 	}
-	const _procedures = {};
-	for (const procedureKey in procedures) {
-		const procedure = procedures[procedureKey];
-		_procedures[procedureKey] = Object.assign({}, procedure, {
-			name: procedureKey,
+	const procedures = {};
+	for (const name in options.procedures) {
+		const procedure = options.procedures[name];
+		procedures[name] = createSchema({
+			...procedure,
+			name,
 			namespace: options?.name
 		});
 	}
@@ -24,8 +27,8 @@ export const NamespaceContract = (options) => {
 		[Kind]: NamespaceKind,
 		type: "neemata:namespace",
 		name,
-		procedures: _procedures,
-		events: _events,
+		procedures,
+		events,
 		timeout
 	});
 };

package/dist/schemas/namespace.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAItE,OAAO,MAAM,gBAAgB;AAwC7B,OAAO,MAAM,oBAAoB,CAI/BA,YAMI;CACJ,MAAM,EACJ,aAAa,CAAE,GACf,SAAS,CAAE,GACX,MACA,SACA,gBAAgB,CAAE,GACnB,GAAG,WAAW,CAAE;CACjB,MAAM,UAAU,CAAE;AAElB,MAAK,MAAM,YAAY,QAAQ;EAC7B,MAAM,QAAQ,OAAO;AACrB,UAAQ,YAAY,OAAO,OAAO,CAAE,GAAE,OAAO;GAC3C,MAAM;GACN,WAAW,SAAS;EACrB,EAAC;CACH;CAED,MAAM,cAAc,CAAE;AACtB,MAAK,MAAM,gBAAgB,YAAY;EACrC,MAAMC,YAAiB,WAAW;AAClC,cAAY,gBAAgB,OAAO,OAAO,CAAE,GAAE,WAAW;GACvD,MAAM;GACN,WAAW,SAAS;EACrB,EAAC;CACH;AAED,QAAO,aAA2D;EAChE,GAAG;GACF,OAAO;EACR,MAAM;EACA;EACN,YAAY;EACZ,QAAQ;EACR;CACD,EAAC;AACH;AAED,OAAO,SAAS,oBACdC,OACgC;AAChC,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options?: {\n  procedures?: Procedures\n  events?: Events\n  name?: Name\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n}","procedure: any","value: any"],"sources":["../../src/schemas/namespace.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\nimport type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'\n\nexport const NamespaceKind = 'NeemataNamespace'\n\nexport type TAnyNamespaceContract = TNamespaceContract<\n  Record<string, any>,\n  Record<string, any>,\n  string | undefined\n>\n\nexport interface TNamespaceContract<\n  Procedures extends Record<string, unknown> = {},\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n> {\n  [Kind]: typeof NamespaceKind\n  type: 'neemata:namespace'\n  name: Name\n  procedures: {\n    [K in keyof Procedures]: Procedures[K] extends TAnyProcedureContract\n      ? TProcedureContract<\n          Procedures[K]['input'],\n          Procedures[K]['output'],\n          Procedures[K]['stream'],\n          Extract<K, string>,\n          Name\n        >\n      : never\n  }\n  events: {\n    [K in keyof Events]: Events[K] extends TAnyEventContract\n      ? TEventContract<\n          Events[K]['payload'],\n          Extract<K, string>,\n          undefined,\n          Name\n        >\n      : never\n  }\n  timeout?: number\n}\n\nexport const NamespaceContract = <\n  Procedures extends Record<string, unknown> = {},\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n>(options?: {\n  procedures?: Procedures\n  events?: Events\n  name?: Name\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n}) => {\n  const {\n    procedures = {} as Procedures,\n    events = {} as Events,\n    name,\n    timeout,\n    schemaOptions = {} as ContractSchemaOptions,\n  } = options ?? {}\n  const _events = {} as any\n\n  for (const eventKey in events) {\n    const event = events[eventKey]\n    _events[eventKey] = Object.assign({}, event, {\n      name: eventKey,\n      namespace: options?.name,\n    })\n  }\n\n  const _procedures = {} as any\n  for (const procedureKey in procedures) {\n    const procedure: any = procedures[procedureKey]\n    _procedures[procedureKey] = Object.assign({}, procedure, {\n      name: procedureKey,\n      namespace: options?.name,\n    })\n  }\n\n  return createSchema<TNamespaceContract<Procedures, Events, Name>>({\n    ...schemaOptions,\n    [Kind]: NamespaceKind,\n    type: 'neemata:namespace',\n    name: name as Name,\n    procedures: _procedures,\n    events: _events,\n    timeout,\n  })\n}\n\nexport function IsNamespaceContract(\n  value: any,\n): value is TAnyNamespaceContract {\n  return Kind in value && value[Kind] === NamespaceKind\n}\n"],"version":3,"file":"namespace.js"}
+{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAItE,OAAO,MAAM,gBAAgB,OAAO,mBAAmB;AAyCvD,OAAO,MAAM,oBAAoB,CAS/BA,YACG;CACH,MAAM,EAAE,MAAM,SAAS,gBAAgB,CAAE,GAA2B,GAAG;CACvE,MAAMC,SAA8B,CAAE;AAEtC,MAAK,MAAM,QAAQ,QAAQ,QAAQ;EACjC,MAAM,QAAQ,QAAQ,OAAO;AAC7B,SAAO,QAAQ,aAOb;GACA,GAAG;GACH,cAAc;GACR;GACN,WAAW,SAAS;EACrB,EAAC;CACH;CAED,MAAMC,aAAkC,CAAE;AAE1C,MAAK,MAAM,QAAQ,QAAQ,YAAY;EACrC,MAAMC,YAAiB,QAAQ,WAAW;AAC1C,aAAW,QAAQ,aAQjB;GACA,GAAG;GACG;GACN,WAAW,SAAS;EACrB,EAAC;CACH;AAED,QAAO,aAML;EACA,GAAG;GACF,OAAO;EACR,MAAM;EACA;EACM;EACJ;EACR;CACD,EAAC;AACH;AAED,OAAO,SAAS,oBACdC,OACgC;AAChC,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options: Options","events: Record<string, any>","procedures: Record<string, any>","procedure: any","value: any"],"sources":["../../src/schemas/namespace.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\nimport type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'\n\nexport const NamespaceKind = Symbol('NeemataNamespace')\n\nexport type TAnyNamespaceContract<\n  Procedures extends Record<string, TAnyProcedureContract> = Record<\n    string,\n    TAnyProcedureContract\n  >,\n> = TNamespaceContract<\n  Procedures,\n  Record<string, TAnyEventContract>,\n  string | undefined\n>\n\nexport interface TNamespaceContract<\n  Procedures extends Record<string, TAnyProcedureContract> = {},\n  Events extends Record<string, TAnyEventContract> = {},\n  Name extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof NamespaceKind\n  readonly type: 'neemata:namespace'\n  readonly name: Name\n  readonly procedures: {\n    [K in keyof Procedures]: TProcedureContract<\n      Procedures[K]['input'],\n      Procedures[K]['output'],\n      Procedures[K]['stream'],\n      Extract<K, string>,\n      Name\n    >\n  }\n  readonly events: {\n    [K in keyof Events]: TEventContract<\n      Events[K]['payload'],\n      Extract<K, string>,\n      undefined,\n      Name\n    >\n  }\n  readonly timeout?: number\n}\n\nexport const NamespaceContract = <\n  const Options extends {\n    procedures: Record<string, TAnyProcedureContract>\n    events: Record<string, TAnyEventContract>\n    name?: string\n    timeout?: number\n    schemaOptions?: ContractSchemaOptions\n  },\n>(\n  options: Options,\n) => {\n  const { name, timeout, schemaOptions = {} as ContractSchemaOptions } = options\n  const events: Record<string, any> = {}\n\n  for (const name in options.events) {\n    const event = options.events[name]\n    events[name] = createSchema<\n      TEventContract<\n        (typeof event)['payload'],\n        Extract<typeof name, string>,\n        undefined,\n        Options['name'] extends string ? Options['name'] : undefined\n      >\n    >({\n      ...event,\n      subscription: undefined,\n      name: name as any,\n      namespace: options?.name as any,\n    })\n  }\n\n  const procedures: Record<string, any> = {}\n\n  for (const name in options.procedures) {\n    const procedure: any = options.procedures[name]\n    procedures[name] = createSchema<\n      TProcedureContract<\n        (typeof procedure)['input'],\n        (typeof procedure)['output'],\n        (typeof procedure)['stream'],\n        Extract<typeof name, string>,\n        Options['name'] extends string ? Options['name'] : undefined\n      >\n    >({\n      ...procedure,\n      name: name as any,\n      namespace: options?.name as any,\n    })\n  }\n\n  return createSchema<\n    TNamespaceContract<\n      Options['procedures'],\n      Options['events'],\n      Options['name'] extends string ? Options['name'] : undefined\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: NamespaceKind,\n    type: 'neemata:namespace',\n    name: name as any,\n    procedures: procedures as any,\n    events: events as any,\n    timeout,\n  })\n}\n\nexport function IsNamespaceContract(\n  value: any,\n): value is TAnyNamespaceContract {\n  return Kind in value && value[Kind] === NamespaceKind\n}\n"],"version":3,"file":"namespace.js"}

package/dist/schemas/procedure.js

@@ -1,9 +1,9 @@
 import { t } from "@nmtjs/type";
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const ProcedureKind = "NeemataProcedure";
+export const ProcedureKind = Symbol("NeemataProcedure");
 export const ProcedureContract = (options) => {
-	const { input = t.never(), output = t.never(), stream = t.never(), timeout, schemaOptions = {}, name } = options;
+	const { input = t.never(), output = t.never(), stream = undefined, name = undefined, timeout, schemaOptions = {} } = options;
 	return createSchema({
 		...schemaOptions,
 		[Kind]: ProcedureKind,
@@ -11,13 +11,16 @@ export const ProcedureContract = (options) => {
 		input,
 		output,
 		stream,
-		timeout,
 		name,
+		timeout,
 		namespace: undefined
 	});
 };
 export function IsProcedureContract(contract) {
 	return Kind in contract && contract[Kind] === ProcedureKind;
 }
+export function IsStreamProcedureContract(contract) {
+	return IsProcedureContract(contract) && typeof contract.stream !== "undefined";
+}
 
 //# sourceMappingURL=procedure.js.map

package/dist/schemas/procedure.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAwB,SAAS,aAAa;AAC9C,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAUtE,OAAO,MAAM,gBAAgB;AAmB7B,OAAO,MAAM,oBAAoB,CAK/BA,YAOI;CACJ,MAAM,EACJ,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,OAAO,EAClB,SAAS,EAAE,OAAO,EAClB,SACA,gBAAgB,CAAE,GAClB,MACD,GAAG;AACJ,QAAO,aAA8D;EACnE,GAAG;GACF,OAAO;EACR,MAAM;EACN;EACA;EACA;EACA;EACM;EACN,WAAW;CACZ,EAAC;AACH;AAED,OAAO,SAAS,oBACdC,UACmC;AACnC,QAAO,QAAQ,YAAY,SAAS,UAAU;AAC/C","names":["options: {\n  input?: Input\n  output?: Output\n  stream?: Stream\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}","contract: any"],"sources":["../../src/schemas/procedure.ts"],"sourcesContent":["import { type BaseType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport type TAnyProcedureContract = TProcedureContract<\n  BaseType,\n  BaseType,\n  BaseType,\n  string | undefined,\n  string | undefined\n>\n\nexport const ProcedureKind = 'NeemataProcedure'\n\nexport interface TProcedureContract<\n  Input extends BaseType = t.NeverType,\n  Output extends BaseType = t.NeverType,\n  Stream extends BaseType = t.NeverType,\n  Name extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  [Kind]: typeof ProcedureKind\n  type: 'neemata:procedure'\n  name: Name\n  namespace: Namespace\n  input: Input\n  output: Output\n  timeout?: number\n  stream: Stream\n}\n\nexport const ProcedureContract = <\n  Input extends BaseType = t.NeverType,\n  Output extends BaseType = t.NeverType,\n  Stream extends BaseType = t.NeverType,\n  Name extends string | undefined = undefined,\n>(options: {\n  input?: Input\n  output?: Output\n  stream?: Stream\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}) => {\n  const {\n    input = t.never() as unknown as Input,\n    output = t.never() as unknown as Output,\n    stream = t.never() as unknown as Stream,\n    timeout,\n    schemaOptions = {},\n    name,\n  } = options\n  return createSchema<TProcedureContract<Input, Output, Stream, Name>>({\n    ...schemaOptions,\n    [Kind]: ProcedureKind,\n    type: 'neemata:procedure',\n    input,\n    output,\n    stream,\n    timeout,\n    name: name as Name,\n    namespace: undefined,\n  })\n}\n\nexport function IsProcedureContract(\n  contract: any,\n): contract is TAnyProcedureContract {\n  return Kind in contract && contract[Kind] === ProcedureKind\n}\n"],"version":3,"file":"procedure.js"}
+{"mappings":"AAAA,SAAwB,SAAS,aAAa;AAC9C,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAUtE,OAAO,MAAM,gBAAgB,OAAO,mBAAmB;AAmBvD,OAAO,MAAM,oBAAoB,CAU/BA,YACG;CACH,MAAM,EACJ,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,OAAO,EAClB,SAAS,WACT,OAAO,WACP,SACA,gBAAgB,CAAE,GACnB,GAAG;AACJ,QAAO,aAOL;EACA,GAAG;GACF,OAAO;EACR,MAAM;EACN;EACA;EACA;EACA;EACA;EACA,WAAW;CACZ,EAAC;AACH;AAED,OAAO,SAAS,oBACdC,UACmC;AACnC,QAAO,QAAQ,YAAY,SAAS,UAAU;AAC/C;AAED,OAAO,SAAS,0BACdA,UACmC;AACnC,QAAO,oBAAoB,SAAS,WAAW,SAAS,WAAW;AACpE","names":["options: Options","contract: any"],"sources":["../../src/schemas/procedure.ts"],"sourcesContent":["import { type BaseType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport type TAnyProcedureContract = TProcedureContract<\n  BaseType,\n  BaseType,\n  BaseType | undefined,\n  string | undefined,\n  string | undefined\n>\n\nexport const ProcedureKind = Symbol('NeemataProcedure')\n\nexport interface TProcedureContract<\n  Input extends BaseType,\n  Output extends BaseType,\n  Stream extends BaseType | undefined,\n  Name extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof ProcedureKind\n  readonly type: 'neemata:procedure'\n  readonly name: Name\n  readonly namespace: Namespace\n  readonly input: Input\n  readonly output: Output\n  readonly stream: Stream\n  readonly timeout?: number\n}\n\nexport const ProcedureContract = <\n  const Options extends {\n    input?: BaseType\n    output?: BaseType\n    stream?: BaseType | undefined\n    timeout?: number\n    schemaOptions?: ContractSchemaOptions\n    name?: string\n  },\n>(\n  options: Options,\n) => {\n  const {\n    input = t.never() as any,\n    output = t.never() as any,\n    stream = undefined as any,\n    name = undefined as any,\n    timeout,\n    schemaOptions = {},\n  } = options\n  return createSchema<\n    TProcedureContract<\n      Options['input'] extends BaseType ? Options['input'] : t.NeverType,\n      Options['output'] extends BaseType ? Options['output'] : t.NeverType,\n      Options['stream'] extends BaseType ? Options['stream'] : undefined,\n      Options['name'] extends string ? Options['name'] : undefined\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: ProcedureKind,\n    type: 'neemata:procedure',\n    input,\n    output,\n    stream,\n    name,\n    timeout,\n    namespace: undefined,\n  })\n}\n\nexport function IsProcedureContract(\n  contract: any,\n): contract is TAnyProcedureContract {\n  return Kind in contract && contract[Kind] === ProcedureKind\n}\n\nexport function IsStreamProcedureContract(\n  contract: any,\n): contract is TAnyProcedureContract {\n  return IsProcedureContract(contract) && typeof contract.stream !== 'undefined'\n}\n"],"version":3,"file":"procedure.js"}

package/dist/schemas/subscription.js

@@ -1,25 +1,30 @@
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const SubscriptionKind = "NeemataSubscription";
-export const SubscriptionContract = (options) => {
-	const { events = {}, schemaOptions = {}, name } = options ?? {};
+export const SubscriptionKind = Symbol("NeemataSubscription");
+const _SubscriptionContract = (options) => {
+	const { schemaOptions = {}, name } = options;
 	const _events = {};
-	for (const key in events) {
-		const event = events[key];
-		_events[key] = Object.assign({}, event, {
+	for (const key in options.events) {
+		const event = options.events[key];
+		_events[key] = createSchema({
+			...event,
 			name: key,
+			namespace: undefined,
 			subscription: name
 		});
 	}
-	return { $withOptions: () => createSchema({
+	return createSchema({
 		...schemaOptions,
 		[Kind]: SubscriptionKind,
 		type: "neemata:subscription",
 		events: _events,
 		name,
 		options: undefined
-	}) };
+	});
 };
+export const SubscriptionContract = Object.assign(_SubscriptionContract, { withOptions: () => {
+	return (options) => _SubscriptionContract(options);
+} });
 export function IsSubscriptionContract(contract) {
 	return Kind in contract && contract[Kind] === SubscriptionKind;
 }

package/dist/schemas/subscription.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAGtE,OAAO,MAAM,mBAAmB;AA0BhC,OAAO,MAAM,uBAAuB,CAGlCA,YAII;CACJ,MAAM,EAAE,SAAS,CAAE,GAAY,gBAAgB,CAAE,GAAE,MAAM,GAAG,WAAW,CAAE;CACzE,MAAM,UAAU,CAAE;AAClB,MAAK,MAAM,OAAO,QAAQ;EACxB,MAAM,QAAQ,OAAO;AACrB,UAAQ,OAAO,OAAO,OAAO,CAAE,GAAE,OAAO;GAAE,MAAM;GAAK,cAAc;EAAM,EAAC;CAC3E;AACD,QAAO,EACL,cAAc,MACZ,aAA2D;EACzD,GAAG;GACF,OAAO;EACR,MAAM;EACN,QAAQ;EACF;EACN,SAAS;CACV,EAAC,CACL;AACF;AAED,OAAO,SAAS,uBACdC,UACsC;AACtC,QAAO,QAAQ,YAAY,SAAS,UAAU;AAC/C","names":["options?: {\n  events?: Events\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}","contract: any"],"sources":["../../src/schemas/subscription.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\n\nexport const SubscriptionKind = 'NeemataSubscription'\n\nexport type SubcriptionOptions = Record<string, string | number | boolean>\n\nexport type TAnySubscriptionContract = TSubscriptionContract<\n  SubcriptionOptions,\n  Record<string, TAnyEventContract>,\n  string | undefined\n>\n\nexport interface TSubscriptionContract<\n  Options extends SubcriptionOptions = {},\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n> {\n  [Kind]: typeof SubscriptionKind\n  type: 'neemata:subscription'\n  name: Name\n  options: Options\n  events: {\n    [K in keyof Events]: Events[K] extends TAnyEventContract\n      ? TEventContract<Events[K]['payload'], Extract<K, string>, Name>\n      : never\n  }\n}\n\nexport const SubscriptionContract = <\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n>(options?: {\n  events?: Events\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}) => {\n  const { events = {} as Events, schemaOptions = {}, name } = options ?? {}\n  const _events = {} as any\n  for (const key in events) {\n    const event = events[key]\n    _events[key] = Object.assign({}, event, { name: key, subscription: name })\n  }\n  return {\n    $withOptions: <Options extends SubcriptionOptions>() =>\n      createSchema<TSubscriptionContract<Options, Events, Name>>({\n        ...schemaOptions,\n        [Kind]: SubscriptionKind,\n        type: 'neemata:subscription',\n        events: _events,\n        name: name as Name,\n        options: undefined as unknown as Options,\n      }),\n  }\n}\n\nexport function IsSubscriptionContract(\n  contract: any,\n): contract is TAnySubscriptionContract {\n  return Kind in contract && contract[Kind] === SubscriptionKind\n}\n"],"version":3,"file":"subscription.js"}
+{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAGtE,OAAO,MAAM,mBAAmB,OAAO,sBAAsB;AA6B7D,MAAM,wBAAwB,CAQ5BA,YACG;CACH,MAAM,EAAE,gBAAgB,CAAE,GAAE,MAAM,GAAG;CACrC,MAAM,UAAU,CAAE;AAClB,MAAK,MAAM,OAAO,QAAQ,QAAQ;EAChC,MAAM,QAAQ,QAAQ,OAAO;AAC7B,UAAQ,OAAO,aAOb;GACA,GAAG;GACH,MAAM;GACN,WAAW;GACX,cAAc;EACf,EAAC;CACH;AACD,QAAO,aAML;EACA,GAAG;GACF,OAAO;EACR,MAAM;EACN,QAAQ;EACF;EACN,SAAS;CACV,EAAC;AACH;AAED,OAAO,MAAM,uBAAuB,OAAO,OAAO,uBAAuB,EACvE,aAAa,MAA0C;AACrD,QAAO,CAOLC,YACG,sBAAkC,QAAQ;AAChD,EACF,EAAC;AAEF,OAAO,SAAS,uBACdC,UACsC;AACtC,QAAO,QAAQ,YAAY,SAAS,UAAU;AAC/C","names":["options: Options","options: T","contract: any"],"sources":["../../src/schemas/subscription.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\n\nexport const SubscriptionKind = Symbol('NeemataSubscription')\n\nexport type SubcriptionOptions = Record<\n  string,\n  string | number | boolean\n> | null\n\nexport type TAnySubscriptionContract = TSubscriptionContract<\n  SubcriptionOptions,\n  Record<string, TAnyEventContract>,\n  string | undefined\n>\n\nexport interface TSubscriptionContract<\n  Options extends SubcriptionOptions = null,\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof SubscriptionKind\n  readonly type: 'neemata:subscription'\n  readonly name: Name\n  readonly options: Options\n  readonly events: {\n    [K in keyof Events]: Events[K] extends TAnyEventContract\n      ? TEventContract<Events[K]['payload'], Extract<K, string>, Name>\n      : never\n  }\n}\n\nconst _SubscriptionContract = <\n  const Options extends {\n    events: Record<string, TAnyEventContract>\n    name?: string\n    schemaOptions?: ContractSchemaOptions\n  },\n  SubOpt extends SubcriptionOptions = null,\n>(\n  options: Options,\n) => {\n  const { schemaOptions = {}, name } = options\n  const _events = {} as any\n  for (const key in options.events) {\n    const event = options.events[key]\n    _events[key] = createSchema<\n      TEventContract<\n        (typeof event)['payload'],\n        Extract<typeof key, string>,\n        undefined,\n        Options['name'] extends string ? Options['name'] : undefined\n      >\n    >({\n      ...event,\n      name: key,\n      namespace: undefined,\n      subscription: name as any,\n    })\n  }\n  return createSchema<\n    TSubscriptionContract<\n      SubOpt,\n      Options['events'],\n      Options['name'] extends string ? Options['name'] : undefined\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: SubscriptionKind,\n    type: 'neemata:subscription',\n    events: _events,\n    name: name as any,\n    options: undefined as unknown as SubOpt,\n  })\n}\n\nexport const SubscriptionContract = Object.assign(_SubscriptionContract, {\n  withOptions: <Options extends SubcriptionOptions>() => {\n    return <\n      T extends {\n        events: Record<string, TAnyEventContract>\n        name?: string\n        schemaOptions?: ContractSchemaOptions\n      },\n    >(\n      options: T,\n    ) => _SubscriptionContract<T, Options>(options)\n  },\n})\n\nexport function IsSubscriptionContract(\n  contract: any,\n): contract is TAnySubscriptionContract {\n  return Kind in contract && contract[Kind] === SubscriptionKind\n}\n"],"version":3,"file":"subscription.js"}

package/dist/utils.js

@@ -5,6 +5,6 @@ export const applyNames = (params, opts) => {
 		...opts
 	}]));
 };
-export const createSchema = (schema) => schema;
+export const createSchema = (schema) => Object.freeze(schema);
 
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"mappings":"AAKA,OAAO,MAAM,aAAa,CACxBA,QACAC,SACG;AACH,QAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG;EAAE,GAAG;EAAG,MAAM;EAAG,GAAG;CAAM,CAAC,EAAC,CACxE;AACF;AAED,OAAO,MAAM,eAAe,CAAIC,WAAc","names":["params: T","opts: { serviceName?: string; subscriptionName?: string }","schema: T"],"sources":["../src/utils.ts"],"sourcesContent":["export type ContractSchemaOptions = {\n  title?: string\n  description?: string\n}\n\nexport const applyNames = <T extends Record<string, { serviceName?: string }>>(\n  params: T,\n  opts: { serviceName?: string; subscriptionName?: string },\n) => {\n  return Object.fromEntries(\n    Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]),\n  )\n}\n\nexport const createSchema = <T>(schema: T) => schema as T\n"],"version":3,"file":"utils.js"}
+{"mappings":"AAKA,OAAO,MAAM,aAAa,CACxBA,QACAC,SACG;AACH,QAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG;EAAE,GAAG;EAAG,MAAM;EAAG,GAAG;CAAM,CAAC,EAAC,CACxE;AACF;AAED,OAAO,MAAM,eAAe,CAAIC,WAAc,OAAO,OAAO,OAAO","names":["params: T","opts: { serviceName?: string; subscriptionName?: string }","schema: T"],"sources":["../src/utils.ts"],"sourcesContent":["export type ContractSchemaOptions = {\n  title?: string\n  description?: string\n}\n\nexport const applyNames = <T extends Record<string, { serviceName?: string }>>(\n  params: T,\n  opts: { serviceName?: string; subscriptionName?: string },\n) => {\n  return Object.fromEntries(\n    Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]),\n  )\n}\n\nexport const createSchema = <T>(schema: T) => Object.freeze(schema) as T\n"],"version":3,"file":"utils.js"}

package/package.json

@@ -8,8 +8,8 @@
     }
   },
   "dependencies": {
-    "@nmtjs/type": "0.11.9",
-    "@nmtjs/protocol": "0.11.9"
+    "@nmtjs/protocol": "0.12.1",
+    "@nmtjs/type": "0.12.1"
   },
   "files": [
     "src",
@@ -17,7 +17,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.11.9",
+  "version": "0.12.1",
   "scripts": {
     "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/schemas/api.ts

@@ -1,86 +1,96 @@
 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 = 'NeemataAPI'
+export const APIKind = Symbol('NeemataAPI')
 
-export type TAnyAPIContract = TAPIContract<Record<string, any>>
+export type TAnyAPIContract = TAPIContract<
+  Record<string, TAnyNamespaceContract>
+>
 
-export interface TAPIContract<Namespaces extends Record<string, unknown> = {}> {
-  [Kind]: typeof APIKind
-  type: 'neemata:api'
-  namespaces: {
-    [K in keyof Namespaces]: Namespaces[K] extends TAnyNamespaceContract
-      ? TNamespaceContract<
-          Namespaces[K]['procedures'],
-          // Namespaces[K]['subscriptions'],
-          Namespaces[K]['events'],
-          Extract<K, string>
-        >
-      : never
+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>
+    >
   }
-  timeout?: number
+  readonly timeout?: number
 }
 
 export const APIContract = <
-  Namespaces extends Record<string, unknown> = {},
->(options?: {
-  namespaces?: Namespaces
-  timeout?: number
-  schemaOptions?: ContractSchemaOptions
-}) => {
-  const { namespaces = {}, timeout = 1000, schemaOptions = {} } = options || {}
+  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 namespaces) {
-    const namespace = namespaces[namespaceKey]
+  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] = Object.assign({}, procedure, {
+      _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 _subscriptions = {} as any
-    for (const subscriptionKey in namespace.subscriptions) {
-      const subscription = namespace.subscriptions[subscriptionKey]
-      const _events = {} as any
-      for (const eventKey in subscription.events) {
-        const event = subscription.events[eventKey]
-        _events[eventKey] = Object.assign({}, event, {
-          name: eventKey,
-          namespace: namespaceKey,
-          subscription: subscriptionKey,
-        })
-      }
-      _subscriptions[subscriptionKey] = Object.assign({}, subscription, {
-        name: subscriptionKey,
-        namespace: namespaceKey,
-        events: _events,
-      })
-    }
-
     const _events = {} as any
     for (const eventKey in namespace.events) {
       const event = namespace.events[eventKey]
-      _events[eventKey] = Object.assign({}, event, {
+      _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] = Object.assign({}, namespace, {
-      name: namespaceKey,
+    _namespaces[namespaceKey] = createSchema<
+      TNamespaceContract<
+        typeof _procedures,
+        typeof _events,
+        Extract<typeof namespaceKey, string>
+      >
+    >({
+      ...namespace,
       procedures: _procedures,
-      subscriptions: _subscriptions,
       events: _events,
+      name: namespaceKey,
     })
   }
 
-  return createSchema<TAPIContract<Namespaces>>({
+  return createSchema<TAPIContract<Options['namespaces']>>({
     ...schemaOptions,
     [Kind]: APIKind,
     type: 'neemata:api',

package/src/schemas/event.ts

@@ -2,7 +2,7 @@ import { type BaseType, t } from '@nmtjs/type'
 import { Kind } from '../constants.ts'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 
-export const EventKind = 'NeemataEvent'
+export const EventKind = Symbol('NeemataEvent')
 
 export type TAnyEventContract = TEventContract<
   BaseType,
@@ -17,12 +17,12 @@ export interface TEventContract<
   Subscription extends string | undefined = undefined,
   Namespace extends string | undefined = undefined,
 > {
-  [Kind]: typeof EventKind
-  type: 'neemata:event'
-  name: Name
-  subscription: Subscription
-  namespace: Namespace
-  payload: Payload
+  readonly [Kind]: typeof EventKind
+  readonly type: 'neemata:event'
+  readonly name: Name
+  readonly subscription: Subscription
+  readonly namespace: Namespace
+  readonly payload: Payload
 }
 
 export const EventContract = <

package/src/schemas/namespace.ts

@@ -3,90 +3,110 @@ import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 import type { TAnyEventContract, TEventContract } from './event.ts'
 import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'
 
-export const NamespaceKind = 'NeemataNamespace'
+export const NamespaceKind = Symbol('NeemataNamespace')
 
-export type TAnyNamespaceContract = TNamespaceContract<
-  Record<string, any>,
-  Record<string, any>,
+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, unknown> = {},
-  Events extends Record<string, unknown> = {},
+  Procedures extends Record<string, TAnyProcedureContract> = {},
+  Events extends Record<string, TAnyEventContract> = {},
   Name extends string | undefined = undefined,
 > {
-  [Kind]: typeof NamespaceKind
-  type: 'neemata:namespace'
-  name: Name
-  procedures: {
-    [K in keyof Procedures]: Procedures[K] extends TAnyProcedureContract
-      ? TProcedureContract<
-          Procedures[K]['input'],
-          Procedures[K]['output'],
-          Procedures[K]['stream'],
-          Extract<K, string>,
-          Name
-        >
-      : never
+  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
+    >
   }
-  events: {
-    [K in keyof Events]: Events[K] extends TAnyEventContract
-      ? TEventContract<
-          Events[K]['payload'],
-          Extract<K, string>,
-          undefined,
-          Name
-        >
-      : never
+  readonly events: {
+    [K in keyof Events]: TEventContract<
+      Events[K]['payload'],
+      Extract<K, string>,
+      undefined,
+      Name
+    >
   }
-  timeout?: number
+  readonly timeout?: number
 }
 
 export const NamespaceContract = <
-  Procedures extends Record<string, unknown> = {},
-  Events extends Record<string, unknown> = {},
-  Name extends string | undefined = undefined,
->(options?: {
-  procedures?: Procedures
-  events?: Events
-  name?: Name
-  timeout?: number
-  schemaOptions?: ContractSchemaOptions
-}) => {
-  const {
-    procedures = {} as Procedures,
-    events = {} as Events,
-    name,
-    timeout,
-    schemaOptions = {} as ContractSchemaOptions,
-  } = options ?? {}
-  const _events = {} as any
+  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 eventKey in events) {
-    const event = events[eventKey]
-    _events[eventKey] = Object.assign({}, event, {
-      name: eventKey,
-      namespace: options?.name,
+  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 = {} as any
-  for (const procedureKey in procedures) {
-    const procedure: any = procedures[procedureKey]
-    _procedures[procedureKey] = Object.assign({}, procedure, {
-      name: procedureKey,
-      namespace: options?.name,
+  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<Procedures, Events, Name>>({
+  return createSchema<
+    TNamespaceContract<
+      Options['procedures'],
+      Options['events'],
+      Options['name'] extends string ? Options['name'] : undefined
+    >
+  >({
     ...schemaOptions,
     [Kind]: NamespaceKind,
     type: 'neemata:namespace',
-    name: name as Name,
-    procedures: _procedures,
-    events: _events,
+    name: name as any,
+    procedures: procedures as any,
+    events: events as any,
     timeout,
   })
 }

package/src/schemas/procedure.ts

@@ -5,60 +5,66 @@ import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 export type TAnyProcedureContract = TProcedureContract<
   BaseType,
   BaseType,
-  BaseType,
+  BaseType | undefined,
   string | undefined,
   string | undefined
 >
 
-export const ProcedureKind = 'NeemataProcedure'
+export const ProcedureKind = Symbol('NeemataProcedure')
 
 export interface TProcedureContract<
-  Input extends BaseType = t.NeverType,
-  Output extends BaseType = t.NeverType,
-  Stream extends BaseType = t.NeverType,
+  Input extends BaseType,
+  Output extends BaseType,
+  Stream extends BaseType | undefined,
   Name extends string | undefined = undefined,
   Namespace extends string | undefined = undefined,
 > {
-  [Kind]: typeof ProcedureKind
-  type: 'neemata:procedure'
-  name: Name
-  namespace: Namespace
-  input: Input
-  output: Output
-  timeout?: number
-  stream: Stream
+  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 = <
-  Input extends BaseType = t.NeverType,
-  Output extends BaseType = t.NeverType,
-  Stream extends BaseType = t.NeverType,
-  Name extends string | undefined = undefined,
->(options: {
-  input?: Input
-  output?: Output
-  stream?: Stream
-  timeout?: number
-  schemaOptions?: ContractSchemaOptions
-  name?: Name
-}) => {
+  const Options extends {
+    input?: BaseType
+    output?: BaseType
+    stream?: BaseType | undefined
+    timeout?: number
+    schemaOptions?: ContractSchemaOptions
+    name?: string
+  },
+>(
+  options: Options,
+) => {
   const {
-    input = t.never() as unknown as Input,
-    output = t.never() as unknown as Output,
-    stream = t.never() as unknown as Stream,
+    input = t.never() as any,
+    output = t.never() as any,
+    stream = undefined as any,
+    name = undefined as any,
     timeout,
     schemaOptions = {},
-    name,
   } = options
-  return createSchema<TProcedureContract<Input, Output, Stream, Name>>({
+  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,
-    name: name as Name,
     namespace: undefined,
   })
 }
@@ -68,3 +74,9 @@ export function IsProcedureContract(
 ): 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

@@ -2,9 +2,12 @@ import { Kind } from '../constants.ts'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 import type { TAnyEventContract, TEventContract } from './event.ts'
 
-export const SubscriptionKind = 'NeemataSubscription'
+export const SubscriptionKind = Symbol('NeemataSubscription')
 
-export type SubcriptionOptions = Record<string, string | number | boolean>
+export type SubcriptionOptions = Record<
+  string,
+  string | number | boolean
+> | null
 
 export type TAnySubscriptionContract = TSubscriptionContract<
   SubcriptionOptions,
@@ -13,48 +16,79 @@ export type TAnySubscriptionContract = TSubscriptionContract<
 >
 
 export interface TSubscriptionContract<
-  Options extends SubcriptionOptions = {},
+  Options extends SubcriptionOptions = null,
   Events extends Record<string, unknown> = {},
   Name extends string | undefined = undefined,
 > {
-  [Kind]: typeof SubscriptionKind
-  type: 'neemata:subscription'
-  name: Name
-  options: Options
-  events: {
+  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
   }
 }
 
-export const SubscriptionContract = <
-  Events extends Record<string, unknown> = {},
-  Name extends string | undefined = undefined,
->(options?: {
-  events?: Events
-  schemaOptions?: ContractSchemaOptions
-  name?: Name
-}) => {
-  const { events = {} as Events, schemaOptions = {}, name } = options ?? {}
+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 events) {
-    const event = events[key]
-    _events[key] = Object.assign({}, event, { name: key, subscription: name })
-  }
-  return {
-    $withOptions: <Options extends SubcriptionOptions>() =>
-      createSchema<TSubscriptionContract<Options, Events, Name>>({
-        ...schemaOptions,
-        [Kind]: SubscriptionKind,
-        type: 'neemata:subscription',
-        events: _events,
-        name: name as Name,
-        options: undefined as unknown as Options,
-      }),
+  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 {

package/src/utils.ts

@@ -12,4 +12,4 @@ export const applyNames = <T extends Record<string, { serviceName?: string }>>(
   )
 }
 
-export const createSchema = <T>(schema: T) => schema as T
+export const createSchema = <T>(schema: T) => Object.freeze(schema) as T