@karmai-cloud/rest.temporalio/lib/index.js

Express middleware for calling Temporal.io using REST Api Calls

"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 () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.useValidator = useValidator;
exports.temporalioMiddleware = temporalioMiddleware;
const express_1 = __importStar(require("express"));
const uuid_1 = require("uuid");
const signalValidators = new WeakMap();
function useValidator(signal, fn) {
    signalValidators.set(signal, fn);
}
function temporalioMiddleware(workflows, client, taskQueue, router) {
    if (router === undefined) {
        router = (0, express_1.Router)();
    }
    for (const key of Object.keys(workflows)) {
        const value = workflows[key];
        if (typeof value === "function") {
            // Workflow
            createWorkflowEndpoint(router, client, key, value, taskQueue);
            cancelWorkflowEndpoint(router, client);
        }
        else if (typeof value === "object" && value != null) {
            if (value["type"] === "signal") {
                // Signal
                createSignalEndpoint(router, client, value);
            }
            else if (value["type"] === "query") {
                // Query
                createQueryEndpoint(router, client, value);
            }
            else if (value["type"] === "update") {
                // Query
                createUpdateEndpoint(router, client, value);
            }
        }
    }
    return router;
}
function createWorkflowEndpoint(router, client, name, fn, taskQueue) {
    router.post(`/workflow/${name}`, express_1.default.json(), function (req, res) {
        const workflowId = req.body?.workflowId || `${name}_${(0, uuid_1.v4)()}`;
        const opts = {
            taskQueue,
            workflowId,
            args: [req.body],
        };
        client.start(fn, opts).then(() => res.status(201).json({ workflowId }));
    });
    router.post(`/workflow/${name}/sync`, express_1.default.json(), function (req, res) {
        const workflowId = req.body?.workflowId || `${name}_${(0, uuid_1.v4)()}`;
        const opts = {
            taskQueue,
            workflowId,
            args: [req.body],
        };
        client
            .execute(fn, opts)
            .then((response) => res.status(201).send(response));
    });
    router.post(`/workflow/${name}/:workflowId`, express_1.default.json(), function (req, res) {
        const workflowId = req.params.workflowId;
        const opts = {
            taskQueue,
            workflowId,
            args: [req.body],
        };
        client
            .start(fn, opts)
            .then(() => res.json({ workflowId }))
            .catch(defaultErrorHandlingMiddleware(req, res));
    });
}
function createSignalEndpoint(router, client, signal) {
    router.put(`/signal/${signal.name}/:workflowId`, express_1.default.json(), function (req, res) {
        let data = req.body;
        let fn = signalValidators.get(signal);
        if (fn != null) {
            data = fn(data);
        }
        const handle = client.getHandle(req.params.workflowId);
        handle
            .signal(signal, req.body)
            .then(() => res.json({ received: true }))
            .catch(defaultErrorHandlingMiddleware(req, res));
    });
}
function createQueryEndpoint(router, client, query) {
    router.get(`/query/${query.name}/:workflowId`, function (req, res) {
        const handle = client.getHandle(req.params.workflowId);
        handle
            .query(query, req.query)
            .then((result) => res.json({ result }))
            .catch(defaultErrorHandlingMiddleware(req, res));
    });
}
function createUpdateEndpoint(router, client, update) {
    router.patch(`/update/${update.name}/:workflowId`, express_1.default.json(), function (req, res) {
        let data = req.body;
        const handle = client.getHandle(req.params.workflowId);
        handle
            .executeUpdate(update, data)
            .then((result) => res.send(result))
            .catch(defaultErrorHandlingMiddleware(req, res));
        // TODO: Implement custom logic to handle errors
    });
}
function cancelWorkflowEndpoint(router, client) {
    router.delete(`/workflow/:workflowId`, function (req, res) {
        const handle = client.getHandle(req.params.workflowId);
        handle
            .cancel()
            .then(() => res.status(204).send())
            .catch(defaultErrorHandlingMiddleware(req, res));
    });
}
function defaultErrorHandlingMiddleware(req, res, next) {
    return (err) => {
        console.error(err);
        return res
            .status(err?.code > 200 && err?.code < 600 ? err.code : 500)
            .json({ message: err.message, issues: err?.issues });
    };
}
//# sourceMappingURL=index.js.map