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

package/dist/index.js

@@ -1,794 +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 });
-exports.HttpError = 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 HttpError_1 = require("./HttpError");
-Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return HttpError_1.HttpError; } });
-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[defaultStatusCode]
-                : error.status in statusDescriptions &&
-                    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.default = createServer;
-const statusDescriptions = {
-    100: 'Continue',
-    101: 'Switching Protocols',
-    102: 'Processing',
-    103: 'Early Hints',
-    200: 'OK',
-    201: 'Created',
-    202: 'Accepted',
-    203: 'Non-Authoritative Information',
-    204: 'No Content',
-    205: 'Reset Content',
-    206: 'Partial Content',
-    207: 'Multi-Status',
-    208: 'Already Reported',
-    226: 'IM Used',
-    300: 'Multiple Choices',
-    301: 'Moved Permanently',
-    302: 'Found',
-    303: 'See Other',
-    304: 'Not Modified',
-    305: 'Use Proxy',
-    306: 'Switch Proxy',
-    307: 'Temporary Redirect',
-    308: 'Permanent Redirect',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    406: 'Not Acceptable',
-    407: 'Proxy Authentication Required',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    410: 'Gone',
-    411: 'Length Required',
-    412: 'Precondition Failed',
-    413: 'Payload Too Large',
-    414: 'URI Too Long',
-    415: 'Unsupported Media Type',
-    416: 'Range Not Satisfiable',
-    417: 'Expectation Failed',
-    418: "I'm a teapot",
-    421: 'Misdirected Request',
-    422: 'Unprocessable Entity',
-    423: 'Locked',
-    424: 'Failed Dependency',
-    425: 'Too Early',
-    426: 'Upgrade Required',
-    428: 'Precondition Required',
-    429: 'Too Many Requests',
-    431: 'Request Header Fields Too Large',
-    451: 'Unavailable For Legal Reasons',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    505: 'HTTP Version Not Supported',
-    506: 'Variant Also Negotiates',
-    507: 'Insufficient Storage',
-    508: 'Loop Detected',
-    510: 'Not Extended',
-    511: 'Network Authentication Required',
-};
+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