@nmtjs/contract 0.15.0-beta.2 → 0.15.0-beta.21

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const Kind: unique symbol;

package/dist/constants.js

@@ -1 +1,2 @@
 export const Kind = Symbol.for('neemata:kind');
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+export * from './schemas/event.ts';
+export * from './schemas/procedure.ts';
+export * from './schemas/router.ts';
+export * from './schemas/subscription.ts';
+export declare namespace contract {
+    const procedure: <const Options extends {
+        input?: import("@nmtjs/type").BaseType;
+        output?: import("@nmtjs/type").BaseType;
+        stream?: true | undefined;
+        timeout?: number;
+        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?: {
+        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"]>;
+    };
+    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 { contract as c };
+export default contract;

package/dist/index.js

@@ -17,3 +17,4 @@ export var contract;
 })(contract || (contract = {}));
 export { contract as c };
 export default contract;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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"}

package/dist/schemas/event.d.ts

@@ -0,0 +1,20 @@
+import type { BaseType } 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> {
+    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?: {
+    payload?: Payload;
+    schemaOptions?: ContractSchemaOptions;
+    name?: Name;
+}) => TEventContract<Payload, Name, Options>;
+export declare function IsEventContract(value: any): value is TAnyEventContract;

package/dist/schemas/event.js

@@ -16,3 +16,4 @@ export const EventContract = (options) => {
 export function IsEventContract(value) {
     return Kind in value && value[Kind] === EventKind;
 }
+//# sourceMappingURL=event.js.map

package/dist/schemas/event.js.map

@@ -0,0 +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"}

package/dist/schemas/procedure.d.ts

@@ -0,0 +1,25 @@
+import type { BaseType } from '@nmtjs/type';
+import type { NeverType } from '@nmtjs/type/never';
+import type { ContractSchemaOptions } from '../utils.ts';
+import { Kind } from '../constants.ts';
+export type TAnyProcedureContract = TProcedureContract<BaseType, BaseType, true | undefined, string | undefined>;
+export declare const ProcedureKind: unique symbol;
+export interface TProcedureContract<Input extends BaseType, Output extends BaseType, Stream extends true | undefined = undefined, Name extends string | undefined = undefined> {
+    readonly [Kind]: typeof ProcedureKind;
+    readonly type: 'neemata:procedure';
+    readonly name: Name;
+    readonly input: Input;
+    readonly output: Output;
+    readonly stream: Stream;
+    readonly timeout?: number;
+}
+export declare const ProcedureContract: <const Options extends {
+    input?: BaseType;
+    output?: BaseType;
+    stream?: true | undefined;
+    timeout?: number;
+    schemaOptions?: ContractSchemaOptions;
+    name?: string;
+}>(options: Options) => TProcedureContract<Options["input"] extends BaseType ? Options["input"] : NeverType, Options["output"] extends BaseType ? Options["output"] : NeverType, Options["stream"] extends true ? true : undefined, Options["name"] extends string ? Options["name"] : undefined>;
+export declare function IsProcedureContract(contract: any): contract is TAnyProcedureContract;
+export declare function IsStreamProcedureContract(contract: any): contract is TAnyProcedureContract;

package/dist/schemas/procedure.js

@@ -21,3 +21,4 @@ export function IsProcedureContract(contract) {
 export function IsStreamProcedureContract(contract) {
     return IsProcedureContract(contract) && typeof contract.stream !== 'undefined';
 }
+//# sourceMappingURL=procedure.js.map

package/dist/schemas/procedure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure.js","sourceRoot":"","sources":["../../src/schemas/procedure.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAA;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAS1C,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;AAiBvD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAU/B,OAAgB,EAMhB,EAAE;IACF,MAAM,EACJ,KAAK,GAAG,CAAC,CAAC,KAAK,EAAS,EACxB,MAAM,GAAG,CAAC,CAAC,KAAK,EAAS,EACzB,MAAM,GAAG,SAAgB,EACzB,IAAI,GAAG,SAAgB,EACvB,OAAO,EACP,aAAa,GAAG,EAAE,GACnB,GAAG,OAAO,CAAA;IACX,OAAO,YAAY,CAAC;QAClB,GAAG,aAAa;QAChB,CAAC,IAAI,CAAC,EAAE,aAAa;QACrB,IAAI,EAAE,mBAAmB;QACzB,KAAK;QACL,MAAM;QACN,MAAM;QACN,IAAI;QACJ,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,MAAM,UAAU,mBAAmB,CACjC,QAAa;IAEb,OAAO,IAAI,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,aAAa,CAAA;AAC7D,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,QAAa;IAEb,OAAO,mBAAmB,CAAC,QAAQ,CAAC,IAAI,OAAO,QAAQ,CAAC,MAAM,KAAK,WAAW,CAAA;AAChF,CAAC"}

package/dist/schemas/router.d.ts

@@ -0,0 +1,23 @@
+import type { ContractSchemaOptions } from '../utils.ts';
+import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts';
+import { Kind } from '../constants.ts';
+export declare const RouterKind: unique symbol;
+export type TAnyRouterContract<RouteContracts extends Record<string, TRouteContract> = Record<string, TRouteContract>, RouterName extends string | undefined = string | undefined> = TRouterContract<RouteContracts, RouterName>;
+export type TRouteContract = TAnyProcedureContract | TRouterContract<Record<string, TRouteContract>, string | undefined>;
+export interface TRouterContract<Routes extends Record<string, TRouteContract> = {}, Name extends string | undefined = undefined> {
+    readonly [Kind]: typeof RouterKind;
+    readonly type: 'neemata:router';
+    readonly name: Name;
+    readonly default?: TProcedureContract<any, any, true | undefined, string | undefined>;
+    readonly routes: {
+        [K in keyof Routes]: Routes[K] extends TAnyRouterContract ? TRouterContract<Routes[K]['routes'], Name extends string ? `${Name}/${Extract<K, string>}` : Extract<K, string>> : Routes[K] extends TAnyProcedureContract ? TProcedureContract<Routes[K]['input'], Routes[K]['output'], Routes[K]['stream'], Name extends string ? `${Name}/${Extract<K, string>}` : Extract<K, string>> : never;
+    };
+    readonly timeout?: number;
+}
+export declare const RouterContract: <const Options extends {
+    routes: Record<string, TRouteContract>;
+    name?: string;
+    timeout?: number;
+    schemaOptions?: ContractSchemaOptions;
+}>(options: Options) => TRouterContract<Options["routes"], Options["name"] extends string ? Options["name"] : undefined>;
+export declare function IsRouterContract(value: any): value is TAnyRouterContract;

package/dist/schemas/router.js

@@ -39,3 +39,4 @@ function processNestedRoutes(routes, parentName) {
 export function IsRouterContract(value) {
     return Kind in value && value[Kind] === RouterKind;
 }
+//# sourceMappingURL=router.js.map

package/dist/schemas/router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.js","sourceRoot":"","sources":["../../src/schemas/router.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,eAAe,CAAC,CAAA;AAiDjD,MAAM,CAAC,MAAM,cAAc,GAAG,CAQ5B,OAAgB,EAChB,EAAE;IACF,MAAM,EACJ,IAAI,GAAG,SAAgB,EACvB,OAAO,EACP,aAAa,GAAG,EAA2B,GAC5C,GAAG,OAAO,CAAA;IAEX,MAAM,MAAM,GAAQ,mBAAmB,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAE7D,OAAO,YAAY,CAKjB;QACA,GAAG,aAAa;QAChB,CAAC,IAAI,CAAC,EAAE,UAAU;QAClB,IAAI,EAAE,gBAAgB;QACtB,IAAI;QACJ,MAAM;QACN,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA;AAED,SAAS,mBAAmB,CAC1B,MAAkE,EAClE,UAA8B;IAE9B,MAAM,SAAS,GAAwB,EAAE,CAAA;IAEzC,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,CAAA;QAE/B,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,UAAU,GAAG,cAAc,CAAC,UAAU,EAAE,SAAS,CAAC,CAAA;YACxD,SAAS,CAAC,SAAS,CAAC,GAAG,YAAY,CAAC;gBAClC,GAAG,KAAK;gBACR,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,mBAAmB,CAAC,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC;aACtD,CAAC,CAAA;QACJ,CAAC;aAAM,IAAI,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YACtC,MAAM,QAAQ,GAAG,cAAc,CAAC,UAAU,EAAE,SAAS,CAAC,CAAA;YACtD,SAAS,CAAC,SAAS,CAAC,GAAG,YAAY,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;QACnE,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,0BAA0B,SAAS,EAAE,CAAC,CAAA;QACxD,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAU;IACzC,OAAO,IAAI,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,UAAU,CAAA;AACpD,CAAC"}

package/dist/schemas/subscription.d.ts

@@ -0,0 +1,27 @@
+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> {
+    readonly [Kind]: typeof SubscriptionKind;
+    readonly type: 'neemata:subscription';
+    readonly name: Name;
+    readonly options: Options;
+    readonly events: {
+        [K in keyof Events]: Events[K] extends TAnyEventContract ? TEventContract<Events[K]['payload'], Name extends string ? `${Name}/${Extract<K, string>}` : Extract<K, string>, Options> : never;
+    };
+}
+export declare const SubscriptionContract: (<const Options extends {
+    events: Record<string, TAnyEventContract>;
+    name?: string;
+    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"]>;
+};
+export declare function IsSubscriptionContract(contract: any): contract is TAnySubscriptionContract;

package/dist/schemas/subscription.js

@@ -26,3 +26,4 @@ export const SubscriptionContract = Object.assign(_SubscriptionContract, {
 export function IsSubscriptionContract(contract) {
     return Kind in contract && contract[Kind] === SubscriptionKind;
 }
+//# sourceMappingURL=subscription.js.map

package/dist/schemas/subscription.js.map

@@ -0,0 +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"}

package/dist/types/blob.d.ts

@@ -0,0 +1,7 @@
+import type { ProtocolBlobInterface } from '@nmtjs/protocol';
+import { CustomType } from '@nmtjs/type/custom';
+export interface BlobOptions {
+    maxSize?: number;
+    contentType?: string;
+}
+export declare const BlobType: (options?: BlobOptions) => CustomType<ProtocolBlobInterface>;

package/dist/types/blob.js

@@ -33,3 +33,4 @@ export const BlobType = (options = {}) => CustomType.factory({
         },
     },
 });
+//# sourceMappingURL=blob.js.map

package/dist/types/blob.js.map

@@ -0,0 +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,UAAuB,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"}

package/dist/utils.d.ts

@@ -0,0 +1,18 @@
+export type ContractSchemaOptions = {
+    title?: string;
+    description?: string;
+};
+export declare const applyNames: <T extends Record<string, {
+    serviceName?: string;
+}>>(params: T, opts: {
+    serviceName?: string;
+    subscriptionName?: string;
+}) => {
+    [k: string]: {
+        serviceName?: string;
+        subscriptionName?: string;
+        name: string;
+    };
+};
+export declare const createSchema: <T>(schema: T) => T;
+export declare const concatFullName: (parent: string | undefined, name: string) => string;

package/dist/utils.js

@@ -5,3 +5,4 @@ export const createSchema = (schema) => Object.freeze(schema);
 export const concatFullName = (parent, name) => {
     return parent ? `${parent}/${name}` : name;
 };
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,MAAS,EACT,IAAyD,EACzD,EAAE;IACF,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CACxE,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,YAAY,GAAG,CAAI,MAAS,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAM,CAAA;AAExE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAA0B,EAAE,IAAY,EAAE,EAAE;IACzE,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;AAC5C,CAAC,CAAA"}

package/package.json

@@ -5,21 +5,22 @@
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.15.0-beta.2",
-    "@nmtjs/type": "0.15.0-beta.2"
+    "@nmtjs/type": "0.15.0-beta.21",
+    "@nmtjs/protocol": "0.15.0-beta.21"
   },
   "devDependencies": {
     "zod": "^4.1.0"
   },
   "files": [
     "dist",
+    "src",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.2",
+  "version": "0.15.0-beta.21",
   "scripts": {
     "clean-build": "rm -rf ./dist",
-    "build": "tsc",
+    "build": "tsc --declaration --sourcemap",
     "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }

package/src/constants.ts

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

package/src/index.ts

@@ -0,0 +1,22 @@
+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'
+export * from './schemas/router.ts'
+export * from './schemas/subscription.ts'
+
+export namespace contract {
+  export const procedure = ProcedureContract
+  export const event = EventContract
+  export const subscription = SubscriptionContract
+  export const router = RouterContract
+  export const blob = BlobType
+}
+
+export { contract as c }
+
+export default contract

package/src/schemas/event.ts

@@ -0,0 +1,55 @@
+import type { BaseType } 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 interface TEventContract<
+  Payload extends BaseType = t.NeverType,
+  Name extends string | undefined = undefined,
+  Options extends SubcriptionOptions | undefined = undefined,
+> {
+  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,
+>(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>>({
+    ...schemaOptions,
+    [Kind]: EventKind,
+    type: 'neemata:event',
+    payload,
+    name,
+    options: undefined as Options,
+  })
+}
+
+export function IsEventContract(value: any): value is TAnyEventContract {
+  return Kind in value && value[Kind] === EventKind
+}

package/src/schemas/procedure.ts

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

package/src/schemas/router.ts

@@ -0,0 +1,118 @@
+import type { ContractSchemaOptions } from '../utils.ts'
+import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'
+import { Kind } from '../constants.ts'
+import { concatFullName, createSchema } from '../utils.ts'
+import { IsProcedureContract } from './procedure.ts'
+
+export const RouterKind = Symbol('NeemataRouter')
+
+export type TAnyRouterContract<
+  RouteContracts extends Record<string, TRouteContract> = Record<
+    string,
+    TRouteContract
+  >,
+  RouterName extends string | undefined = string | undefined,
+> = TRouterContract<RouteContracts, RouterName>
+
+export type TRouteContract =
+  | TAnyProcedureContract
+  | TRouterContract<Record<string, TRouteContract>, string | undefined>
+
+export interface TRouterContract<
+  Routes extends Record<string, TRouteContract> = {},
+  Name extends string | undefined = undefined,
+> {
+  readonly [Kind]: typeof RouterKind
+  readonly type: 'neemata:router'
+  readonly name: Name
+  readonly default?: TProcedureContract<
+    any,
+    any,
+    true | undefined,
+    string | undefined
+  >
+  readonly routes: {
+    [K in keyof Routes]: Routes[K] extends TAnyRouterContract
+      ? TRouterContract<
+          Routes[K]['routes'],
+          Name extends string
+            ? `${Name}/${Extract<K, string>}`
+            : Extract<K, string>
+        >
+      : Routes[K] extends TAnyProcedureContract
+        ? TProcedureContract<
+            Routes[K]['input'],
+            Routes[K]['output'],
+            Routes[K]['stream'],
+            Name extends string
+              ? `${Name}/${Extract<K, string>}`
+              : Extract<K, string>
+          >
+        : never
+  }
+  readonly timeout?: number
+}
+
+export const RouterContract = <
+  const Options extends {
+    routes: Record<string, TRouteContract>
+    name?: string
+    timeout?: number
+    schemaOptions?: ContractSchemaOptions
+  },
+>(
+  options: Options,
+) => {
+  const {
+    name = undefined as any,
+    timeout,
+    schemaOptions = {} as ContractSchemaOptions,
+  } = options
+
+  const routes: any = processNestedRoutes(options.routes, name)
+
+  return createSchema<
+    TRouterContract<
+      Options['routes'],
+      Options['name'] extends string ? Options['name'] : undefined
+    >
+  >({
+    ...schemaOptions,
+    [Kind]: RouterKind,
+    type: 'neemata:router',
+    name,
+    routes,
+    timeout,
+  })
+}
+
+function processNestedRoutes(
+  routes: Record<string, TAnyRouterContract | TAnyProcedureContract>,
+  parentName: string | undefined,
+): Record<string, TAnyRouterContract | TAnyProcedureContract> {
+  const processed: Record<string, any> = {}
+
+  for (const routeName in routes) {
+    const route = routes[routeName]
+
+    if (IsRouterContract(route)) {
+      const nestedName = concatFullName(parentName, routeName)
+      processed[routeName] = createSchema({
+        ...route,
+        name: nestedName,
+        routes: processNestedRoutes(route.routes, nestedName),
+      })
+    } else if (IsProcedureContract(route)) {
+      const fullName = concatFullName(parentName, routeName)
+      processed[routeName] = createSchema({ ...route, name: fullName })
+    } else {
+      throw new Error(`Invalid route type for ${routeName}`)
+    }
+  }
+
+  return processed
+}
+
+export function IsRouterContract(value: any): value is TAnyRouterContract {
+  return Kind in value && value[Kind] === RouterKind
+}

package/src/schemas/subscription.ts

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

package/src/types/blob.ts

@@ -0,0 +1,46 @@
+import type { ProtocolBlobInterface } from '@nmtjs/protocol'
+import { isBlobInterface } from '@nmtjs/protocol'
+import { CustomType } from '@nmtjs/type/custom'
+
+export interface BlobOptions {
+  maxSize?: number
+  contentType?: string
+}
+
+export const BlobType = (
+  options: BlobOptions = {},
+): CustomType<ProtocolBlobInterface> =>
+  CustomType.factory({
+    decode: (value) => value,
+    encode: (value) => value,
+    validation: {
+      decode(value, { addIssue }) {
+        if (isBlobInterface(value)) {
+          if (options.maxSize) {
+            const size = value.metadata.size
+            if (typeof size !== 'undefined' && size > options.maxSize) {
+              addIssue({
+                code: 'custom',
+                message: `Blob size unknown or exceeds maximum allowed size of ${options.maxSize} bytes`,
+              })
+            }
+          }
+        } else {
+          addIssue({
+            code: 'custom',
+            message:
+              'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
+          })
+        }
+      },
+      encode(value, { addIssue }) {
+        if (!isBlobInterface(value)) {
+          addIssue({
+            code: 'custom',
+            message:
+              'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
+          })
+        }
+      },
+    },
+  })

package/src/utils.ts

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