@nmtjs/contract 0.5.3 → 0.6.0

package/dist/constants.js

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

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/constants.ts"],"sourcesContent":["export const Kind = Symbol.for('neemata:kind')\n"],"names":["Kind","Symbol","for"],"mappings":"AAAA,OAAO,MAAMA,OAAOC,OAAOC,GAAG,CAAC,gBAAe"}

package/dist/index.js

@@ -1,13 +1,21 @@
+import { APIContract } from "./schemas/api.js";
 import { EventContract } from "./schemas/event.js";
+import { NamespaceContract } from "./schemas/namespace.js";
 import { ProcedureContract } from "./schemas/procedure.js";
-import { ServiceContract } from "./schemas/service.js";
 import { SubscriptionContract } from "./schemas/subscription.js";
-import { blob as blobType } from "./types/blob.js";
-export var c;
-(function(c) {
-    c.procedure = ProcedureContract;
-    c.event = EventContract;
-    c.subscription = SubscriptionContract;
-    c.service = ServiceContract;
-    c.blob = blobType;
-})(c || (c = {}));
+import { BlobType } from "./types/blob.js";
+export * from "./schemas/api.js";
+export * from "./schemas/event.js";
+export * from "./schemas/namespace.js";
+export * from "./schemas/procedure.js";
+export * from "./schemas/subscription.js";
+export var contract;
+(function(contract) {
+    contract.procedure = ProcedureContract;
+    contract.event = EventContract;
+    contract.subscription = SubscriptionContract;
+    contract.namespace = NamespaceContract;
+    contract.api = APIContract;
+    contract.blob = BlobType;
+})(contract || (contract = {}));
+export { contract as c };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { EventContract, type TEventContract } from './schemas/event.ts'\n\nimport {\n  ProcedureContract,\n  type TBaseProcedureContract,\n  type TProcedureContract,\n} from './schemas/procedure.ts'\nimport { ServiceContract, type TServiceContract } from './schemas/service.ts'\nimport {\n  type SubcriptionOptions,\n  SubscriptionContract,\n  type TSubscriptionContract,\n} from './schemas/subscription.ts'\nimport { blob as blobType } from './types/blob.ts'\n\nexport type {\n  TEventContract,\n  TProcedureContract,\n  TBaseProcedureContract,\n  TServiceContract,\n  TSubscriptionContract,\n  SubcriptionOptions,\n}\n\nexport namespace c {\n  export const procedure = ProcedureContract\n  export const event = EventContract\n  export const subscription = SubscriptionContract\n  export const service = ServiceContract\n  export const blob = blobType\n}\n"],"names":["EventContract","ProcedureContract","ServiceContract","SubscriptionContract","blob","blobType","c","procedure","event","subscription","service"],"mappings":"AAAA,SAASA,aAAa,QAA6B,qBAAoB;AAEvE,SACEC,iBAAiB,QAGZ,yBAAwB;AAC/B,SAASC,eAAe,QAA+B,uBAAsB;AAC7E,SAEEC,oBAAoB,QAEf,4BAA2B;AAClC,SAASC,QAAQC,QAAQ,QAAQ,kBAAiB;;UAWjCC;MACFC,YAAYN;MACZO,QAAQR;MACRS,eAAeN;MACfO,UAAUR;MACVE,OAAOC;AACtB,GANiBC,MAAAA"}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { APIContract } from './schemas/api.ts'\nimport { EventContract } from './schemas/event.ts'\nimport { NamespaceContract } from './schemas/namespace.ts'\nimport { ProcedureContract } from './schemas/procedure.ts'\nimport { SubscriptionContract } from './schemas/subscription.ts'\nimport { BlobType } from './types/blob.ts'\n\nexport * from './schemas/api.ts'\nexport * from './schemas/event.ts'\nexport * from './schemas/namespace.ts'\nexport * from './schemas/procedure.ts'\nexport * from './schemas/subscription.ts'\n\nexport namespace contract {\n  export const procedure = ProcedureContract\n  export const event = EventContract\n  export const subscription = SubscriptionContract\n  export const namespace = NamespaceContract\n  export const api = APIContract\n  export const blob = BlobType\n}\n\nexport { contract as c }\n"],"names":["APIContract","EventContract","NamespaceContract","ProcedureContract","SubscriptionContract","BlobType","contract","procedure","event","subscription","namespace","api","blob","c"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,QAAQ,QAAQ,kBAAiB;AAE1C,cAAc,mBAAkB;AAChC,cAAc,qBAAoB;AAClC,cAAc,yBAAwB;AACtC,cAAc,yBAAwB;AACtC,cAAc,4BAA2B;;UAExBC;aACFC,YAAYJ;aACZK,QAAQP;aACRQ,eAAeL;aACfM,YAAYR;aACZS,MAAMX;aACNY,OAAOP;AACtB,GAPiBC,aAAAA;AASjB,SAASA,YAAYO,CAAC,GAAE"}

package/dist/schemas/api.js

@@ -0,0 +1,60 @@
+import { Kind } from "../constants.js";
+import { createSchema } from "../utils.js";
+export const APIKind = 'NeemataAPI';
+export const APIContract = (options)=>{
+    const { namespaces = {}, timeout = 1000, schemaOptions = {} } = options || {};
+    const _namespaces = {};
+    for(const namespaceKey in namespaces){
+        const namespace = namespaces[namespaceKey];
+        const _procedures = {};
+        for(const procedureKey in namespace.procedures){
+            const procedure = namespace.procedures[procedureKey];
+            _procedures[procedureKey] = Object.assign({}, 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, {
+                name: eventKey,
+                namespace: namespaceKey
+            });
+        }
+        _namespaces[namespaceKey] = Object.assign({}, namespace, {
+            name: namespaceKey,
+            procedures: _procedures,
+            subscriptions: _subscriptions,
+            events: _events
+        });
+    }
+    return createSchema({
+        ...schemaOptions,
+        [Kind]: APIKind,
+        type: 'neemata:api',
+        namespaces: _namespaces,
+        timeout
+    });
+};
+export function IsAPIContract(value) {
+    return Kind in value && value[Kind] === APIKind;
+}

package/dist/schemas/api.js.map

@@ -0,0 +1 @@
+{"version":3,"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"],"names":["Kind","createSchema","APIKind","APIContract","options","namespaces","timeout","schemaOptions","_namespaces","namespaceKey","namespace","_procedures","procedureKey","procedures","procedure","Object","assign","name","_subscriptions","subscriptionKey","subscriptions","subscription","_events","eventKey","events","event","type","IsAPIContract","value"],"mappings":"AAAA,SAASA,IAAI,QAAQ,kBAAiB;AACtC,SAAqCC,YAAY,QAAQ,cAAa;AAGtE,OAAO,MAAMC,UAAU,aAAY;AAoBnC,OAAO,MAAMC,cAAc,CAEzBC;IAKA,MAAM,EAAEC,aAAa,CAAC,CAAC,EAAEC,UAAU,IAAI,EAAEC,gBAAgB,CAAC,CAAC,EAAE,GAAGH,WAAW,CAAC;IAE5E,MAAMI,cAAc,CAAC;IAErB,IAAK,MAAMC,gBAAgBJ,WAAY;QACrC,MAAMK,YAAYL,UAAU,CAACI,aAAa;QAC1C,MAAME,cAAc,CAAC;QACrB,IAAK,MAAMC,gBAAgBF,UAAUG,UAAU,CAAE;YAC/C,MAAMC,YAAYJ,UAAUG,UAAU,CAACD,aAAa;YACpDD,WAAW,CAACC,aAAa,GAAGG,OAAOC,MAAM,CAAC,CAAC,GAAGF,WAAW;gBACvDG,MAAML;gBACNF,WAAWD;YACb;QACF;QAEA,MAAMS,iBAAiB,CAAC;QACxB,IAAK,MAAMC,mBAAmBT,UAAUU,aAAa,CAAE;YACrD,MAAMC,eAAeX,UAAUU,aAAa,CAACD,gBAAgB;YAC7D,MAAMG,UAAU,CAAC;YACjB,IAAK,MAAMC,YAAYF,aAAaG,MAAM,CAAE;gBAC1C,MAAMC,QAAQJ,aAAaG,MAAM,CAACD,SAAS;gBAC3CD,OAAO,CAACC,SAAS,GAAGR,OAAOC,MAAM,CAAC,CAAC,GAAGS,OAAO;oBAC3CR,MAAMM;oBACNb,WAAWD;oBACXY,cAAcF;gBAChB;YACF;YACAD,cAAc,CAACC,gBAAgB,GAAGJ,OAAOC,MAAM,CAAC,CAAC,GAAGK,cAAc;gBAChEJ,MAAME;gBACNT,WAAWD;gBACXe,QAAQF;YACV;QACF;QAEA,MAAMA,UAAU,CAAC;QACjB,IAAK,MAAMC,YAAYb,UAAUc,MAAM,CAAE;YACvC,MAAMC,QAAQf,UAAUc,MAAM,CAACD,SAAS;YACxCD,OAAO,CAACC,SAAS,GAAGR,OAAOC,MAAM,CAAC,CAAC,GAAGS,OAAO;gBAC3CR,MAAMM;gBACNb,WAAWD;YACb;QACF;QAEAD,WAAW,CAACC,aAAa,GAAGM,OAAOC,MAAM,CAAC,CAAC,GAAGN,WAAW;YACvDO,MAAMR;YACNI,YAAYF;YACZS,eAAeF;YACfM,QAAQF;QACV;IACF;IAEA,OAAOrB,aAAuC;QAC5C,GAAGM,aAAa;QAChB,CAACP,KAAK,EAAEE;QACRwB,MAAM;QACNrB,YAAYG;QACZF;IACF;AACF,EAAC;AAED,OAAO,SAASqB,cAAcC,KAAU;IACtC,OAAO5B,QAAQ4B,SAASA,KAAK,CAAC5B,KAAK,KAAKE;AAC1C"}

package/dist/schemas/event.js

@@ -1,12 +1,19 @@
+import { t } from '@nmtjs/type';
+import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
 export const EventKind = 'NeemataEvent';
-export const EventContract = (payload, schemaOptions = {})=>{
+export const EventContract = (options)=>{
+    const { payload = t.never(), schemaOptions = {}, name } = options ?? {};
     return createSchema({
         ...schemaOptions,
+        [Kind]: EventKind,
         type: 'neemata:event',
         payload,
-        name: undefined,
-        serviceName: undefined,
-        subscriptionName: undefined
+        name: name,
+        subscription: undefined,
+        namespace: undefined
     });
 };
+export function IsEventContract(value) {
+    return Kind in value && value[Kind] === EventKind;
+}

package/dist/schemas/event.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/event.ts"],"sourcesContent":["import type { BaseType } from '@nmtjs/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const EventKind = 'NeemataEvent'\n\nexport interface TEventContract<\n  Payload extends BaseType = BaseType,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  SubscriptionName extends string | undefined = string | undefined,\n> {\n  type: 'neemata:event'\n  name: Name\n  serviceName: ServiceName\n  subscriptionName: SubscriptionName\n  payload: Payload\n}\n\nexport const EventContract = <Payload extends BaseType>(\n  payload: Payload,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  return createSchema<TEventContract<Payload>>({\n    ...schemaOptions,\n    type: 'neemata:event',\n    payload,\n    name: undefined,\n    serviceName: undefined,\n    subscriptionName: undefined,\n  })\n}\n"],"names":["createSchema","EventKind","EventContract","payload","schemaOptions","type","name","undefined","serviceName","subscriptionName"],"mappings":"AACA,SAAqCA,YAAY,QAAQ,cAAa;AAEtE,OAAO,MAAMC,YAAY,eAAc;AAevC,OAAO,MAAMC,gBAAgB,CAC3BC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,OAAOJ,aAAsC;QAC3C,GAAGI,aAAa;QAChBC,MAAM;QACNF;QACAG,MAAMC;QACNC,aAAaD;QACbE,kBAAkBF;IACpB;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/event.ts"],"sourcesContent":["import { type BaseType, type NeverType, 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 = 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"],"names":["t","Kind","createSchema","EventKind","EventContract","options","payload","never","schemaOptions","name","type","subscription","undefined","namespace","IsEventContract","value"],"mappings":"AAAA,SAAwCA,CAAC,QAAQ,cAAa;AAC9D,SAASC,IAAI,QAAQ,kBAAiB;AACtC,SAAqCC,YAAY,QAAQ,cAAa;AAEtE,OAAO,MAAMC,YAAY,eAAc;AAuBvC,OAAO,MAAMC,gBAAgB,CAG3BC;IAKA,MAAM,EACJC,UAAUN,EAAEO,KAAK,EAAwB,EACzCC,gBAAgB,CAAC,CAAC,EAClBC,IAAI,EACL,GAAGJ,WAAW,CAAC;IAChB,OAAOH,aAA4C;QACjD,GAAGM,aAAa;QAChB,CAACP,KAAK,EAAEE;QACRO,MAAM;QACNJ;QACAG,MAAMA;QACNE,cAAcC;QACdC,WAAWD;IACb;AACF,EAAC;AAED,OAAO,SAASE,gBAAgBC,KAAU;IACxC,OAAOd,QAAQc,SAASA,KAAK,CAACd,KAAK,KAAKE;AAC1C"}

package/dist/schemas/namespace.js

@@ -0,0 +1,53 @@
+import { Kind } from "../constants.js";
+import { createSchema } from "../utils.js";
+export const NamespaceKind = 'NeemataNamespace';
+export const NamespaceContract = (options)=>{
+    const { procedures = {}, subscriptions = {}, events = {}, name, timeout, schemaOptions = {} } = options ?? {};
+    const _events = {};
+    for(const eventKey in events){
+        const event = events[eventKey];
+        _events[eventKey] = Object.assign({}, event, {
+            name: eventKey,
+            namespace: options?.name
+        });
+    }
+    const _procedures = {};
+    for(const procedureKey in procedures){
+        const procedure = procedures[procedureKey];
+        _procedures[procedureKey] = Object.assign({}, procedure, {
+            name: procedureKey,
+            namespace: options?.name
+        });
+    }
+    const _subscriptions = {};
+    for(const subscriptionKey in subscriptions){
+        const subscription = subscriptions[subscriptionKey];
+        const _events = {};
+        for(const eventKey in subscription.events){
+            const event = subscription.events[eventKey];
+            _events[eventKey] = Object.assign({}, event, {
+                name: eventKey,
+                subscription: subscriptionKey,
+                namespace: options?.name
+            });
+        }
+        _subscriptions[subscriptionKey] = Object.assign({}, subscription, {
+            name: subscriptionKey,
+            namespace: options?.name,
+            events: _events
+        });
+    }
+    return createSchema({
+        ...schemaOptions,
+        [Kind]: NamespaceKind,
+        type: 'neemata:namespace',
+        name: name,
+        procedures: _procedures,
+        subscriptions: _subscriptions,
+        events: _events,
+        timeout
+    });
+};
+export function IsNamespaceContract(value) {
+    return Kind in value && value[Kind] === NamespaceKind;
+}

package/dist/schemas/namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"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'\nimport type {\n  TAnySubscriptionContract,\n  TSubscriptionContract,\n} from './subscription.ts'\n\nexport const NamespaceKind = 'NeemataNamespace'\n\nexport type TAnyNamespaceContract = TNamespaceContract<\n  Record<string, any>,\n  Record<string, any>,\n  Record<string, any>,\n  string | undefined\n>\n\nexport interface TNamespaceContract<\n  Procedures extends Record<string, unknown> = {},\n  Subscriptions 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  subscriptions: {\n    [K in keyof Subscriptions]: Subscriptions[K] extends TAnySubscriptionContract\n      ? TSubscriptionContract<\n          Subscriptions[K]['input'],\n          Subscriptions[K]['output'],\n          Subscriptions[K]['options'],\n          {\n            [E in keyof Subscriptions[K]['events']]: Subscriptions[K]['events'][E] extends TAnyEventContract\n              ? TEventContract<\n                  Subscriptions[K]['events'][E]['payload'],\n                  Extract<E, string>,\n                  Extract<K, string>,\n                  Name\n                >\n              : never\n          },\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  Subscriptions extends Record<string, unknown> = {},\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n>(options?: {\n  procedures?: Procedures\n  subscriptions?: Subscriptions\n  events?: Events\n  name?: Name\n  timeout?: number\n  schemaOptions?: ContractSchemaOptions\n}) => {\n  const {\n    procedures = {} as Procedures,\n    subscriptions = {} as Subscriptions,\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  const _subscriptions = {} as any\n  for (const subscriptionKey in subscriptions) {\n    const subscription: any = subscriptions[subscriptionKey]\n    const _events = {} as any\n\n    for (const eventKey in subscription.events) {\n      const event = subscription.events[eventKey]\n      _events[eventKey] = Object.assign({}, event, {\n        name: eventKey,\n        subscription: subscriptionKey,\n        namespace: options?.name,\n      })\n    }\n\n    _subscriptions[subscriptionKey] = Object.assign({}, subscription, {\n      name: subscriptionKey,\n      namespace: options?.name,\n      events: _events,\n    })\n  }\n\n  return createSchema<\n    TNamespaceContract<Procedures, Subscriptions, Events, Name>\n  >({\n    ...schemaOptions,\n    [Kind]: NamespaceKind,\n    type: 'neemata:namespace',\n    name: name as Name,\n    procedures: _procedures,\n    subscriptions: _subscriptions,\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"],"names":["Kind","createSchema","NamespaceKind","NamespaceContract","options","procedures","subscriptions","events","name","timeout","schemaOptions","_events","eventKey","event","Object","assign","namespace","_procedures","procedureKey","procedure","_subscriptions","subscriptionKey","subscription","type","IsNamespaceContract","value"],"mappings":"AAAA,SAASA,IAAI,QAAQ,kBAAiB;AACtC,SAAqCC,YAAY,QAAQ,cAAa;AAQtE,OAAO,MAAMC,gBAAgB,mBAAkB;AA+D/C,OAAO,MAAMC,oBAAoB,CAK/BC;IAQA,MAAM,EACJC,aAAa,CAAC,CAAe,EAC7BC,gBAAgB,CAAC,CAAkB,EACnCC,SAAS,CAAC,CAAW,EACrBC,IAAI,EACJC,OAAO,EACPC,gBAAgB,CAAC,CAA0B,EAC5C,GAAGN,WAAW,CAAC;IAChB,MAAMO,UAAU,CAAC;IAEjB,IAAK,MAAMC,YAAYL,OAAQ;QAC7B,MAAMM,QAAQN,MAAM,CAACK,SAAS;QAC9BD,OAAO,CAACC,SAAS,GAAGE,OAAOC,MAAM,CAAC,CAAC,GAAGF,OAAO;YAC3CL,MAAMI;YACNI,WAAWZ,SAASI;QACtB;IACF;IAEA,MAAMS,cAAc,CAAC;IACrB,IAAK,MAAMC,gBAAgBb,WAAY;QACrC,MAAMc,YAAiBd,UAAU,CAACa,aAAa;QAC/CD,WAAW,CAACC,aAAa,GAAGJ,OAAOC,MAAM,CAAC,CAAC,GAAGI,WAAW;YACvDX,MAAMU;YACNF,WAAWZ,SAASI;QACtB;IACF;IAEA,MAAMY,iBAAiB,CAAC;IACxB,IAAK,MAAMC,mBAAmBf,cAAe;QAC3C,MAAMgB,eAAoBhB,aAAa,CAACe,gBAAgB;QACxD,MAAMV,UAAU,CAAC;QAEjB,IAAK,MAAMC,YAAYU,aAAaf,MAAM,CAAE;YAC1C,MAAMM,QAAQS,aAAaf,MAAM,CAACK,SAAS;YAC3CD,OAAO,CAACC,SAAS,GAAGE,OAAOC,MAAM,CAAC,CAAC,GAAGF,OAAO;gBAC3CL,MAAMI;gBACNU,cAAcD;gBACdL,WAAWZ,SAASI;YACtB;QACF;QAEAY,cAAc,CAACC,gBAAgB,GAAGP,OAAOC,MAAM,CAAC,CAAC,GAAGO,cAAc;YAChEd,MAAMa;YACNL,WAAWZ,SAASI;YACpBD,QAAQI;QACV;IACF;IAEA,OAAOV,aAEL;QACA,GAAGS,aAAa;QAChB,CAACV,KAAK,EAAEE;QACRqB,MAAM;QACNf,MAAMA;QACNH,YAAYY;QACZX,eAAec;QACfb,QAAQI;QACRF;IACF;AACF,EAAC;AAED,OAAO,SAASe,oBACdC,KAAU;IAEV,OAAOzB,QAAQyB,SAASA,KAAK,CAACzB,KAAK,KAAKE;AAC1C"}

package/dist/schemas/procedure.js

@@ -1,12 +1,21 @@
-export const ProcedureContract = (input, output, timeout, schemaOptions = {})=>{
-    return {
+import { t } from '@nmtjs/type';
+import { Kind } from "../constants.js";
+import { createSchema } from "../utils.js";
+export const ProcedureKind = 'NeemataProcedure';
+export const ProcedureContract = (options)=>{
+    const { input = t.never(), output = t.never(), stream = t.never(), timeout, schemaOptions = {}, name } = options;
+    return createSchema({
         ...schemaOptions,
+        [Kind]: ProcedureKind,
         type: 'neemata:procedure',
         input,
         output,
+        stream,
         timeout,
-        name: undefined,
-        serviceName: undefined,
-        transports: undefined
-    };
+        name: name,
+        namespace: undefined
+    });
 };
+export function IsProcedureContract(contract) {
+    return Kind in contract && contract[Kind] === ProcedureKind;
+}

package/dist/schemas/procedure.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/procedure.ts"],"sourcesContent":["import type { BaseType } from '@nmtjs/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport interface TBaseProcedureContract<\n  Type extends string = string,\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> {\n  type: Type\n  name: Name\n  serviceName: ServiceName\n  transports: Transports\n  input: Input\n  output: Output\n  timeout?: number\n}\n\nexport interface TProcedureContract<\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TBaseProcedureContract<\n    'neemata:procedure',\n    Input,\n    Output,\n    Name,\n    ServiceName,\n    Transports\n  > {}\n\nexport const ProcedureContract = <\n  Input extends BaseType,\n  Output extends BaseType,\n>(\n  input: Input,\n  output: Output,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n): TProcedureContract<Input, Output> => {\n  return {\n    ...schemaOptions,\n    type: 'neemata:procedure',\n    input,\n    output,\n    timeout,\n    name: undefined,\n    serviceName: undefined,\n    transports: undefined,\n  }\n}\n"],"names":["ProcedureContract","input","output","timeout","schemaOptions","type","name","undefined","serviceName","transports"],"mappings":"AAuCA,OAAO,MAAMA,oBAAoB,CAI/BC,OACAC,QACAC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,OAAO;QACL,GAAGA,aAAa;QAChBC,MAAM;QACNJ;QACAC;QACAC;QACAG,MAAMC;QACNC,aAAaD;QACbE,YAAYF;IACd;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/procedure.ts"],"sourcesContent":["import { type BaseType, type NeverType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport type TAnyBaseProcedureContract = TBaseProcedureContract<\n  string,\n  BaseType,\n  BaseType,\n  string | undefined,\n  string | undefined\n>\n\nexport interface TBaseProcedureContract<\n  Type extends string,\n  Input extends BaseType,\n  Output extends BaseType,\n  Name extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  [Kind]: string\n  type: Type\n  name: Name\n  namespace: Namespace\n  input: Input\n  output: Output\n  timeout?: number\n}\n\nexport const ProcedureKind = 'NeemataProcedure'\n\nexport type TAnyProcedureContract = TProcedureContract<\n  BaseType,\n  BaseType,\n  BaseType,\n  string | undefined,\n  string | undefined\n>\n\nexport interface TProcedureContract<\n  Input extends BaseType = NeverType,\n  Output extends BaseType = NeverType,\n  Stream extends BaseType = NeverType,\n  Name extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> extends TBaseProcedureContract<\n    'neemata:procedure',\n    Input,\n    Output,\n    Name,\n    Namespace\n  > {\n  [Kind]: typeof ProcedureKind\n  stream: Stream\n}\n\nexport const ProcedureContract = <\n  Input extends BaseType = NeverType,\n  Output extends BaseType = NeverType,\n  Stream extends BaseType = 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"],"names":["t","Kind","createSchema","ProcedureKind","ProcedureContract","options","input","never","output","stream","timeout","schemaOptions","name","type","namespace","undefined","IsProcedureContract","contract"],"mappings":"AAAA,SAAwCA,CAAC,QAAQ,cAAa;AAC9D,SAASC,IAAI,QAAQ,kBAAiB;AACtC,SAAqCC,YAAY,QAAQ,cAAa;AA0BtE,OAAO,MAAMC,gBAAgB,mBAAkB;AA2B/C,OAAO,MAAMC,oBAAoB,CAK/BC;IAQA,MAAM,EACJC,QAAQN,EAAEO,KAAK,EAAsB,EACrCC,SAASR,EAAEO,KAAK,EAAuB,EACvCE,SAAST,EAAEO,KAAK,EAAuB,EACvCG,OAAO,EACPC,gBAAgB,CAAC,CAAC,EAClBC,IAAI,EACL,GAAGP;IACJ,OAAOH,aAA8D;QACnE,GAAGS,aAAa;QAChB,CAACV,KAAK,EAAEE;QACRU,MAAM;QACNP;QACAE;QACAC;QACAC;QACAE,MAAMA;QACNE,WAAWC;IACb;AACF,EAAC;AAED,OAAO,SAASC,oBACdC,QAAa;IAEb,OAAOhB,QAAQgB,YAAYA,QAAQ,CAAChB,KAAK,KAAKE;AAChD"}

package/dist/schemas/subscription.js

@@ -1,17 +1,31 @@
+import { t } from '@nmtjs/type';
+import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const SubscriptionContract = (input, output, events, timeout, schemaOptions = {})=>{
+export const SubscriptionKind = 'NeemataSubscription';
+export const SubscriptionContract = (options)=>{
+    const { input = t.never(), output = t.never(), events = {}, timeout, schemaOptions = {}, name } = options ?? {};
+    const _events = {};
+    for(const key in events){
+        const event = events[key];
+        _events[key] = Object.assign({}, event, {
+            subscription: name
+        });
+    }
     return {
         $withOptions: ()=>createSchema({
                 ...schemaOptions,
+                [Kind]: SubscriptionKind,
                 type: 'neemata:subscription',
                 input,
                 output,
-                events,
+                events: _events,
                 timeout,
-                options: undefined,
-                name: undefined,
-                serviceName: undefined,
-                transports: undefined
+                name: name,
+                namespace: undefined,
+                options: undefined
             })
     };
 };
+export function IsSubscriptionContract(contract) {
+    return Kind in contract && contract[Kind] === SubscriptionKind;
+}

package/dist/schemas/subscription.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/schemas/subscription.ts"],"sourcesContent":["import type { BaseType } from '@nmtjs/type'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TBaseProcedureContract } from './procedure.ts'\n\nexport type SubcriptionOptions = Record<string, string | number>\n\nexport interface TSubscriptionContract<\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Options extends SubcriptionOptions = SubcriptionOptions,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n  Name extends string | undefined = string | undefined,\n  ServiceName extends string | undefined = string | undefined,\n  Transports extends { [K in string]?: true } | undefined =\n    | { [K in string]?: true }\n    | undefined,\n> extends TBaseProcedureContract<\n    'neemata:subscription',\n    Input,\n    Output,\n    Name,\n    ServiceName,\n    Transports\n  > {\n  options: Options\n  events: Events\n}\n\nexport const SubscriptionContract = <\n  Input extends BaseType = BaseType,\n  Output extends BaseType = BaseType,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n>(\n  input: Input,\n  output: Output,\n  events: Events,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  return {\n    $withOptions: <Options extends SubcriptionOptions>() =>\n      createSchema<TSubscriptionContract<Input, Output, Options, Events>>({\n        ...schemaOptions,\n        type: 'neemata:subscription',\n        input,\n        output,\n        events,\n        timeout,\n        options: undefined as unknown as Options,\n        name: undefined,\n        serviceName: undefined,\n        transports: undefined,\n      }),\n  }\n}\n"],"names":["createSchema","SubscriptionContract","input","output","events","timeout","schemaOptions","$withOptions","type","options","undefined","name","serviceName","transports"],"mappings":"AACA,SAAqCA,YAAY,QAAQ,cAAa;AA+BtE,OAAO,MAAMC,uBAAuB,CAQlCC,OACAC,QACAC,QACAC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,OAAO;QACLC,cAAc,IACZP,aAAoE;gBAClE,GAAGM,aAAa;gBAChBE,MAAM;gBACNN;gBACAC;gBACAC;gBACAC;gBACAI,SAASC;gBACTC,MAAMD;gBACNE,aAAaF;gBACbG,YAAYH;YACd;IACJ;AACF,EAAC"}
+{"version":3,"sources":["../../../src/schemas/subscription.ts"],"sourcesContent":["import { type BaseType, type NeverType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\nimport type { TBaseProcedureContract } from './procedure.ts'\n\nexport const SubscriptionKind = 'NeemataSubscription'\n\nexport type SubcriptionOptions = Record<string, string | number | boolean>\n\nexport type TAnySubscriptionContract = TSubscriptionContract<\n  BaseType,\n  BaseType,\n  SubcriptionOptions,\n  Record<string, unknown>,\n  string | undefined,\n  string | undefined\n>\n\nexport interface TSubscriptionContract<\n  Input extends BaseType = NeverType,\n  Output extends BaseType = NeverType,\n  Options extends SubcriptionOptions = {},\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> extends TBaseProcedureContract<\n    'neemata:subscription',\n    Input,\n    Output,\n    Name,\n    Namespace\n  > {\n  [Kind]: typeof SubscriptionKind\n  options: Options\n  events: {\n    [K in keyof Events]: Events[K] extends TAnyEventContract\n      ? TEventContract<\n          Events[K]['payload'],\n          Extract<K, string>,\n          Name,\n          Namespace\n        >\n      : never\n  }\n}\n\nexport const SubscriptionContract = <\n  Input extends BaseType = NeverType,\n  Output extends BaseType = NeverType,\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n>(options?: {\n  input?: Input\n  output?: Output\n  events?: Events\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    events = {} as Events,\n    timeout,\n    schemaOptions = {},\n    name,\n  } = options ?? {}\n\n  const _events = {} as any\n  for (const key in events) {\n    const event = events[key]\n    _events[key] = Object.assign({}, event, { subscription: name })\n  }\n  return {\n    $withOptions: <Options extends SubcriptionOptions>() =>\n      createSchema<TSubscriptionContract<Input, Output, Options, Events, Name>>(\n        {\n          ...schemaOptions,\n          [Kind]: SubscriptionKind,\n          type: 'neemata:subscription',\n          input,\n          output,\n          events: _events,\n          timeout,\n          name: name as Name,\n          namespace: undefined,\n          options: undefined as unknown as Options,\n        },\n      ),\n  }\n}\n\nexport function IsSubscriptionContract(\n  contract: any,\n): contract is TAnySubscriptionContract {\n  return Kind in contract && contract[Kind] === SubscriptionKind\n}\n"],"names":["t","Kind","createSchema","SubscriptionKind","SubscriptionContract","options","input","never","output","events","timeout","schemaOptions","name","_events","key","event","Object","assign","subscription","$withOptions","type","namespace","undefined","IsSubscriptionContract","contract"],"mappings":"AAAA,SAAwCA,CAAC,QAAQ,cAAa;AAC9D,SAASC,IAAI,QAAQ,kBAAiB;AACtC,SAAqCC,YAAY,QAAQ,cAAa;AAItE,OAAO,MAAMC,mBAAmB,sBAAqB;AAyCrD,OAAO,MAAMC,uBAAuB,CAKlCC;IAQA,MAAM,EACJC,QAAQN,EAAEO,KAAK,EAAsB,EACrCC,SAASR,EAAEO,KAAK,EAAuB,EACvCE,SAAS,CAAC,CAAW,EACrBC,OAAO,EACPC,gBAAgB,CAAC,CAAC,EAClBC,IAAI,EACL,GAAGP,WAAW,CAAC;IAEhB,MAAMQ,UAAU,CAAC;IACjB,IAAK,MAAMC,OAAOL,OAAQ;QACxB,MAAMM,QAAQN,MAAM,CAACK,IAAI;QACzBD,OAAO,CAACC,IAAI,GAAGE,OAAOC,MAAM,CAAC,CAAC,GAAGF,OAAO;YAAEG,cAAcN;QAAK;IAC/D;IACA,OAAO;QACLO,cAAc,IACZjB,aACE;gBACE,GAAGS,aAAa;gBAChB,CAACV,KAAK,EAAEE;gBACRiB,MAAM;gBACNd;gBACAE;gBACAC,QAAQI;gBACRH;gBACAE,MAAMA;gBACNS,WAAWC;gBACXjB,SAASiB;YACX;IAEN;AACF,EAAC;AAED,OAAO,SAASC,uBACdC,QAAa;IAEb,OAAOvB,QAAQuB,YAAYA,QAAQ,CAACvB,KAAK,KAAKE;AAChD"}

package/dist/types/blob.js

@@ -1,6 +1,6 @@
 import { t } from '@nmtjs/type';
-export const BlobKind = 'ApiBlob';
-export const blob = (options = {})=>t.custom((value)=>{
+export const BlobKind = 'ProtocolBlob';
+export const BlobType = (options = {})=>t.custom((value)=>{
         if ('metadata' in value) {
             if (options.maxSize) {
                 const size = value.metadata.size;

package/dist/types/blob.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/blob.ts"],"sourcesContent":["import type { ApiBlobInterface } from '@nmtjs/common'\nimport { t } from '@nmtjs/type'\n\nexport const BlobKind = 'ApiBlob'\n\nexport interface BlobOptions {\n  maxSize?: number\n  contentType?: string\n}\n\nexport const blob = (options: BlobOptions = {}) =>\n  t.custom<ApiBlobInterface>(\n    (value) => {\n      // TODO: this should be registered separately for server and client\n      // ref: https://github.com/sinclairzx81/typebox/issues/977\n      if ('metadata' in value) {\n        if (options.maxSize) {\n          const size = (value as ApiBlobInterface).metadata.size\n          if (size === -1 || size > options.maxSize) {\n            throw new Error('Blob size unknown or exceeds maximum allowed size')\n          }\n        }\n      }\n      return value\n    },\n    (value) => value,\n  )\n"],"names":["t","BlobKind","blob","options","custom","value","maxSize","size","metadata","Error"],"mappings":"AACA,SAASA,CAAC,QAAQ,cAAa;AAE/B,OAAO,MAAMC,WAAW,UAAS;AAOjC,OAAO,MAAMC,OAAO,CAACC,UAAuB,CAAC,CAAC,GAC5CH,EAAEI,MAAM,CACN,CAACC;QAGC,IAAI,cAAcA,OAAO;YACvB,IAAIF,QAAQG,OAAO,EAAE;gBACnB,MAAMC,OAAO,AAACF,MAA2BG,QAAQ,CAACD,IAAI;gBACtD,IAAIA,SAAS,CAAC,KAAKA,OAAOJ,QAAQG,OAAO,EAAE;oBACzC,MAAM,IAAIG,MAAM;gBAClB;YACF;QACF;QACA,OAAOJ;IACT,GACA,CAACA,QAAUA,OACZ"}
+{"version":3,"sources":["../../../src/types/blob.ts"],"sourcesContent":["import type { ProtocolBlobInterface } from '@nmtjs/protocol/common'\nimport { t } from '@nmtjs/type'\n\nexport const BlobKind = 'ProtocolBlob'\n\nexport interface BlobOptions {\n  maxSize?: number\n  contentType?: string\n}\n\nexport const BlobType = (options: BlobOptions = {}) =>\n  t.custom<ProtocolBlobInterface>(\n    (value) => {\n      // TODO: this should be registered separately for server and client\n      // ref: https://github.com/sinclairzx81/typebox/issues/977\n      if ('metadata' in value) {\n        if (options.maxSize) {\n          const size = (value as ProtocolBlobInterface).metadata.size\n          if (size === -1 || size > options.maxSize) {\n            throw new Error('Blob size unknown or exceeds maximum allowed size')\n          }\n        }\n      }\n      return value\n    },\n    (value) => value,\n  )\n"],"names":["t","BlobKind","BlobType","options","custom","value","maxSize","size","metadata","Error"],"mappings":"AACA,SAASA,CAAC,QAAQ,cAAa;AAE/B,OAAO,MAAMC,WAAW,eAAc;AAOtC,OAAO,MAAMC,WAAW,CAACC,UAAuB,CAAC,CAAC,GAChDH,EAAEI,MAAM,CACN,CAACC;QAGC,IAAI,cAAcA,OAAO;YACvB,IAAIF,QAAQG,OAAO,EAAE;gBACnB,MAAMC,OAAO,AAACF,MAAgCG,QAAQ,CAACD,IAAI;gBAC3D,IAAIA,SAAS,CAAC,KAAKA,OAAOJ,QAAQG,OAAO,EAAE;oBACzC,MAAM,IAAIG,MAAM;gBAClB;YACF;QACF;QACA,OAAOJ;IACT,GACA,CAACA,QAAUA,OACZ"}

package/package.json

@@ -9,8 +9,8 @@
     }
   },
   "dependencies": {
-    "@nmtjs/type": "0.5.3",
-    "@nmtjs/common": "0.5.3"
+    "@nmtjs/type": "0.6.0",
+    "@nmtjs/protocol": "0.6.0"
   },
   "files": [
     "src",
@@ -19,7 +19,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.5.3",
+  "version": "0.6.0",
   "scripts": {
     "build": "neemata-build -p neutral --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/constants.ts

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

package/src/index.ts

@@ -1,31 +1,23 @@
-import { EventContract, type TEventContract } from './schemas/event.ts'
+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'
 
-import {
-  ProcedureContract,
-  type TBaseProcedureContract,
-  type TProcedureContract,
-} from './schemas/procedure.ts'
-import { ServiceContract, type TServiceContract } from './schemas/service.ts'
-import {
-  type SubcriptionOptions,
-  SubscriptionContract,
-  type TSubscriptionContract,
-} from './schemas/subscription.ts'
-import { blob as 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 type {
-  TEventContract,
-  TProcedureContract,
-  TBaseProcedureContract,
-  TServiceContract,
-  TSubscriptionContract,
-  SubcriptionOptions,
-}
-
-export namespace c {
+export namespace contract {
   export const procedure = ProcedureContract
   export const event = EventContract
   export const subscription = SubscriptionContract
-  export const service = ServiceContract
-  export const blob = blobType
+  export const namespace = NamespaceContract
+  export const api = APIContract
+  export const blob = BlobType
 }
+
+export { contract as c }

package/src/schemas/api.ts

@@ -0,0 +1,94 @@
+import { Kind } from '../constants.ts'
+import { type ContractSchemaOptions, createSchema } from '../utils.ts'
+import type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts'
+
+export const APIKind = 'NeemataAPI'
+
+export type TAnyAPIContract = TAPIContract<Record<string, any>>
+
+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
+  }
+  timeout?: number
+}
+
+export const APIContract = <
+  Namespaces extends Record<string, unknown> = {},
+>(options?: {
+  namespaces?: Namespaces
+  timeout?: number
+  schemaOptions?: ContractSchemaOptions
+}) => {
+  const { namespaces = {}, timeout = 1000, schemaOptions = {} } = options || {}
+
+  const _namespaces = {} as any
+
+  for (const namespaceKey in namespaces) {
+    const namespace = namespaces[namespaceKey]
+    const _procedures = {} as any
+    for (const procedureKey in namespace.procedures) {
+      const procedure = namespace.procedures[procedureKey]
+      _procedures[procedureKey] = Object.assign({}, 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, {
+        name: eventKey,
+        namespace: namespaceKey,
+      })
+    }
+
+    _namespaces[namespaceKey] = Object.assign({}, namespace, {
+      name: namespaceKey,
+      procedures: _procedures,
+      subscriptions: _subscriptions,
+      events: _events,
+    })
+  }
+
+  return createSchema<TAPIContract<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,31 +1,54 @@
-import type { BaseType } from '@nmtjs/type'
+import { type BaseType, type NeverType, t } from '@nmtjs/type'
+import { Kind } from '../constants.ts'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 
 export const EventKind = 'NeemataEvent'
 
+export type TAnyEventContract = TEventContract<
+  BaseType,
+  string | undefined,
+  string | undefined,
+  string | undefined
+>
+
 export interface TEventContract<
-  Payload extends BaseType = BaseType,
-  Name extends string | undefined = string | undefined,
-  ServiceName extends string | undefined = string | undefined,
-  SubscriptionName extends string | undefined = string | undefined,
+  Payload extends BaseType = NeverType,
+  Name extends string | undefined = undefined,
+  Subscription extends string | undefined = undefined,
+  Namespace extends string | undefined = undefined,
 > {
+  [Kind]: typeof EventKind
   type: 'neemata:event'
   name: Name
-  serviceName: ServiceName
-  subscriptionName: SubscriptionName
+  subscription: Subscription
+  namespace: Namespace
   payload: Payload
 }
 
-export const EventContract = <Payload extends BaseType>(
-  payload: Payload,
-  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
-) => {
-  return createSchema<TEventContract<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: undefined,
-    serviceName: undefined,
-    subscriptionName: undefined,
+    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

@@ -0,0 +1,152 @@
+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'
+import type {
+  TAnySubscriptionContract,
+  TSubscriptionContract,
+} from './subscription.ts'
+
+export const NamespaceKind = 'NeemataNamespace'
+
+export type TAnyNamespaceContract = TNamespaceContract<
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>,
+  string | undefined
+>
+
+export interface TNamespaceContract<
+  Procedures extends Record<string, unknown> = {},
+  Subscriptions extends Record<string, unknown> = {},
+  Events extends Record<string, unknown> = {},
+  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
+  }
+  subscriptions: {
+    [K in keyof Subscriptions]: Subscriptions[K] extends TAnySubscriptionContract
+      ? TSubscriptionContract<
+          Subscriptions[K]['input'],
+          Subscriptions[K]['output'],
+          Subscriptions[K]['options'],
+          {
+            [E in keyof Subscriptions[K]['events']]: Subscriptions[K]['events'][E] extends TAnyEventContract
+              ? TEventContract<
+                  Subscriptions[K]['events'][E]['payload'],
+                  Extract<E, string>,
+                  Extract<K, string>,
+                  Name
+                >
+              : never
+          },
+          Extract<K, string>,
+          Name
+        >
+      : never
+  }
+  events: {
+    [K in keyof Events]: Events[K] extends TAnyEventContract
+      ? TEventContract<
+          Events[K]['payload'],
+          Extract<K, string>,
+          undefined,
+          Name
+        >
+      : never
+  }
+  timeout?: number
+}
+
+export const NamespaceContract = <
+  Procedures extends Record<string, unknown> = {},
+  Subscriptions extends Record<string, unknown> = {},
+  Events extends Record<string, unknown> = {},
+  Name extends string | undefined = undefined,
+>(options?: {
+  procedures?: Procedures
+  subscriptions?: Subscriptions
+  events?: Events
+  name?: Name
+  timeout?: number
+  schemaOptions?: ContractSchemaOptions
+}) => {
+  const {
+    procedures = {} as Procedures,
+    subscriptions = {} as Subscriptions,
+    events = {} as Events,
+    name,
+    timeout,
+    schemaOptions = {} as ContractSchemaOptions,
+  } = options ?? {}
+  const _events = {} as any
+
+  for (const eventKey in events) {
+    const event = events[eventKey]
+    _events[eventKey] = Object.assign({}, event, {
+      name: eventKey,
+      namespace: options?.name,
+    })
+  }
+
+  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 _subscriptions = {} as any
+  for (const subscriptionKey in subscriptions) {
+    const subscription: any = subscriptions[subscriptionKey]
+    const _events = {} as any
+
+    for (const eventKey in subscription.events) {
+      const event = subscription.events[eventKey]
+      _events[eventKey] = Object.assign({}, event, {
+        name: eventKey,
+        subscription: subscriptionKey,
+        namespace: options?.name,
+      })
+    }
+
+    _subscriptions[subscriptionKey] = Object.assign({}, subscription, {
+      name: subscriptionKey,
+      namespace: options?.name,
+      events: _events,
+    })
+  }
+
+  return createSchema<
+    TNamespaceContract<Procedures, Subscriptions, Events, Name>
+  >({
+    ...schemaOptions,
+    [Kind]: NamespaceKind,
+    type: 'neemata:namespace',
+    name: name as Name,
+    procedures: _procedures,
+    subscriptions: _subscriptions,
+    events: _events,
+    timeout,
+  })
+}
+
+export function IsNamespaceContract(
+  value: any,
+): value is TAnyNamespaceContract {
+  return Kind in value && value[Kind] === NamespaceKind
+}

package/src/schemas/procedure.ts

@@ -1,59 +1,94 @@
-import type { BaseType } from '@nmtjs/type'
+import { type BaseType, type NeverType, t } from '@nmtjs/type'
+import { Kind } from '../constants.ts'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
 
+export type TAnyBaseProcedureContract = TBaseProcedureContract<
+  string,
+  BaseType,
+  BaseType,
+  string | undefined,
+  string | undefined
+>
+
 export interface TBaseProcedureContract<
-  Type extends string = string,
-  Input extends BaseType = BaseType,
-  Output extends BaseType = BaseType,
-  Name extends string | undefined = string | undefined,
-  ServiceName extends string | undefined = string | undefined,
-  Transports extends { [K in string]?: true } | undefined =
-    | { [K in string]?: true }
-    | undefined,
+  Type extends string,
+  Input extends BaseType,
+  Output extends BaseType,
+  Name extends string | undefined = undefined,
+  Namespace extends string | undefined = undefined,
 > {
+  [Kind]: string
   type: Type
   name: Name
-  serviceName: ServiceName
-  transports: Transports
+  namespace: Namespace
   input: Input
   output: Output
   timeout?: number
 }
 
+export const ProcedureKind = 'NeemataProcedure'
+
+export type TAnyProcedureContract = TProcedureContract<
+  BaseType,
+  BaseType,
+  BaseType,
+  string | undefined,
+  string | undefined
+>
+
 export interface TProcedureContract<
-  Input extends BaseType = BaseType,
-  Output extends BaseType = BaseType,
-  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 extends BaseType = NeverType,
+  Output extends BaseType = NeverType,
+  Stream extends BaseType = NeverType,
+  Name extends string | undefined = undefined,
+  Namespace extends string | undefined = undefined,
 > extends TBaseProcedureContract<
     'neemata:procedure',
     Input,
     Output,
     Name,
-    ServiceName,
-    Transports
-  > {}
+    Namespace
+  > {
+  [Kind]: typeof ProcedureKind
+  stream: Stream
+}
 
 export const ProcedureContract = <
-  Input extends BaseType,
-  Output extends BaseType,
->(
-  input: Input,
-  output: Output,
-  timeout?: number,
-  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
-): TProcedureContract<Input, Output> => {
-  return {
+  Input extends BaseType = NeverType,
+  Output extends BaseType = NeverType,
+  Stream extends BaseType = NeverType,
+  Name extends string | undefined = undefined,
+>(options: {
+  input?: Input
+  output?: Output
+  stream?: Stream
+  timeout?: number
+  schemaOptions?: ContractSchemaOptions
+  name?: Name
+}) => {
+  const {
+    input = t.never() as unknown as Input,
+    output = t.never() as unknown as Output,
+    stream = t.never() as unknown as Stream,
+    timeout,
+    schemaOptions = {},
+    name,
+  } = options
+  return createSchema<TProcedureContract<Input, Output, Stream, Name>>({
     ...schemaOptions,
+    [Kind]: ProcedureKind,
     type: 'neemata:procedure',
     input,
     output,
+    stream,
     timeout,
-    name: undefined,
-    serviceName: undefined,
-    transports: undefined,
-  }
+    name: name as Name,
+    namespace: undefined,
+  })
+}
+
+export function IsProcedureContract(
+  contract: any,
+): contract is TAnyProcedureContract {
+  return Kind in contract && contract[Kind] === ProcedureKind
 }

package/src/schemas/subscription.ts

@@ -1,62 +1,98 @@
-import type { BaseType } from '@nmtjs/type'
+import { type BaseType, type NeverType, t } from '@nmtjs/type'
+import { Kind } from '../constants.ts'
 import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TEventContract } from './event.ts'
+import type { TAnyEventContract, TEventContract } from './event.ts'
 import type { TBaseProcedureContract } from './procedure.ts'
 
-export type SubcriptionOptions = Record<string, string | number>
+export const SubscriptionKind = 'NeemataSubscription'
+
+export type SubcriptionOptions = Record<string, string | number | boolean>
+
+export type TAnySubscriptionContract = TSubscriptionContract<
+  BaseType,
+  BaseType,
+  SubcriptionOptions,
+  Record<string, unknown>,
+  string | undefined,
+  string | undefined
+>
 
 export interface TSubscriptionContract<
-  Input extends BaseType = BaseType,
-  Output extends BaseType = BaseType,
-  Options extends SubcriptionOptions = SubcriptionOptions,
-  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 extends BaseType = NeverType,
+  Output extends BaseType = NeverType,
+  Options extends SubcriptionOptions = {},
+  Events extends Record<string, unknown> = {},
+  Name extends string | undefined = undefined,
+  Namespace extends string | undefined = undefined,
 > extends TBaseProcedureContract<
     'neemata:subscription',
     Input,
     Output,
     Name,
-    ServiceName,
-    Transports
+    Namespace
   > {
+  [Kind]: typeof SubscriptionKind
   options: Options
-  events: Events
+  events: {
+    [K in keyof Events]: Events[K] extends TAnyEventContract
+      ? TEventContract<
+          Events[K]['payload'],
+          Extract<K, string>,
+          Name,
+          Namespace
+        >
+      : never
+  }
 }
 
 export const SubscriptionContract = <
-  Input extends BaseType = BaseType,
-  Output extends BaseType = BaseType,
-  Events extends Record<string, TEventContract> = Record<
-    string,
-    TEventContract
-  >,
->(
-  input: Input,
-  output: Output,
-  events: Events,
-  timeout?: number,
-  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,
-) => {
+  Input extends BaseType = NeverType,
+  Output extends BaseType = NeverType,
+  Events extends Record<string, unknown> = {},
+  Name extends string | undefined = undefined,
+>(options?: {
+  input?: Input
+  output?: Output
+  events?: Events
+  timeout?: number
+  schemaOptions?: ContractSchemaOptions
+  name?: Name
+}) => {
+  const {
+    input = t.never() as unknown as Input,
+    output = t.never() as unknown as Output,
+    events = {} as Events,
+    timeout,
+    schemaOptions = {},
+    name,
+  } = options ?? {}
+
+  const _events = {} as any
+  for (const key in events) {
+    const event = events[key]
+    _events[key] = Object.assign({}, event, { subscription: name })
+  }
   return {
     $withOptions: <Options extends SubcriptionOptions>() =>
-      createSchema<TSubscriptionContract<Input, Output, Options, Events>>({
-        ...schemaOptions,
-        type: 'neemata:subscription',
-        input,
-        output,
-        events,
-        timeout,
-        options: undefined as unknown as Options,
-        name: undefined,
-        serviceName: undefined,
-        transports: undefined,
-      }),
+      createSchema<TSubscriptionContract<Input, Output, Options, Events, Name>>(
+        {
+          ...schemaOptions,
+          [Kind]: SubscriptionKind,
+          type: 'neemata:subscription',
+          input,
+          output,
+          events: _events,
+          timeout,
+          name: name as Name,
+          namespace: undefined,
+          options: undefined as unknown as Options,
+        },
+      ),
   }
 }
+
+export function IsSubscriptionContract(
+  contract: any,
+): contract is TAnySubscriptionContract {
+  return Kind in contract && contract[Kind] === SubscriptionKind
+}

package/src/types/blob.ts

@@ -1,21 +1,21 @@
-import type { ApiBlobInterface } from '@nmtjs/common'
+import type { ProtocolBlobInterface } from '@nmtjs/protocol/common'
 import { t } from '@nmtjs/type'
 
-export const BlobKind = 'ApiBlob'
+export const BlobKind = 'ProtocolBlob'
 
 export interface BlobOptions {
   maxSize?: number
   contentType?: string
 }
 
-export const blob = (options: BlobOptions = {}) =>
-  t.custom<ApiBlobInterface>(
+export const BlobType = (options: BlobOptions = {}) =>
+  t.custom<ProtocolBlobInterface>(
     (value) => {
       // TODO: this should be registered separately for server and client
       // ref: https://github.com/sinclairzx81/typebox/issues/977
       if ('metadata' in value) {
         if (options.maxSize) {
-          const size = (value as ApiBlobInterface).metadata.size
+          const size = (value as ProtocolBlobInterface).metadata.size
           if (size === -1 || size > options.maxSize) {
             throw new Error('Blob size unknown or exceeds maximum allowed size')
           }

package/dist/schemas/service.js

@@ -1,30 +0,0 @@
-import { applyNames, createSchema } from "../utils.js";
-export const ServiceContract = (name, transports, procedures = {}, events = {}, timeout, schemaOptions = {})=>{
-    const serviceProcedures = {};
-    for (const [procedureName, procedure] of Object.entries(procedures)){
-        if (procedure.type === 'neemata:subscription') {
-            serviceProcedures[procedureName] = {
-                ...procedure,
-                events: applyNames(procedure.events, {
-                    serviceName: name,
-                    subscriptionName: procedureName
-                })
-            };
-        } else {
-            serviceProcedures[procedureName] = procedure;
-        }
-    }
-    return createSchema({
-        ...schemaOptions,
-        name: name,
-        type: 'neemata:service',
-        procedures: applyNames(serviceProcedures, {
-            serviceName: name
-        }),
-        events: applyNames(events, {
-            serviceName: name
-        }),
-        transports,
-        timeout
-    });
-};

package/dist/schemas/service.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/schemas/service.ts"],"sourcesContent":["import {\n  type ContractSchemaOptions,\n  applyNames,\n  createSchema,\n} from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TBaseProcedureContract, TProcedureContract } from './procedure.ts'\nimport type { TSubscriptionContract } from './subscription.ts'\n\nexport interface TServiceContract<\n  Name extends string = string,\n  Transports extends { [K in string]?: true } = { [K in string]?: true },\n  Procedures extends Record<string, TBaseProcedureContract> = Record<\n    string,\n    TBaseProcedureContract\n  >,\n  Events extends Record<string, TEventContract> = Record<\n    string,\n    TEventContract\n  >,\n> {\n  type: 'neemata:service'\n  name: Name\n  transports: Transports\n  procedures: {\n    [K in keyof Procedures]: Procedures[K] extends TProcedureContract<\n      infer Input,\n      infer Output,\n      any,\n      any,\n      any\n    >\n      ? // ? true\n        TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>\n      : Procedures[K] extends TSubscriptionContract<\n            infer Input,\n            infer Output,\n            infer Options,\n            infer Events,\n            any,\n            any,\n            any\n          >\n        ? TSubscriptionContract<\n            Input,\n            Output,\n            Options,\n            {\n              [EK in keyof Events]: Events[EK] extends TEventContract<\n                infer Payload\n              >\n                ? TEventContract<\n                    Payload,\n                    Extract<EK, string>,\n                    Name,\n                    Extract<K, string>\n                  >\n                : never\n            },\n            Extract<K, string>,\n            Name,\n            Transports\n          >\n        : Procedures[K]\n  }\n  events: {\n    [K in Extract<keyof Events, string>]: Events[K] extends TEventContract<\n      infer Payload\n    >\n      ? TEventContract<Payload, K, Name>\n      : Events[K]\n  }\n  timeout?: number\n}\n\nexport const ServiceContract = <\n  Name extends string,\n  Transports extends { [key: string]: true },\n  Procedures extends Record<\n    string,\n    TBaseProcedureContract | TProcedureContract | TSubscriptionContract\n  >,\n  Events extends Record<string, TEventContract>,\n>(\n  name: Name,\n  transports: Transports,\n  procedures: Procedures = {} as Procedures,\n  events: Events = {} as Events,\n  timeout?: number,\n  schemaOptions: ContractSchemaOptions = {} as ContractSchemaOptions,\n) => {\n  const serviceProcedures = {}\n\n  for (const [procedureName, procedure] of Object.entries(procedures)) {\n    if (procedure.type === 'neemata:subscription') {\n      serviceProcedures[procedureName] = {\n        ...procedure,\n        events: applyNames((procedure as TSubscriptionContract).events, {\n          serviceName: name,\n          subscriptionName: procedureName,\n        }),\n      }\n    } else {\n      serviceProcedures[procedureName] = procedure\n    }\n  }\n\n  return createSchema<TServiceContract<Name, Transports, Procedures, Events>>({\n    ...schemaOptions,\n    name: name,\n    type: 'neemata:service',\n    // @ts-expect-error\n    procedures: applyNames(serviceProcedures, { serviceName: name }),\n    // @ts-expect-error\n    events: applyNames(events, { serviceName: name }),\n    transports,\n    timeout,\n  })\n}\n"],"names":["applyNames","createSchema","ServiceContract","name","transports","procedures","events","timeout","schemaOptions","serviceProcedures","procedureName","procedure","Object","entries","type","serviceName","subscriptionName"],"mappings":"AAAA,SAEEA,UAAU,EACVC,YAAY,QACP,cAAa;AAuEpB,OAAO,MAAMC,kBAAkB,CAS7BC,MACAC,YACAC,aAAyB,CAAC,CAAe,EACzCC,SAAiB,CAAC,CAAW,EAC7BC,SACAC,gBAAuC,CAAC,CAA0B;IAElE,MAAMC,oBAAoB,CAAC;IAE3B,KAAK,MAAM,CAACC,eAAeC,UAAU,IAAIC,OAAOC,OAAO,CAACR,YAAa;QACnE,IAAIM,UAAUG,IAAI,KAAK,wBAAwB;YAC7CL,iBAAiB,CAACC,cAAc,GAAG;gBACjC,GAAGC,SAAS;gBACZL,QAAQN,WAAW,AAACW,UAAoCL,MAAM,EAAE;oBAC9DS,aAAaZ;oBACba,kBAAkBN;gBACpB;YACF;QACF,OAAO;YACLD,iBAAiB,CAACC,cAAc,GAAGC;QACrC;IACF;IAEA,OAAOV,aAAqE;QAC1E,GAAGO,aAAa;QAChBL,MAAMA;QACNW,MAAM;QAENT,YAAYL,WAAWS,mBAAmB;YAAEM,aAAaZ;QAAK;QAE9DG,QAAQN,WAAWM,QAAQ;YAAES,aAAaZ;QAAK;QAC/CC;QACAG;IACF;AACF,EAAC"}

package/src/schemas/service.ts

@@ -1,119 +0,0 @@
-import {
-  type ContractSchemaOptions,
-  applyNames,
-  createSchema,
-} from '../utils.ts'
-import type { TEventContract } from './event.ts'
-import type { TBaseProcedureContract, TProcedureContract } from './procedure.ts'
-import type { TSubscriptionContract } from './subscription.ts'
-
-export interface TServiceContract<
-  Name extends string = string,
-  Transports extends { [K in string]?: true } = { [K in string]?: true },
-  Procedures extends Record<string, TBaseProcedureContract> = Record<
-    string,
-    TBaseProcedureContract
-  >,
-  Events extends Record<string, TEventContract> = Record<
-    string,
-    TEventContract
-  >,
-> {
-  type: 'neemata:service'
-  name: Name
-  transports: Transports
-  procedures: {
-    [K in keyof Procedures]: Procedures[K] extends TProcedureContract<
-      infer Input,
-      infer Output,
-      any,
-      any,
-      any
-    >
-      ? // ? true
-        TProcedureContract<Input, Output, Extract<K, string>, Name, Transports>
-      : Procedures[K] extends TSubscriptionContract<
-            infer Input,
-            infer Output,
-            infer Options,
-            infer Events,
-            any,
-            any,
-            any
-          >
-        ? 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
-          >
-        : Procedures[K]
-  }
-  events: {
-    [K in Extract<keyof Events, string>]: Events[K] extends TEventContract<
-      infer Payload
-    >
-      ? TEventContract<Payload, K, Name>
-      : Events[K]
-  }
-  timeout?: number
-}
-
-export const ServiceContract = <
-  Name extends string,
-  Transports extends { [key: string]: true },
-  Procedures extends Record<
-    string,
-    TBaseProcedureContract | 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,
-) => {
-  const serviceProcedures = {}
-
-  for (const [procedureName, procedure] of Object.entries(procedures)) {
-    if (procedure.type === 'neemata:subscription') {
-      serviceProcedures[procedureName] = {
-        ...procedure,
-        events: applyNames((procedure as TSubscriptionContract).events, {
-          serviceName: name,
-          subscriptionName: procedureName,
-        }),
-      }
-    } else {
-      serviceProcedures[procedureName] = procedure
-    }
-  }
-
-  return createSchema<TServiceContract<Name, Transports, Procedures, Events>>({
-    ...schemaOptions,
-    name: name,
-    type: 'neemata:service',
-    // @ts-expect-error
-    procedures: applyNames(serviceProcedures, { serviceName: name }),
-    // @ts-expect-error
-    events: applyNames(events, { serviceName: name }),
-    transports,
-    timeout,
-  })
-}