@nmtjs/contract 0.14.5 → 0.15.0-beta.2

package/LICENSE.md

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

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/dist/index.js

@@ -1,10 +1,8 @@
-import { APIContract } from "./schemas/api.js";
 import { EventContract } from "./schemas/event.js";
 import { ProcedureContract } from "./schemas/procedure.js";
 import { RouterContract } from "./schemas/router.js";
 import { SubscriptionContract } from "./schemas/subscription.js";
 import { BlobType } from "./types/blob.js";
-export * from "./schemas/api.js";
 export * from "./schemas/event.js";
 export * from "./schemas/procedure.js";
 export * from "./schemas/router.js";
@@ -15,7 +13,6 @@ export var contract;
     contract.event = EventContract;
     contract.subscription = SubscriptionContract;
     contract.router = RouterContract;
-    contract.api = APIContract;
     contract.blob = BlobType;
 })(contract || (contract = {}));
 export { contract as c };

package/dist/types/blob.js

@@ -1,16 +1,35 @@
-import { t } from '@nmtjs/type';
-export const BlobType = (options = {}) => t.custom({
-    decode: (value) => {
-        // TODO: here should be some validation logic to check if the value is an actual blob
-        if ('metadata' in value) {
-            if (options.maxSize) {
-                const size = value.metadata.size;
-                if (typeof size !== 'undefined' && size > options.maxSize) {
-                    throw new Error('Blob size unknown or exceeds maximum allowed size');
+import { isBlobInterface } from '@nmtjs/protocol';
+import { CustomType } from '@nmtjs/type/custom';
+export const BlobType = (options = {}) => CustomType.factory({
+    decode: (value) => value,
+    encode: (value) => value,
+    validation: {
+        decode(value, { addIssue }) {
+            if (isBlobInterface(value)) {
+                if (options.maxSize) {
+                    const size = value.metadata.size;
+                    if (typeof size !== 'undefined' && size > options.maxSize) {
+                        addIssue({
+                            code: 'custom',
+                            message: `Blob size unknown or exceeds maximum allowed size of ${options.maxSize} bytes`,
+                        });
+                    }
                 }
             }
-        }
-        return value;
+            else {
+                addIssue({
+                    code: 'custom',
+                    message: 'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
+                });
+            }
+        },
+        encode(value, { addIssue }) {
+            if (!isBlobInterface(value)) {
+                addIssue({
+                    code: 'custom',
+                    message: 'Value is not a Neemata Blob. Make sure to use transport that supports encoded streams.',
+                });
+            }
+        },
     },
-    encode: (value) => value,
 });

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/protocol": "0.14.5",
-    "@nmtjs/type": "0.14.5"
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2"
+  },
+  "devDependencies": {
+    "zod": "^4.1.0"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.5",
+  "version": "0.15.0-beta.2",
   "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/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/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/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/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/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/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/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;