@mountainpass/waycharter 1.0.74 → 2.0.0

package/dist/waycharter.js

@@ -1,308 +1,494 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WayCharter = void 0;
-
-var _express = require("express");
-
-var _uriTemplateLite = require("uri-template-lite");
-
-var _jsonpointer = _interopRequireDefault(require("jsonpointer"));
-
-var _methodCanHaveBody = require("./method-can-have-body");
-
-var _convertResourceLinks = require("./convert-resource-links");
-
-var _buildFirstLink = require("./collections/build-first-link");
-
-var _buildPreviousLink = require("./collections/build-previous-link");
-
-var _buildNextLink = require("./collections/build-next-link");
-
-var _builtItemLinks = require("./collections/built-item-links");
-
-var _methodIsCacheable = require("./method-is-cacheable");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * @param url
- */
-function routerToRfc6570(url) {
-  return url.replace(/:(\w*)/g, '{+$1}');
-}
-
-class WayCharter {
-  constructor() {
-    this.router = (0, _express.Router)();
-  }
-
-  registerResourceType({
-    path,
-    loader,
-    loaderVaries
-  }) {
-    // TODO: error handling for path not set
-    // TODO: error handling for loader not set
-    const lowerCaseLoaderVaries = new Set(loaderVaries ? loaderVaries.map(header => header.toLowerCase()) : []);
-    const uriTemplate = routerToRfc6570(path);
-    this.router.get(path, async function (request, response, next) {
-      const filteredHeaders = Object.keys(request.headers).reduce((filtered, key) => lowerCaseLoaderVaries.has(key) ? { ...filtered,
-        [key]: request.headers[key]
-      } : filtered, {});
-
-      try {
-        const resource = await loader({ ...request.params,
-          ...request.query
-        }, filteredHeaders, request.url);
-
-        if (loaderVaries) {
-          response.header('vary', [...lowerCaseLoaderVaries]);
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
         }
-
-        sendResponse(resource, response, request.url, [{
-          rel: 'self',
-          uri: request.url
-        }]);
-      } catch (error) {
-        // next(error)
-        console.error(error);
-        response.status(500);
-        response.json({});
-      }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-    return {
-      pathTemplate: uriTemplate,
-      path: parameters => _uriTemplateLite.URI.expand(uriTemplate, parameters)
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
     };
-  }
-
-  registerOperation({
-    method,
-    path,
-    operation,
-    bodyParameters,
-    headerParameters
-  }) {
-    const upperCaseMethod = method.toUpperCase();
-    const lowerCaseMethod = method.toLowerCase();
-    const lowerCaseHeaderParameters = headerParameters && new Set(headerParameters.map(header => header.toLowerCase()));
-    this.router[lowerCaseMethod](path, async (request, response, next) => {
-      try {
-        let filteredHeaders = request.headers;
-
-        if ((0, _methodIsCacheable.methodIsCacheable)(upperCaseMethod) && headerParameters) {
-          response.header('vary', [...lowerCaseHeaderParameters]);
-          filteredHeaders = {};
-
-          for (const headerName in request.headers) {
-            if (lowerCaseHeaderParameters.has(headerName)) {
-              filteredHeaders[headerName] = request.headers[headerName];
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndPoint = void 0;
+var uri_template_lite_1 = require("uri-template-lite");
+var convert_resource_links_1 = require("./util/convert-resource-links");
+var build_first_link_1 = require("./collections/build-first-link");
+var build_previous_link_1 = require("./collections/build-previous-link");
+var build_next_link_1 = require("./collections/build-next-link");
+var built_item_links_1 = require("./collections/built-item-links");
+var router_to_rfc6570_1 = require("./util/router-to-rfc6570");
+var to_links_1 = require("./to-links");
+var filter_headers_1 = require("./util/filter-headers");
+var check_page_1 = require("./util/check-page");
+var extract_path_parameters_1 = require("./util/extract-path-parameters");
+var array_to_lower_case_1 = require("./util/array-to-lower-case");
+var filter_parameters_1 = require("./util/filter-parameters");
+var unique_1 = require("./util/unique");
+/**
+ * @param resource
+ * @param response
+ * @param requestUrl
+ * @param additionalLinks
+ */
+function sendHandlerResponse(resource, response, additionalLinks) {
+    if (resource.links || additionalLinks) {
+        var links = (0, convert_resource_links_1.covertResourceLinks)(__spreadArray(__spreadArray([], __read((additionalLinks || [])), false), __read((resource.links || [])), false));
+        response.header('link', links.toString());
+    }
+    if (resource.status) {
+        response.status(resource.status);
+    }
+    if (resource.headers) {
+        for (var header in resource.headers) {
+            response.header(header, resource.headers[header]);
+        }
+    }
+    if ('body' in resource) {
+        response.json(resource.body);
+    }
+    else {
+        response.end();
+    }
+}
+var EndPoint = /** @class */ (function () {
+    function EndPoint(_a) {
+        var e_1, _b;
+        var _this = this;
+        var router = _a.router, path = _a.path, headerParameters = _a.headerParameters, handler = _a.handler, actions = _a.actions, links = _a.links;
+        this.router = router;
+        this.handler = handler;
+        this.headerParameters = (0, unique_1.unique)((0, array_to_lower_case_1.arrayToLowerCase)(headerParameters));
+        this.pathTemplate = (0, router_to_rfc6570_1.routerToRfc6570)(path);
+        this.pathParameters = (0, extract_path_parameters_1.extractPathParameters)(this.pathTemplate);
+        this.links = links || [];
+        router.get(path, function (request, response, next) { return __awaiter(_this, void 0, void 0, function () {
+            var filteredHeaders, error_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        filteredHeaders = (0, filter_headers_1.filterHeaders)(request, response, this.headerParameters);
+                        response.chart = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                this.sendResponse(resource, request, response, actions);
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        response.chartError = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                this.sendResponse(resource, request, response, actions);
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        response.chartRedirect = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                this.sendResponse(resource, request, response, actions);
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        return [4 /*yield*/, this.handler({
+                                pathParameters: request.params,
+                                queryParameters: request.query,
+                                requestHeaders: filteredHeaders,
+                                request: request,
+                                response: response,
+                                next: next
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        next(error_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); });
+        for (var method in actions) {
+            var methodActions = actions[method];
+            var _loop_1 = function (action) {
+                router[method.toLowerCase()](path, function (request, response, next) { return __awaiter(_this, void 0, void 0, function () {
+                    var parameters, handler_1, filteredBodyParameters;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        response.chart = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                this.sendResponse(resource, request, response, actions);
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        try {
+                            parameters = action.parameters, handler_1 = action.handler;
+                            filteredBodyParameters = (0, filter_parameters_1.filterBodyParameters)(request, parameters);
+                            handler_1({
+                                pathParameters: request.params,
+                                queryParameters: request.query,
+                                bodyParameters: filteredBodyParameters,
+                                request: request,
+                                response: response,
+                                next: next
+                            });
+                        }
+                        catch (error) {
+                            next(error);
+                        }
+                        return [2 /*return*/];
+                    });
+                }); });
+            };
+            try {
+                for (var methodActions_1 = (e_1 = void 0, __values(methodActions)), methodActions_1_1 = methodActions_1.next(); !methodActions_1_1.done; methodActions_1_1 = methodActions_1.next()) {
+                    var action = methodActions_1_1.value;
+                    _loop_1(action);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (methodActions_1_1 && !methodActions_1_1.done && (_b = methodActions_1.return)) _b.call(methodActions_1);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
-          }
         }
-
-        const resource = await operation({
-          parameters: { ...request.params,
-            ...request.query,
-            ...((0, _methodCanHaveBody.methodCanHaveBody)(upperCaseMethod) && request.body)
-          },
-          requestHeaders: filteredHeaders,
-          requestUrl: request.url,
-          request,
-          response
+    }
+    EndPoint.createStatic = function (_a) {
+        var _this = this;
+        var router = _a.router, path = _a.path, headerParameters = _a.headerParameters, actions = _a.actions, handlerResponse = __rest(_a, ["router", "path", "headerParameters", "actions"]);
+        return EndPoint.create({
+            router: router,
+            path: path,
+            headerParameters: headerParameters,
+            handler: function (_a) {
+                var response = _a.response;
+                return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_b) {
+                        response.chart(handlerResponse);
+                        return [2 /*return*/];
+                    });
+                });
+            },
+            actions: actions,
         });
-        sendResponse(resource, response, request.url);
-      } catch (error) {
-        // next(error)
-        console.error(error);
-        response.status(500);
-        response.json({});
-      }
-    });
-    const uriTemplate = routerToRfc6570(path);
-    const template = new _uriTemplateLite.URI.Template(uriTemplate);
-    const pathParameters = template.match(uriTemplate);
-    return {
-      method: upperCaseMethod,
-      ...((0, _methodCanHaveBody.methodCanHaveBody)(upperCaseMethod) && {
-        bodyParameters
-      }),
-      pathParameters,
-      ...((0, _methodIsCacheable.methodIsCacheable)(upperCaseMethod) && {
-        headerParameters: lowerCaseHeaderParameters
-      }),
-      pathTemplate: uriTemplate,
-      path: parameters => _uriTemplateLite.URI.expand(uriTemplate, parameters)
     };
-  }
-
-  registerStaticResource({
-    path,
-    body,
-    links
-  }) {
-    // TODO: error handling for path not set
-    // TODO: error handling for body not set
-    return this.registerResourceType({
-      path,
-      loader: async () => {
-        return {
-          body,
-          links
-        };
-      }
-    });
-  }
-
-  registerCollection({
-    itemPath,
-    itemLoader,
-    collectionPath,
-    collectionLoader,
-    filters = []
-  }) {
-    // TODO: error handling for itemPath set, but itemLoader isn't and visa-versa
-    // TODO: error handling for collectionPath not set
-    // TODO: error handling for collectionLoader not set
-    const itemType = itemPath !== undefined && itemLoader !== undefined ? this.registerResourceType({
-      path: `${collectionPath}${itemPath}`,
-      loader: itemLoader
-    }) : undefined;
-    const linkTemplates = [];
-
-    for (const filter of filters) {
-      linkTemplates.push({
-        rel: filter.rel,
-        uri: `${collectionPath}{?${filter.parameters.join(',')}}`
-      });
-    }
-
-    const type = this.registerResourceType({
-      path: collectionPath,
-      loader: async ({
-        page,
-        ...otherParameters
-      }, filteredHeaders, selfUri) => {
-        // ${collectionPath}?page=0 should redirect to ${collectionPath}
-        if (page === '0') {
-          return {
-            status: 308,
-            headers: {
-              location: collectionPath
+    EndPoint.createCollection = function (_a) {
+        var e_2, _b, e_3, _c;
+        var _this = this;
+        var router = _a.router, path = _a.path, headerParameters = _a.headerParameters, filters = _a.filters, handler = _a.handler, actions = _a.actions, links = _a.links, itemActions = _a.itemActions, itemEndpoint = _a.itemEndpoint;
+        var filterLinks = [];
+        try {
+            for (var _d = __values(filters || []), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var filter = _e.value;
+                filterLinks.push({
+                    rel: filter.rel,
+                    uri: "".concat(path, "{?").concat(filter.parameters.join(','), "}")
+                });
             }
-          };
-        } // TODO: page is not a number
-        // page should be >= 0
-
-
-        const pageInt = Number.parseInt(page || '0');
-
-        if (page < 0) {
-          return {
-            status: 400
-          };
         }
-
-        const filteredParameters = {};
-
-        for (const filter of filters) {
-          for (const parameter of filter.parameters) {
-            if (otherParameters[parameter] !== undefined) {
-              filteredParameters[parameter] = otherParameters[parameter];
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
             }
-          }
+            finally { if (e_2) throw e_2.error; }
         }
-
-        const {
-          body,
-          arrayPointer,
-          hasMore,
-          headers,
-          itemOperations
-        } = await collectionLoader({
-          page: pageInt,
-          ...filteredParameters
+        var endpoint = new EndPoint({
+            router: router,
+            path: path,
+            headerParameters: headerParameters,
+            actions: actions,
+            links: __spreadArray(__spreadArray([], __read(links || []), false), __read(filterLinks), false),
+            handler: function (_a) {
+                var pathParameters = _a.pathParameters, queryParameters = _a.queryParameters, requestHeaders = _a.requestHeaders, request = _a.request, response = _a.response, next = _a.next;
+                return __awaiter(_this, void 0, void 0, function () {
+                    var expandedPath, page, pageCheckResult, filteredQueryParameters_1;
+                    var _this = this;
+                    return __generator(this, function (_b) {
+                        expandedPath = endpoint.path(__assign(__assign({}, pathParameters || {}), queryParameters || {}));
+                        page = queryParameters.page;
+                        pageCheckResult = (0, check_page_1.checkPage)(page, expandedPath);
+                        if ('redirect' in pageCheckResult) {
+                            response.chartRedirect(pageCheckResult.redirect);
+                        }
+                        else if ('pageValidationError' in pageCheckResult) {
+                            response.chartError(pageCheckResult.pageValidationError);
+                        }
+                        else {
+                            filteredQueryParameters_1 = (0, filter_parameters_1.filterParameters)(filters, request.query);
+                            response.chartCollection = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    sendCollectionHandlerResponse(resource, request.url, response, pageCheckResult.pageInt, expandedPath, filteredQueryParameters_1, itemActions, itemEndpoint);
+                                    return [2 /*return*/];
+                                });
+                            }); };
+                            handler({
+                                page: pageCheckResult.pageInt,
+                                pathParameters: request.params,
+                                queryParameters: filteredQueryParameters_1,
+                                requestHeaders: requestHeaders,
+                                request: request,
+                                response: response,
+                                next: next
+                            });
+                        }
+                        return [2 /*return*/];
+                    });
+                });
+            }
         });
-        const array = arrayPointer ? _jsonpointer.default.get(body, arrayPointer) : body;
-        const {
-          itemLinks,
-          canonicalLinks
-        } = (0, _builtItemLinks.builtItemLinks)(array, arrayPointer, itemType, selfUri, itemOperations);
-        return {
-          body,
-          links: [...itemLinks, ...canonicalLinks, ...(0, _buildNextLink.buildNextLink)(hasMore, pageInt, collectionPath, otherParameters), ...(0, _buildPreviousLink.buildPreviousLink)(pageInt, collectionPath, otherParameters), ...(0, _buildFirstLink.buildFirstLink)(hasMore, pageInt, collectionPath, otherParameters)],
-          linkTemplates,
-          headers
-        };
-      }
-    });
-    return { ...type,
-      additionalPaths: linkTemplates
+        for (var method in itemActions) {
+            var methodActions = itemActions[method];
+            var _loop_2 = function (action) {
+                router[method.toLowerCase()](path, function (request, response, next) { return __awaiter(_this, void 0, void 0, function () {
+                    var parameters, handler_2, filteredBodyParameters;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        response.chart = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                endpoint.sendResponse(resource, request, response, actions, itemActions);
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        response.chartError = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                endpoint.sendResponse(resource, request, response, actions, itemActions);
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        try {
+                            parameters = action.parameters, handler_2 = action.handler;
+                            filteredBodyParameters = (0, filter_parameters_1.filterBodyParameters)(request, parameters);
+                            handler_2({
+                                pathParameters: request.params,
+                                queryParameters: (0, filter_parameters_1.filterParameters)(filters, request.query),
+                                bodyParameters: filteredBodyParameters,
+                                request: request,
+                                response: response,
+                                next: next
+                            });
+                        }
+                        catch (error) {
+                            next(error);
+                        }
+                        return [2 /*return*/];
+                    });
+                }); });
+            };
+            try {
+                for (var methodActions_2 = (e_3 = void 0, __values(methodActions)), methodActions_2_1 = methodActions_2.next(); !methodActions_2_1.done; methodActions_2_1 = methodActions_2.next()) {
+                    var action = methodActions_2_1.value;
+                    _loop_2(action);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (methodActions_2_1 && !methodActions_2_1.done && (_c = methodActions_2.return)) _c.call(methodActions_2);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        endpoint.addDefaultHandler(path, actions, itemActions);
+        return endpoint;
     };
-  }
-
-  registerStaticCollection({
-    collectionPath,
-    collection,
-    pageSize,
-    arrayPointer,
-    headers
-  }) {
-    return this.registerCollection({
-      collectionPath,
-      collectionLoader: async ({
-        page
-      }) => {
-        const items = pageSize ? collection.slice(page * pageSize, (page + 1) * pageSize) : collection;
-        return {
-          body: items,
-          hasMore: pageSize && page < collection.length / pageSize - 1,
-          arrayPointer,
-          headers
-        };
-      }
-    });
-  }
-
-}
+    EndPoint.createStaticCollection = function (_a) {
+        var _this = this;
+        var router = _a.router, path = _a.path, headerParameters = _a.headerParameters, filters = _a.filters, actions = _a.actions, itemActions = _a.itemActions, itemEndpoint = _a.itemEndpoint, collectionHandlerResponse = __rest(_a, ["router", "path", "headerParameters", "filters", "actions", "itemActions", "itemEndpoint"]);
+        return EndPoint.createCollection({
+            router: router,
+            path: path,
+            headerParameters: headerParameters,
+            filters: filters,
+            handler: function (_a) {
+                var response = _a.response;
+                return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_b) {
+                        response.chartCollection(collectionHandlerResponse);
+                        return [2 /*return*/];
+                    });
+                });
+            },
+            actions: actions,
+            itemActions: itemActions,
+            itemEndpoint: itemEndpoint
+        });
+    };
+    EndPoint.create = function (_a) {
+        var router = _a.router, path = _a.path, headerParameters = _a.headerParameters, handler = _a.handler, actions = _a.actions, links = _a.links;
+        var endpoint = new EndPoint({
+            router: router,
+            path: path,
+            headerParameters: headerParameters,
+            handler: handler,
+            actions: actions,
+            links: links
+        });
+        endpoint.addDefaultHandler(path, actions);
+        return endpoint;
+    };
+    EndPoint.prototype.addDefaultHandler = function (path, actions, itemActions) {
+        var _this = this;
+        // default options handler
+        this.router.options(path, function (request, response, next) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.sendResponse({
+                    status: 204,
+                    headers: {
+                        allow: (0, unique_1.unique)(__spreadArray(__spreadArray([
+                            'GET',
+                            'HEAD',
+                            'OPTIONS'
+                        ], __read((actions ? Object.keys(actions) : [])), false), __read((itemActions ? Object.keys(itemActions) : [])), false)).join(', ')
+                    }
+                }, request, response, actions, itemActions);
+                return [2 /*return*/];
+            });
+        }); });
+        this.router.all(path, function (request, response, next) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.sendResponse({
+                    status: 406
+                }, request, response, actions, itemActions);
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    EndPoint.prototype.sendResponse = function (resource, request, response, actions, itemActions) {
+        var actionLinks = __spreadArray(__spreadArray([], __read((actions ? (0, to_links_1.toLinks)(actions, request.url) : [])), false), __read((itemActions ? (0, to_links_1.toLinks)(itemActions, request.url) : [])), false);
+        if (this.headerParameters.length > 0) {
+            response.header('vary', this.headerParameters);
+        }
+        sendHandlerResponse(resource, response, __spreadArray(__spreadArray([
+            {
+                rel: 'self',
+                uri: request.url
+            }
+        ], __read(this.links), false), __read(actionLinks), false));
+    };
+    EndPoint.prototype.sendCollectionResponse = function (resource, request, response, actions, itemActions) {
+        var actionLinks = __spreadArray(__spreadArray([], __read((actions ? (0, to_links_1.toLinks)(actions, request.url) : [])), false), __read((itemActions ? (0, to_links_1.toLinks)(itemActions, request.url) : [])), false);
+        if (this.headerParameters.length > 0) {
+            response.header('vary', this.headerParameters);
+        }
+        sendHandlerResponse(resource, response, __spreadArray(__spreadArray([
+            {
+                rel: 'self',
+                uri: request.url
+            }
+        ], __read(this.links), false), __read(actionLinks), false));
+    };
+    EndPoint.prototype.path = function (parameters) {
+        return parameters
+            ? uri_template_lite_1.URI.expand(this.pathTemplate, parameters)
+            : this.pathTemplate;
+    };
+    EndPoint.prototype.linkTo = function (link) {
+        this.links.push(link);
+        return this;
+    };
+    return EndPoint;
+}());
+exports.EndPoint = EndPoint;
 /**
  * @param resource
- * @param response
  * @param requestUrl
- * @param additionalLinks
+ * @param response
+ * @param pageInt
+ * @param expandedPath
+ * @param filteredParameters
+ * @param itemActions
+ * @param itemEndpoint
+ * @param staticLinks
  */
-
-
-exports.WayCharter = WayCharter;
-
-function sendResponse(resource, response, requestUrl, additionalLinks = []) {
-  if (resource.links || additionalLinks.length > 0) {
-    const links = (0, _convertResourceLinks.covertResourceLinks)([...additionalLinks, ...(resource.links || [])]);
-    response.header('link', links.toString());
-  }
-
-  if (resource.linkTemplates) {
-    const linkTemplates = (0, _convertResourceLinks.covertResourceLinks)(resource.linkTemplates);
-    response.header('link-template', linkTemplates.toString());
-  }
-
-  if (resource.status) {
-    response.status(resource.status);
-  }
-
-  if (resource.headers) {
-    for (const header in resource.headers) {
-      response.header(header, resource.headers[header]);
-    }
-  }
-
-  if (resource.body) {
-    response.json(resource.body);
-  } else {
-    response.end();
-  }
+function sendCollectionHandlerResponse(resource, requestUrl, response, pageInt, expandedPath, filteredParameters, itemActions, itemEndpoint) {
+    var body = resource.body, collectionPointer = resource.collectionPointer, hasMore = resource.hasMore, links = resource.links, other = __rest(resource, ["body", "collectionPointer", "hasMore", "links"]);
+    var _a = (0, built_item_links_1.builtItemLinks)(collectionPointer, itemEndpoint, requestUrl, itemActions), itemLinks = _a.itemLinks, canonicalLinks = _a.canonicalLinks;
+    response.chart(__assign({ body: body, links: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(itemLinks), false), __read(canonicalLinks), false), __read((0, build_next_link_1.buildNextLink)(hasMore, pageInt, expandedPath, filteredParameters)), false), __read((0, build_previous_link_1.buildPreviousLink)(pageInt, expandedPath, filteredParameters)), false), __read((0, build_first_link_1.buildFirstLink)(hasMore, pageInt, expandedPath, filteredParameters)), false), __read(links || []), false) }, other));
 }
 //# sourceMappingURL=waycharter.js.map