@nmtjs/contract 0.14.5 → 0.15.0-beta.10

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - 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

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

@@ -1,4 +1,3 @@
-export * from './schemas/api.ts';
 export * from './schemas/event.ts';
 export * from './schemas/procedure.ts';
 export * from './schemas/router.ts';
@@ -7,11 +6,11 @@ export declare namespace contract {
     const procedure: <const Options extends {
         input?: import("@nmtjs/type").BaseType;
         output?: import("@nmtjs/type").BaseType;
-        stream?: import("@nmtjs/type").BaseType | undefined;
+        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 import("@nmtjs/type").BaseType ? Options["stream"] : undefined, Options["name"] extends string ? Options["name"] : undefined>;
+    }>(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;
@@ -34,11 +33,6 @@ export declare namespace contract {
         timeout?: number;
         schemaOptions?: import("./utils.ts").ContractSchemaOptions;
     }>(options: Options) => import("./schemas/router.ts").TRouterContract<Options["routes"], Options["name"] extends string ? Options["name"] : undefined>;
-    const api: <const Options extends {
-        router: import("./schemas/router.ts").TAnyRouterContract;
-        timeout?: number;
-        schemaOptions?: import("./utils.ts").ContractSchemaOptions;
-    }>(options: Options) => import("./schemas/api.ts").TAPIContract<Options["router"]>;
     const blob: (options?: import("./types/blob.ts").BlobOptions) => import("@nmtjs/type/custom").CustomType<import("@nmtjs/protocol").ProtocolBlobInterface>;
 }
 export { contract as c };

package/dist/index.js

@@ -1,10 +1,8 @@
-import { APIContract } from "./schemas/api.js";
 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/api.js";
 export * from "./schemas/event.js";
 export * from "./schemas/procedure.js";
 export * from "./schemas/router.js";
@@ -15,8 +13,8 @@ export var contract;
     contract.event = EventContract;
     contract.subscription = SubscriptionContract;
     contract.router = RouterContract;
-    contract.api = APIContract;
     contract.blob = BlobType;
 })(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.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

@@ -2,9 +2,9 @@ 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, BaseType | undefined, string | undefined>;
+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 BaseType | undefined, Name extends string | undefined = undefined> {
+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;
@@ -16,10 +16,10 @@ export interface TProcedureContract<Input extends BaseType, Output extends BaseT
 export declare const ProcedureContract: <const Options extends {
     input?: BaseType;
     output?: BaseType;
-    stream?: BaseType | undefined;
+    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 BaseType ? Options["stream"] : undefined, Options["name"] extends string ? Options["name"] : undefined>;
+}>(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

@@ -2,7 +2,7 @@ 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>> = TRouterContract<RouteContracts, string | undefined>;
+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;

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;AA2CjD,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.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

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

package/dist/types/blob.js

@@ -1,16 +1,36 @@
-import { t } from '@nmtjs/type';
-export const BlobType = (options = {}) => t.custom({
-    decode: (value) => {
-        // TODO: here should be some validation logic to check if the value is an actual blob
-        if ('metadata' in value) {
-            if (options.maxSize) {
-                const size = value.metadata.size;
-                if (typeof size !== 'undefined' && size > options.maxSize) {
-                    throw new Error('Blob size unknown or exceeds maximum allowed size');
+import { isBlobInterface } from '@nmtjs/protocol';
+import { CustomType } from '@nmtjs/type/custom';
+export const BlobType = (options = {}) => 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`,
+                        });
+                    }
                 }
             }
-        }
-        return value;
+            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.',
+                });
+            }
+        },
     },
-    encode: (value) => value,
 });
+//# 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.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

@@ -2,24 +2,26 @@
   "name": "@nmtjs/contract",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "module-sync": "./dist/index.js"
-    }
+    ".": "./dist/index.js"
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.14.5",
-    "@nmtjs/type": "0.14.5"
+    "@nmtjs/protocol": "0.15.0-beta.10",
+    "@nmtjs/type": "0.15.0-beta.10"
+  },
+  "devDependencies": {
+    "zod": "^4.1.0"
   },
   "files": [
     "dist",
+    "src",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.5",
+  "version": "0.15.0-beta.10",
   "scripts": {
-    "build": "tsc",
+    "clean-build": "rm -rf ./dist",
+    "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,112 @@
+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 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
+}

package/dist/schemas/api.d.ts

@@ -1,17 +0,0 @@
-import type { ContractSchemaOptions } from '../utils.ts';
-import type { TAnyRouterContract } from './router.ts';
-import { Kind } from '../constants.ts';
-export declare const APIKind: unique symbol;
-export type TAnyAPIContract = TAPIContract<TAnyRouterContract>;
-export interface TAPIContract<Router extends TAnyRouterContract = TAnyRouterContract> {
-    readonly [Kind]: typeof APIKind;
-    readonly type: 'neemata:api';
-    readonly router: Router;
-    readonly timeout?: number;
-}
-export declare const APIContract: <const Options extends {
-    router: TAnyRouterContract;
-    timeout?: number;
-    schemaOptions?: ContractSchemaOptions;
-}>(options: Options) => TAPIContract<Options["router"]>;
-export declare function IsAPIContract(value: any): value is TAnyAPIContract;

package/dist/schemas/api.js

@@ -1,16 +0,0 @@
-import { Kind } from "../constants.js";
-import { createSchema } from "../utils.js";
-export const APIKind = Symbol('NeemataAPI');
-export const APIContract = (options) => {
-    const { router, timeout, schemaOptions } = options;
-    return createSchema({
-        ...schemaOptions,
-        [Kind]: APIKind,
-        type: 'neemata:api',
-        router,
-        timeout,
-    });
-};
-export function IsAPIContract(value) {
-    return Kind in value && value[Kind] === APIKind;
-}