@nmtjs/contract 0.15.0-beta.1 → 0.15.0-beta.2

package/dist/constants.js

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

package/dist/index.js

@@ -0,0 +1,19 @@
+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/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.blob = BlobType;
+})(contract || (contract = {}));
+export { contract as c };
+export default contract;

package/dist/schemas/event.js

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

@@ -0,0 +1,23 @@
+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.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.js

@@ -0,0 +1,28 @@
+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.js

@@ -0,0 +1,35 @@
+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`,
+                        });
+                    }
+                }
+            }
+            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.',
+                });
+            }
+        },
+    },
+});

package/dist/utils.js

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

@@ -5,8 +5,8 @@
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "@nmtjs/protocol": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1"
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2"
   },
   "devDependencies": {
     "zod": "^4.1.0"
@@ -16,7 +16,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",