hasura-node-types/lib/express.js

Add Hasura types, event trigger and action wrapper for common web frameworks

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.withExpress = void 0;
const types_1 = require("./types");
const utils_1 = require("./utils");
const withActionInternal = (options) => (req, res) => __awaiter(void 0, void 0, void 0, function* () {
    const { debug = false, logger = utils_1.defaultLogger, logResponseData = false, context, getAction, } = options;
    const extraLoggingInfo = {
        startTime: new Date(),
    };
    try {
        utils_1.validateActionPayload(req.body);
        const body = req.body;
        const fn = yield getAction(body);
        const result = yield fn(Object.assign({ request: req, logger,
            debug }, context), body);
        utils_1.printLog(logger, Object.assign(Object.assign({}, serializeActionRequest(req, extraLoggingInfo, options)), { level: "info", message: `executed ${body.action.name} successfully`, response: debug || logResponseData ? result : null, http_code: types_1.HASURA_ACTION_SUCCESS_STATUS }));
        return res.status(types_1.HASURA_ACTION_SUCCESS_STATUS).json(result);
    }
    catch (err) {
        utils_1.printLog(logger, Object.assign(Object.assign({}, serializeActionRequest(req, extraLoggingInfo, options)), { level: "error", message: err.message, error: err, http_code: types_1.HASURA_ACTION_ERROR_STATUS, stack: debug ? err.stack : undefined }));
        return res.status(types_1.HASURA_ACTION_ERROR_STATUS).json({
            code: err.code,
            message: err.message,
        });
    }
});
// Hasura event
const withEventInternal = (options) => (req, res) => __awaiter(void 0, void 0, void 0, function* () {
    const { debug = false, logResponseData = false, logger = utils_1.defaultLogger, context, getAction, } = options;
    const extraLoggingInfo = {
        startTime: new Date(),
    };
    try {
        utils_1.validateEventPayload(req.body);
        const body = req.body;
        const fn = yield getAction(body);
        const result = yield fn(Object.assign({ request: req, logger,
            debug }, context), body);
        utils_1.printLog(logger, Object.assign(Object.assign({}, serializeTriggerRequest(req, extraLoggingInfo, options)), { level: "info", message: `executed trigger ${body.trigger.name} successfully`, response: debug || logResponseData ? result : null, http_code: types_1.HASURA_EVENT_SUCCESS_STATUS }));
        return res.status(types_1.HASURA_EVENT_SUCCESS_STATUS).json(result);
    }
    catch (err) {
        utils_1.printLog(logger, Object.assign(Object.assign({}, serializeTriggerRequest(req, extraLoggingInfo, options)), { level: "error", message: err.message, error: err, http_code: types_1.HASURA_EVENT_ERROR_STATUS, stack: debug ? err.stack : undefined }));
        return res.status(types_1.HASURA_EVENT_ERROR_STATUS).json({
            code: err.code,
            message: err.message,
            error: err,
            stack: debug ? err.stack : undefined,
        });
    }
});
const withScheduledTriggerInternal = (options) => (req, res) => __awaiter(void 0, void 0, void 0, function* () {
    const { debug = false, logger = utils_1.defaultLogger, logResponseData = false, context, getAction, } = options;
    const extraLoggingInfo = {
        startTime: new Date(),
    };
    try {
        utils_1.validateScheduledTriggerPayload(req.body);
        const body = req.body;
        const fn = yield getAction(body);
        const result = yield fn(Object.assign({ request: req, logger,
            debug }, context), body);
        utils_1.printLog(logger, Object.assign(Object.assign({}, serializeScheduledEventRequest(req, extraLoggingInfo, options)), { level: "info", message: `executed ${body.name} successfully`, response: debug || logResponseData ? result : null, http_code: types_1.HASURA_SCHEDULED_TRIGGER_SUCCESS_STATUS }));
        return res.status(types_1.HASURA_SCHEDULED_TRIGGER_SUCCESS_STATUS).json(result);
    }
    catch (err) {
        utils_1.printLog(logger, Object.assign(Object.assign({}, serializeScheduledEventRequest(req, extraLoggingInfo, options)), { level: "error", message: err.message, error: err, http_code: types_1.HASURA_SCHEDULED_TRIGGER_ERROR_STATUS, stack: debug ? err.stack : undefined }));
        return res.status(types_1.HASURA_SCHEDULED_TRIGGER_ERROR_STATUS).json({
            code: err.code,
            message: err.message,
        });
    }
});
// logging serializer
function serializeTriggerRequest(req, info, options) {
    const body = (req.body || {});
    return {
        request_body: options.debug || options.logRequestBody ? body : null,
        request_header: req.headers,
        trigger_name: body.trigger ? body.trigger.name : null,
        latency: new Date().getTime() - info.startTime.getTime(),
    };
}
function serializeActionRequest(req, info, options) {
    const payload = (req.body || {});
    return {
        action_name: payload.action ? payload.action.name : null,
        session_variables: payload.session_variables,
        request_headers: req.headers,
        request_body: options.debug || options.logRequestBody ? payload.input : null,
        latency: new Date().getTime() - info.startTime.getTime(),
    };
}
function serializeScheduledEventRequest(req, info, options) {
    const payload = (req.body || {});
    return {
        event_name: payload.name ? payload.name : null,
        request_headers: req.headers,
        request_body: options.debug || options.logRequestBody ? payload.payload : null,
        latency: new Date().getTime() - info.startTime.getTime(),
    };
}
exports.withExpress = (options) => ({
    useEvent: (fn) => withEventInternal(Object.assign(Object.assign({}, options), { getAction: () => Promise.resolve(fn) })),
    useEvents: (events) => withEventInternal(Object.assign(Object.assign({}, options), { getAction: (body) => {
            const fn = events[body.trigger.name];
            const defaultFn = events.default || events["*"];
            if (!fn && !defaultFn) {
                return Promise.reject(new types_1.HasuraActionError({
                    message: `trigger name ${body.trigger.name} doesn't exist`,
                }));
            }
            return Promise.resolve(fn || defaultFn);
        } })),
    useAction: (action) => withActionInternal(Object.assign(Object.assign({}, options), { getAction: () => Promise.resolve(action) })),
    useActions: (actions) => withActionInternal(Object.assign(Object.assign({}, options), { getAction: (body) => {
            const fn = actions[body.action.name];
            if (!fn) {
                return Promise.reject(new types_1.HasuraActionError({
                    message: `action ${body.action.name} doesn't exist`,
                }));
            }
            return Promise.resolve(fn);
        } })),
    useScheduledTrigger: (event) => withScheduledTriggerInternal(Object.assign(Object.assign({}, options), { getAction: () => Promise.resolve(event) })),
    useScheduledTriggers: (event) => withScheduledTriggerInternal(Object.assign(Object.assign({}, options), { getAction: (body) => {
            const fn = event[body.name];
            if (!fn) {
                return Promise.reject(new types_1.HasuraActionError({
                    message: `scheduled trigger ${body.name} doesn't exist`,
                }));
            }
            return Promise.resolve(fn);
        } })),
});
//# sourceMappingURL=express.js.map