@hostwebhook/node-types 1.0.0

package/dist/connections.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Node Connection Registry — THE single source of truth for what each node
+ * type can receive from and send to.
+ *
+ * Used by: API (pipeline dispatch), Broker (agent wiring), Dashboard (canvas validation)
+ *
+ * Adding a new node type = add 1 entry here. All repos import from this package.
+ */
+import type { NodeType, NodeConnectionConfig } from './types';
+export declare const NODE_CONNECTIONS: Record<NodeType, NodeConnectionConfig>;
+export declare function canReceiveFrom(targetType: NodeType, sourceType: NodeType): boolean;
+export declare function canReceiveFromNodes(nodeType: NodeType): boolean;
+export declare function canSendToNodes(nodeType: NodeType): boolean;
+export declare function isTerminal(nodeType: NodeType): boolean;
+export declare function isNodeType(type: string): type is NodeType;
+/** All valid node type strings */
+export declare const ALL_NODE_TYPES: NodeType[];

package/dist/connections.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Node Connection Registry — THE single source of truth for what each node
+ * type can receive from and send to.
+ *
+ * Used by: API (pipeline dispatch), Broker (agent wiring), Dashboard (canvas validation)
+ *
+ * Adding a new node type = add 1 entry here. All repos import from this package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_NODE_TYPES = exports.NODE_CONNECTIONS = void 0;
+exports.canReceiveFrom = canReceiveFrom;
+exports.canReceiveFromNodes = canReceiveFromNodes;
+exports.canSendToNodes = canSendToNodes;
+exports.isTerminal = isTerminal;
+exports.isNodeType = isNodeType;
+/** All node types that can appear as pipeline outputs */
+const PROCESSING_OUTPUTS = [
+    'endpoint', 'router', 'filter', 'transform', 'cache', 'rateLimiter',
+    'aggregator', 'conditional', 'delay', 'schemaValidator',
+    'emailAction', 'httpAction', 'mongoAction', 'notificationAction', 'sheetsAction',
+];
+/** Standard processing input sources */
+const STANDARD_INPUTS = [
+    'endpoint', 'scheduledWebhook', 'router', 'filter', 'transform',
+    'cache', 'rateLimiter', 'aggregator', 'conditional', 'delay', 'schemaValidator',
+];
+/** Action nodes that can chain (non-terminal) */
+const CHAINABLE_ACTIONS = ['httpAction', 'mongoAction', 'sheetsAction'];
+/** Full input list for action nodes (standard + chainable actions) */
+const ACTION_INPUTS = [...STANDARD_INPUTS, ...CHAINABLE_ACTIONS];
+exports.NODE_CONNECTIONS = {
+    // ── Source nodes ──
+    endpoint: { acceptsInputFrom: [], canOutputTo: PROCESSING_OUTPUTS },
+    scheduledWebhook: { acceptsInputFrom: [], canOutputTo: PROCESSING_OUTPUTS },
+    // ── Pipeline processing nodes ──
+    filter: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    transform: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    schemaValidator: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    conditional: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS, special: { hasBranches: true } },
+    delay: { acceptsInputFrom: ['endpoint', 'filter', 'transform', 'cache', 'rateLimiter', 'aggregator', 'conditional', 'delay', 'schemaValidator'], canOutputTo: PROCESSING_OUTPUTS },
+    rateLimiter: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    aggregator: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    cache: { acceptsInputFrom: STANDARD_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    ai: { acceptsInputFrom: [...ACTION_INPUTS], canOutputTo: PROCESSING_OUTPUTS },
+    // ── Flow control nodes ──
+    merge: { acceptsInputFrom: ['endpoint', 'filter', 'transform', 'cache', 'rateLimiter', 'aggregator', 'conditional', 'delay', 'schemaValidator'], canOutputTo: PROCESSING_OUTPUTS },
+    approval: { acceptsInputFrom: ['endpoint', 'filter', 'transform'], canOutputTo: ['endpoint', 'filter', 'transform', 'emailAction', 'httpAction', 'mongoAction', 'notificationAction', 'sheetsAction'], special: { hasRejectionOutputNodes: true } },
+    // ── Routing nodes ──
+    router: { acceptsInputFrom: ['endpoint', 'scheduledWebhook', 'filter', 'transform'], canOutputTo: ['endpoint', 'notificationAction', 'filter', 'transform', 'emailAction', 'httpAction', 'mongoAction', 'sheetsAction'] },
+    fanout: { acceptsInputFrom: ['endpoint'], canOutputTo: [] },
+    // ── Action nodes ──
+    emailAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: [], special: { isTerminal: true } },
+    httpAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    mongoAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    notificationAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: [], special: { isTerminal: true } },
+    sheetsAction: { acceptsInputFrom: ACTION_INPUTS, canOutputTo: PROCESSING_OUTPUTS },
+    // ── Monitoring ──
+    alert: { acceptsInputFrom: ['endpoint', 'scheduledWebhook'], canOutputTo: [], special: { isTerminal: true } },
+};
+// ── Helper functions ──
+function canReceiveFrom(targetType, sourceType) {
+    return exports.NODE_CONNECTIONS[targetType]?.acceptsInputFrom.includes(sourceType) ?? false;
+}
+function canReceiveFromNodes(nodeType) {
+    return (exports.NODE_CONNECTIONS[nodeType]?.acceptsInputFrom.length ?? 0) > 0;
+}
+function canSendToNodes(nodeType) {
+    return (exports.NODE_CONNECTIONS[nodeType]?.canOutputTo.length ?? 0) > 0;
+}
+function isTerminal(nodeType) {
+    return exports.NODE_CONNECTIONS[nodeType]?.special?.isTerminal ?? false;
+}
+function isNodeType(type) {
+    return type in exports.NODE_CONNECTIONS;
+}
+/** All valid node type strings */
+exports.ALL_NODE_TYPES = Object.keys(exports.NODE_CONNECTIONS);

package/dist/dispatch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * API dispatch config — service names, collection names, filter support.
+ * Only imported by the API. Broker and Dashboard don't need this.
+ */
+import type { NodeType, NodeDispatchConfig } from './types';
+export declare const NODE_DISPATCH: Record<NodeType, NodeDispatchConfig>;
+/** Get all MongoDB collection names for cascade cleanup */
+export declare function getAllNodeCollections(): string[];
+/** Find dispatch config by node type */
+export declare function getNodeDispatchConfig(type: string): NodeDispatchConfig | undefined;

package/dist/dispatch.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * API dispatch config — service names, collection names, filter support.
+ * Only imported by the API. Broker and Dashboard don't need this.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_DISPATCH = void 0;
+exports.getAllNodeCollections = getAllNodeCollections;
+exports.getNodeDispatchConfig = getNodeDispatchConfig;
+exports.NODE_DISPATCH = {
+    // ── Pipeline processing (generic dispatch) ──
+    filter: { service: 'filterNodesService', collection: 'filternodes', hasFilters: true, outputFields: ['outputNodes'], customDispatch: false },
+    transform: { service: 'transformNodesService', collection: 'transformnodes', hasFilters: false, outputFields: ['outputNodes'], customDispatch: false },
+    schemaValidator: { service: 'schemaValidatorsService', collection: 'schemavalidators', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    delay: { service: 'delayNodesService', collection: 'delaynodes', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true },
+    rateLimiter: { service: 'rateLimiterNodesService', collection: 'ratelimiternodes', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    aggregator: { service: 'aggregatorNodesService', collection: 'aggregatornodes', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true },
+    cache: { service: 'cacheNodesService', collection: 'cachenodes', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    ai: { service: 'aiNodesService', collection: 'ainodes', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true },
+    // ── Flow control ──
+    conditional: { service: 'conditionalNodesService', collection: 'conditionalnodes', hasFilters: false, outputFields: ['outputNodes', 'elseOutputNodes'], customDispatch: true },
+    merge: { service: 'mergeNodesService', collection: 'mergenodes', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    approval: { service: 'approvalNodesService', collection: 'approvalnodes', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    // ── Routing ──
+    router: { service: 'routersService', collection: 'routers', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    // ── Action nodes ──
+    emailAction: { service: 'emailActionsService', collection: 'emailactions', hasFilters: true, outputFields: [], customDispatch: true },
+    httpAction: { service: 'httpActionsService', collection: 'httpactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true },
+    mongoAction: { service: 'mongoActionsService', collection: 'mongoactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true },
+    notificationAction: { service: 'notificationActionsService', collection: 'notificationactions', hasFilters: true, outputFields: [], customDispatch: true },
+    sheetsAction: { service: 'sheetsActionsService', collection: 'sheetsactions', hasFilters: true, outputFields: ['outputNodes'], customDispatch: true },
+    // ── Source + monitoring ──
+    fanout: { service: 'fanOutService', collection: 'fanouts', hasFilters: true, outputFields: [], customDispatch: true },
+    alert: { service: 'alertService', collection: 'alerts', hasFilters: false, outputFields: [], customDispatch: true },
+    endpoint: { service: 'endpointsService', collection: 'endpoints', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+    scheduledWebhook: { service: 'scheduledWebhooksService', collection: 'scheduledwebhooks', hasFilters: false, outputFields: ['outputNodes'], customDispatch: true },
+};
+/** Get all MongoDB collection names for cascade cleanup */
+function getAllNodeCollections() {
+    return Object.values(exports.NODE_DISPATCH).map(n => n.collection);
+}
+/** Find dispatch config by node type */
+function getNodeDispatchConfig(type) {
+    return exports.NODE_DISPATCH[type];
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { NodeType, NodeRole, HandlePosition, NodeConnectionConfig, NodeUIConfig, NodeDispatchConfig, PrefixMapping, } from './types';
+export { NODE_CONNECTIONS, canReceiveFrom, canReceiveFromNodes, canSendToNodes, isTerminal, isNodeType, ALL_NODE_TYPES, } from './connections';
+export { NODE_UI, PREFIX_TO_TYPE, resolveNodeId, } from './ui';
+export { NODE_DISPATCH, getAllNodeCollections, getNodeDispatchConfig, } from './dispatch';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeDispatchConfig = exports.getAllNodeCollections = exports.NODE_DISPATCH = exports.resolveNodeId = exports.PREFIX_TO_TYPE = exports.NODE_UI = exports.ALL_NODE_TYPES = exports.isNodeType = exports.isTerminal = exports.canSendToNodes = exports.canReceiveFromNodes = exports.canReceiveFrom = exports.NODE_CONNECTIONS = void 0;
+// ── Connection rules (used by ALL repos) ──
+var connections_1 = require("./connections");
+Object.defineProperty(exports, "NODE_CONNECTIONS", { enumerable: true, get: function () { return connections_1.NODE_CONNECTIONS; } });
+Object.defineProperty(exports, "canReceiveFrom", { enumerable: true, get: function () { return connections_1.canReceiveFrom; } });
+Object.defineProperty(exports, "canReceiveFromNodes", { enumerable: true, get: function () { return connections_1.canReceiveFromNodes; } });
+Object.defineProperty(exports, "canSendToNodes", { enumerable: true, get: function () { return connections_1.canSendToNodes; } });
+Object.defineProperty(exports, "isTerminal", { enumerable: true, get: function () { return connections_1.isTerminal; } });
+Object.defineProperty(exports, "isNodeType", { enumerable: true, get: function () { return connections_1.isNodeType; } });
+Object.defineProperty(exports, "ALL_NODE_TYPES", { enumerable: true, get: function () { return connections_1.ALL_NODE_TYPES; } });
+// ── UI config (Dashboard only) ──
+var ui_1 = require("./ui");
+Object.defineProperty(exports, "NODE_UI", { enumerable: true, get: function () { return ui_1.NODE_UI; } });
+Object.defineProperty(exports, "PREFIX_TO_TYPE", { enumerable: true, get: function () { return ui_1.PREFIX_TO_TYPE; } });
+Object.defineProperty(exports, "resolveNodeId", { enumerable: true, get: function () { return ui_1.resolveNodeId; } });
+// ── Dispatch config (API only) ──
+var dispatch_1 = require("./dispatch");
+Object.defineProperty(exports, "NODE_DISPATCH", { enumerable: true, get: function () { return dispatch_1.NODE_DISPATCH; } });
+Object.defineProperty(exports, "getAllNodeCollections", { enumerable: true, get: function () { return dispatch_1.getAllNodeCollections; } });
+Object.defineProperty(exports, "getNodeDispatchConfig", { enumerable: true, get: function () { return dispatch_1.getNodeDispatchConfig; } });

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+/** All valid node type identifiers */
+export type NodeType = 'endpoint' | 'scheduledWebhook' | 'filter' | 'transform' | 'schemaValidator' | 'conditional' | 'delay' | 'rateLimiter' | 'aggregator' | 'cache' | 'ai' | 'merge' | 'approval' | 'router' | 'fanout' | 'emailAction' | 'httpAction' | 'mongoAction' | 'notificationAction' | 'sheetsAction' | 'alert';
+/** Node role in the pipeline */
+export type NodeRole = 'source' | 'processing' | 'flowControl' | 'routing' | 'action' | 'monitoring';
+/** Handle positions on the canvas node */
+export type HandlePosition = 'left' | 'right' | 'top' | 'bottom';
+/** Connection rules — which node types can connect to/from this node */
+export interface NodeConnectionConfig {
+    acceptsInputFrom: NodeType[];
+    canOutputTo: NodeType[];
+    special?: {
+        hasRejectionOutputNodes?: boolean;
+        hasBranches?: boolean;
+        isTerminal?: boolean;
+    };
+}
+/** UI-specific config for the dashboard canvas */
+export interface NodeUIConfig {
+    fromNodes: boolean;
+    toNodes: boolean;
+    isSource?: boolean;
+    inputHandles?: HandlePosition[];
+    outputHandles?: HandlePosition[];
+    dotHandles?: {
+        input?: string[];
+        output?: string[];
+    };
+    special?: {
+        rejectionEndpoints?: string;
+        hasBranches?: boolean;
+        isTerminal?: boolean;
+        connectModal?: 'branch' | 'rule';
+        routerTargetLabel?: string;
+    };
+}
+/** API dispatch config — how the event pipeline processes each node */
+export interface NodeDispatchConfig {
+    service: string;
+    collection: string;
+    hasFilters: boolean;
+    outputFields: string[];
+    customDispatch: boolean;
+}
+/** Canvas prefix → node type mapping */
+export interface PrefixMapping {
+    prefix: string;
+    type: NodeType;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Dashboard UI config — handle positions, dot visibility, canvas prefixes.
+ * Only imported by the Dashboard. Broker and API don't need this.
+ */
+import type { NodeType, NodeUIConfig, PrefixMapping } from './types';
+export declare const NODE_UI: Record<NodeType, NodeUIConfig>;
+/** Canvas prefix → node type mapping (used by FlowCanvas to identify node type from XYFlow node ID) */
+export declare const PREFIX_TO_TYPE: PrefixMapping[];
+/** Resolve canvas node ID to { type, entityId } */
+export declare function resolveNodeId(canvasId: string): {
+    type: NodeType;
+    entityId: string;
+} | null;

package/dist/ui.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Dashboard UI config — handle positions, dot visibility, canvas prefixes.
+ * Only imported by the Dashboard. Broker and API don't need this.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFIX_TO_TYPE = exports.NODE_UI = void 0;
+exports.resolveNodeId = resolveNodeId;
+exports.NODE_UI = {
+    // ── Source nodes ──
+    endpoint: { fromNodes: true, toNodes: true, isSource: true, inputHandles: ['left', 'top'], outputHandles: ['right', 'bottom'] },
+    scheduledWebhook: { fromNodes: false, toNodes: true, isSource: true, outputHandles: ['right', 'bottom'], dotHandles: { output: ['right-out', 'bottom-out'] } },
+    // ── Pipeline processing nodes ──
+    filter: { fromNodes: true, toNodes: true },
+    transform: { fromNodes: true, toNodes: true },
+    schemaValidator: { fromNodes: true, toNodes: true },
+    conditional: { fromNodes: true, toNodes: true, outputHandles: ['right', 'bottom'], special: { hasBranches: true, connectModal: 'branch' } },
+    delay: { fromNodes: true, toNodes: true },
+    rateLimiter: { fromNodes: true, toNodes: true },
+    aggregator: { fromNodes: true, toNodes: true },
+    cache: { fromNodes: true, toNodes: true },
+    ai: { fromNodes: true, toNodes: true },
+    // ── Flow control nodes ──
+    merge: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'] },
+    approval: { fromNodes: true, toNodes: true, outputHandles: ['right', 'bottom'], special: { rejectionEndpoints: 'rejectionEndpointIds' } },
+    // ── Routing nodes ──
+    router: { fromNodes: true, toNodes: true, outputHandles: ['right', 'bottom'], dotHandles: { output: ['right-out', 'bottom-out'] }, special: { connectModal: 'rule' } },
+    fanout: { fromNodes: true, toNodes: false },
+    // ── Action nodes ──
+    emailAction: { fromNodes: true, toNodes: false, inputHandles: ['left', 'top'], dotHandles: { input: ['left-in', 'top-in'] }, special: { isTerminal: true, routerTargetLabel: 'email' } },
+    httpAction: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'], dotHandles: { input: ['left-in', 'top-in'], output: ['right-out', 'bottom-out'] } },
+    mongoAction: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'], dotHandles: { input: ['left-in', 'top-in'], output: ['right-out', 'bottom-out'] } },
+    notificationAction: { fromNodes: true, toNodes: false, inputHandles: ['left', 'top'], dotHandles: { input: ['left-in', 'top-in'] }, special: { isTerminal: true, routerTargetLabel: 'notification' } },
+    sheetsAction: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'], dotHandles: { input: ['left-in', 'top-in'], output: ['right-out', 'bottom-out'] } },
+    // ── Monitoring ──
+    alert: { fromNodes: true, toNodes: false, inputHandles: ['bottom'], special: { isTerminal: true } },
+};
+/** Canvas prefix → node type mapping (used by FlowCanvas to identify node type from XYFlow node ID) */
+exports.PREFIX_TO_TYPE = [
+    { prefix: 'ep-', type: 'endpoint' },
+    { prefix: 'sw-', type: 'scheduledWebhook' },
+    { prefix: 'fo-', type: 'fanout' },
+    { prefix: 'al-', type: 'alert' },
+    { prefix: 'ea-', type: 'emailAction' },
+    { prefix: 'ha-', type: 'httpAction' },
+    { prefix: 'ma-', type: 'mongoAction' },
+    { prefix: 'na-', type: 'notificationAction' },
+    { prefix: 'ro-', type: 'router' },
+    { prefix: 'fi-', type: 'filter' },
+    { prefix: 'tr-', type: 'transform' },
+    { prefix: 'sv-', type: 'schemaValidator' },
+    { prefix: 'delay-', type: 'delay' },
+    { prefix: 'sheet-', type: 'sheetsAction' },
+    { prefix: 'appr-', type: 'approval' },
+    { prefix: 'merge-', type: 'merge' },
+    { prefix: 'cond-', type: 'conditional' },
+    { prefix: 'rl-', type: 'rateLimiter' },
+    { prefix: 'agg-', type: 'aggregator' },
+    { prefix: 'cache-', type: 'cache' },
+    { prefix: 'ai-', type: 'ai' },
+];
+/** Resolve canvas node ID to { type, entityId } */
+function resolveNodeId(canvasId) {
+    // Sort by prefix length descending so longer prefixes match first
+    const sorted = [...exports.PREFIX_TO_TYPE].sort((a, b) => b.prefix.length - a.prefix.length);
+    for (const { prefix, type } of sorted) {
+        if (canvasId.startsWith(prefix)) {
+            return { type, entityId: canvasId.slice(prefix.length) };
+        }
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@hostwebhook/node-types",
+  "version": "1.0.0",
+  "description": "Shared node type definitions, connection rules, and dispatch config for HostWebhook",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["hostwebhook", "nodes", "registry"],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}