@nmtjs/contract 0.15.0-beta.1 → 0.15.0-beta.3

package/dist/constants.d.ts

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

package/dist/constants.js

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

@@ -0,0 +1,20 @@
+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";
+export * from "./schemas/subscription.js";
+export var contract;
+(function (contract) {
+    contract.procedure = ProcedureContract;
+    contract.event = EventContract;
+    contract.subscription = SubscriptionContract;
+    contract.router = RouterContract;
+    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.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

@@ -0,0 +1,19 @@
+import { t } from '@nmtjs/type';
+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 ?? {};
+    return createSchema({
+        ...schemaOptions,
+        [Kind]: EventKind,
+        type: 'neemata:event',
+        payload,
+        name,
+        options: undefined,
+    });
+};
+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

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

package/dist/schemas/procedure.js.map

@@ -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,22 @@
+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 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

@@ -0,0 +1,42 @@
+import { Kind } from "../constants.js";
+import { concatFullName, createSchema } from "../utils.js";
+import { IsProcedureContract } from "./procedure.js";
+export const RouterKind = Symbol('NeemataRouter');
+export const RouterContract = (options) => {
+    const { name = undefined, timeout, schemaOptions = {}, } = options;
+    const routes = processNestedRoutes(options.routes, name);
+    return createSchema({
+        ...schemaOptions,
+        [Kind]: RouterKind,
+        type: 'neemata:router',
+        name,
+        routes,
+        timeout,
+    });
+};
+function processNestedRoutes(routes, parentName) {
+    const processed = {};
+    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) {
+    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.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

@@ -0,0 +1,29 @@
+import { Kind } from "../constants.js";
+import { concatFullName, 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({
+        ...schemaOptions,
+        [Kind]: SubscriptionKind,
+        type: 'neemata:subscription',
+        events: _events,
+        name: name,
+        options: undefined,
+    });
+};
+export const SubscriptionContract = Object.assign(_SubscriptionContract, {
+    withOptions: () => {
+        return (options) => _SubscriptionContract(options);
+    },
+});
+export function IsSubscriptionContract(contract) {
+    return Kind in contract && contract[Kind] === SubscriptionKind;
+}
+//# 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

@@ -0,0 +1,36 @@
+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`,
+                        });
+                    }
+                }
+            }
+            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.',
+                });
+            }
+        },
+    },
+});
+//# 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

@@ -0,0 +1,8 @@
+export const applyNames = (params, opts) => {
+    return Object.fromEntries(Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]));
+};
+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,8 +5,8 @@
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1"
+    "@nmtjs/type": "0.15.0-beta.3",
+    "@nmtjs/protocol": "0.15.0-beta.3"
   },
   "devDependencies": {
     "zod": "^4.1.0"
@@ -16,10 +16,10 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.3",
   "scripts": {
     "clean-build": "rm -rf ./dist",
-    "build": "tsc",
+    "build": "tsc --declaration --sourcemap",
     "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }