@cortexql/core/api/context.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const path_1 = require("path");
const core_1 = require("@cortexql/core");
const paths_1 = require("../paths");
const expressRequestContextParams_1 = require("../hooks/expressRequestContextParams");
const webSocketTransportContextParams_1 = require("../hooks/webSocketTransportContextParams");
const context_1 = require("../hooks/context");
const contextExecution_1 = require("../hooks/contextExecution");
const __1 = require("..");
const getSchema_1 = require("../api/getSchema");
const contextId_1 = require("../hooks/contextId");
const contextExecutionId_1 = require("../hooks/contextExecutionId");
contextId_1.default.addFilter('default', () => {
    return `${(new Date()).getTime()}.${Math.floor(Math.random() * Math.pow(10, 5))}`;
});
const $$executionSeq = Symbol();
contextExecutionId_1.default.addFilter('default', (value, { context }) => {
    if (typeof context[$$executionSeq] === 'undefined') {
        context[$$executionSeq] = -1;
    }
    context[$$executionSeq] = context[$$executionSeq] + 1;
    return `${context.id}.${context[$$executionSeq]}`;
});
function createContextId(context) {
    return contextId_1.default.filter(null, { context });
}
exports.createContextId = createContextId;
function createExecutionContextId(context, info) {
    return contextExecutionId_1.default.filter(null, { context, info });
}
exports.createExecutionContextId = createExecutionContextId;
function createContextNamespace(context, info, id) {
    let { operationName, operationType, } = context;
    let namespace;
    if (typeof info !== 'undefined') {
        if (typeof operationType === 'undefined') {
            operationType = info.operation.operation;
        }
        if (typeof operationName === 'undefined'
            && typeof info.operation.name !== 'undefined') {
            operationName = info.operation.name.value;
        }
        operationType = `${operationType}.${info.fieldName}`;
        if (info.path.key !== info.fieldName) {
            if (typeof operationName === 'undefined') {
                operationName = '';
            }
            operationName = `${operationName}.${info.path.key}`;
        }
    }
    if (typeof operationType !== 'undefined') {
        namespace = `${operationType}`;
    }
    else {
        namespace = '';
    }
    if (typeof operationName !== 'undefined') {
        namespace = `${namespace}@${operationName}`;
    }
    return `${namespace}::${typeof id !== 'undefined' ? id : context.id}`;
}
exports.createContextNamespace = createContextNamespace;
class BaseContext {
    constructor(params, operationName, operationType, id) {
        this.params = params;
        this.operationName = operationName;
        this.operationType = operationType;
        this.id = id;
        this.context = undefined;
        this.debug = ((...args) => {
            Object.defineProperty(this, 'debug', {
                configurable: true,
                value: core_1.debug(createContextNamespace(this)),
            });
            return this.debug(...args);
        });
        this.event = new events_1.EventEmitter();
        this.schema = getSchema_1.getSchema();
        this.execute = (document, variableValues, operationName) => __awaiter(this, void 0, void 0, function* () { return __1.execute(document, this.params, variableValues, operationName); });
        this.subscribe = (document, variableValues, operationName) => __awaiter(this, void 0, void 0, function* () { return __1.subscribe(document, this.params, variableValues, operationName); });
        Object.defineProperty(this, 'completed', { value: false, configurable: true });
        this.end(() => Object.defineProperty(this, 'completed', { value: true }));
        if (typeof this.id === 'undefined') {
            this.id = createContextId(this);
        }
    }
    execution(info) {
        return createExecutionContext(this, info);
    }
    end(handler, reason) {
        if (handler == null || handler instanceof Error) {
            if (this.completed) {
                throw new Error('The execution has already ended');
            }
            this.completionReason = reason;
            if (handler instanceof Error) {
                this.completionError = handler;
                this.event.emit('end', handler, reason);
            }
            else {
                this.event.emit('end', null, reason);
            }
        }
        else {
            if (this.completed) {
                process.nextTick(handler);
            }
            else {
                this.event.once('end', handler);
            }
        }
    }
}
exports.BaseContext = BaseContext;
;
const $$executionCount = Symbol();
class BaseExecutionContext {
    constructor(context, info) {
        this.context = context;
        this.info = info;
        this.isExecution = true;
        this.id = createExecutionContextId(context, info);
        const namespace = createContextNamespace(context, info, this.id);
        this.debug = core_1.debug(namespace);
        if (typeof context[$$executionCount] === 'undefined') {
            context[$$executionCount] = 0;
        }
        context[$$executionCount] = context[$$executionCount] + 1;
        this.context.end(() => {
            if (!this.completed) {
                this.end(null, 'context');
            }
        });
        this.end(() => {
            context[$$executionCount] = context[$$executionCount] - 1;
            if (context[$$executionCount] <= 0) {
                if (!this.context.completed) {
                    this.context.end();
                }
            }
        });
        Object.defineProperty(this, 'completed', { value: false, configurable: true });
        this.end(() => Object.defineProperty(this, 'completed', { value: true }));
    }
    end(handler, reason) {
        if (handler == null || handler instanceof Error) {
            if (this.completed) {
                throw new Error('The execution has already ended');
            }
            this.completionReason = reason;
            if (handler instanceof Error) {
                this.completionError = handler;
                this.context.event.emit('endExecution', handler, reason);
            }
            else {
                this.context.event.emit('endExecution', null, reason);
            }
        }
        else {
            if (this.completed) {
                process.nextTick(handler);
            }
            else {
                this.context.event.once('endExecution', handler);
            }
        }
    }
}
exports.BaseExecutionContext = BaseExecutionContext;
function createContext(params, operationName, operationType, executionId) {
    return __awaiter(this, void 0, void 0, function* () {
        const { Context } = require(path_1.resolve(paths_1.getApiPath(), 'context'));
        let context = new Context(params, operationName, operationType, executionId);
        yield context_1.default.do({ context, params });
        return context;
    });
}
exports.createContext = createContext;
function createExecutionContext(context, info) {
    return __awaiter(this, void 0, void 0, function* () {
        const contextModule = require(path_1.resolve(paths_1.getApiPath(), 'context'));
        let execution;
        if ('ExecutionContext' in contextModule) {
            const { ExecutionContext } = contextModule;
            execution = new ExecutionContext(context, info);
        }
        else {
            execution = new BaseExecutionContext(context, info);
        }
        yield contextExecution_1.default.do({ execution, context, info });
        return Object.assign(execution, Object.assign({}, context, execution));
    });
}
exports.createExecutionContext = createExecutionContext;
function getOperationFromQuery(query) {
    const match = query.match(/^\s*([^\s]+)(?:\s+([^\s]+))?\s*{/);
    if (match != null) {
        return {
            operationName: match[2],
            operationType: match[1],
        };
    }
    return {
        operationName: undefined,
        operationType: undefined,
    };
}
exports.getOperationFromQuery = getOperationFromQuery;
function createContextFromExpressRequest(req, params) {
    return __awaiter(this, void 0, void 0, function* () {
        let contextParams = Object.assign({}, params);
        contextParams = expressRequestContextParams_1.default.filter(contextParams, { req, params });
        const query = req.method === 'POST' ? req.body.query : req.query;
        const { operationName, operationType, } = getOperationFromQuery(query);
        return yield createContext(contextParams, operationName, operationType);
    });
}
exports.createContextFromExpressRequest = createContextFromExpressRequest;
function createContextFromWebSocketTransport(webSocket, message, params) {
    return __awaiter(this, void 0, void 0, function* () {
        let contextParams = Object.assign({}, (typeof message !== 'undefined' && typeof message.payload !== 'undefined' ? message.payload.context : null));
        contextParams = webSocketTransportContextParams_1.default.filter(contextParams, { webSocket, message, params });
        let operationName;
        let operationType;
        if (typeof params.query === 'string') {
            ({
                operationName,
                operationType,
            } = getOperationFromQuery(params.query));
        }
        return yield createContext(contextParams, operationName, operationType);
    });
}
exports.createContextFromWebSocketTransport = createContextFromWebSocketTransport;
//# sourceMappingURL=context.js.map