@flowcore/pathways 0.2.1

package/script/pathways/postgres/postgres-adapter.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresJsAdapter = void 0;
+exports.createPostgresAdapter = createPostgresAdapter;
+/**
+ * Implementation of PostgresAdapter using the postgres.js library
+ *
+ * @implements {PostgresAdapter}
+ */
+class PostgresJsAdapter {
+    /**
+     * Creates a new PostgresJsAdapter instance
+     *
+     * @param {PostgresConfig} config The PostgreSQL connection configuration
+     */
+    constructor(config) {
+        /** The postgres.js client factory function */
+        Object.defineProperty(this, "postgres", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The active postgres.js client */
+        Object.defineProperty(this, "sql", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The PostgreSQL configuration */
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The connection string built from the configuration */
+        Object.defineProperty(this, "connectionString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.config = config;
+        this.connectionString = `postgres://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
+        if (config.ssl) {
+            this.connectionString += "?sslmode=require";
+        }
+    }
+    /**
+     * Establishes a connection to the PostgreSQL database
+     *
+     * @returns {Promise<void>}
+     * @throws {Error} If connection fails
+     */
+    async connect() {
+        try {
+            const module = await Promise.resolve().then(() => __importStar(require("postgres")));
+            this.postgres = module.default;
+            this.sql = this.postgres(this.connectionString);
+        }
+        catch (error) {
+            console.error("Failed to connect to PostgreSQL:", error);
+            throw error;
+        }
+    }
+    /**
+     * Closes the connection to the PostgreSQL database
+     *
+     * @returns {Promise<void>}
+     */
+    async disconnect() {
+        if (this.sql) {
+            await this.sql.end();
+            this.sql = null;
+        }
+    }
+    /**
+     * Executes a SQL query and returns the results
+     *
+     * @template T The expected result type
+     * @param {string} sql The SQL query to execute
+     * @param {unknown[]} [params=[]] Optional parameters for the query
+     * @returns {Promise<T>} The query results
+     */
+    async query(sql, params = []) {
+        if (!this.sql) {
+            await this.connect();
+        }
+        return await this.sql.unsafe(sql, params);
+    }
+    /**
+     * Executes a SQL statement without returning results
+     *
+     * @param {string} sql The SQL statement to execute
+     * @param {unknown[]} [params=[]] Optional parameters for the statement
+     * @returns {Promise<void>}
+     */
+    async execute(sql, params = []) {
+        if (!this.sql) {
+            await this.connect();
+        }
+        await this.sql.unsafe(sql, params);
+    }
+}
+exports.PostgresJsAdapter = PostgresJsAdapter;
+/**
+ * Creates and initializes a PostgreSQL adapter
+ *
+ * @param {PostgresConfig} config The PostgreSQL connection configuration
+ * @returns {Promise<PostgresAdapter>} An initialized PostgreSQL adapter
+ */
+async function createPostgresAdapter(config) {
+    const adapter = new PostgresJsAdapter(config);
+    await adapter.connect();
+    return adapter;
+}

package/script/pathways/postgres/postgres-pathway-state.d.ts

@@ -0,0 +1,113 @@
+import type { PathwayState } from "../types.js";
+/**
+ * Configuration options for PostgreSQL pathway state storage
+ *
+ * @interface PostgresPathwayStateConfig
+ */
+export interface PostgresPathwayStateConfig {
+    /** PostgreSQL server hostname */
+    host: string;
+    /** PostgreSQL server port */
+    port: number;
+    /** PostgreSQL username */
+    user: string;
+    /** PostgreSQL password */
+    password: string;
+    /** PostgreSQL database name */
+    database: string;
+    /** Whether to use SSL for the connection */
+    ssl?: boolean;
+    /** Table name for storing pathway state (default: "pathway_state") */
+    tableName?: string;
+    /** Time-to-live in milliseconds for processed events (default: 5 minutes) */
+    ttlMs?: number;
+}
+/**
+ * Implementation of PathwayState that uses PostgreSQL for storage
+ *
+ * This class provides persistent storage of pathway state using a PostgreSQL database,
+ * which allows for state to be shared across multiple instances of the application.
+ *
+ * @implements {PathwayState}
+ */
+export declare class PostgresPathwayState implements PathwayState {
+    private config;
+    /**
+     * Default time-to-live for processed event records (5 minutes)
+     * @private
+     */
+    private static readonly DEFAULT_TTL_MS;
+    /**
+     * Default table name for storing pathway state
+     * @private
+     */
+    private static readonly DEFAULT_TABLE_NAME;
+    /**
+     * The PostgreSQL adapter instance
+     * @private
+     */
+    private postgres;
+    /**
+     * The table name for storing pathway state
+     * @private
+     */
+    private tableName;
+    /**
+     * Time-to-live in milliseconds for processed events
+     * @private
+     */
+    private ttlMs;
+    /**
+     * Whether the database has been initialized
+     * @private
+     */
+    private initialized;
+    /**
+     * Creates a new PostgresPathwayState instance
+     *
+     * @param {PostgresPathwayStateConfig} config The PostgreSQL configuration
+     */
+    constructor(config: PostgresPathwayStateConfig);
+    /**
+     * Initializes the PostgreSQL connection and creates the necessary table and index
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private initialize;
+    /**
+     * Checks if an event has already been processed
+     *
+     * @param {string} eventId - The ID of the event to check
+     * @returns {Promise<boolean>} True if the event has been processed, false otherwise
+     */
+    isProcessed(eventId: string): Promise<boolean>;
+    /**
+     * Marks an event as processed
+     *
+     * @param {string} eventId - The ID of the event to mark as processed
+     * @returns {Promise<void>}
+     */
+    setProcessed(eventId: string): Promise<void>;
+    /**
+     * Removes expired event records from the database
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private cleanupExpired;
+    /**
+     * Closes the PostgreSQL connection
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+}
+/**
+ * Creates a new PostgreSQL pathway state instance
+ *
+ * @param {PostgresPathwayStateConfig} config The PostgreSQL configuration
+ * @returns {PostgresPathwayState} A new PostgresPathwayState instance
+ */
+export declare function createPostgresPathwayState(config: PostgresPathwayStateConfig): PostgresPathwayState;
+//# sourceMappingURL=postgres-pathway-state.d.ts.map

package/script/pathways/postgres/postgres-pathway-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-pathway-state.d.ts","sourceRoot":"","sources":["../../../src/pathways/postgres/postgres-pathway-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IA0C3C,OAAO,CAAC,MAAM;IAzC1B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAEvD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAmB;IAE7D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAkB;IAElC;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAS;IAEtB;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAS;IAE5B;;;;OAIG;gBACiB,MAAM,EAAE,0BAA0B;IAMtD;;;;;OAKG;YACW,UAAU;IAgCxB;;;;;OAKG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAcpD;;;;;OAKG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAelD;;;;;OAKG;YACW,cAAc;IAQ5B;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,0BAA0B,GAAG,oBAAoB,CAGnG"}

package/script/pathways/postgres/postgres-pathway-state.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresPathwayState = void 0;
+exports.createPostgresPathwayState = createPostgresPathwayState;
+const postgres_adapter_js_1 = require("./postgres-adapter.js");
+/**
+ * Implementation of PathwayState that uses PostgreSQL for storage
+ *
+ * This class provides persistent storage of pathway state using a PostgreSQL database,
+ * which allows for state to be shared across multiple instances of the application.
+ *
+ * @implements {PathwayState}
+ */
+class PostgresPathwayState {
+    /**
+     * Creates a new PostgresPathwayState instance
+     *
+     * @param {PostgresPathwayStateConfig} config The PostgreSQL configuration
+     */
+    constructor(config) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        /**
+         * The PostgreSQL adapter instance
+         * @private
+         */
+        Object.defineProperty(this, "postgres", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The table name for storing pathway state
+         * @private
+         */
+        Object.defineProperty(this, "tableName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Time-to-live in milliseconds for processed events
+         * @private
+         */
+        Object.defineProperty(this, "ttlMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether the database has been initialized
+         * @private
+         */
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.tableName = config.tableName || PostgresPathwayState.DEFAULT_TABLE_NAME;
+        this.ttlMs = config.ttlMs || PostgresPathwayState.DEFAULT_TTL_MS;
+        this.postgres = null;
+    }
+    /**
+     * Initializes the PostgreSQL connection and creates the necessary table and index
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.postgres = await (0, postgres_adapter_js_1.createPostgresAdapter)({
+            host: this.config.host,
+            port: this.config.port,
+            user: this.config.user,
+            password: this.config.password,
+            database: this.config.database,
+            ssl: this.config.ssl,
+        });
+        // Create table if it doesn't exist
+        await this.postgres.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        event_id TEXT PRIMARY KEY,
+        processed BOOLEAN NOT NULL,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+        expires_at TIMESTAMP WITH TIME ZONE NOT NULL
+      )
+    `);
+        // Create index on expires_at to help with cleanup
+        await this.postgres.execute(`
+      CREATE INDEX IF NOT EXISTS ${this.tableName}_expires_at_idx ON ${this.tableName} (expires_at)
+    `);
+        this.initialized = true;
+    }
+    /**
+     * Checks if an event has already been processed
+     *
+     * @param {string} eventId - The ID of the event to check
+     * @returns {Promise<boolean>} True if the event has been processed, false otherwise
+     */
+    async isProcessed(eventId) {
+        await this.initialize();
+        // Clean up expired entries
+        await this.cleanupExpired();
+        const result = await this.postgres.query(`
+      SELECT processed FROM ${this.tableName}
+      WHERE event_id = $1 AND expires_at > NOW()
+    `, [eventId]);
+        return result.length > 0 && result[0].processed;
+    }
+    /**
+     * Marks an event as processed
+     *
+     * @param {string} eventId - The ID of the event to mark as processed
+     * @returns {Promise<void>}
+     */
+    async setProcessed(eventId) {
+        await this.initialize();
+        // Insert or update the event state
+        // Using ON CONFLICT to handle the case where the event is already in the table
+        await this.postgres.execute(`
+      INSERT INTO ${this.tableName} (event_id, processed, expires_at)
+      VALUES ($1, TRUE, NOW() + interval '${Math.floor(this.ttlMs / 1000)} seconds')
+      ON CONFLICT (event_id) 
+      DO UPDATE SET 
+        processed = TRUE, 
+        expires_at = NOW() + interval '${Math.floor(this.ttlMs / 1000)} seconds'
+    `, [eventId]);
+    }
+    /**
+     * Removes expired event records from the database
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    async cleanupExpired() {
+        // Delete expired entries
+        await this.postgres.execute(`
+      DELETE FROM ${this.tableName}
+      WHERE expires_at < NOW()
+    `);
+    }
+    /**
+     * Closes the PostgreSQL connection
+     *
+     * @returns {Promise<void>}
+     */
+    async close() {
+        if (this.postgres) {
+            await this.postgres.disconnect();
+        }
+    }
+}
+exports.PostgresPathwayState = PostgresPathwayState;
+/**
+ * Default time-to-live for processed event records (5 minutes)
+ * @private
+ */
+Object.defineProperty(PostgresPathwayState, "DEFAULT_TTL_MS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5 * 60 * 1000
+}); // 5 minutes
+/**
+ * Default table name for storing pathway state
+ * @private
+ */
+Object.defineProperty(PostgresPathwayState, "DEFAULT_TABLE_NAME", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "pathway_state"
+});
+/**
+ * Creates a new PostgreSQL pathway state instance
+ *
+ * @param {PostgresPathwayStateConfig} config The PostgreSQL configuration
+ * @returns {PostgresPathwayState} A new PostgresPathwayState instance
+ */
+function createPostgresPathwayState(config) {
+    const state = new PostgresPathwayState(config);
+    return state;
+}

package/script/pathways/types.d.ts

@@ -0,0 +1,87 @@
+import type { TSchema } from "@sinclair/typebox";
+import type { WebhookFileData, WebhookSendOptions } from "@flowcore/sdk-transformer-core";
+/**
+ * Helper type to create a custom type error for non-writable pathways
+ */
+type NonWritablePathwayError<T extends string> = T & {
+    readonly __nonWritablePathwayError: "This pathway is not writable. To make it writable, remove 'writable: false' from the pathway contract.";
+};
+/**
+ * Contract for defining a pathway
+ * @template F - The flow type
+ * @template E - The event type
+ * @template T - The schema type
+ */
+export interface PathwayContract<F extends string, E extends string, T extends TSchema> {
+    flowType: F;
+    eventType: E;
+    schema: T;
+    /**
+     * Whether the pathway is writable. Use `false as const` to make the pathway non-writable at compile time.
+     * @example
+     * ```ts
+     * // Non-writable pathway (will not be available in write)
+     * register({
+     *   flowType: "test",
+     *   eventType: "event",
+     *   schema: Type.Object({}),
+     *   writable: false as const
+     * })
+     *
+     * // Writable pathway
+     * register({
+     *   flowType: "test",
+     *   eventType: "writable",
+     *   schema: Type.Object({})
+     * })
+     * ```
+     * @default true
+     */
+    writable?: boolean;
+    /**
+     * The maximum number of times to retry processing an event if it fails
+     * @default 0
+     */
+    maxRetries?: number;
+    /**
+     * The delay in milliseconds between retry attempts
+     * Used as the base for exponential backoff if retries > 1
+     * @default 1000
+     */
+    retryDelayMs?: number;
+    /**
+     * HTTP status codes that should trigger a retry
+     * @default [500, 502, 503, 504]
+     */
+    retryStatusCodes?: number[];
+    /**
+     * Custom timeout for this pathway in milliseconds
+     */
+    timeoutMs?: number;
+    /**
+     * Whether this pathway is for file processing
+     */
+    isFilePathway?: boolean;
+}
+export type PathwayKey<F extends string, E extends string> = `${F}/${E}`;
+export interface EventMetadata extends Record<string, unknown> {
+}
+export type SendWebhook<EventPayload> = (payload: EventPayload, metadata?: EventMetadata, options?: WebhookSendOptions) => Promise<string>;
+export type SendFilehook = (payload: WebhookFileData, metadata?: EventMetadata, options?: WebhookSendOptions) => Promise<string[]>;
+/**
+ * Helper type to create a better error message for non-writable pathways
+ */
+export type WritablePathway<T extends string, IsWritable extends boolean> = IsWritable extends false ? NonWritablePathwayError<T> : T;
+export type PathwayState = {
+    isProcessed: (eventId: string) => (boolean | Promise<boolean>);
+    setProcessed: (eventId: string) => (void | Promise<void>);
+};
+/**
+ * Options for pathway writes, extending WebhookSendOptions
+ */
+export type PathwayWriteOptions = WebhookSendOptions & {
+    fireAndForget?: boolean;
+    headers?: Record<string, string>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/script/pathways/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/pathways/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAEzF;;GAEG;AACH,KAAK,uBAAuB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG;IACnD,QAAQ,CAAC,yBAAyB,EAAE,wGAAwG,CAAA;CAC7I,CAAA;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO;IACpF,QAAQ,EAAE,CAAC,CAAA;IACX,SAAS,EAAE,CAAC,CAAA;IACZ,MAAM,EAAE,CAAC,CAAA;IACT;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,EAAE,CAAA;AAExE,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAAG;AAEjE,MAAM,MAAM,WAAW,CAAC,YAAY,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,kBAAkB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAC1I,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,kBAAkB,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;AAElI;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,UAAU,SAAS,OAAO,IAAI,UAAU,SAAS,KAAK,GAAG,uBAAuB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAErI,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9D,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;CAC1D,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG;IACrD,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,CAAA"}

package/script/pathways/types.js

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

package/script/router/index.d.ts

@@ -0,0 +1,35 @@
+import type { FlowcoreLegacyEvent } from "../common/flowcore.type.js";
+import type { PathwaysBuilder } from "../pathways/index.js";
+import type { Logger } from "../pathways/logger.js";
+/**
+ * Router class that handles directing events to the appropriate pathway handlers
+ *
+ * @class PathwayRouter
+ */
+export declare class PathwayRouter {
+    private readonly pathways;
+    private readonly secretKey;
+    private readonly logger;
+    /**
+     * Creates a new instance of PathwayRouter
+     *
+     * @param {PathwaysBuilder<Record<string, any>>} pathways - The pathways builder instance that contains all registered pathways
+     * @param {string} secretKey - Secret key used for authentication when processing events
+     * @param {Logger} [logger] - Optional logger instance (defaults to NoopLogger if not provided)
+     * @throws {Error} Will throw an error if secretKey is empty or not provided
+     */
+    constructor(pathways: PathwaysBuilder<Record<string, any>>, secretKey: string, logger?: Logger);
+    /**
+     * Processes an incoming event by routing it to the appropriate pathway
+     *
+     * @param {FlowcoreLegacyEvent} event - The event to process
+     * @param {string} providedSecret - The secret key provided for authentication
+     * @returns {Promise<{ success: boolean; message: string }>} Result of the event processing
+     * @throws {Error} Will throw an error if authentication fails, pathway is not found, or processing fails
+     */
+    processEvent(event: FlowcoreLegacyEvent, providedSecret: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=index.d.ts.map

package/script/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/router/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAErE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAGnD;;;;GAIG;AACH,qBAAa,aAAa;IAatB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAb5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC;;;;;;;OAOG;gBAGgB,QAAQ,EAAE,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAC9C,SAAS,EAAE,MAAM,EAClC,MAAM,CAAC,EAAE,MAAM;IAYjB;;;;;;;OAOG;IACG,YAAY,CAAC,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAoDvH"}

package/script/router/index.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathwayRouter = void 0;
+const logger_js_1 = require("../pathways/logger.js");
+/**
+ * Router class that handles directing events to the appropriate pathway handlers
+ *
+ * @class PathwayRouter
+ */
+class PathwayRouter {
+    /**
+     * Creates a new instance of PathwayRouter
+     *
+     * @param {PathwaysBuilder<Record<string, any>>} pathways - The pathways builder instance that contains all registered pathways
+     * @param {string} secretKey - Secret key used for authentication when processing events
+     * @param {Logger} [logger] - Optional logger instance (defaults to NoopLogger if not provided)
+     * @throws {Error} Will throw an error if secretKey is empty or not provided
+     */
+    constructor(
+    // deno-lint-ignore no-explicit-any
+    pathways, secretKey, logger) {
+        Object.defineProperty(this, "pathways", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: pathways
+        });
+        Object.defineProperty(this, "secretKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: secretKey
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.logger = logger ?? new logger_js_1.NoopLogger();
+        if (!secretKey || secretKey.trim() === "") {
+            this.logger.error("Secret key is required for PathwayRouter");
+            throw new Error("Secret key is required for PathwayRouter");
+        }
+        this.logger.debug("PathwayRouter initialized");
+    }
+    /**
+     * Processes an incoming event by routing it to the appropriate pathway
+     *
+     * @param {FlowcoreLegacyEvent} event - The event to process
+     * @param {string} providedSecret - The secret key provided for authentication
+     * @returns {Promise<{ success: boolean; message: string }>} Result of the event processing
+     * @throws {Error} Will throw an error if authentication fails, pathway is not found, or processing fails
+     */
+    async processEvent(event, providedSecret) {
+        // Validate secret key
+        if (!providedSecret || providedSecret !== this.secretKey) {
+            this.logger.error("Invalid secret key provided");
+            throw new Error("Invalid secret key");
+        }
+        const compatibleEvent = {
+            ...event,
+            ...(event.aggregator ? { flowType: event.aggregator } : {}),
+        };
+        const pathwayKey = `${compatibleEvent.flowType}/${compatibleEvent.eventType}`;
+        this.logger.debug(`Processing event for pathway: ${pathwayKey}`, {
+            eventId: compatibleEvent.eventId
+        });
+        const pathway = this.pathways.get(pathwayKey);
+        if (!pathway) {
+            const error = `Pathway ${pathwayKey} not found`;
+            this.logger.error(error);
+            throw new Error(error);
+        }
+        try {
+            this.logger.debug(`Delegating event processing to pathway handler`, {
+                pathwayKey,
+                eventId: compatibleEvent.eventId
+            });
+            await this.pathways.process(pathwayKey, compatibleEvent);
+            this.logger.debug(`Event successfully processed through pathway`, {
+                pathwayKey,
+                eventId: compatibleEvent.eventId
+            });
+            return { success: true, message: `Event processed through pathway ${pathwayKey}` };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : String(error);
+            this.logger.error(`Error processing pathway ${pathwayKey}`, {
+                error: errorMessage,
+                eventId: compatibleEvent.eventId
+            });
+            // Rethrow the error with additional context
+            throw new Error(`Failed to process event in pathway ${pathwayKey}: ${errorMessage}`);
+        }
+    }
+}
+exports.PathwayRouter = PathwayRouter;