@nymphjs/server 1.0.0-beta.11 → 1.0.0-beta.111

package/dist/createServer.js

@@ -0,0 +1,907 @@
+import express from 'express';
+import cookieParser from 'cookie-parser';
+import { Entity, EntityConflictError, InvalidParametersError, TilmeldAccessLevels, classNamesToEntityConstructors, } from '@nymphjs/nymph';
+import { EntityInvalidDataError } from '@nymphjs/nymph';
+import { statusDescriptions } from './statusDescriptions.js';
+const NOT_FOUND_ERROR = 'Entity is not found.';
+export class ForbiddenClassError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ForbiddenClassError';
+    }
+}
+/**
+ * A REST server middleware creator for Nymph.
+ *
+ * Written by Hunter Perrin for SciActive.
+ *
+ * @author Hunter Perrin <hperrin@gmail.com>
+ * @copyright SciActive Inc
+ * @see http://nymph.io/
+ */
+export function createServer(nymph, { jsonOptions = {} } = {}) {
+    const rest = express();
+    rest.use(cookieParser());
+    rest.use(express.json(jsonOptions || {}));
+    function instantiateNymph(_request, response, next) {
+        response.locals.nymph = nymph.clone();
+        next();
+    }
+    async function authenticateTilmeld(request, response, next) {
+        if (response.locals.nymph.tilmeld) {
+            response.locals.nymph.tilmeld.request = request;
+            response.locals.nymph.tilmeld.response = response;
+            try {
+                await response.locals.nymph.tilmeld.authenticate(false, request.header('x-tilmeld-token-renewal') === 'off');
+            }
+            catch (e) {
+                httpError(response, 500, e);
+                return;
+            }
+        }
+        next();
+    }
+    function unauthenticateTilmeld(_request, response, next) {
+        if (response.locals.nymph.tilmeld) {
+            response.locals.nymph.tilmeld.request = null;
+            response.locals.nymph.tilmeld.response = null;
+            try {
+                response.locals.nymph.tilmeld.clearSession();
+            }
+            catch (e) {
+                httpError(response, 500, e);
+                return;
+            }
+        }
+        next();
+    }
+    function getActionData(request) {
+        if (request.method === 'GET') {
+            if (typeof request.query?.action !== 'string' ||
+                typeof request.query?.data !== 'string') {
+                return {
+                    action: '',
+                    data: {},
+                };
+            }
+            return {
+                action: JSON.parse(request.query.action) ?? '',
+                data: JSON.parse(request.query.data),
+            };
+        }
+        else {
+            return {
+                action: request.body.action ?? '',
+                data: request.body.data,
+            };
+        }
+    }
+    // Create a new instance of Nymph for the request/response.
+    rest.use(instantiateNymph);
+    // Authenticate before the request.
+    rest.use(authenticateTilmeld);
+    rest.get('/', async (request, response) => {
+        try {
+            const { action, data } = getActionData(request);
+            if (['entity', 'entities', 'uid'].indexOf(action) === -1) {
+                httpError(response, 400);
+                return;
+            }
+            if (['entity', 'entities'].indexOf(action) !== -1) {
+                if (!Array.isArray(data)) {
+                    httpError(response, 400);
+                    return;
+                }
+                const count = data.length;
+                if (count < 1 || typeof data[0] !== 'object') {
+                    httpError(response, 400);
+                    return;
+                }
+                if (!('class' in data[0])) {
+                    httpError(response, 400);
+                    return;
+                }
+                let [options, ...selectors] = data;
+                let EntityClass;
+                try {
+                    EntityClass = response.locals.nymph.getEntityClass(data[0].class);
+                    if (!EntityClass.restEnabled) {
+                        httpError(response, 403);
+                        return;
+                    }
+                }
+                catch (e) {
+                    httpError(response, 400, e);
+                    return;
+                }
+                options.class = EntityClass;
+                options.source = 'client';
+                options.skipAc = false;
+                if (options.return === 'object') {
+                    options.return = 'entity';
+                }
+                try {
+                    selectors = classNamesToEntityConstructors(response.locals.nymph, selectors, true);
+                }
+                catch (e) {
+                    if (e?.message === 'Not accessible.') {
+                        httpError(response, 403);
+                        return;
+                    }
+                    else {
+                        httpError(response, 500, e);
+                        return;
+                    }
+                }
+                let result;
+                try {
+                    if (action === 'entity') {
+                        result = await response.locals.nymph.getEntity(options, ...selectors);
+                    }
+                    else {
+                        result = await response.locals.nymph.getEntities(options, ...selectors);
+                    }
+                }
+                catch (e) {
+                    httpError(response, 500, e);
+                    return;
+                }
+                if (result == null || (Array.isArray(result) && result.length === 0)) {
+                    if (action === 'entity' ||
+                        response.locals.nymph.config.emptyListError) {
+                        httpError(response, 404);
+                        return;
+                    }
+                }
+                response.setHeader('Content-Type', 'application/json');
+                response.send(JSON.stringify(result));
+            }
+            else {
+                if (typeof data !== 'string') {
+                    httpError(response, 400);
+                    return;
+                }
+                if (response.locals.nymph.tilmeld) {
+                    if (!(await response.locals.nymph.tilmeld.checkClientUIDPermissions(data, TilmeldAccessLevels.READ_ACCESS))) {
+                        httpError(response, 403);
+                        return;
+                    }
+                }
+                let result;
+                try {
+                    result = await response.locals.nymph.getUID(data);
+                }
+                catch (e) {
+                    httpError(response, 500, e);
+                    return;
+                }
+                if (result === null) {
+                    httpError(response, 404);
+                    return;
+                }
+                else if (typeof result !== 'number') {
+                    httpError(response, 500);
+                    return;
+                }
+                response.setHeader('Content-Type', 'text/plain');
+                response.send(`${result}`);
+            }
+        }
+        catch (e) {
+            httpError(response, 500, e);
+            return;
+        }
+    });
+    rest.post('/', async (request, response) => {
+        try {
+            const { action, data: dataConst } = getActionData(request);
+            let data = dataConst;
+            if (['entity', 'entities', 'uid', 'method'].indexOf(action) === -1) {
+                httpError(response, 400);
+                return;
+            }
+            if (['entity', 'entities'].indexOf(action) !== -1) {
+                if (action === 'entity') {
+                    data = [data];
+                }
+                const created = [];
+                let hadSuccess = false;
+                let invalidRequest = false;
+                let conflict = false;
+                let notfound = false;
+                let forbidden = false;
+                let lastException = null;
+                for (let entData of data) {
+                    if (entData.guid) {
+                        invalidRequest = true;
+                        created.push(null);
+                        continue;
+                    }
+                    let entity;
+                    try {
+                        entity = await loadEntity(entData, response.locals.nymph);
+                    }
+                    catch (e) {
+                        if (e instanceof EntityConflictError) {
+                            conflict = true;
+                        }
+                        else if (e instanceof ForbiddenClassError) {
+                            forbidden = true;
+                        }
+                        else if (e.message === NOT_FOUND_ERROR) {
+                            notfound = true;
+                        }
+                        else if (e instanceof InvalidParametersError) {
+                            invalidRequest = true;
+                            lastException = e;
+                        }
+                        else {
+                            lastException = e;
+                        }
+                        created.push(null);
+                        continue;
+                    }
+                    if (!entity) {
+                        invalidRequest = true;
+                        created.push(null);
+                        continue;
+                    }
+                    try {
+                        if (await entity.$save()) {
+                            created.push(entity);
+                            hadSuccess = true;
+                        }
+                        else {
+                            created.push(false);
+                        }
+                    }
+                    catch (e) {
+                        if (e instanceof EntityInvalidDataError) {
+                            invalidRequest = true;
+                        }
+                        else {
+                            lastException = e;
+                        }
+                        created.push(null);
+                    }
+                }
+                if (!hadSuccess) {
+                    if (invalidRequest) {
+                        httpError(response, 400, lastException);
+                        return;
+                    }
+                    else if (conflict) {
+                        httpError(response, 409);
+                        return;
+                    }
+                    else if (forbidden) {
+                        httpError(response, 403);
+                        return;
+                    }
+                    else if (notfound) {
+                        httpError(response, 404);
+                        return;
+                    }
+                    else {
+                        httpError(response, 500, lastException);
+                        return;
+                    }
+                }
+                response.status(201);
+                response.setHeader('Content-Type', 'application/json');
+                if (action === 'entity') {
+                    response.send(JSON.stringify(created[0]));
+                }
+                else {
+                    response.send(created);
+                }
+            }
+            else if (action === 'method') {
+                if (!Array.isArray(data.params)) {
+                    httpError(response, 400);
+                    return;
+                }
+                try {
+                    const params = referencesToEntities([...data.params], response.locals.nymph);
+                    if (data.static) {
+                        let EntityClass;
+                        try {
+                            EntityClass = response.locals.nymph.getEntityClass(data.class);
+                            if (!EntityClass.restEnabled) {
+                                httpError(response, 403);
+                                return;
+                            }
+                        }
+                        catch (e) {
+                            httpError(response, 400);
+                            return;
+                        }
+                        if (EntityClass.clientEnabledStaticMethods.indexOf(data.method) === -1) {
+                            httpError(response, 403);
+                            return;
+                        }
+                        if (!(data.method in EntityClass)) {
+                            httpError(response, 400);
+                            return;
+                        }
+                        // @ts-ignore Dynamic methods make TypeScript sad.
+                        const method = EntityClass[data.method];
+                        if (typeof method !== 'function') {
+                            httpError(response, 400);
+                            return;
+                        }
+                        if (data.iterator) {
+                            // Ping every 15 seconds to keep connection alive.
+                            const interval = setInterval(() => {
+                                if (response.headersSent) {
+                                    response.write('event: ping\n');
+                                    response.write(`data: ${new Date().toISOString()}\n\n`);
+                                }
+                            }, 15000);
+                            try {
+                                response.set({
+                                    'Cache-Control': 'no-cache',
+                                    'Content-Type': 'text/event-stream',
+                                    Connection: 'keep-alive',
+                                });
+                                response.flushHeaders();
+                                const result = method.call(EntityClass, ...params);
+                                let sequence = result;
+                                if (result instanceof Promise) {
+                                    sequence = await result;
+                                }
+                                let { value, done } = await sequence.next(response.destroyed);
+                                while (!done) {
+                                    response.write('event: next\n');
+                                    response.write(`data: ${JSON.stringify(value)}\n\n`);
+                                    // Wait for an event loop each iteration, to allow data to flush.
+                                    await new Promise((resolve) => setImmediate(resolve));
+                                    ({ value, done } = await sequence.next(response.destroyed));
+                                }
+                                clearInterval(interval);
+                                response.write('event: finished\n');
+                                response.write('data: \n\n');
+                                response.end();
+                            }
+                            catch (e) {
+                                clearInterval(interval);
+                                eventStreamError(response, 500, e);
+                                return;
+                            }
+                        }
+                        else {
+                            try {
+                                const result = method.call(EntityClass, ...params);
+                                let ret = result;
+                                if (result instanceof Promise) {
+                                    ret = await result;
+                                }
+                                response.status(200);
+                                response.setHeader('Content-Type', 'application/json');
+                                response.send({ return: ret });
+                            }
+                            catch (e) {
+                                httpError(response, 500, e);
+                                return;
+                            }
+                        }
+                    }
+                    else {
+                        let entity;
+                        try {
+                            entity = await loadEntity(data.entity, response.locals.nymph);
+                        }
+                        catch (e) {
+                            if (e instanceof EntityConflictError) {
+                                httpError(response, 409);
+                            }
+                            else if (e instanceof ForbiddenClassError) {
+                                httpError(response, 403);
+                            }
+                            else if (e.message === NOT_FOUND_ERROR) {
+                                httpError(response, 404, e);
+                            }
+                            else if (e instanceof InvalidParametersError) {
+                                httpError(response, 400, e);
+                            }
+                            else {
+                                httpError(response, 500, e);
+                            }
+                            return;
+                        }
+                        if (data.entity.guid && !entity.guid) {
+                            httpError(response, 400);
+                            return;
+                        }
+                        if (entity.$getClientEnabledMethods().indexOf(data.method) === -1) {
+                            httpError(response, 403);
+                            return;
+                        }
+                        if (!(data.method in entity) ||
+                            typeof entity[data.method] !== 'function') {
+                            httpError(response, 400);
+                            return;
+                        }
+                        try {
+                            const result = entity[data.method](...params);
+                            let ret = result;
+                            if (result instanceof Promise) {
+                                ret = await result;
+                            }
+                            response.status(200);
+                            response.setHeader('Content-Type', 'application/json');
+                            if (data.stateless) {
+                                response.send({ return: ret });
+                            }
+                            else {
+                                response.send({ entity: entity, return: ret });
+                            }
+                        }
+                        catch (e) {
+                            httpError(response, 500, e);
+                            return;
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e instanceof ForbiddenClassError) {
+                        httpError(response, 403);
+                        return;
+                    }
+                    else {
+                        httpError(response, 500, e);
+                        return;
+                    }
+                }
+            }
+            else {
+                if (typeof data !== 'string') {
+                    httpError(response, 400);
+                    return;
+                }
+                if (response.locals.nymph.tilmeld) {
+                    if (!(await response.locals.nymph.tilmeld.checkClientUIDPermissions(data, TilmeldAccessLevels.WRITE_ACCESS))) {
+                        httpError(response, 403);
+                        return;
+                    }
+                }
+                let result;
+                try {
+                    result = await response.locals.nymph.newUID(data);
+                }
+                catch (e) {
+                    httpError(response, 500, e);
+                    return;
+                }
+                if (typeof result !== 'number') {
+                    httpError(response, 500);
+                    return;
+                }
+                response.status(201);
+                response.setHeader('Content-Type', 'text/plain');
+                response.send(`${result}`);
+            }
+        }
+        catch (e) {
+            httpError(response, 500, e);
+            return;
+        }
+    });
+    rest.put('/', async (request, response) => {
+        try {
+            const { action, data } = getActionData(request);
+            if (['entity', 'entities', 'uid'].indexOf(action) === -1) {
+                httpError(response, 400);
+                return;
+            }
+            await doPutOrPatch(response, action, data, false);
+        }
+        catch (e) {
+            httpError(response, 500, e);
+            return;
+        }
+    });
+    rest.patch('/', async (request, response) => {
+        try {
+            const { action, data } = getActionData(request);
+            if (['entity', 'entities'].indexOf(action) === -1) {
+                httpError(response, 400);
+                return;
+            }
+            await doPutOrPatch(response, action, data, true);
+        }
+        catch (e) {
+            httpError(response, 500, e);
+            return;
+        }
+    });
+    async function doPutOrPatch(response, action, data, patch) {
+        if (action === 'uid') {
+            if (typeof data.name !== 'string' || typeof data.value !== 'number') {
+                httpError(response, 400);
+                return;
+            }
+            if (response.locals.nymph.tilmeld) {
+                if (!(await response.locals.nymph.tilmeld.checkClientUIDPermissions(data.name, TilmeldAccessLevels.FULL_ACCESS))) {
+                    httpError(response, 403);
+                    return;
+                }
+            }
+            let result;
+            try {
+                result = await response.locals.nymph.setUID(data.name, data.value);
+            }
+            catch (e) {
+                httpError(response, 500, e);
+                return;
+            }
+            if (!result) {
+                httpError(response, 500);
+                return;
+            }
+            response.status(200);
+            response.setHeader('Content-Type', 'text/plain');
+            response.send(`${result}`);
+        }
+        else {
+            if (action === 'entity') {
+                data = [data];
+            }
+            const saved = [];
+            let hadSuccess = false;
+            let invalidRequest = false;
+            let conflict = false;
+            let forbidden = false;
+            let notfound = false;
+            let lastException = null;
+            for (let entData of data) {
+                if (entData.guid && entData.guid.length != 24) {
+                    invalidRequest = true;
+                    saved.push(null);
+                    continue;
+                }
+                let entity;
+                try {
+                    entity = await loadEntity(entData, response.locals.nymph, patch);
+                }
+                catch (e) {
+                    if (e instanceof EntityConflictError) {
+                        conflict = true;
+                    }
+                    else if (e instanceof ForbiddenClassError) {
+                        forbidden = true;
+                    }
+                    else if (e.message === NOT_FOUND_ERROR) {
+                        notfound = true;
+                    }
+                    else if (e instanceof InvalidParametersError) {
+                        invalidRequest = true;
+                        lastException = e;
+                    }
+                    else {
+                        lastException = e;
+                    }
+                    saved.push(null);
+                    continue;
+                }
+                if (!entity) {
+                    invalidRequest = true;
+                    saved.push(null);
+                    continue;
+                }
+                try {
+                    if (await entity.$save()) {
+                        saved.push(entity);
+                        hadSuccess = true;
+                    }
+                    else {
+                        saved.push(false);
+                    }
+                }
+                catch (e) {
+                    if (e instanceof EntityInvalidDataError) {
+                        invalidRequest = true;
+                    }
+                    else {
+                        lastException = e;
+                    }
+                    saved.push(null);
+                }
+            }
+            if (!hadSuccess) {
+                if (invalidRequest) {
+                    httpError(response, 400, lastException);
+                }
+                else if (forbidden) {
+                    httpError(response, 403);
+                }
+                else if (conflict) {
+                    httpError(response, 409);
+                }
+                else if (notfound) {
+                    httpError(response, 404);
+                }
+                else {
+                    httpError(response, 500, lastException);
+                }
+                return;
+            }
+            response.status(200);
+            response.setHeader('Content-Type', 'application/json');
+            if (action === 'entity') {
+                response.send(JSON.stringify(saved[0]));
+            }
+            else {
+                response.send(saved);
+            }
+        }
+    }
+    rest.delete('/', async (request, response) => {
+        try {
+            const { action, data: dataConst } = getActionData(request);
+            let data = dataConst;
+            if (['entity', 'entities', 'uid'].indexOf(action) === -1) {
+                httpError(response, 400);
+                return;
+            }
+            if (['entity', 'entities'].indexOf(action) !== -1) {
+                if (action === 'entity') {
+                    data = [data];
+                }
+                const deleted = [];
+                let failures = false;
+                let invalidRequest = false;
+                let notfound = false;
+                let lastException = null;
+                for (let entData of data) {
+                    if (entData.guid && entData.guid.length != 24) {
+                        invalidRequest = true;
+                        continue;
+                    }
+                    let EntityClass;
+                    try {
+                        EntityClass = response.locals.nymph.getEntityClass(entData.class);
+                        if (!EntityClass.restEnabled) {
+                            httpError(response, 403);
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        invalidRequest = true;
+                        failures = true;
+                        continue;
+                    }
+                    let entity;
+                    try {
+                        entity = await response.locals.nymph.getEntity({ class: EntityClass }, { type: '&', guid: entData.guid });
+                    }
+                    catch (e) {
+                        lastException = e;
+                        failures = true;
+                        continue;
+                    }
+                    if (!entity) {
+                        notfound = true;
+                        failures = true;
+                        continue;
+                    }
+                    try {
+                        if (await entity.$delete()) {
+                            deleted.push(entData.guid);
+                        }
+                        else {
+                            failures = true;
+                        }
+                    }
+                    catch (e) {
+                        lastException = e;
+                        failures = true;
+                    }
+                }
+                if (deleted.length === 0) {
+                    if (invalidRequest || !failures) {
+                        httpError(response, 400, lastException);
+                    }
+                    else if (notfound) {
+                        httpError(response, 404);
+                    }
+                    else {
+                        httpError(response, 500, lastException);
+                    }
+                    return;
+                }
+                response.status(200);
+                response.setHeader('Content-Type', 'application/json');
+                if (action === 'entity') {
+                    response.send(JSON.stringify(deleted[0]));
+                }
+                else {
+                    response.send(deleted);
+                }
+            }
+            else {
+                if (typeof data !== 'string') {
+                    httpError(response, 400);
+                    return;
+                }
+                if (response.locals.nymph.tilmeld) {
+                    if (!(await response.locals.nymph.tilmeld.checkClientUIDPermissions(data, TilmeldAccessLevels.FULL_ACCESS))) {
+                        httpError(response, 403);
+                        return;
+                    }
+                }
+                let result;
+                try {
+                    result = await response.locals.nymph.deleteUID(data);
+                }
+                catch (e) {
+                    httpError(response, 500, e);
+                    return;
+                }
+                if (!result) {
+                    httpError(response, 500);
+                    return;
+                }
+                response.status(200);
+                response.setHeader('Content-Type', 'application/json');
+                response.send(JSON.stringify(result));
+            }
+        }
+        catch (e) {
+            httpError(response, 500, e);
+            return;
+        }
+    });
+    // Unauthenticate after the request.
+    rest.use(unauthenticateTilmeld);
+    async function loadEntity(entityData, nymph, patch = false, allowConflict = false) {
+        if (entityData.class === 'Entity') {
+            // Don't let clients use the `Entity` class, since it has no validity/AC checks.
+            throw new InvalidParametersError("Can't use Entity class directly from the front end.");
+        }
+        let EntityClass = nymph.getEntityClass(entityData.class);
+        if (!EntityClass.restEnabled) {
+            throw new ForbiddenClassError('Not accessible.');
+        }
+        let entity;
+        if (entityData.guid) {
+            entity = await nymph.getEntity({ class: EntityClass, source: 'client' }, {
+                type: '&',
+                guid: `${entityData['guid']}`,
+            });
+            if (entity === null) {
+                throw new Error(NOT_FOUND_ERROR);
+            }
+        }
+        else {
+            entity = await EntityClass.factory();
+        }
+        if (patch) {
+            entity.$jsonAcceptPatch(entityData, allowConflict);
+        }
+        else {
+            entity.$jsonAcceptData(entityData, allowConflict);
+        }
+        return entity;
+    }
+    /**
+     * Check if an item is a reference, and if it is, convert it to an entity.
+     *
+     * This function will recurse into deeper arrays and objects.
+     *
+     * @param item The item to check.
+     * @returns The item, converted.
+     */
+    function referencesToEntities(item, nymph) {
+        if (item == null) {
+            return item;
+        }
+        else if (Array.isArray(item)) {
+            if (item.length === 3 && item[0] === 'nymph_entity_reference') {
+                try {
+                    const EntityClass = nymph.getEntityClass(item[1]);
+                    if (!EntityClass.restEnabled) {
+                        throw new ForbiddenClassError('Not accessible.');
+                    }
+                    return EntityClass.factoryReference(item);
+                }
+                catch (e) {
+                    return item;
+                }
+            }
+            return item.map((entry) => referencesToEntities(entry, nymph));
+        }
+        else if (typeof item === 'object' && !(item instanceof Entity)) {
+            // Only do this for non-entity objects.
+            const newItem = {};
+            for (let curProperty in item) {
+                newItem[curProperty] = referencesToEntities(item[curProperty], nymph);
+            }
+            return newItem;
+        }
+        return item;
+    }
+    /**
+     * Return the request with an HTTP error response.
+     *
+     * @param res The server response object.
+     * @param defaultStatusCode The HTTP status code to use if none is given in the error object.
+     * @param error An optional error object to report.
+     */
+    function httpError(res, defaultStatusCode, error) {
+        const status = error?.status || defaultStatusCode;
+        const statusText = error?.statusText ||
+            (error?.status == null
+                ? statusDescriptions[defaultStatusCode]
+                : error.status in statusDescriptions &&
+                    statusDescriptions[error.status]) ||
+            'Internal Server Error';
+        const errorResponse = error
+            ? {
+                textStatus: `${status} ${statusText}`,
+                statusText,
+                message: error.message,
+                error,
+                ...(process.env.NODE_ENV !== 'production'
+                    ? { stack: error.stack }
+                    : {}),
+            }
+            : {
+                textStatus: `${status} ${statusText}`,
+                statusText,
+                message: statusText,
+            };
+        if (!res.headersSent) {
+            res.status(status);
+            res.setHeader('Content-Type', 'application/json');
+        }
+        res.send(errorResponse);
+    }
+    /**
+     * End the event stream with an HTTP error response.
+     *
+     * @param res The server response object.
+     * @param defaultStatusCode The HTTP status code to use if none is given in the error object.
+     * @param error An optional error object to report.
+     */
+    function eventStreamError(res, defaultStatusCode, error) {
+        const status = error?.status || defaultStatusCode;
+        const statusText = error?.statusText ||
+            (error?.status == null
+                ? statusDescriptions[defaultStatusCode]
+                : error.status in statusDescriptions &&
+                    statusDescriptions[error.status]) ||
+            'Internal Server Error';
+        const errorResponse = error
+            ? {
+                status,
+                textStatus: `${status} ${statusText}`,
+                statusText,
+                message: error.message,
+                error,
+                ...(process.env.NODE_ENV !== 'production'
+                    ? { stack: error.stack }
+                    : {}),
+            }
+            : {
+                status,
+                textStatus: `${status} ${statusText}`,
+                statusText,
+                message: statusText,
+            };
+        if (!res.headersSent) {
+            res.status(status);
+            res.setHeader('Content-Type', 'application/json');
+            res.send(errorResponse);
+        }
+        else {
+            res.write('event: error\n');
+            res.write(`data: ${JSON.stringify(errorResponse)}\n\n`);
+            res.write('event: finished\n');
+            res.write('data: \n\n');
+            res.end();
+        }
+    }
+    return rest;
+}
+//# sourceMappingURL=createServer.js.map