@nmtjs/contract 0.14.0 → 0.14.1

package/dist/index.d.ts

@@ -30,7 +30,6 @@ export declare namespace contract {
     };
     const router: <const Options extends {
         routes: Record<string, import("./schemas/router.ts").TRouteContract>;
-        events?: Record<string, import("./schemas/event.ts").TAnyEventContract>;
         name?: string;
         timeout?: number;
         schemaOptions?: import("./utils.ts").ContractSchemaOptions;

package/dist/schemas/router.d.ts

@@ -1,5 +1,4 @@
 import type { ContractSchemaOptions } from '../utils.ts';
-import type { TAnyEventContract } from './event.ts';
 import type { TAnyProcedureContract, TProcedureContract } from './procedure.ts';
 import { Kind } from '../constants.ts';
 export declare const RouterKind: unique symbol;
@@ -16,7 +15,6 @@ export interface TRouterContract<Routes extends Record<string, TRouteContract> =
 }
 export declare const RouterContract: <const Options extends {
     routes: Record<string, TRouteContract>;
-    events?: Record<string, TAnyEventContract>;
     name?: string;
     timeout?: number;
     schemaOptions?: ContractSchemaOptions;

package/dist/schemas/router.js

@@ -1,34 +1,10 @@
 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 events = {};
-    for (const eventName in options.events || {}) {
-        const event = options.events[eventName];
-        const fullName = concatFullName(name, eventName);
-        events[eventName] = createSchema({
-            ...event,
-            subscription: undefined,
-            name: fullName,
-        });
-    }
-    const routes = {};
-    for (const routeName in options.routes) {
-        const route = options.routes[routeName];
-        if (IsRouterContract(route)) {
-            const nestedName = concatFullName(name, routeName);
-            routes[routeName] = createSchema({
-                ...route,
-                name: nestedName,
-                routes: processNestedRoutes(route.routes, nestedName),
-            });
-        }
-        else {
-            const fullName = concatFullName(name, routeName);
-            routes[routeName] = createSchema({ ...route, name: fullName });
-        }
-    }
+    const routes = processNestedRoutes(options.routes, name);
     return createSchema({
         ...schemaOptions,
         [Kind]: RouterKind,
@@ -50,10 +26,13 @@ function processNestedRoutes(routes, parentName) {
                 routes: processNestedRoutes(route.routes, nestedName),
             });
         }
-        else {
+        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;
 }

package/package.json

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