@nmtjs/contract 0.12.5 → 0.12.7

package/dist/constants.d.ts

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

package/dist/constants.js

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

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+import t from '@nmtjs/type';
+export * from './schemas/api.ts';
+export * from './schemas/event.ts';
+export * from './schemas/namespace.ts';
+export * from './schemas/procedure.ts';
+export * from './schemas/subscription.ts';
+export declare namespace contract {
+    const procedure: <const Options extends {
+        input?: import("@nmtjs/type").BaseType;
+        output?: import("@nmtjs/type").BaseType;
+        stream?: import("@nmtjs/type").BaseType | undefined;
+        timeout?: number;
+        schemaOptions?: import("./utils.ts").ContractSchemaOptions;
+        name?: string;
+    }>(options: Options) => import("./schemas/procedure.ts").TProcedureContract<Options["input"] extends import("@nmtjs/type").BaseType<import("@nmtjs/type").SimpleZodType, import("@nmtjs/type").SimpleZodType, import("@nmtjs/type").TypeProps> ? Options["input"] : t.NeverType, Options["output"] extends import("@nmtjs/type").BaseType<import("@nmtjs/type").SimpleZodType, import("@nmtjs/type").SimpleZodType, import("@nmtjs/type").TypeProps> ? Options["output"] : t.NeverType, Options["stream"] extends import("@nmtjs/type").BaseType<import("@nmtjs/type").SimpleZodType, import("@nmtjs/type").SimpleZodType, import("@nmtjs/type").TypeProps> ? Options["stream"] : undefined, Options["name"] extends string ? Options["name"] : undefined, undefined>;
+    const event: <Payload extends import("@nmtjs/type").BaseType, Name extends string | undefined = undefined>(options?: {
+        payload?: Payload;
+        schemaOptions?: import("./utils.ts").ContractSchemaOptions;
+        name?: Name;
+    }) => import("./schemas/event.ts").TEventContract<Payload, Name, undefined, undefined>;
+    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"] extends string ? Options["name"] : undefined>) & {
+        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"] extends string ? T["name"] : undefined>;
+    };
+    const namespace: <const Options extends {
+        procedures: Record<string, import("./schemas/procedure.ts").TAnyProcedureContract>;
+        events: Record<string, import("./schemas/event.ts").TAnyEventContract>;
+        name?: string;
+        timeout?: number;
+        schemaOptions?: import("./utils.ts").ContractSchemaOptions;
+    }>(options: Options) => import("./schemas/namespace.ts").TNamespaceContract<Options["procedures"], Options["events"], Options["name"] extends string ? Options["name"] : undefined>;
+    const api: <const Options extends {
+        namespaces: Record<string, import("./schemas/namespace.ts").TAnyNamespaceContract>;
+        timeout?: number;
+        schemaOptions?: import("./utils.ts").ContractSchemaOptions;
+    }>(options: Options) => import("./schemas/api.ts").TAPIContract<Options["namespaces"]>;
+    const blob: (options?: import("./types/blob.ts").BlobOptions) => t.CustomType<import("@nmtjs/protocol").ProtocolBlobInterface>;
+}
+export { contract as c };
+export default contract;

package/dist/index.js

@@ -1,3 +1,5 @@
+// biome-ignore lint/correctness/noUnusedImports: TSC wants it
+import t from '@nmtjs/type';
 import { APIContract } from "./schemas/api.js";
 import { EventContract } from "./schemas/event.js";
 import { NamespaceContract } from "./schemas/namespace.js";
@@ -9,16 +11,14 @@ export * from "./schemas/event.js";
 export * from "./schemas/namespace.js";
 export * from "./schemas/procedure.js";
 export * from "./schemas/subscription.js";
-export let contract;
-(function(_contract) {
-	const procedure = _contract.procedure = ProcedureContract;
-	const event = _contract.event = EventContract;
-	const subscription = _contract.subscription = SubscriptionContract;
-	const namespace = _contract.namespace = NamespaceContract;
-	const api = _contract.api = APIContract;
-	const blob = _contract.blob = BlobType;
+export var contract;
+(function (contract) {
+    contract.procedure = ProcedureContract;
+    contract.event = EventContract;
+    contract.subscription = SubscriptionContract;
+    contract.namespace = NamespaceContract;
+    contract.api = APIContract;
+    contract.blob = BlobType;
 })(contract || (contract = {}));
 export { contract as c };
 export default contract;
-
-//# sourceMappingURL=index.js.map

package/dist/schemas/api.d.ts

@@ -0,0 +1,19 @@
+import { Kind } from '../constants.ts';
+import { type ContractSchemaOptions } from '../utils.ts';
+import type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts';
+export declare const APIKind: unique symbol;
+export type TAnyAPIContract = TAPIContract<Record<string, TAnyNamespaceContract>>;
+export interface TAPIContract<Namespaces extends Record<string, TAnyNamespaceContract> = {}> {
+    readonly [Kind]: typeof APIKind;
+    readonly type: 'neemata:api';
+    readonly namespaces: {
+        [K in keyof Namespaces]: TNamespaceContract<Namespaces[K]['procedures'], Namespaces[K]['events'], Extract<K, string>>;
+    };
+    readonly timeout?: number;
+}
+export declare const APIContract: <const Options extends {
+    namespaces: Record<string, TAnyNamespaceContract>;
+    timeout?: number;
+    schemaOptions?: ContractSchemaOptions;
+}>(options: Options) => TAPIContract<Options["namespaces"]>;
+export declare function IsAPIContract(value: any): value is TAnyAPIContract;

package/dist/schemas/api.js

@@ -1,47 +1,45 @@
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const APIKind = Symbol("NeemataAPI");
+export const APIKind = Symbol('NeemataAPI');
 export const APIContract = (options) => {
-	const { timeout, schemaOptions } = options;
-	const _namespaces = {};
-	for (const namespaceKey in options.namespaces) {
-		const namespace = options.namespaces[namespaceKey];
-		const _procedures = {};
-		for (const procedureKey in namespace.procedures) {
-			const procedure = namespace.procedures[procedureKey];
-			_procedures[procedureKey] = createSchema({
-				...procedure,
-				name: procedureKey,
-				namespace: namespaceKey
-			});
-		}
-		const _events = {};
-		for (const eventKey in namespace.events) {
-			const event = namespace.events[eventKey];
-			_events[eventKey] = createSchema({
-				...event,
-				subscription: undefined,
-				name: eventKey,
-				namespace: namespaceKey
-			});
-		}
-		_namespaces[namespaceKey] = createSchema({
-			...namespace,
-			procedures: _procedures,
-			events: _events,
-			name: namespaceKey
-		});
-	}
-	return createSchema({
-		...schemaOptions,
-		[Kind]: APIKind,
-		type: "neemata:api",
-		namespaces: _namespaces,
-		timeout
-	});
+    const { timeout, schemaOptions } = options;
+    const _namespaces = {};
+    for (const namespaceKey in options.namespaces) {
+        const namespace = options.namespaces[namespaceKey];
+        const _procedures = {};
+        for (const procedureKey in namespace.procedures) {
+            const procedure = namespace.procedures[procedureKey];
+            _procedures[procedureKey] = createSchema({
+                ...procedure,
+                name: procedureKey,
+                namespace: namespaceKey,
+            });
+        }
+        const _events = {};
+        for (const eventKey in namespace.events) {
+            const event = namespace.events[eventKey];
+            _events[eventKey] = createSchema({
+                ...event,
+                subscription: undefined,
+                name: eventKey,
+                namespace: namespaceKey,
+            });
+        }
+        _namespaces[namespaceKey] = createSchema({
+            ...namespace,
+            procedures: _procedures,
+            events: _events,
+            name: namespaceKey,
+        });
+    }
+    return createSchema({
+        ...schemaOptions,
+        [Kind]: APIKind,
+        type: 'neemata:api',
+        namespaces: _namespaces,
+        timeout,
+    });
 };
 export function IsAPIContract(value) {
-	return Kind in value && value[Kind] === APIKind;
+    return Kind in value && value[Kind] === APIKind;
 }
-
-//# sourceMappingURL=api.js.map

package/dist/schemas/event.d.ts

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

package/dist/schemas/event.js

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

package/dist/schemas/namespace.d.ts

@@ -0,0 +1,26 @@
+import { Kind } from '../constants.ts';
+import { type ContractSchemaOptions } from '../utils.ts';
+import type { TAnyEventContract, TEventContract } from './event.ts';
+import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts';
+export declare const NamespaceKind: unique symbol;
+export type TAnyNamespaceContract<Procedures extends Record<string, TAnyProcedureContract> = Record<string, TAnyProcedureContract>> = TNamespaceContract<Procedures, Record<string, TAnyEventContract>, string | undefined>;
+export interface TNamespaceContract<Procedures extends Record<string, TAnyProcedureContract> = {}, Events extends Record<string, TAnyEventContract> = {}, Name extends string | undefined = undefined> {
+    readonly [Kind]: typeof NamespaceKind;
+    readonly type: 'neemata:namespace';
+    readonly name: Name;
+    readonly procedures: {
+        [K in keyof Procedures]: TProcedureContract<Procedures[K]['input'], Procedures[K]['output'], Procedures[K]['stream'], Extract<K, string>, Name>;
+    };
+    readonly events: {
+        [K in keyof Events]: TEventContract<Events[K]['payload'], Extract<K, string>, undefined, Name>;
+    };
+    readonly timeout?: number;
+}
+export declare const NamespaceContract: <const Options extends {
+    procedures: Record<string, TAnyProcedureContract>;
+    events: Record<string, TAnyEventContract>;
+    name?: string;
+    timeout?: number;
+    schemaOptions?: ContractSchemaOptions;
+}>(options: Options) => TNamespaceContract<Options["procedures"], Options["events"], Options["name"] extends string ? Options["name"] : undefined>;
+export declare function IsNamespaceContract(value: any): value is TAnyNamespaceContract;

package/dist/schemas/namespace.js

@@ -1,39 +1,37 @@
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const NamespaceKind = Symbol("NeemataNamespace");
+export const NamespaceKind = Symbol('NeemataNamespace');
 export const NamespaceContract = (options) => {
-	const { name, timeout, schemaOptions = {} } = options;
-	const events = {};
-	for (const name in options.events) {
-		const event = options.events[name];
-		events[name] = createSchema({
-			...event,
-			subscription: undefined,
-			name,
-			namespace: options?.name
-		});
-	}
-	const procedures = {};
-	for (const name in options.procedures) {
-		const procedure = options.procedures[name];
-		procedures[name] = createSchema({
-			...procedure,
-			name,
-			namespace: options?.name
-		});
-	}
-	return createSchema({
-		...schemaOptions,
-		[Kind]: NamespaceKind,
-		type: "neemata:namespace",
-		name,
-		procedures,
-		events,
-		timeout
-	});
+    const { name, timeout, schemaOptions = {} } = options;
+    const events = {};
+    for (const name in options.events) {
+        const event = options.events[name];
+        events[name] = createSchema({
+            ...event,
+            subscription: undefined,
+            name: name,
+            namespace: options?.name,
+        });
+    }
+    const procedures = {};
+    for (const name in options.procedures) {
+        const procedure = options.procedures[name];
+        procedures[name] = createSchema({
+            ...procedure,
+            name: name,
+            namespace: options?.name,
+        });
+    }
+    return createSchema({
+        ...schemaOptions,
+        [Kind]: NamespaceKind,
+        type: 'neemata:namespace',
+        name: name,
+        procedures: procedures,
+        events: events,
+        timeout,
+    });
 };
 export function IsNamespaceContract(value) {
-	return Kind in value && value[Kind] === NamespaceKind;
+    return Kind in value && value[Kind] === NamespaceKind;
 }
-
-//# sourceMappingURL=namespace.js.map

package/dist/schemas/procedure.d.ts

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

package/dist/schemas/procedure.js

@@ -1,26 +1,24 @@
-import { t } from "@nmtjs/type";
+import { t } from '@nmtjs/type';
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const ProcedureKind = Symbol("NeemataProcedure");
+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,
-		namespace: undefined
-	});
+    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,
+        namespace: undefined,
+    });
 };
 export function IsProcedureContract(contract) {
-	return Kind in contract && contract[Kind] === ProcedureKind;
+    return Kind in contract && contract[Kind] === ProcedureKind;
 }
 export function IsStreamProcedureContract(contract) {
-	return IsProcedureContract(contract) && typeof contract.stream !== "undefined";
+    return IsProcedureContract(contract) && typeof contract.stream !== 'undefined';
 }
-
-//# sourceMappingURL=procedure.js.map

package/dist/schemas/subscription.d.ts

@@ -0,0 +1,27 @@
+import { Kind } from '../constants.ts';
+import { type ContractSchemaOptions } from '../utils.ts';
+import type { TAnyEventContract, TEventContract } from './event.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'], Extract<K, string>, Name> : 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"] extends string ? Options["name"] : undefined>) & {
+    withOptions: <Options extends SubcriptionOptions>() => <T extends {
+        events: Record<string, TAnyEventContract>;
+        name?: string;
+        schemaOptions?: ContractSchemaOptions;
+    }>(options: T) => TSubscriptionContract<Options, T["events"], T["name"] extends string ? T["name"] : undefined>;
+};
+export declare function IsSubscriptionContract(contract: any): contract is TAnySubscriptionContract;

package/dist/schemas/subscription.js

@@ -1,32 +1,32 @@
 import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
-export const SubscriptionKind = Symbol("NeemataSubscription");
+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];
-		_events[key] = createSchema({
-			...event,
-			name: key,
-			namespace: undefined,
-			subscription: name
-		});
-	}
-	return createSchema({
-		...schemaOptions,
-		[Kind]: SubscriptionKind,
-		type: "neemata:subscription",
-		events: _events,
-		name,
-		options: undefined
-	});
+    const { schemaOptions = {}, name } = options;
+    const _events = {};
+    for (const key in options.events) {
+        const event = options.events[key];
+        _events[key] = createSchema({
+            ...event,
+            name: key,
+            namespace: undefined,
+            subscription: name,
+        });
+    }
+    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 const SubscriptionContract = Object.assign(_SubscriptionContract, {
+    withOptions: () => {
+        return (options) => _SubscriptionContract(options);
+    },
+});
 export function IsSubscriptionContract(contract) {
-	return Kind in contract && contract[Kind] === SubscriptionKind;
+    return Kind in contract && contract[Kind] === SubscriptionKind;
 }
-
-//# sourceMappingURL=subscription.js.map

package/dist/types/blob.d.ts

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

package/dist/types/blob.js

@@ -1,17 +1,16 @@
-import { t } from "@nmtjs/type";
+import { t } from '@nmtjs/type';
 export const BlobType = (options = {}) => t.custom({
-	decode: (value) => {
-		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");
-				}
-			}
-		}
-		return value;
-	},
-	encode: (value) => value
+    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');
+                }
+            }
+        }
+        return value;
+    },
+    encode: (value) => value,
 });
-
-//# sourceMappingURL=blob.js.map

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -1,10 +1,4 @@
 export const applyNames = (params, opts) => {
-	return Object.fromEntries(Object.entries(params).map(([k, v]) => [k, {
-		...v,
-		name: k,
-		...opts
-	}]));
+    return Object.fromEntries(Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]));
 };
 export const createSchema = (schema) => Object.freeze(schema);
-
-//# sourceMappingURL=utils.js.map

package/package.json

@@ -3,23 +3,23 @@
   "type": "module",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./src/index.ts"
+      "module-sync": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.12.5",
-    "@nmtjs/type": "0.12.5"
+    "@nmtjs/protocol": "0.12.7",
+    "@nmtjs/type": "0.12.7"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.5",
+  "version": "0.12.7",
   "scripts": {
-    "build": "neemata-build --root=./src './**/*.ts'",
+    "build": "tsc",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,OAAO,MAAM,OAAO,OAAO,IAAI,eAAe","names":[],"sources":["../src/constants.ts"],"sourcesContent":["export const Kind = Symbol.for('neemata:kind')\n"],"version":3,"file":"constants.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,SAAS,mBAAmB,kBAAkB;AAC9C,SAAS,qBAAqB,oBAAoB;AAClD,SAAS,yBAAyB,wBAAwB;AAC1D,SAAS,yBAAyB,wBAAwB;AAC1D,SAAS,4BAA4B,2BAA2B;AAChE,SAAS,gBAAgB,iBAAiB;AAE1C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;;AAEP;CACE,MAAM,kCAAY;CAClB,MAAM,0BAAQ;CACd,MAAM,wCAAe;CACrB,MAAM,kCAAY;CAClB,MAAM,sBAAM;CACZ,MAAM,wBAAO;;AAGtB,SAAS,YAAY;AAErB,eAAe","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { APIContract } from './schemas/api.ts'\nimport { EventContract } from './schemas/event.ts'\nimport { NamespaceContract } from './schemas/namespace.ts'\nimport { ProcedureContract } from './schemas/procedure.ts'\nimport { SubscriptionContract } from './schemas/subscription.ts'\nimport { BlobType } from './types/blob.ts'\n\nexport * from './schemas/api.ts'\nexport * from './schemas/event.ts'\nexport * from './schemas/namespace.ts'\nexport * from './schemas/procedure.ts'\nexport * from './schemas/subscription.ts'\n\nexport namespace contract {\n  export const procedure = ProcedureContract\n  export const event = EventContract\n  export const subscription = SubscriptionContract\n  export const namespace = NamespaceContract\n  export const api = APIContract\n  export const blob = BlobType\n}\n\nexport { contract as c }\n\nexport default contract\n"],"version":3,"file":"index.js"}

package/dist/schemas/api.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAKtE,OAAO,MAAM,UAAU,OAAO,aAAa;AAqB3C,OAAO,MAAM,cAAc,CAOzBA,YACG;CACH,MAAM,EAAE,SAAS,eAAe,GAAG;CAEnC,MAAM,cAAc,CAAE;AAEtB,MAAK,MAAM,gBAAgB,QAAQ,YAAY;EAC7C,MAAM,YAAY,QAAQ,WAAW;EACrC,MAAM,cAAc,CAAE;AACtB,OAAK,MAAM,gBAAgB,UAAU,YAAY;GAC/C,MAAM,YAAY,UAAU,WAAW;AACvC,eAAY,gBAAgB,aAQ1B;IACA,GAAG;IACH,MAAM;IACN,WAAW;GACZ,EAAC;EACH;EAED,MAAM,UAAU,CAAE;AAClB,OAAK,MAAM,YAAY,UAAU,QAAQ;GACvC,MAAM,QAAQ,UAAU,OAAO;AAC/B,WAAQ,YAAY,aAOlB;IACA,GAAG;IACH,cAAc;IACd,MAAM;IACN,WAAW;GACZ,EAAC;EACH;AAED,cAAY,gBAAgB,aAM1B;GACA,GAAG;GACH,YAAY;GACZ,QAAQ;GACR,MAAM;EACP,EAAC;CACH;AAED,QAAO,aAAkD;EACvD,GAAG;GACF,OAAO;EACR,MAAM;EACN,YAAY;EACZ;CACD,EAAC;AACH;AAED,OAAO,SAAS,cAAcC,OAAsC;AAClE,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options: Options","value: any"],"sources":["../../src/schemas/api.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TEventContract } from './event.ts'\nimport type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts'\nimport type { TProcedureContract } from './procedure.ts'\n\nexport const APIKind = Symbol('NeemataAPI')\n\nexport type TAnyAPIContract = TAPIContract<\n  Record<string, TAnyNamespaceContract>\n>\n\nexport interface TAPIContract<\n  Namespaces extends Record<string, TAnyNamespaceContract> = {},\n> {\n  readonly [Kind]: typeof APIKind\n  readonly type: 'neemata:api'\n  readonly namespaces: {\n    [K in keyof Namespaces]: TNamespaceContract<\n      Namespaces[K]['procedures'],\n      Namespaces[K]['events'],\n      Extract<K, string>\n    >\n  }\n  readonly timeout?: number\n}\n\nexport const APIContract = <\n  const Options extends {\n    namespaces: Record<string, TAnyNamespaceContract>\n    timeout?: number\n    schemaOptions?: ContractSchemaOptions\n  },\n>(\n  options: Options,\n) => {\n  const { timeout, schemaOptions } = options\n\n  const _namespaces = {} as any\n\n  for (const namespaceKey in options.namespaces) {\n    const namespace = options.namespaces[namespaceKey]\n    const _procedures = {} as any\n    for (const procedureKey in namespace.procedures) {\n      const procedure = namespace.procedures[procedureKey]\n      _procedures[procedureKey] = createSchema<\n        TProcedureContract<\n          (typeof procedure)['input'],\n          (typeof procedure)['output'],\n          (typeof procedure)['stream'],\n          Extract<typeof procedureKey, string>,\n          Extract<typeof namespaceKey, string>\n        >\n      >({\n        ...procedure,\n        name: procedureKey,\n        namespace: namespaceKey,\n      })\n    }\n\n    const _events = {} as any\n    for (const eventKey in namespace.events) {\n      const event = namespace.events[eventKey]\n      _events[eventKey] = createSchema<\n        TEventContract<\n          (typeof event)['payload'],\n          Extract<typeof eventKey, string>,\n          undefined,\n          Extract<typeof namespaceKey, string>\n        >\n      >({\n        ...event,\n        subscription: undefined,\n        name: eventKey,\n        namespace: namespaceKey,\n      })\n    }\n\n    _namespaces[namespaceKey] = createSchema<\n      TNamespaceContract<\n        typeof _procedures,\n        typeof _events,\n        Extract<typeof namespaceKey, string>\n      >\n    >({\n      ...namespace,\n      procedures: _procedures,\n      events: _events,\n      name: namespaceKey,\n    })\n  }\n\n  return createSchema<TAPIContract<Options['namespaces']>>({\n    ...schemaOptions,\n    [Kind]: APIKind,\n    type: 'neemata:api',\n    namespaces: _namespaces,\n    timeout,\n  })\n}\n\nexport function IsAPIContract(value: any): value is TAnyAPIContract {\n  return Kind in value && value[Kind] === APIKind\n}\n"],"version":3,"file":"api.js"}

package/dist/schemas/event.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,SAAwB,SAAS,aAAa;AAC9C,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAEtE,OAAO,MAAM,YAAY,OAAO,eAAe;AAuB/C,OAAO,MAAM,gBAAgB,CAG3BA,YAII;CACJ,MAAM,EACJ,UAAU,EAAE,OAAO,EACnB,gBAAgB,CAAE,GAClB,MACD,GAAG,WAAW,CAAE;AACjB,QAAO,aAA4C;EACjD,GAAG;GACF,OAAO;EACR,MAAM;EACN;EACM;EACN,cAAc;EACd,WAAW;CACZ,EAAC;AACH;AAED,OAAO,SAAS,gBAAgBC,OAAwC;AACtE,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options?: {\n  payload?: Payload\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}","value: any"],"sources":["../../src/schemas/event.ts"],"sourcesContent":["import { type BaseType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport const EventKind = Symbol('NeemataEvent')\n\nexport type TAnyEventContract = TEventContract<\n  BaseType,\n  string | undefined,\n  string | undefined,\n  string | undefined\n>\n\nexport interface TEventContract<\n  Payload extends BaseType = t.NeverType,\n  Name extends string | undefined = undefined,\n  Subscription extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof EventKind\n  readonly type: 'neemata:event'\n  readonly name: Name\n  readonly subscription: Subscription\n  readonly namespace: Namespace\n  readonly payload: Payload\n}\n\nexport const EventContract = <\n  Payload extends BaseType,\n  Name extends string | undefined = undefined,\n>(options?: {\n  payload?: Payload\n  schemaOptions?: ContractSchemaOptions\n  name?: Name\n}) => {\n  const {\n    payload = t.never() as unknown as Payload,\n    schemaOptions = {},\n    name,\n  } = options ?? {}\n  return createSchema<TEventContract<Payload, Name>>({\n    ...schemaOptions,\n    [Kind]: EventKind,\n    type: 'neemata:event',\n    payload,\n    name: name as Name,\n    subscription: undefined,\n    namespace: undefined,\n  })\n}\n\nexport function IsEventContract(value: any): value is TAnyEventContract {\n  return Kind in value && value[Kind] === EventKind\n}\n"],"version":3,"file":"event.js"}

package/dist/schemas/namespace.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAItE,OAAO,MAAM,gBAAgB,OAAO,mBAAmB;AAyCvD,OAAO,MAAM,oBAAoB,CAS/BA,YACG;CACH,MAAM,EAAE,MAAM,SAAS,gBAAgB,CAAE,GAA2B,GAAG;CACvE,MAAMC,SAA8B,CAAE;AAEtC,MAAK,MAAM,QAAQ,QAAQ,QAAQ;EACjC,MAAM,QAAQ,QAAQ,OAAO;AAC7B,SAAO,QAAQ,aAOb;GACA,GAAG;GACH,cAAc;GACR;GACN,WAAW,SAAS;EACrB,EAAC;CACH;CAED,MAAMC,aAAkC,CAAE;AAE1C,MAAK,MAAM,QAAQ,QAAQ,YAAY;EACrC,MAAMC,YAAiB,QAAQ,WAAW;AAC1C,aAAW,QAAQ,aAQjB;GACA,GAAG;GACG;GACN,WAAW,SAAS;EACrB,EAAC;CACH;AAED,QAAO,aAML;EACA,GAAG;GACF,OAAO;EACR,MAAM;EACA;EACM;EACJ;EACR;CACD,EAAC;AACH;AAED,OAAO,SAAS,oBACdC,OACgC;AAChC,QAAO,QAAQ,SAAS,MAAM,UAAU;AACzC","names":["options: Options","events: Record<string, any>","procedures: Record<string, any>","procedure: any","value: any"],"sources":["../../src/schemas/namespace.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\nimport type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'\n\nexport const NamespaceKind = Symbol('NeemataNamespace')\n\nexport type TAnyNamespaceContract<\n  Procedures extends Record<string, TAnyProcedureContract> = Record<\n    string,\n    TAnyProcedureContract\n  >,\n> = TNamespaceContract<\n  Procedures,\n  Record<string, TAnyEventContract>,\n  string | undefined\n>\n\nexport interface TNamespaceContract<\n  Procedures extends Record<string, TAnyProcedureContract> = {},\n  Events extends Record<string, TAnyEventContract> = {},\n  Name extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof NamespaceKind\n  readonly type: 'neemata:namespace'\n  readonly name: Name\n  readonly procedures: {\n    [K in keyof Procedures]: TProcedureContract<\n      Procedures[K]['input'],\n      Procedures[K]['output'],\n      Procedures[K]['stream'],\n      Extract<K, string>,\n      Name\n    >\n  }\n  readonly events: {\n    [K in keyof Events]: TEventContract<\n      Events[K]['payload'],\n      Extract<K, string>,\n      undefined,\n      Name\n    >\n  }\n  readonly timeout?: number\n}\n\nexport const NamespaceContract = <\n  const Options extends {\n    procedures: Record<string, TAnyProcedureContract>\n    events: Record<string, TAnyEventContract>\n    name?: string\n    timeout?: number\n    schemaOptions?: ContractSchemaOptions\n  },\n>(\n  options: Options,\n) => {\n  const { name, timeout, schemaOptions = {} as ContractSchemaOptions } = options\n  const events: Record<string, any> = {}\n\n  for (const name in options.events) {\n    const event = options.events[name]\n    events[name] = createSchema<\n      TEventContract<\n        (typeof event)['payload'],\n        Extract<typeof name, string>,\n        undefined,\n        Options['name'] extends string ? Options['name'] : undefined\n      >\n    >({\n      ...event,\n      subscription: undefined,\n      name: name as any,\n      namespace: options?.name as any,\n    })\n  }\n\n  const procedures: Record<string, any> = {}\n\n  for (const name in options.procedures) {\n    const procedure: any = options.procedures[name]\n    procedures[name] = createSchema<\n      TProcedureContract<\n        (typeof procedure)['input'],\n        (typeof procedure)['output'],\n        (typeof procedure)['stream'],\n        Extract<typeof name, string>,\n        Options['name'] extends string ? Options['name'] : undefined\n      >\n    >({\n      ...procedure,\n      name: name as any,\n      namespace: options?.name as any,\n    })\n  }\n\n  return createSchema<\n    TNamespaceContract<\n      Options['procedures'],\n      Options['events'],\n      Options['name'] extends string ? Options['name'] : undefined\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: NamespaceKind,\n    type: 'neemata:namespace',\n    name: name as any,\n    procedures: procedures as any,\n    events: events as any,\n    timeout,\n  })\n}\n\nexport function IsNamespaceContract(\n  value: any,\n): value is TAnyNamespaceContract {\n  return Kind in value && value[Kind] === NamespaceKind\n}\n"],"version":3,"file":"namespace.js"}

package/dist/schemas/procedure.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,SAAwB,SAAS,aAAa;AAC9C,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAUtE,OAAO,MAAM,gBAAgB,OAAO,mBAAmB;AAmBvD,OAAO,MAAM,oBAAoB,CAU/BA,YACG;CACH,MAAM,EACJ,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,OAAO,EAClB,SAAS,WACT,OAAO,WACP,SACA,gBAAgB,CAAE,GACnB,GAAG;AACJ,QAAO,aAOL;EACA,GAAG;GACF,OAAO;EACR,MAAM;EACN;EACA;EACA;EACA;EACA;EACA,WAAW;CACZ,EAAC;AACH;AAED,OAAO,SAAS,oBACdC,UACmC;AACnC,QAAO,QAAQ,YAAY,SAAS,UAAU;AAC/C;AAED,OAAO,SAAS,0BACdA,UACmC;AACnC,QAAO,oBAAoB,SAAS,WAAW,SAAS,WAAW;AACpE","names":["options: Options","contract: any"],"sources":["../../src/schemas/procedure.ts"],"sourcesContent":["import { type BaseType, t } from '@nmtjs/type'\nimport { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\n\nexport type TAnyProcedureContract = TProcedureContract<\n  BaseType,\n  BaseType,\n  BaseType | undefined,\n  string | undefined,\n  string | undefined\n>\n\nexport const ProcedureKind = Symbol('NeemataProcedure')\n\nexport interface TProcedureContract<\n  Input extends BaseType,\n  Output extends BaseType,\n  Stream extends BaseType | undefined,\n  Name extends string | undefined = undefined,\n  Namespace extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof ProcedureKind\n  readonly type: 'neemata:procedure'\n  readonly name: Name\n  readonly namespace: Namespace\n  readonly input: Input\n  readonly output: Output\n  readonly stream: Stream\n  readonly timeout?: number\n}\n\nexport const ProcedureContract = <\n  const Options extends {\n    input?: BaseType\n    output?: BaseType\n    stream?: BaseType | undefined\n    timeout?: number\n    schemaOptions?: ContractSchemaOptions\n    name?: string\n  },\n>(\n  options: Options,\n) => {\n  const {\n    input = t.never() as any,\n    output = t.never() as any,\n    stream = undefined as any,\n    name = undefined as any,\n    timeout,\n    schemaOptions = {},\n  } = options\n  return createSchema<\n    TProcedureContract<\n      Options['input'] extends BaseType ? Options['input'] : t.NeverType,\n      Options['output'] extends BaseType ? Options['output'] : t.NeverType,\n      Options['stream'] extends BaseType ? Options['stream'] : undefined,\n      Options['name'] extends string ? Options['name'] : undefined\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: ProcedureKind,\n    type: 'neemata:procedure',\n    input,\n    output,\n    stream,\n    name,\n    timeout,\n    namespace: undefined,\n  })\n}\n\nexport function IsProcedureContract(\n  contract: any,\n): contract is TAnyProcedureContract {\n  return Kind in contract && contract[Kind] === ProcedureKind\n}\n\nexport function IsStreamProcedureContract(\n  contract: any,\n): contract is TAnyProcedureContract {\n  return IsProcedureContract(contract) && typeof contract.stream !== 'undefined'\n}\n"],"version":3,"file":"procedure.js"}

package/dist/schemas/subscription.js.map

@@ -1 +0,0 @@
-{"mappings":"AAAA,SAAS,YAAY,iBAAiB;AACtC,SAAqC,oBAAoB,aAAa;AAGtE,OAAO,MAAM,mBAAmB,OAAO,sBAAsB;AA6B7D,MAAM,wBAAwB,CAQ5BA,YACG;CACH,MAAM,EAAE,gBAAgB,CAAE,GAAE,MAAM,GAAG;CACrC,MAAM,UAAU,CAAE;AAClB,MAAK,MAAM,OAAO,QAAQ,QAAQ;EAChC,MAAM,QAAQ,QAAQ,OAAO;AAC7B,UAAQ,OAAO,aAOb;GACA,GAAG;GACH,MAAM;GACN,WAAW;GACX,cAAc;EACf,EAAC;CACH;AACD,QAAO,aAML;EACA,GAAG;GACF,OAAO;EACR,MAAM;EACN,QAAQ;EACF;EACN,SAAS;CACV,EAAC;AACH;AAED,OAAO,MAAM,uBAAuB,OAAO,OAAO,uBAAuB,EACvE,aAAa,MAA0C;AACrD,QAAO,CAOLC,YACG,sBAAkC,QAAQ;AAChD,EACF,EAAC;AAEF,OAAO,SAAS,uBACdC,UACsC;AACtC,QAAO,QAAQ,YAAY,SAAS,UAAU;AAC/C","names":["options: Options","options: T","contract: any"],"sources":["../../src/schemas/subscription.ts"],"sourcesContent":["import { Kind } from '../constants.ts'\nimport { type ContractSchemaOptions, createSchema } from '../utils.ts'\nimport type { TAnyEventContract, TEventContract } from './event.ts'\n\nexport const SubscriptionKind = Symbol('NeemataSubscription')\n\nexport type SubcriptionOptions = Record<\n  string,\n  string | number | boolean\n> | null\n\nexport type TAnySubscriptionContract = TSubscriptionContract<\n  SubcriptionOptions,\n  Record<string, TAnyEventContract>,\n  string | undefined\n>\n\nexport interface TSubscriptionContract<\n  Options extends SubcriptionOptions = null,\n  Events extends Record<string, unknown> = {},\n  Name extends string | undefined = undefined,\n> {\n  readonly [Kind]: typeof SubscriptionKind\n  readonly type: 'neemata:subscription'\n  readonly name: Name\n  readonly options: Options\n  readonly events: {\n    [K in keyof Events]: Events[K] extends TAnyEventContract\n      ? TEventContract<Events[K]['payload'], Extract<K, string>, Name>\n      : never\n  }\n}\n\nconst _SubscriptionContract = <\n  const Options extends {\n    events: Record<string, TAnyEventContract>\n    name?: string\n    schemaOptions?: ContractSchemaOptions\n  },\n  SubOpt extends SubcriptionOptions = null,\n>(\n  options: Options,\n) => {\n  const { schemaOptions = {}, name } = options\n  const _events = {} as any\n  for (const key in options.events) {\n    const event = options.events[key]\n    _events[key] = createSchema<\n      TEventContract<\n        (typeof event)['payload'],\n        Extract<typeof key, string>,\n        undefined,\n        Options['name'] extends string ? Options['name'] : undefined\n      >\n    >({\n      ...event,\n      name: key,\n      namespace: undefined,\n      subscription: name as any,\n    })\n  }\n  return createSchema<\n    TSubscriptionContract<\n      SubOpt,\n      Options['events'],\n      Options['name'] extends string ? Options['name'] : undefined\n    >\n  >({\n    ...schemaOptions,\n    [Kind]: SubscriptionKind,\n    type: 'neemata:subscription',\n    events: _events,\n    name: name as any,\n    options: undefined as unknown as SubOpt,\n  })\n}\n\nexport const SubscriptionContract = Object.assign(_SubscriptionContract, {\n  withOptions: <Options extends SubcriptionOptions>() => {\n    return <\n      T extends {\n        events: Record<string, TAnyEventContract>\n        name?: string\n        schemaOptions?: ContractSchemaOptions\n      },\n    >(\n      options: T,\n    ) => _SubscriptionContract<T, Options>(options)\n  },\n})\n\nexport function IsSubscriptionContract(\n  contract: any,\n): contract is TAnySubscriptionContract {\n  return Kind in contract && contract[Kind] === SubscriptionKind\n}\n"],"version":3,"file":"subscription.js"}

package/dist/types/blob.js.map

@@ -1 +0,0 @@
-{"mappings":"AACA,SAAS,SAAS,aAAa;AAO/B,OAAO,MAAM,WAAW,CAACA,UAAuB,CAAE,MAChD,EAAE,OAA8B;CAC9B,QAAQ,CAAC,UAAU;AAEjB,MAAI,cAAc,OAAO;AACvB,OAAI,QAAQ,SAAS;IACnB,MAAM,OAAQ,MAAgC,SAAS;AACvD,eAAW,SAAS,eAAe,OAAO,QAAQ,SAAS;AACzD,WAAM,IAAI,MAAM;IACjB;GACF;EACF;AACD,SAAO;CACR;CACD,QAAQ,CAAC,UAAU;AACpB,EAAC","names":["options: BlobOptions"],"sources":["../../src/types/blob.ts"],"sourcesContent":["import type { ProtocolBlobInterface } from '@nmtjs/protocol'\nimport { t } from '@nmtjs/type'\n\nexport interface BlobOptions {\n  maxSize?: number\n  contentType?: string\n}\n\nexport const BlobType = (options: BlobOptions = {}) =>\n  t.custom<ProtocolBlobInterface>({\n    decode: (value) => {\n      // TODO: here should be some validation logic to check if the value is an actual blob\n      if ('metadata' in value) {\n        if (options.maxSize) {\n          const size = (value as ProtocolBlobInterface).metadata.size\n          if (typeof size !== 'undefined' && size > options.maxSize) {\n            throw new Error('Blob size unknown or exceeds maximum allowed size')\n          }\n        }\n      }\n      return value\n    },\n    encode: (value) => value,\n  })\n"],"version":3,"file":"blob.js"}

package/dist/utils.js.map

@@ -1 +0,0 @@
-{"mappings":"AAKA,OAAO,MAAM,aAAa,CACxBA,QACAC,SACG;AACH,QAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG;EAAE,GAAG;EAAG,MAAM;EAAG,GAAG;CAAM,CAAC,EAAC,CACxE;AACF;AAED,OAAO,MAAM,eAAe,CAAIC,WAAc,OAAO,OAAO,OAAO","names":["params: T","opts: { serviceName?: string; subscriptionName?: string }","schema: T"],"sources":["../src/utils.ts"],"sourcesContent":["export type ContractSchemaOptions = {\n  title?: string\n  description?: string\n}\n\nexport const applyNames = <T extends Record<string, { serviceName?: string }>>(\n  params: T,\n  opts: { serviceName?: string; subscriptionName?: string },\n) => {\n  return Object.fromEntries(\n    Object.entries(params).map(([k, v]) => [k, { ...v, name: k, ...opts }]),\n  )\n}\n\nexport const createSchema = <T>(schema: T) => Object.freeze(schema) as T\n"],"version":3,"file":"utils.js"}

package/src/constants.ts

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

package/src/index.ts

@@ -1,25 +0,0 @@
-import { APIContract } from './schemas/api.ts'
-import { EventContract } from './schemas/event.ts'
-import { NamespaceContract } from './schemas/namespace.ts'
-import { ProcedureContract } from './schemas/procedure.ts'
-import { SubscriptionContract } from './schemas/subscription.ts'
-import { BlobType } from './types/blob.ts'
-
-export * from './schemas/api.ts'
-export * from './schemas/event.ts'
-export * from './schemas/namespace.ts'
-export * from './schemas/procedure.ts'
-export * from './schemas/subscription.ts'
-
-export namespace contract {
-  export const procedure = ProcedureContract
-  export const event = EventContract
-  export const subscription = SubscriptionContract
-  export const namespace = NamespaceContract
-  export const api = APIContract
-  export const blob = BlobType
-}
-
-export { contract as c }
-
-export default contract

package/src/schemas/api.ts

@@ -1,104 +0,0 @@
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TEventContract } from './event.ts'
-import type { TAnyNamespaceContract, TNamespaceContract } from './namespace.ts'
-import type { TProcedureContract } from './procedure.ts'
-
-export const APIKind = Symbol('NeemataAPI')
-
-export type TAnyAPIContract = TAPIContract<
-  Record<string, TAnyNamespaceContract>
->
-
-export interface TAPIContract<
-  Namespaces extends Record<string, TAnyNamespaceContract> = {},
-> {
-  readonly [Kind]: typeof APIKind
-  readonly type: 'neemata:api'
-  readonly namespaces: {
-    [K in keyof Namespaces]: TNamespaceContract<
-      Namespaces[K]['procedures'],
-      Namespaces[K]['events'],
-      Extract<K, string>
-    >
-  }
-  readonly timeout?: number
-}
-
-export const APIContract = <
-  const Options extends {
-    namespaces: Record<string, TAnyNamespaceContract>
-    timeout?: number
-    schemaOptions?: ContractSchemaOptions
-  },
->(
-  options: Options,
-) => {
-  const { timeout, schemaOptions } = options
-
-  const _namespaces = {} as any
-
-  for (const namespaceKey in options.namespaces) {
-    const namespace = options.namespaces[namespaceKey]
-    const _procedures = {} as any
-    for (const procedureKey in namespace.procedures) {
-      const procedure = namespace.procedures[procedureKey]
-      _procedures[procedureKey] = createSchema<
-        TProcedureContract<
-          (typeof procedure)['input'],
-          (typeof procedure)['output'],
-          (typeof procedure)['stream'],
-          Extract<typeof procedureKey, string>,
-          Extract<typeof namespaceKey, string>
-        >
-      >({
-        ...procedure,
-        name: procedureKey,
-        namespace: namespaceKey,
-      })
-    }
-
-    const _events = {} as any
-    for (const eventKey in namespace.events) {
-      const event = namespace.events[eventKey]
-      _events[eventKey] = createSchema<
-        TEventContract<
-          (typeof event)['payload'],
-          Extract<typeof eventKey, string>,
-          undefined,
-          Extract<typeof namespaceKey, string>
-        >
-      >({
-        ...event,
-        subscription: undefined,
-        name: eventKey,
-        namespace: namespaceKey,
-      })
-    }
-
-    _namespaces[namespaceKey] = createSchema<
-      TNamespaceContract<
-        typeof _procedures,
-        typeof _events,
-        Extract<typeof namespaceKey, string>
-      >
-    >({
-      ...namespace,
-      procedures: _procedures,
-      events: _events,
-      name: namespaceKey,
-    })
-  }
-
-  return createSchema<TAPIContract<Options['namespaces']>>({
-    ...schemaOptions,
-    [Kind]: APIKind,
-    type: 'neemata:api',
-    namespaces: _namespaces,
-    timeout,
-  })
-}
-
-export function IsAPIContract(value: any): value is TAnyAPIContract {
-  return Kind in value && value[Kind] === APIKind
-}

package/src/schemas/event.ts

@@ -1,54 +0,0 @@
-import { type BaseType, t } from '@nmtjs/type'
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-
-export const EventKind = Symbol('NeemataEvent')
-
-export type TAnyEventContract = TEventContract<
-  BaseType,
-  string | undefined,
-  string | undefined,
-  string | undefined
->
-
-export interface TEventContract<
-  Payload extends BaseType = t.NeverType,
-  Name extends string | undefined = undefined,
-  Subscription extends string | undefined = undefined,
-  Namespace extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof EventKind
-  readonly type: 'neemata:event'
-  readonly name: Name
-  readonly subscription: Subscription
-  readonly namespace: Namespace
-  readonly payload: Payload
-}
-
-export const EventContract = <
-  Payload extends BaseType,
-  Name extends string | undefined = undefined,
->(options?: {
-  payload?: Payload
-  schemaOptions?: ContractSchemaOptions
-  name?: Name
-}) => {
-  const {
-    payload = t.never() as unknown as Payload,
-    schemaOptions = {},
-    name,
-  } = options ?? {}
-  return createSchema<TEventContract<Payload, Name>>({
-    ...schemaOptions,
-    [Kind]: EventKind,
-    type: 'neemata:event',
-    payload,
-    name: name as Name,
-    subscription: undefined,
-    namespace: undefined,
-  })
-}
-
-export function IsEventContract(value: any): value is TAnyEventContract {
-  return Kind in value && value[Kind] === EventKind
-}

package/src/schemas/namespace.ts

@@ -1,118 +0,0 @@
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TAnyEventContract, TEventContract } from './event.ts'
-import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts'
-
-export const NamespaceKind = Symbol('NeemataNamespace')
-
-export type TAnyNamespaceContract<
-  Procedures extends Record<string, TAnyProcedureContract> = Record<
-    string,
-    TAnyProcedureContract
-  >,
-> = TNamespaceContract<
-  Procedures,
-  Record<string, TAnyEventContract>,
-  string | undefined
->
-
-export interface TNamespaceContract<
-  Procedures extends Record<string, TAnyProcedureContract> = {},
-  Events extends Record<string, TAnyEventContract> = {},
-  Name extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof NamespaceKind
-  readonly type: 'neemata:namespace'
-  readonly name: Name
-  readonly procedures: {
-    [K in keyof Procedures]: TProcedureContract<
-      Procedures[K]['input'],
-      Procedures[K]['output'],
-      Procedures[K]['stream'],
-      Extract<K, string>,
-      Name
-    >
-  }
-  readonly events: {
-    [K in keyof Events]: TEventContract<
-      Events[K]['payload'],
-      Extract<K, string>,
-      undefined,
-      Name
-    >
-  }
-  readonly timeout?: number
-}
-
-export const NamespaceContract = <
-  const Options extends {
-    procedures: Record<string, TAnyProcedureContract>
-    events: Record<string, TAnyEventContract>
-    name?: string
-    timeout?: number
-    schemaOptions?: ContractSchemaOptions
-  },
->(
-  options: Options,
-) => {
-  const { name, timeout, schemaOptions = {} as ContractSchemaOptions } = options
-  const events: Record<string, any> = {}
-
-  for (const name in options.events) {
-    const event = options.events[name]
-    events[name] = createSchema<
-      TEventContract<
-        (typeof event)['payload'],
-        Extract<typeof name, string>,
-        undefined,
-        Options['name'] extends string ? Options['name'] : undefined
-      >
-    >({
-      ...event,
-      subscription: undefined,
-      name: name as any,
-      namespace: options?.name as any,
-    })
-  }
-
-  const procedures: Record<string, any> = {}
-
-  for (const name in options.procedures) {
-    const procedure: any = options.procedures[name]
-    procedures[name] = createSchema<
-      TProcedureContract<
-        (typeof procedure)['input'],
-        (typeof procedure)['output'],
-        (typeof procedure)['stream'],
-        Extract<typeof name, string>,
-        Options['name'] extends string ? Options['name'] : undefined
-      >
-    >({
-      ...procedure,
-      name: name as any,
-      namespace: options?.name as any,
-    })
-  }
-
-  return createSchema<
-    TNamespaceContract<
-      Options['procedures'],
-      Options['events'],
-      Options['name'] extends string ? Options['name'] : undefined
-    >
-  >({
-    ...schemaOptions,
-    [Kind]: NamespaceKind,
-    type: 'neemata:namespace',
-    name: name as any,
-    procedures: procedures as any,
-    events: events as any,
-    timeout,
-  })
-}
-
-export function IsNamespaceContract(
-  value: any,
-): value is TAnyNamespaceContract {
-  return Kind in value && value[Kind] === NamespaceKind
-}

package/src/schemas/procedure.ts

@@ -1,82 +0,0 @@
-import { type BaseType, t } from '@nmtjs/type'
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-
-export type TAnyProcedureContract = TProcedureContract<
-  BaseType,
-  BaseType,
-  BaseType | undefined,
-  string | undefined,
-  string | undefined
->
-
-export const ProcedureKind = Symbol('NeemataProcedure')
-
-export interface TProcedureContract<
-  Input extends BaseType,
-  Output extends BaseType,
-  Stream extends BaseType | undefined,
-  Name extends string | undefined = undefined,
-  Namespace extends string | undefined = undefined,
-> {
-  readonly [Kind]: typeof ProcedureKind
-  readonly type: 'neemata:procedure'
-  readonly name: Name
-  readonly namespace: Namespace
-  readonly input: Input
-  readonly output: Output
-  readonly stream: Stream
-  readonly timeout?: number
-}
-
-export const ProcedureContract = <
-  const Options extends {
-    input?: BaseType
-    output?: BaseType
-    stream?: BaseType | undefined
-    timeout?: number
-    schemaOptions?: ContractSchemaOptions
-    name?: string
-  },
->(
-  options: Options,
-) => {
-  const {
-    input = t.never() as any,
-    output = t.never() as any,
-    stream = undefined as any,
-    name = undefined as any,
-    timeout,
-    schemaOptions = {},
-  } = options
-  return createSchema<
-    TProcedureContract<
-      Options['input'] extends BaseType ? Options['input'] : t.NeverType,
-      Options['output'] extends BaseType ? Options['output'] : t.NeverType,
-      Options['stream'] extends BaseType ? Options['stream'] : undefined,
-      Options['name'] extends string ? Options['name'] : undefined
-    >
-  >({
-    ...schemaOptions,
-    [Kind]: ProcedureKind,
-    type: 'neemata:procedure',
-    input,
-    output,
-    stream,
-    name,
-    timeout,
-    namespace: undefined,
-  })
-}
-
-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/subscription.ts

@@ -1,96 +0,0 @@
-import { Kind } from '../constants.ts'
-import { type ContractSchemaOptions, createSchema } from '../utils.ts'
-import type { TAnyEventContract, TEventContract } from './event.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'], Extract<K, string>, Name>
-      : 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]
-    _events[key] = createSchema<
-      TEventContract<
-        (typeof event)['payload'],
-        Extract<typeof key, string>,
-        undefined,
-        Options['name'] extends string ? Options['name'] : undefined
-      >
-    >({
-      ...event,
-      name: key,
-      namespace: undefined,
-      subscription: name as any,
-    })
-  }
-  return createSchema<
-    TSubscriptionContract<
-      SubOpt,
-      Options['events'],
-      Options['name'] extends string ? Options['name'] : undefined
-    >
-  >({
-    ...schemaOptions,
-    [Kind]: SubscriptionKind,
-    type: 'neemata:subscription',
-    events: _events,
-    name: name as any,
-    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

@@ -1,24 +0,0 @@
-import type { ProtocolBlobInterface } from '@nmtjs/protocol'
-import { t } from '@nmtjs/type'
-
-export interface BlobOptions {
-  maxSize?: number
-  contentType?: string
-}
-
-export const BlobType = (options: BlobOptions = {}) =>
-  t.custom<ProtocolBlobInterface>({
-    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 as ProtocolBlobInterface).metadata.size
-          if (typeof size !== 'undefined' && size > options.maxSize) {
-            throw new Error('Blob size unknown or exceeds maximum allowed size')
-          }
-        }
-      }
-      return value
-    },
-    encode: (value) => value,
-  })

package/src/utils.ts

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