@nmtjs/contract 0.14.4 → 0.15.0-beta.1

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/package.json

@@ -2,24 +2,25 @@
   "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/type": "0.14.4",
-    "@nmtjs/protocol": "0.14.4"
+    "@nmtjs/protocol": "0.15.0-beta.1",
+    "@nmtjs/type": "0.15.0-beta.1"
+  },
+  "devDependencies": {
+    "zod": "^4.1.0"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.4",
+  "version": "0.15.0-beta.1",
   "scripts": {
+    "clean-build": "rm -rf ./dist",
     "build": "tsc",
+    "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/constants.d.ts

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

package/dist/constants.js

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

package/dist/index.d.ts

@@ -1,45 +0,0 @@
-export * from './schemas/api.ts';
-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?: 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 ? 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>;
-    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 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 };
-export default contract;

package/dist/index.js

@@ -1,22 +0,0 @@
-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";
-export * from "./schemas/subscription.js";
-export var contract;
-(function (contract) {
-    contract.procedure = ProcedureContract;
-    contract.event = EventContract;
-    contract.subscription = SubscriptionContract;
-    contract.router = RouterContract;
-    contract.api = APIContract;
-    contract.blob = BlobType;
-})(contract || (contract = {}));
-export { contract as c };
-export default contract;

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;
-}

package/dist/schemas/event.d.ts

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

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

package/dist/schemas/procedure.d.ts

@@ -1,25 +0,0 @@
-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 declare const ProcedureKind: unique symbol;
-export interface TProcedureContract<Input extends BaseType, Output extends BaseType, Stream extends BaseType | 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?: BaseType | 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>;
-export declare function IsProcedureContract(contract: any): contract is TAnyProcedureContract;
-export declare function IsStreamProcedureContract(contract: any): contract is TAnyProcedureContract;

package/dist/schemas/procedure.js

@@ -1,23 +0,0 @@
-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';
-}

package/dist/schemas/router.d.ts

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

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

package/dist/schemas/subscription.d.ts

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

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

package/dist/types/blob.d.ts

@@ -1,7 +0,0 @@
-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,16 +0,0 @@
-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');
-                }
-            }
-        }
-        return value;
-    },
-    encode: (value) => value,
-});

package/dist/utils.d.ts

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

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