@nymphjs/server 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/createServer.js

@@ -0,0 +1,728 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const express_1 = __importDefault(require("express"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const nymph_1 = require("@nymphjs/nymph");
+const nymph_2 = require("@nymphjs/nymph");
+const statusDescriptions_1 = require("./statusDescriptions");
+const NOT_FOUND_ERROR = 'Entity is not found.';
+function createServer(nymph, { jsonOptions = {} } = {}) {
+    const rest = (0, express_1.default)();
+    rest.use((0, cookie_parser_1.default)());
+    rest.use(express_1.default.json(jsonOptions || {}));
+    function instantiateNymph(_request, response, next) {
+        response.locals.nymph = nymph.clone();
+        next();
+    }
+    function authenticateTilmeld(request, response, next) {
+        if (response.locals.nymph.tilmeld) {
+            response.locals.nymph.tilmeld.request = request;
+            response.locals.nymph.tilmeld.response = response;
+            try {
+                response.locals.nymph.tilmeld.authenticate();
+            }
+            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,
+            };
+        }
+    }
+    rest.use(instantiateNymph);
+    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);
+                }
+                catch (e) {
+                    httpError(response, 400, e);
+                    return;
+                }
+                options.class = EntityClass;
+                options.source = 'client';
+                options.skipAc = false;
+                selectors = (0, nymph_1.classNamesToEntityConstructors)(response.locals.nymph, selectors);
+                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 (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data, nymph_1.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 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 nymph_1.EntityConflictError) {
+                            conflict = true;
+                        }
+                        else if (e.message === NOT_FOUND_ERROR) {
+                            notfound = true;
+                        }
+                        else if (e instanceof nymph_1.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 nymph_2.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 (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;
+                }
+                const params = referencesToEntities([...data.params], response.locals.nymph);
+                if (data.static) {
+                    let EntityClass;
+                    try {
+                        EntityClass = response.locals.nymph.getEntityClass(data.class);
+                    }
+                    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;
+                    }
+                    const method = EntityClass[data.method];
+                    if (typeof method !== 'function') {
+                        httpError(response, 400);
+                        return;
+                    }
+                    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 nymph_1.EntityConflictError) {
+                            httpError(response, 409);
+                        }
+                        else if (e.message === NOT_FOUND_ERROR) {
+                            httpError(response, 404, e);
+                        }
+                        else if (e instanceof nymph_1.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;
+                    }
+                }
+            }
+            else {
+                if (typeof data !== 'string') {
+                    httpError(response, 400);
+                    return;
+                }
+                if (response.locals.nymph.tilmeld) {
+                    if (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data, nymph_1.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 (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data.name, nymph_1.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 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 nymph_1.EntityConflictError) {
+                        conflict = true;
+                    }
+                    else if (e.message === NOT_FOUND_ERROR) {
+                        notfound = true;
+                    }
+                    else if (e instanceof nymph_1.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 nymph_2.EntityInvalidDataError) {
+                        invalidRequest = true;
+                    }
+                    else {
+                        lastException = e;
+                    }
+                    saved.push(null);
+                }
+            }
+            if (!hadSuccess) {
+                if (invalidRequest) {
+                    httpError(response, 400, lastException);
+                }
+                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);
+                    }
+                    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 (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data, nymph_1.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;
+        }
+    });
+    rest.use(unauthenticateTilmeld);
+    async function loadEntity(entityData, nymph, patch = false, allowConflict = false) {
+        if (entityData.class === 'Entity') {
+            throw new nymph_1.InvalidParametersError("Can't use Entity class directly from the front end.");
+        }
+        let EntityClass = nymph.getEntityClass(entityData.class);
+        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;
+    }
+    function referencesToEntities(item, nymph) {
+        if (Array.isArray(item)) {
+            if (item.length === 3 && item[0] === 'nymph_entity_reference') {
+                try {
+                    const EntityClass = nymph.getEntityClass(item[1]);
+                    return EntityClass.factoryReference(item);
+                }
+                catch (e) {
+                    return item;
+                }
+            }
+            return item.map((entry) => referencesToEntities(entry, nymph));
+        }
+        else if (typeof item === 'object' && !(item instanceof nymph_1.Entity)) {
+            const newItem = {};
+            for (let curProperty in item) {
+                newItem[curProperty] = referencesToEntities(item[curProperty], nymph);
+            }
+            return newItem;
+        }
+        return item;
+    }
+    function httpError(res, defaultStatusCode, error) {
+        const status = error?.status || defaultStatusCode;
+        const statusText = error?.statusText ||
+            (error?.status == null
+                ? statusDescriptions_1.statusDescriptions[defaultStatusCode]
+                : error.status in statusDescriptions_1.statusDescriptions &&
+                    statusDescriptions_1.statusDescriptions[error.status]) ||
+            'Internal Server Error';
+        if (!res.headersSent) {
+            res.status(status);
+            res.setHeader('Content-Type', 'application/json');
+        }
+        if (error) {
+            res.send({
+                textStatus: `${status} ${statusText}`,
+                statusText,
+                message: error.message,
+                error,
+                ...(process.env.NODE_ENV !== 'production'
+                    ? { stack: error.stack }
+                    : {}),
+            });
+        }
+        else {
+            res.send({
+                textStatus: `${status} ${statusText}`,
+                statusText,
+                message: statusText,
+            });
+        }
+    }
+    return rest;
+}
+exports.createServer = createServer;
+//# sourceMappingURL=createServer.js.map