@nmtjs/contract 0.16.1 → 0.17.0-beta.2

package/LICENSE.md

@@ -4,4 +4,4 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,9 +1,49 @@
 # NeemataJS - RPC application server for real-time applications (proof of concept)
 
 ### Built with following in mind:
+
 - transport-agnostic (like WebSockets, WebTransport, .etc)
 - format-agnostic (like JSON, MessagePack, BSON, .etc)
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers
+
+## Neem CLI draft
+
+`neem build` compiles config, app entries, plugin entries, and plugin-declared
+artifacts into `dist` by default. It writes an internal `neem.manifest.json`
+with relative artifact paths.
+
+`neem start` consumes an existing built output directory. It reads the manifest
+for executable artifacts and serialized runtime config, registers built plugin
+hooks, and starts app workers in production mode.
+
+`neem dev` uses `.neem` by default as a build-like watched output directory. It
+uses the same manifest shape as `start`, restarts app workers after successful
+config/app rebuilds, reloads plugin hooks after plugin entry rebuilds, and keeps
+existing workers alive on rebuild errors.
+
+## Service integration tests
+
+Service-backed package integration tests live beside package owners under
+`packages/*/tests/integration`.
+
+Local services:
+
+```sh
+docker compose up -d --wait redis valkey kafka
+```
+
+Run required service tests:
+
+```sh
+NMTJS_REQUIRE_SERVICE_TESTS=1 \
+REDIS_URL=redis://localhost:6379 \
+VALKEY_URL=redis://localhost:6380 \
+KAFKA_BROKERS=localhost:9092 \
+pnpm run test:integration:services
+```
+
+Without service env, these tests skip in normal package/root test runs. In CI,
+`NMTJS_REQUIRE_SERVICE_TESTS=1` makes missing service env fail instead of skip.

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { SubscriptionContract } from './schemas/subscription.ts';
 export * from './schemas/event.ts';
 export * from './schemas/procedure.ts';
 export * from './schemas/router.ts';
@@ -11,29 +12,18 @@ export declare namespace contract {
         schemaOptions?: import("./utils.ts").ContractSchemaOptions;
         name?: string;
     }>(options: Options) => import("./schemas/procedure.ts").TProcedureContract<Options['input'] extends import("@nmtjs/type").BaseType ? Options['input'] : import("@nmtjs/type/never").NeverType, Options['output'] extends import("@nmtjs/type").BaseType ? Options['output'] : import("@nmtjs/type/never").NeverType, Options['stream'] extends true ? true : undefined, Options['name'] extends string ? Options['name'] : undefined>;
-    const event: <Payload extends import("@nmtjs/type").BaseType, Name extends string | undefined = undefined, Options extends import("./schemas/subscription.ts").SubcriptionOptions | undefined = undefined>(options?: {
+    const event: <Payload extends import("@nmtjs/type").BaseType = import("@nmtjs/type/never").NeverType>(options?: {
         payload?: Payload;
         schemaOptions?: import("./utils.ts").ContractSchemaOptions;
-        name?: Name;
-    }) => import("./schemas/event.ts").TEventContract<Payload, Name, Options>;
-    const subscription: (<const Options extends {
-        events: Record<string, import("./schemas/event.ts").TAnyEventContract>;
-        name?: string;
-        schemaOptions?: import("./utils.ts").ContractSchemaOptions;
-    }, SubOpt extends import("./schemas/subscription.ts").SubcriptionOptions = null>(options: Options) => import("./schemas/subscription.ts").TSubscriptionContract<SubOpt, Options["events"], Options["name"]>) & {
-        withOptions: <Options extends import("./schemas/subscription.ts").SubcriptionOptions>() => <T extends {
-            events: Record<string, import("./schemas/event.ts").TAnyEventContract>;
-            name?: string;
-            schemaOptions?: import("./utils.ts").ContractSchemaOptions;
-        }>(options: T) => import("./schemas/subscription.ts").TSubscriptionContract<Options, T["events"], T["name"]>;
-    };
+    }) => import("./schemas/event.ts").TEventContract<Payload>;
+    const subscription: typeof SubscriptionContract;
     const router: <const Options extends {
         routes: Record<string, import("./schemas/router.ts").TRouteContract>;
         name?: string;
         timeout?: number;
         schemaOptions?: import("./utils.ts").ContractSchemaOptions;
     }>(options: Options) => import("./schemas/router.ts").TRouterContract<Options["routes"], Options["name"] extends string ? Options["name"] : undefined>;
-    const blob: (options?: import("./types/blob.ts").BlobOptions) => import("@nmtjs/type/custom").CustomType<import("@nmtjs/protocol").ProtocolBlobInterface>;
 }
+export { BlobType as blobType } from './types/blob.ts';
 export { contract as c };
 export default contract;

package/dist/index.js

@@ -2,7 +2,6 @@ import { EventContract } from './schemas/event.js';
 import { ProcedureContract } from './schemas/procedure.js';
 import { RouterContract } from './schemas/router.js';
 import { SubscriptionContract } from './schemas/subscription.js';
-import { BlobType } from './types/blob.js';
 export * from './schemas/event.js';
 export * from './schemas/procedure.js';
 export * from './schemas/router.js';
@@ -13,8 +12,8 @@ export var contract;
     contract.event = EventContract;
     contract.subscription = SubscriptionContract;
     contract.router = RouterContract;
-    contract.blob = BlobType;
 })(contract || (contract = {}));
+export { BlobType as blobType } from './types/blob.js';
 export { contract as c };
 export default contract;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AAEzC,MAAM,KAAW,QAAQ,CAMxB;AAND,WAAiB,QAAQ;IACV,kBAAS,GAAG,iBAAiB,CAAA;IAC7B,cAAK,GAAG,aAAa,CAAA;IACrB,qBAAY,GAAG,oBAAoB,CAAA;IACnC,eAAM,GAAG,cAAc,CAAA;IACvB,aAAI,GAAG,QAAQ,CAAA;AAC9B,CAAC,EANgB,QAAQ,KAAR,QAAQ,QAMxB;AAED,OAAO,EAAE,QAAQ,IAAI,CAAC,EAAE,CAAA;AAExB,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAEhE,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AAEzC,MAAM,KAAW,QAAQ,CAKxB;AALD,WAAiB,QAAQ;IACV,kBAAS,GAAG,iBAAiB,CAAA;IAC7B,cAAK,GAAG,aAAa,CAAA;IACrB,qBAAY,GAAG,oBAAoB,CAAA;IACnC,eAAM,GAAG,cAAc,CAAA;AACtC,CAAC,EALgB,QAAQ,KAAR,QAAQ,QAKxB;AAED,OAAO,EAAE,QAAQ,IAAI,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAEtD,OAAO,EAAE,QAAQ,IAAI,CAAC,EAAE,CAAA;AAExB,eAAe,QAAQ,CAAA"}

package/dist/schemas/event.d.ts

@@ -1,20 +1,16 @@
-import type { BaseType } from '@nmtjs/type';
+import type { BaseType, BaseTypeAny } from '@nmtjs/type';
 import { t } from '@nmtjs/type';
 import type { ContractSchemaOptions } from '../utils.ts';
-import type { SubcriptionOptions } from './subscription.ts';
 import { Kind } from '../constants.ts';
 export declare const EventKind: unique symbol;
-export type TAnyEventContract = TEventContract<BaseType, string | undefined, SubcriptionOptions | undefined>;
-export interface TEventContract<Payload extends BaseType = t.NeverType, Name extends string | undefined = undefined, Options extends SubcriptionOptions | undefined = undefined> {
+export type TAnyEventContract = TEventContract<BaseTypeAny>;
+export interface TEventContract<Payload extends BaseType = t.NeverType> {
     readonly [Kind]: typeof EventKind;
     readonly type: 'neemata:event';
-    readonly name: Name;
     readonly payload: Payload;
-    readonly options: Options;
 }
-export declare const EventContract: <Payload extends BaseType, Name extends string | undefined = undefined, Options extends SubcriptionOptions | undefined = undefined>(options?: {
+export declare const EventContract: <Payload extends BaseType = t.NeverType>(options?: {
     payload?: Payload;
     schemaOptions?: ContractSchemaOptions;
-    name?: Name;
-}) => TEventContract<Payload, Name, Options>;
+}) => TEventContract<Payload>;
 export declare function IsEventContract(value: any): value is TAnyEventContract;

package/dist/schemas/event.js

@@ -3,14 +3,12 @@ import { Kind } from '../constants.js';
 import { createSchema } from '../utils.js';
 export const EventKind = Symbol('NeemataEvent');
 export const EventContract = (options) => {
-    const { payload = t.never(), schemaOptions = {}, name = undefined, } = options ?? {};
+    const { payload = t.never(), schemaOptions = {} } = options ?? {};
     return createSchema({
         ...schemaOptions,
         [Kind]: EventKind,
         type: 'neemata:event',
         payload,
-        name,
-        options: undefined,
     });
 };
 export function IsEventContract(value) {

package/dist/schemas/event.js.map

@@ -1 +1 @@
-{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/schemas/event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAA;AAI/B,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,CAAA;AAoB/C,MAAM,CAAC,MAAM,aAAa,GAAG,CAI3B,OAID,EAAE,EAAE;IACH,MAAM,EACJ,OAAO,GAAG,CAAC,CAAC,KAAK,EAAwB,EACzC,aAAa,GAAG,EAAE,EAClB,IAAI,GAAG,SAAgB,GACxB,GAAG,OAAO,IAAI,EAAE,CAAA;IACjB,OAAO,YAAY,CAAyC;QAC1D,GAAG,aAAa;QAChB,CAAC,IAAI,CAAC,EAAE,SAAS;QACjB,IAAI,EAAE,eAAe;QACrB,OAAO;QACP,IAAI;QACJ,OAAO,EAAE,SAAoB;KAC9B,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,MAAM,UAAU,eAAe,CAAC,KAAU;IACxC,OAAO,IAAI,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,SAAS,CAAA;AACnD,CAAC"}
+{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/schemas/event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAA;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,CAAA;AAU/C,MAAM,CAAC,MAAM,aAAa,GAAG,CAE3B,OAGD,EAAE,EAAE;IACH,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAwB,EAAE,aAAa,GAAG,EAAE,EAAE,GACrE,OAAO,IAAI,EAAE,CAAA;IACf,OAAO,YAAY,CAA0B;QAC3C,GAAG,aAAa;QAChB,CAAC,IAAI,CAAC,EAAE,SAAS;QACjB,IAAI,EAAE,eAAe;QACrB,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,MAAM,UAAU,eAAe,CAAC,KAAU;IACxC,OAAO,IAAI,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,SAAS,CAAA;AACnD,CAAC"}

package/dist/schemas/subscription.d.ts

@@ -1,27 +1,52 @@
+import type { AnyCompatibleType, BaseType, BaseTypeAny, t } from '@nmtjs/type';
 import type { ContractSchemaOptions } from '../utils.ts';
 import type { TAnyEventContract, TEventContract } from './event.ts';
 import { Kind } from '../constants.ts';
 export declare const SubscriptionKind: unique symbol;
-export type SubcriptionOptions = Record<string, string | number | boolean> | null;
-export type TAnySubscriptionContract = TSubscriptionContract<SubcriptionOptions, Record<string, TAnyEventContract>, string | undefined>;
-export interface TSubscriptionContract<Options extends SubcriptionOptions = null, Events extends Record<string, unknown> = {}, Name extends string | undefined = undefined> {
+export type SubscriptionParamsType = AnyCompatibleType<Record<string, string | number | boolean | null>>;
+export type SubscriptionKey<Params extends BaseType> = Params extends t.NeverType ? undefined : (params: t.infer.decode.output<Params>) => string;
+export type TAnySubscriptionContract = TSubscriptionContract<any, Record<string, TAnyEventContract>, string>;
+export type TAnySubscriptionEventContract = TSubscriptionEventContract<BaseTypeAny, string, TAnySubscriptionContract>;
+export type SubscriptionParams<Contract extends TAnySubscriptionContract> = t.infer.decode.output<Contract['params']>;
+export type SubscriptionEventMessage<E extends TAnySubscriptionEventContract> = {
+    event: E['event'];
+    payload: t.infer.decode.output<E['payload']>;
+};
+export type SubscriptionPublishInput<E extends TAnySubscriptionEventContract> = t.infer.encode.input<E['payload']>;
+export type SubscriptionEventUnion<Events extends Record<string, TAnySubscriptionEventContract>> = {
+    [K in keyof Events]: SubscriptionEventMessage<Events[K]>;
+}[keyof Events];
+export type SubscriptionSelectedEventUnion<Contract extends TAnySubscriptionContract, Events extends Partial<Record<keyof Contract['events'], true>>> = {} extends Events ? SubscriptionEventUnion<Contract['events']> : {
+    [K in keyof Events]: K extends keyof Contract['events'] ? SubscriptionEventMessage<Contract['events'][K]> : never;
+}[keyof Events];
+export interface TSubscriptionEventContract<Payload extends BaseType = BaseTypeAny, Event extends string = string, Subscription = TAnySubscriptionContract> extends TEventContract<Payload> {
+    readonly event: Event;
+    readonly subscription: Subscription;
+}
+export interface TSubscriptionContract<Params extends BaseType = t.NeverType, Events extends Record<string, unknown> = {}, Namespace extends string = string> {
     readonly [Kind]: typeof SubscriptionKind;
     readonly type: 'neemata:subscription';
-    readonly name: Name;
-    readonly options: Options;
+    readonly namespace: Namespace;
+    readonly params: Params;
+    readonly key: SubscriptionKey<Params>;
     readonly events: {
-        [K in keyof Events]: Events[K] extends TAnyEventContract ? TEventContract<Events[K]['payload'], Name extends string ? `${Name}/${Extract<K, string>}` : Extract<K, string>, Options> : never;
+        [K in keyof Events]: Events[K] extends TAnyEventContract ? TSubscriptionEventContract<Events[K]['payload'], Extract<K, string>, TSubscriptionContract<Params, Events, Namespace>> : never;
     };
 }
-export declare const SubscriptionContract: (<const Options extends {
-    events: Record<string, TAnyEventContract>;
-    name?: string;
+type SubscriptionContractBaseOptions<Namespace extends string, Events extends Record<string, TAnyEventContract>> = {
+    namespace: Namespace;
+    events: Events;
     schemaOptions?: ContractSchemaOptions;
-}, SubOpt extends SubcriptionOptions = null>(options: Options) => TSubscriptionContract<SubOpt, Options["events"], Options["name"]>) & {
-    withOptions: <Options extends SubcriptionOptions>() => <T extends {
-        events: Record<string, TAnyEventContract>;
-        name?: string;
-        schemaOptions?: ContractSchemaOptions;
-    }>(options: T) => TSubscriptionContract<Options, T["events"], T["name"]>;
 };
+type SubscriptionContractNoParamsOptions<Namespace extends string, Events extends Record<string, TAnyEventContract>> = SubscriptionContractBaseOptions<Namespace, Events> & {
+    params?: undefined;
+    key?: undefined;
+};
+type SubscriptionContractWithParamsOptions<Namespace extends string, Params extends SubscriptionParamsType, Events extends Record<string, TAnyEventContract>> = SubscriptionContractBaseOptions<Namespace, Events> & {
+    params: Params;
+    key: (params: t.infer.decode.output<Params>) => string;
+};
+export declare function SubscriptionContract<const Namespace extends string, const Events extends Record<string, TAnyEventContract>>(options: SubscriptionContractNoParamsOptions<Namespace, Events>): TSubscriptionContract<t.NeverType, Events, Namespace>;
+export declare function SubscriptionContract<const Namespace extends string, const Params extends SubscriptionParamsType, const Events extends Record<string, TAnyEventContract>>(options: SubscriptionContractWithParamsOptions<Namespace, Params, Events>): TSubscriptionContract<Params, Events, Namespace>;
 export declare function IsSubscriptionContract(contract: any): contract is TAnySubscriptionContract;
+export {};

package/dist/schemas/subscription.js

@@ -1,28 +1,30 @@
+import { t as types } from '@nmtjs/type';
 import { Kind } from '../constants.js';
-import { concatFullName, createSchema } from '../utils.js';
+import { createSchema } from '../utils.js';
 export const SubscriptionKind = Symbol('NeemataSubscription');
-const _SubscriptionContract = (options) => {
-    const { schemaOptions = {}, name } = options;
-    const _events = {};
-    for (const key in options.events) {
-        const event = options.events[key];
-        const fullName = concatFullName(name, key);
-        _events[key] = createSchema({ ...event, name: fullName });
-    }
-    return createSchema({
+export function SubscriptionContract(options) {
+    const { schemaOptions = {} } = options;
+    const params = options.params ?? types.never();
+    const events = {};
+    const subscription = createSchema({
         ...schemaOptions,
         [Kind]: SubscriptionKind,
         type: 'neemata:subscription',
-        events: _events,
-        name: name,
-        options: undefined,
+        namespace: options.namespace,
+        params,
+        key: options.key,
+        events,
     });
-};
-export const SubscriptionContract = Object.assign(_SubscriptionContract, {
-    withOptions: () => {
-        return (options) => _SubscriptionContract(options);
-    },
-});
+    for (const eventName in options.events) {
+        const event = options.events[eventName];
+        events[eventName] = createSchema({
+            ...event,
+            event: eventName,
+            subscription,
+        });
+    }
+    return subscription;
+}
 export function IsSubscriptionContract(contract) {
     return Kind in contract && contract[Kind] === SubscriptionKind;
 }

package/dist/schemas/subscription.js.map

@@ -1 +1 @@
-{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../src/schemas/subscription.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1D,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAA;AAmC7D,MAAM,qBAAqB,GAAG,CAQ5B,OAAgB,EAChB,EAAE;IACF,MAAM,EAAE,aAAa,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,CAAA;IAC5C,MAAM,OAAO,GAAG,EAAS,CAAA;IACzB,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACjC,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QAC1C,OAAO,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;IAC3D,CAAC;IACD,OAAO,YAAY,CAEjB;QACA,GAAG,aAAa;QAChB,CAAC,IAAI,CAAC,EAAE,gBAAgB;QACxB,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,OAAO;QACf,IAAI,EAAE,IAAI;QACV,OAAO,EAAE,SAA8B;KACxC,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE;IACvE,WAAW,EAAE,GAAuC,EAAE;QACpD,OAAO,CAOL,OAAU,EACV,EAAE,CAAC,qBAAqB,CAAa,OAAO,CAAC,CAAA;IACjD,CAAC;CACF,CAAC,CAAA;AAEF,MAAM,UAAU,sBAAsB,CACpC,QAAa;IAEb,OAAO,IAAI,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,gBAAgB,CAAA;AAChE,CAAC"}
+{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../src/schemas/subscription.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,IAAI,KAAK,EAAE,MAAM,aAAa,CAAA;AAIxC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAA;AAsH7D,MAAM,UAAU,oBAAoB,CAAC,OAMpC;IACC,MAAM,EAAE,aAAa,GAAG,EAAE,EAAE,GAAG,OAAO,CAAA;IACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,EAAE,CAAA;IAC9C,MAAM,MAAM,GAAG,EAAmD,CAAA;IAClE,MAAM,YAAY,GAAG,YAAY,CAAM;QACrC,GAAG,aAAa;QAChB,CAAC,IAAI,CAAC,EAAE,gBAAgB;QACxB,IAAI,EAAE,sBAAsB;QAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,MAAM;QACN,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,MAAM;KACP,CAAC,CAAA;IAEF,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;QACvC,MAAM,CAAC,SAAS,CAAC,GAAG,YAAY,CAAgC;YAC9D,GAAG,KAAK;YACR,KAAK,EAAE,SAAS;YAChB,YAAY;SACb,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,YAAY,CAAA;AACrB,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,QAAa;IAEb,OAAO,IAAI,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,gBAAgB,CAAA;AAChE,CAAC"}

package/dist/types/blob.js

@@ -4,12 +4,12 @@ export const BlobType = (options = {}) => CustomType.factory({
     decode: (value) => value,
     encode: (value) => value,
     validation: {
-        decode(value, { addIssue }) {
+        decode(value, payload) {
             if (isBlobInterface(value)) {
                 if (options.maxSize) {
                     const size = value.metadata.size;
                     if (typeof size !== 'undefined' && size > options.maxSize) {
-                        addIssue({
+                        payload.addIssue({
                             code: 'custom',
                             message: `Blob size unknown or exceeds maximum allowed size of ${options.maxSize} bytes`,
                         });
@@ -17,15 +17,15 @@ export const BlobType = (options = {}) => CustomType.factory({
                 }
             }
             else {
-                addIssue({
+                payload.addIssue({
                     code: 'custom',
                     message: 'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
                 });
             }
         },
-        encode(value, { addIssue }) {
+        encode(value, payload) {
             if (!isBlobInterface(value)) {
-                addIssue({
+                payload.addIssue({
                     code: 'custom',
                     message: 'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
                 });

package/dist/types/blob.js.map

@@ -1 +1 @@
-{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../src/types/blob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAO/C,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,OAAO,GAAgB,EAAE,EACU,EAAE,CACrC,UAAU,CAAC,OAAO,CAAC;IACjB,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;IACxB,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;IACxB,UAAU,EAAE;QACV,MAAM,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE;YACxB,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3B,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;oBACpB,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAA;oBAChC,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;wBAC1D,QAAQ,CAAC;4BACP,IAAI,EAAE,QAAQ;4BACd,OAAO,EAAE,wDAAwD,OAAO,CAAC,OAAO,QAAQ;yBACzF,CAAC,CAAA;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,QAAQ,CAAC;oBACP,IAAI,EAAE,QAAQ;oBACd,OAAO,EACL,wFAAwF;iBAC3F,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QACD,MAAM,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE;YACxB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC5B,QAAQ,CAAC;oBACP,IAAI,EAAE,QAAQ;oBACd,OAAO,EACL,wFAAwF;iBAC3F,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;KACF;CACF,CAAC,CAAA"}
+{"version":3,"file":"blob.js","sourceRoot":"","sources":["../../src/types/blob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAO/C,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,OAAO,GAAgB,EAAE,EACU,EAAE,CACrC,UAAU,CAAC,OAAO,CAAC;IACjB,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;IACxB,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;IACxB,UAAU,EAAE;QACV,MAAM,CAAC,KAAK,EAAE,OAAO;YACnB,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3B,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;oBACpB,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAA;oBAChC,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;wBAC1D,OAAO,CAAC,QAAQ,CAAC;4BACf,IAAI,EAAE,QAAQ;4BACd,OAAO,EAAE,wDAAwD,OAAO,CAAC,OAAO,QAAQ;yBACzF,CAAC,CAAA;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,QAAQ,CAAC;oBACf,IAAI,EAAE,QAAQ;oBACd,OAAO,EACL,wFAAwF;iBAC3F,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QACD,MAAM,CAAC,KAAK,EAAE,OAAO;YACnB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC5B,OAAO,CAAC,QAAQ,CAAC;oBACf,IAAI,EAAE,QAAQ;oBACd,OAAO,EACL,wFAAwF;iBAC3F,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;KACF;CACF,CAAC,CAAA"}

package/package.json

@@ -10,8 +10,8 @@
     }
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.16.1",
-    "@nmtjs/type": "0.16.1"
+    "@nmtjs/protocol": "0.17.0-beta.2",
+    "@nmtjs/type": "0.17.0-beta.2"
   },
   "devDependencies": {
     "zod": "^4.0.0"
@@ -22,12 +22,9 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.16.1",
+  "version": "0.17.0-beta.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/neematajs/neemata"
-  },
-  "scripts": {
-    "clean-build": "rm -rf ./dist"
   }
 }

package/src/index.ts

@@ -2,7 +2,6 @@ import { EventContract } from './schemas/event.ts'
 import { ProcedureContract } from './schemas/procedure.ts'
 import { RouterContract } from './schemas/router.ts'
 import { SubscriptionContract } from './schemas/subscription.ts'
-import { BlobType } from './types/blob.ts'
 
 export * from './schemas/event.ts'
 export * from './schemas/procedure.ts'
@@ -14,9 +13,10 @@ export namespace contract {
   export const event = EventContract
   export const subscription = SubscriptionContract
   export const router = RouterContract
-  export const blob = BlobType
 }
 
+export { BlobType as blobType } from './types/blob.ts'
+
 export { contract as c }
 
 export default contract

package/src/schemas/event.ts

@@ -1,52 +1,33 @@
-import type { BaseType } from '@nmtjs/type'
+import type { BaseType, BaseTypeAny } from '@nmtjs/type'
 import { t } from '@nmtjs/type'
 
 import type { ContractSchemaOptions } from '../utils.ts'
-import type { SubcriptionOptions } from './subscription.ts'
 import { Kind } from '../constants.ts'
 import { createSchema } from '../utils.ts'
 
 export const EventKind = Symbol('NeemataEvent')
 
-export type TAnyEventContract = TEventContract<
-  BaseType,
-  string | undefined,
-  SubcriptionOptions | undefined
->
+export type TAnyEventContract = TEventContract<BaseTypeAny>
 
-export interface TEventContract<
-  Payload extends BaseType = t.NeverType,
-  Name extends string | undefined = undefined,
-  Options extends SubcriptionOptions | undefined = undefined,
-> {
+export interface TEventContract<Payload extends BaseType = t.NeverType> {
   readonly [Kind]: typeof EventKind
   readonly type: 'neemata:event'
-  readonly name: Name
   readonly payload: Payload
-  readonly options: Options
 }
 
 export const EventContract = <
-  Payload extends BaseType,
-  Name extends string | undefined = undefined,
-  Options extends SubcriptionOptions | undefined = undefined,
+  Payload extends BaseType = t.NeverType,
 >(options?: {
   payload?: Payload
   schemaOptions?: ContractSchemaOptions
-  name?: Name
 }) => {
-  const {
-    payload = t.never() as unknown as Payload,
-    schemaOptions = {},
-    name = undefined as any,
-  } = options ?? {}
-  return createSchema<TEventContract<Payload, Name, Options>>({
+  const { payload = t.never() as unknown as Payload, schemaOptions = {} } =
+    options ?? {}
+  return createSchema<TEventContract<Payload>>({
     ...schemaOptions,
     [Kind]: EventKind,
     type: 'neemata:event',
     payload,
-    name,
-    options: undefined as Options,
   })
 }
 

package/src/schemas/subscription.ts

@@ -1,85 +1,160 @@
+import type { AnyCompatibleType, BaseType, BaseTypeAny, t } from '@nmtjs/type'
+import { t as types } from '@nmtjs/type'
+
 import type { ContractSchemaOptions } from '../utils.ts'
 import type { TAnyEventContract, TEventContract } from './event.ts'
 import { Kind } from '../constants.ts'
-import { concatFullName, createSchema } from '../utils.ts'
+import { createSchema } from '../utils.ts'
 
 export const SubscriptionKind = Symbol('NeemataSubscription')
 
-export type SubcriptionOptions = Record<
-  string,
-  string | number | boolean
-> | null
+export type SubscriptionParamsType = AnyCompatibleType<
+  Record<string, string | number | boolean | null>
+>
+
+export type SubscriptionKey<Params extends BaseType> =
+  Params extends t.NeverType
+    ? undefined
+    : (params: t.infer.decode.output<Params>) => string
 
 export type TAnySubscriptionContract = TSubscriptionContract<
-  SubcriptionOptions,
+  any,
   Record<string, TAnyEventContract>,
-  string | undefined
+  string
+>
+
+export type TAnySubscriptionEventContract = TSubscriptionEventContract<
+  BaseTypeAny,
+  string,
+  TAnySubscriptionContract
 >
 
+export type SubscriptionParams<Contract extends TAnySubscriptionContract> =
+  t.infer.decode.output<Contract['params']>
+
+export type SubscriptionEventMessage<E extends TAnySubscriptionEventContract> =
+  { event: E['event']; payload: t.infer.decode.output<E['payload']> }
+
+export type SubscriptionPublishInput<E extends TAnySubscriptionEventContract> =
+  t.infer.encode.input<E['payload']>
+
+export type SubscriptionEventUnion<
+  Events extends Record<string, TAnySubscriptionEventContract>,
+> = {
+  [K in keyof Events]: SubscriptionEventMessage<Events[K]>
+}[keyof Events]
+
+export type SubscriptionSelectedEventUnion<
+  Contract extends TAnySubscriptionContract,
+  Events extends Partial<Record<keyof Contract['events'], true>>,
+> = {} extends Events
+  ? SubscriptionEventUnion<Contract['events']>
+  : {
+      [K in keyof Events]: K extends keyof Contract['events']
+        ? SubscriptionEventMessage<Contract['events'][K]>
+        : never
+    }[keyof Events]
+
+export interface TSubscriptionEventContract<
+  Payload extends BaseType = BaseTypeAny,
+  Event extends string = string,
+  Subscription = TAnySubscriptionContract,
+> extends TEventContract<Payload> {
+  readonly event: Event
+  readonly subscription: Subscription
+}
+
 export interface TSubscriptionContract<
-  Options extends SubcriptionOptions = null,
+  Params extends BaseType = t.NeverType,
   Events extends Record<string, unknown> = {},
-  Name extends string | undefined = undefined,
+  Namespace extends string = string,
 > {
   readonly [Kind]: typeof SubscriptionKind
   readonly type: 'neemata:subscription'
-  readonly name: Name
-  readonly options: Options
+  readonly namespace: Namespace
+  readonly params: Params
+  readonly key: SubscriptionKey<Params>
   readonly events: {
     [K in keyof Events]: Events[K] extends TAnyEventContract
-      ? TEventContract<
+      ? TSubscriptionEventContract<
           Events[K]['payload'],
-          Name extends string
-            ? `${Name}/${Extract<K, string>}`
-            : Extract<K, string>,
-          Options
+          Extract<K, string>,
+          TSubscriptionContract<Params, Events, Namespace>
         >
       : never
   }
 }
 
-const _SubscriptionContract = <
-  const Options extends {
-    events: Record<string, TAnyEventContract>
-    name?: string
-    schemaOptions?: ContractSchemaOptions
-  },
-  SubOpt extends SubcriptionOptions = null,
+type SubscriptionContractBaseOptions<
+  Namespace extends string,
+  Events extends Record<string, TAnyEventContract>,
+> = {
+  namespace: Namespace
+  events: Events
+  schemaOptions?: ContractSchemaOptions
+}
+
+type SubscriptionContractNoParamsOptions<
+  Namespace extends string,
+  Events extends Record<string, TAnyEventContract>,
+> = SubscriptionContractBaseOptions<Namespace, Events> & {
+  params?: undefined
+  key?: undefined
+}
+
+type SubscriptionContractWithParamsOptions<
+  Namespace extends string,
+  Params extends SubscriptionParamsType,
+  Events extends Record<string, TAnyEventContract>,
+> = SubscriptionContractBaseOptions<Namespace, Events> & {
+  params: Params
+  key: (params: t.infer.decode.output<Params>) => string
+}
+
+export function SubscriptionContract<
+  const Namespace extends string,
+  const Events extends Record<string, TAnyEventContract>,
 >(
-  options: Options,
-) => {
-  const { schemaOptions = {}, name } = options
-  const _events = {} as any
-  for (const key in options.events) {
-    const event = options.events[key]
-    const fullName = concatFullName(name, key)
-    _events[key] = createSchema({ ...event, name: fullName })
-  }
-  return createSchema<
-    TSubscriptionContract<SubOpt, Options['events'], Options['name']>
-  >({
+  options: SubscriptionContractNoParamsOptions<Namespace, Events>,
+): TSubscriptionContract<t.NeverType, Events, Namespace>
+export function SubscriptionContract<
+  const Namespace extends string,
+  const Params extends SubscriptionParamsType,
+  const Events extends Record<string, TAnyEventContract>,
+>(
+  options: SubscriptionContractWithParamsOptions<Namespace, Params, Events>,
+): TSubscriptionContract<Params, Events, Namespace>
+export function SubscriptionContract(options: {
+  namespace: string
+  events: Record<string, TAnyEventContract>
+  params?: BaseType
+  key?: (params: any) => string
+  schemaOptions?: ContractSchemaOptions
+}) {
+  const { schemaOptions = {} } = options
+  const params = options.params ?? types.never()
+  const events = {} as Record<string, TAnySubscriptionEventContract>
+  const subscription = createSchema<any>({
     ...schemaOptions,
     [Kind]: SubscriptionKind,
     type: 'neemata:subscription',
-    events: _events,
-    name: name,
-    options: undefined as unknown as SubOpt,
+    namespace: options.namespace,
+    params,
+    key: options.key,
+    events,
   })
-}
 
-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)
-  },
-})
+  for (const eventName in options.events) {
+    const event = options.events[eventName]
+    events[eventName] = createSchema<TAnySubscriptionEventContract>({
+      ...event,
+      event: eventName,
+      subscription,
+    })
+  }
+
+  return subscription
+}
 
 export function IsSubscriptionContract(
   contract: any,

package/src/types/blob.ts

@@ -14,28 +14,28 @@ export const BlobType = (
     decode: (value) => value,
     encode: (value) => value,
     validation: {
-      decode(value, { addIssue }) {
+      decode(value, payload) {
         if (isBlobInterface(value)) {
           if (options.maxSize) {
             const size = value.metadata.size
             if (typeof size !== 'undefined' && size > options.maxSize) {
-              addIssue({
+              payload.addIssue({
                 code: 'custom',
                 message: `Blob size unknown or exceeds maximum allowed size of ${options.maxSize} bytes`,
               })
             }
           }
         } else {
-          addIssue({
+          payload.addIssue({
             code: 'custom',
             message:
               'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
           })
         }
       },
-      encode(value, { addIssue }) {
+      encode(value, payload) {
         if (!isBlobInterface(value)) {
-          addIssue({
+          payload.addIssue({
             code: 'custom',
             message:
               'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',