@nmtjs/contract 0.13.1 → 0.14.1

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-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/router.ts';
 export * from './schemas/subscription.ts';
 export declare namespace contract {
     const procedure: <const Options extends {
@@ -12,36 +11,35 @@ export declare namespace contract {
         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?: {
+    }>(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, undefined, undefined>;
+    }) => 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"] extends string ? Options["name"] : undefined>) & {
+    }, 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"] extends string ? T["name"] : undefined>;
+        }>(options: T) => import("./schemas/subscription.ts").TSubscriptionContract<Options, T["events"], T["name"]>;
     };
-    const namespace: <const Options extends {
-        procedures: Record<string, import("./schemas/procedure.ts").TAnyProcedureContract>;
-        events: Record<string, import("./schemas/event.ts").TAnyEventContract>;
+    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/namespace.ts").TNamespaceContract<Options["procedures"], Options["events"], Options["name"] extends string ? Options["name"] : undefined>;
+    }>(options: Options) => import("./schemas/router.ts").TRouterContract<Options["routes"], Options["name"] extends string ? Options["name"] : undefined>;
     const api: <const Options extends {
-        namespaces: Record<string, import("./schemas/namespace.ts").TAnyNamespaceContract>;
+        router: import("./schemas/router.ts").TAnyRouterContract;
         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>;
+    }>(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 +1,20 @@
-// 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";
 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/namespace.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.namespace = NamespaceContract;
+    contract.router = RouterContract;
     contract.api = APIContract;
     contract.blob = BlobType;
 })(contract || (contract = {}));

package/dist/schemas/api.d.ts

@@ -1,19 +1,17 @@
+import type { ContractSchemaOptions } from '../utils.ts';
+import type { TAnyRouterContract } from './router.ts';
 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> = {}> {
+export type TAnyAPIContract = TAPIContract<TAnyRouterContract>;
+export interface TAPIContract<Router extends TAnyRouterContract = TAnyRouterContract> {
     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 router: Router;
     readonly timeout?: number;
 }
 export declare const APIContract: <const Options extends {
-    namespaces: Record<string, TAnyNamespaceContract>;
+    router: TAnyRouterContract;
     timeout?: number;
     schemaOptions?: ContractSchemaOptions;
-}>(options: Options) => TAPIContract<Options["namespaces"]>;
+}>(options: Options) => TAPIContract<Options["router"]>;
 export declare function IsAPIContract(value: any): value is TAnyAPIContract;

package/dist/schemas/api.js

@@ -2,41 +2,12 @@ import { Kind } from "../constants.js";
 import { createSchema } from "../utils.js";
 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,
-        });
-    }
+    const { router, timeout, schemaOptions } = options;
     return createSchema({
         ...schemaOptions,
         [Kind]: APIKind,
         type: 'neemata:api',
-        namespaces: _namespaces,
+        router,
         timeout,
     });
 };

package/dist/schemas/event.d.ts

@@ -1,19 +1,20 @@
-import { type BaseType, t } from '@nmtjs/type';
+import type { BaseType } from '@nmtjs/type';
+import { t } from '@nmtjs/type';
+import type { ContractSchemaOptions } from '../utils.ts';
+import type { SubcriptionOptions } from './subscription.ts';
 import { Kind } from '../constants.ts';
-import { 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> {
+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 subscription: Subscription;
-    readonly namespace: Namespace;
     readonly payload: Payload;
+    readonly options: Options;
 }
-export declare const EventContract: <Payload extends BaseType, Name extends string | undefined = undefined>(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, undefined, undefined>;
+}) => TEventContract<Payload, Name, Options>;
 export declare function IsEventContract(value: any): value is TAnyEventContract;

package/dist/schemas/event.js

@@ -3,15 +3,14 @@ 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, } = options ?? {};
+    const { payload = t.never(), schemaOptions = {}, name = undefined, } = options ?? {};
     return createSchema({
         ...schemaOptions,
         [Kind]: EventKind,
         type: 'neemata:event',
         payload,
-        name: name,
-        subscription: undefined,
-        namespace: undefined,
+        name,
+        options: undefined,
     });
 };
 export function IsEventContract(value) {

package/dist/schemas/procedure.d.ts

@@ -1,13 +1,13 @@
-import { type BaseType, t } from '@nmtjs/type';
+import type { BaseType } from '@nmtjs/type';
+import type { NeverType } from '@nmtjs/type/never';
+import type { ContractSchemaOptions } from '../utils.ts';
 import { Kind } from '../constants.ts';
-import { type ContractSchemaOptions } from '../utils.ts';
-export type TAnyProcedureContract = TProcedureContract<BaseType, BaseType, BaseType | undefined, string | undefined, string | undefined>;
+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, Namespace extends string | undefined = undefined> {
+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 namespace: Namespace;
     readonly input: Input;
     readonly output: Output;
     readonly stream: Stream;
@@ -20,6 +20,6 @@ export declare const ProcedureContract: <const Options extends {
     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>;
+}>(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

@@ -13,7 +13,6 @@ export const ProcedureContract = (options) => {
         stream,
         name,
         timeout,
-        namespace: undefined,
     });
 };
 export function IsProcedureContract(contract) {

package/dist/schemas/router.d.ts

@@ -0,0 +1,22 @@
+import type { ContractSchemaOptions } from '../utils.ts';
+import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts';
+import { Kind } from '../constants.ts';
+export declare const RouterKind: unique symbol;
+export type TAnyRouterContract<RouteContracts extends Record<string, TRouteContract> = Record<string, TRouteContract>> = 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

@@ -0,0 +1,41 @@
+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,6 +1,6 @@
-import { Kind } from '../constants.ts';
-import { type ContractSchemaOptions } from '../utils.ts';
+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>;
@@ -10,18 +10,18 @@ export interface TSubscriptionContract<Options extends SubcriptionOptions = null
     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;
+        [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"] extends string ? Options["name"] : undefined>) & {
+}, 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"] extends string ? T["name"] : undefined>;
+    }>(options: T) => TSubscriptionContract<Options, T["events"], T["name"]>;
 };
 export declare function IsSubscriptionContract(contract: any): contract is TAnySubscriptionContract;

package/dist/schemas/subscription.js

@@ -1,17 +1,13 @@
 import { Kind } from "../constants.js";
-import { createSchema } from "../utils.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];
-        _events[key] = createSchema({
-            ...event,
-            name: key,
-            namespace: undefined,
-            subscription: name,
-        });
+        const fullName = concatFullName(name, key);
+        _events[key] = createSchema({ ...event, name: fullName });
     }
     return createSchema({
         ...schemaOptions,

package/dist/utils.d.ts

@@ -15,3 +15,4 @@ export declare const applyNames: <T extends Record<string, {
     };
 };
 export declare const createSchema: <T>(schema: T) => T;
+export declare const concatFullName: (parent: string | undefined, name: string) => string;

package/dist/utils.js

@@ -2,3 +2,6 @@ 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;
+};

package/package.json

@@ -9,15 +9,15 @@
     }
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.13.1",
-    "@nmtjs/type": "0.13.1"
+    "@nmtjs/protocol": "0.14.1",
+    "@nmtjs/type": "0.14.1"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.13.1",
+  "version": "0.14.1",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"

package/dist/schemas/namespace.d.ts

@@ -1,26 +0,0 @@
-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,37 +0,0 @@
-import { Kind } from "../constants.js";
-import { createSchema } from "../utils.js";
-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: 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;
-}