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

package/dist/index.js

@@ -1,716 +1,22 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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 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, 'Internal Server Error', 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, 'Internal Server Error', 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, 'Bad Request');
-                return;
-            }
-            if (['entity', 'entities'].indexOf(action) !== -1) {
-                if (!Array.isArray(data)) {
-                    httpError(response, 400, 'Bad Request');
-                    return;
-                }
-                const count = data.length;
-                if (count < 1 || typeof data[0] !== 'object') {
-                    httpError(response, 400, 'Bad Request');
-                    return;
-                }
-                if (!('class' in data[0])) {
-                    httpError(response, 400, 'Bad Request');
-                    return;
-                }
-                let [options, ...selectors] = data;
-                let EntityClass;
-                try {
-                    EntityClass = response.locals.nymph.getEntityClass(data[0].class);
-                }
-                catch (e) {
-                    httpError(response, 400, 'Bad Request', 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, 'Internal Server Error', e);
-                    return;
-                }
-                if (result == null || (Array.isArray(result) && result.length === 0)) {
-                    if (action === 'entity' ||
-                        response.locals.nymph.config.emptyListError) {
-                        httpError(response, 404, 'Not Found');
-                        return;
-                    }
-                }
-                response.setHeader('Content-Type', 'application/json');
-                response.send(JSON.stringify(result));
-            }
-            else {
-                if (typeof data !== 'string') {
-                    httpError(response, 400, 'Bad Request');
-                    return;
-                }
-                if (response.locals.nymph.tilmeld) {
-                    if (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data, nymph_1.TilmeldAccessLevels.READ_ACCESS)) {
-                        httpError(response, 403, 'Forbidden');
-                        return;
-                    }
-                }
-                let result;
-                try {
-                    result = await response.locals.nymph.getUID(data);
-                }
-                catch (e) {
-                    httpError(response, 500, 'Internal Server Error', e);
-                    return;
-                }
-                if (result === null) {
-                    httpError(response, 404, 'Not Found');
-                    return;
-                }
-                else if (typeof result !== 'number') {
-                    httpError(response, 500, 'Internal Server Error');
-                    return;
-                }
-                response.setHeader('Content-Type', 'text/plain');
-                response.send(`${result}`);
-            }
-        }
-        catch (e) {
-            httpError(response, 500, 'Internal Server Error', 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, 'Bad Request');
-                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, 'Bad Request', lastException);
-                        return;
-                    }
-                    else if (conflict) {
-                        httpError(response, 409, 'Conflict');
-                        return;
-                    }
-                    else if (notfound) {
-                        httpError(response, 404, 'Not Found');
-                        return;
-                    }
-                    else {
-                        httpError(response, 500, 'Internal Server Error', 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, 'Bad Request');
-                    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, 'Bad Request');
-                        return;
-                    }
-                    if (EntityClass.clientEnabledStaticMethods.indexOf(data.method) === -1) {
-                        httpError(response, 403, 'Forbidden');
-                        return;
-                    }
-                    if (!(data.method in EntityClass)) {
-                        httpError(response, 400, 'Bad Request');
-                        return;
-                    }
-                    const method = EntityClass[data.method];
-                    if (typeof method !== 'function') {
-                        httpError(response, 400, 'Bad Request');
-                        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, 'Internal Server Error', 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, 'Conflict');
-                        }
-                        else if (e.message === NOT_FOUND_ERROR) {
-                            httpError(response, 404, 'Not Found', e);
-                        }
-                        else if (e instanceof nymph_1.InvalidParametersError) {
-                            httpError(response, 400, 'Bad Request', e);
-                        }
-                        else {
-                            httpError(response, 500, 'Internal Server Error', e);
-                        }
-                        return;
-                    }
-                    if (data.entity.guid && !entity.guid) {
-                        httpError(response, 400, 'Bad Request');
-                        return;
-                    }
-                    if (entity.$getClientEnabledMethods().indexOf(data.method) === -1) {
-                        httpError(response, 403, 'Forbidden');
-                        return;
-                    }
-                    if (!(data.method in entity) ||
-                        typeof entity[data.method] !== 'function') {
-                        httpError(response, 400, 'Bad Request');
-                        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, 'Internal Server Error', e);
-                        return;
-                    }
-                }
-            }
-            else {
-                if (typeof data !== 'string') {
-                    httpError(response, 400, 'Bad Request');
-                    return;
-                }
-                if (response.locals.nymph.tilmeld) {
-                    if (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data, nymph_1.TilmeldAccessLevels.WRITE_ACCESS)) {
-                        httpError(response, 403, 'Forbidden');
-                        return;
-                    }
-                }
-                let result;
-                try {
-                    result = await response.locals.nymph.newUID(data);
-                }
-                catch (e) {
-                    httpError(response, 500, 'Internal Server Error', e);
-                    return;
-                }
-                if (typeof result !== 'number') {
-                    httpError(response, 500, 'Internal Server Error');
-                    return;
-                }
-                response.status(201);
-                response.setHeader('Content-Type', 'text/plain');
-                response.send(`${result}`);
-            }
-        }
-        catch (e) {
-            httpError(response, 500, 'Internal Server Error', e);
-            return;
-        }
-    });
-    rest.put('/', async (request, response) => {
-        try {
-            const { action, data } = getActionData(request);
-            if (['entity', 'entities', 'uid'].indexOf(action) === -1) {
-                httpError(response, 400, 'Bad Request');
-                return;
-            }
-            await doPutOrPatch(response, action, data, false);
-        }
-        catch (e) {
-            httpError(response, 500, 'Internal Server Error', e);
-            return;
-        }
-    });
-    rest.patch('/', async (request, response) => {
-        try {
-            const { action, data } = getActionData(request);
-            if (['entity', 'entities'].indexOf(action) === -1) {
-                httpError(response, 400, 'Bad Request');
-                return;
-            }
-            await doPutOrPatch(response, action, data, true);
-        }
-        catch (e) {
-            httpError(response, 500, 'Internal Server Error', e);
-            return;
-        }
-    });
-    async function doPutOrPatch(response, action, data, patch) {
-        if (action === 'uid') {
-            if (typeof data.name !== 'string' || typeof data.value !== 'number') {
-                httpError(response, 400, 'Bad Request');
-                return;
-            }
-            if (response.locals.nymph.tilmeld) {
-                if (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data.name, nymph_1.TilmeldAccessLevels.FULL_ACCESS)) {
-                    httpError(response, 403, 'Forbidden');
-                    return;
-                }
-            }
-            let result;
-            try {
-                result = await response.locals.nymph.setUID(data.name, data.value);
-            }
-            catch (e) {
-                httpError(response, 500, 'Internal Server Error', e);
-                return;
-            }
-            if (!result) {
-                httpError(response, 500, 'Internal Server Error');
-                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, 'Bad Request', lastException);
-                }
-                else if (conflict) {
-                    httpError(response, 409, 'Conflict');
-                }
-                else if (notfound) {
-                    httpError(response, 404, 'Not Found');
-                }
-                else {
-                    httpError(response, 500, 'Internal Server Error', 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, 'Bad Request');
-                return;
-            }
-            if (['entity', 'entities'].indexOf(action) !== -1) {
-                if (action === 'entity') {
-                    data = [data];
-                }
-                const deleted = [];
-                let failures = false;
-                let hadSuccess = 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);
-                            hadSuccess = true;
-                        }
-                        else {
-                            failures = true;
-                        }
-                    }
-                    catch (e) {
-                        lastException = e;
-                        failures = true;
-                    }
-                }
-                if (deleted.length === 0) {
-                    if (invalidRequest || !failures) {
-                        httpError(response, 400, 'Bad Request', lastException);
-                    }
-                    else if (notfound) {
-                        httpError(response, 404, 'Not Found');
-                    }
-                    else {
-                        httpError(response, 500, 'Internal Server Error', 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, 'Bad Request');
-                    return;
-                }
-                if (response.locals.nymph.tilmeld) {
-                    if (!response.locals.nymph.tilmeld.checkClientUIDPermissions(data, nymph_1.TilmeldAccessLevels.FULL_ACCESS)) {
-                        httpError(response, 403, 'Forbidden');
-                        return;
-                    }
-                }
-                let result;
-                try {
-                    result = await response.locals.nymph.deleteUID(data);
-                }
-                catch (e) {
-                    httpError(response, 500, 'Internal Server Error', e);
-                    return;
-                }
-                if (!result) {
-                    httpError(response, 500, 'Internal Server Error');
-                    return;
-                }
-                response.status(200);
-                response.setHeader('Content-Type', 'application/json');
-                response.send(JSON.stringify(result));
-            }
-        }
-        catch (e) {
-            httpError(response, 500, 'Internal Server Error', 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, errorCode, message, error) {
-        if (!res.headersSent) {
-            res.status(errorCode);
-            res.setHeader('Content-Type', 'application/json');
-        }
-        if (error) {
-            res.send({
-                textStatus: `${errorCode} ${message}`,
-                message: error.message,
-                error,
-                ...(process.env.NODE_ENV !== 'production'
-                    ? { stack: error.stack }
-                    : {}),
-            });
-        }
-        else {
-            res.send({ textStatus: `${errorCode} ${message}` });
-        }
-    }
-    return rest;
-}
-exports.default = createServer;
+const createServer_1 = require("./createServer");
+__exportStar(require("./HttpError"), exports);
+__exportStar(require("./statusDescriptions"), exports);
+__exportStar(require("./createServer"), exports);
+exports.default = createServer_1.createServer;
 //# sourceMappingURL=index.js.map