@wertzui/ngx-restworld-client 2.0.0 → 3.0.0

package/esm2020/lib/services/restworld-client.mjs

@@ -0,0 +1,162 @@
+import { HttpHeaders } from '@angular/common/http';
+import * as _ from "lodash";
+import { FormsResource, Link, PagedListResource, Resource } from "@wertzui/ngx-hal-client";
+import { LinkNames } from "../constants/link-names";
+import { ProblemDetails } from "../models/problem-details";
+export class RESTworldClient {
+    constructor(_halClient, _options) {
+        this._halClient = _halClient;
+        this._options = _options;
+    }
+    get halClient() {
+        return this._halClient;
+    }
+    async ensureHomeResourceIsSet() {
+        if (!this._homeResource) {
+            const response = await this.getHomeForced();
+            if (ProblemDetails.isProblemDetails(response.body)) {
+                throw new Error(`Cannot get the home resource from ${this._options.BaseUrl} with Version ${this._options.Version}. Response was: ${response}`);
+            }
+            if (!response.body)
+                throw new Error(`Cannot get the home resource from ${this._options.BaseUrl} with Version ${this._options.Version}. Response was empty.`);
+            this._homeResource = response.body;
+            this.setDefaultCurie();
+        }
+    }
+    async getHomeForced() {
+        const header = RESTworldClient.createHeaders('application/hal+json', this._options.Version);
+        const response = await this.halClient.get(this._options.BaseUrl, Resource, ProblemDetails, header);
+        return response;
+    }
+    setDefaultCurie() {
+        const curies = this._homeResource?._links?.curies;
+        if (!curies || curies.length === 0 || !curies[0])
+            this._defaultCurie = undefined;
+        else
+            this._defaultCurie = curies[0].name;
+    }
+    async getList(rel, parameters, headers, curie) {
+        const link = this.getLinkFromHome(rel, LinkNames.getList, curie);
+        const uri = link.fillTemplate(parameters);
+        const response = await this.halClient.get(uri, PagedListResource, ProblemDetails, headers);
+        return response;
+    }
+    async getListByUri(uri, parameters, headers) {
+        const link = new Link();
+        link.href = uri;
+        const filledUri = link.fillTemplate(parameters);
+        const response = await this.halClient.get(filledUri, PagedListResource, ProblemDetails, headers);
+        return response;
+    }
+    async getSingle(relOrUri, id, headers, curie) {
+        let uri;
+        if (relOrUri.startsWith('http')) {
+            if (id !== undefined)
+                throw new Error('When supplying a URI, an ID cannot be supplied too.');
+            if (curie)
+                throw new Error('When supplying a URI, a curie cannot be supplied too.');
+            uri = relOrUri;
+        }
+        else {
+            if (!_.isNumber(id))
+                throw new Error('When supplying a rel, an ID must be supplied too.');
+            const link = this.getLinkFromHome(relOrUri, LinkNames.get, curie);
+            uri = link.fillTemplate({ id: id.toString() });
+        }
+        const response = await this.halClient.get(uri, Resource, ProblemDetails, headers);
+        return response;
+    }
+    async save(resource) {
+        const saveLink = resource.findLink('save');
+        if (!saveLink)
+            throw new Error(`The resource ${resource} does not have a save link.`);
+        if (!saveLink.name)
+            throw new Error(`The save link ${saveLink} does not have a save name.`);
+        const uri = saveLink.href;
+        const method = saveLink.name.toLowerCase();
+        const header = RESTworldClient.createHeaders('application/hal+json', this._options.Version);
+        let response;
+        switch (method) {
+            case 'put':
+                response = await this.halClient.put(uri, resource, Resource, ProblemDetails, header);
+                break;
+            case 'post':
+                response = await this.halClient.post(uri, resource, Resource, ProblemDetails, header);
+                break;
+            default:
+                throw new Error(`'${method}' is not allowed as link name for the save link. Only 'POST' and 'PUT' are allowed.`);
+        }
+        return response;
+    }
+    async getAllForms(resource) {
+        const urls = resource.getFormLinkHrefs();
+        const header = RESTworldClient.createHeaders('application/prs.hal-forms+json', this._options.Version);
+        const formsPromises = urls.map(url => this._halClient.get(url, FormsResource, ProblemDetails, header));
+        const formsAndProblems = await Promise.all(formsPromises);
+        return formsAndProblems;
+    }
+    async submit(template, formValues) {
+        const uri = template.target || '';
+        const method = template.method?.toLowerCase();
+        const header = RESTworldClient.createHeaders('application/prs.hal-forms+json', this._options.Version);
+        let response;
+        switch (method) {
+            case 'put':
+                response = await this.halClient.put(uri, formValues, FormsResource, ProblemDetails, header);
+                break;
+            case 'post':
+                response = await this.halClient.post(uri, formValues, FormsResource, ProblemDetails, header);
+                break;
+            default:
+                response = await this.halClient.get(uri, FormsResource, ProblemDetails, header);
+        }
+        return response;
+    }
+    async delete(resource) {
+        const deleteLink = resource.findLink('delete');
+        if (!deleteLink)
+            throw new Error(`The resource ${resource} does not have a delete link.`);
+        const uri = deleteLink.href;
+        const header = RESTworldClient.createHeaders('application/hal+json', this._options.Version);
+        const response = await this.halClient.delete(uri, ProblemDetails, header);
+        return response;
+    }
+    getAllLinksFromHome() {
+        if (!this._homeResource)
+            throw new Error('Home resource is not set. Call ensureHomeResourceIsSet() first.');
+        return this._homeResource._links;
+    }
+    getLinkFromHome(rel, name, curie) {
+        const links = this.getLinksFromHome(rel, curie);
+        const link = name ? links.find(l => l.name === name) : links[0];
+        if (!link)
+            throw new Error(`The home resource does not have a link with the rel '${this.getFullRel(rel, curie)}' and the name '${name}'.`);
+        return link;
+    }
+    getLinksFromHome(rel, curie) {
+        if (!this._homeResource)
+            throw new Error('Home resource is not set. Call ensureHomeResourceIsSet() first.');
+        const fullRel = this.getFullRel(rel, curie);
+        const links = this._homeResource._links[fullRel];
+        if (!links || links.length === 0)
+            throw Error(`The home resource does not have a link with the rel '${fullRel}'.`);
+        return links;
+    }
+    getFullRel(rel, curie) {
+        // rel already includes a curie => just return it
+        if (rel.includes(':'))
+            return rel;
+        // No curie given => use default curie.
+        if (!curie)
+            curie = this._defaultCurie;
+        // Combine curie and rel
+        const fullRel = `${curie}:${rel}`;
+        return fullRel;
+    }
+    static createHeaders(mediaType, version) {
+        if (version)
+            return new HttpHeaders({ 'Accept': `${mediaType || 'application/hal+json'}; v=${version}` });
+        return new HttpHeaders();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restworld-client.js","sourceRoot":"","sources":["../../../../../projects/ngx-restworld-client/src/lib/services/restworld-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAa,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAY,MAAM,yBAAyB,CAAA;AAC/G,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D,MAAM,OAAO,eAAe;IAQ1B,YACU,UAAqB,EACrB,QAA0B;QAD1B,eAAU,GAAV,UAAU,CAAW;QACrB,aAAQ,GAAR,QAAQ,CAAkB;IAChC,CAAC;IAPL,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAOM,KAAK,CAAC,uBAAuB;QAClC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YAC5C,IAAI,cAAc,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBAClD,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,CAAC,QAAQ,CAAC,OAAO,iBAAiB,IAAI,CAAC,QAAQ,CAAC,OAAO,mBAAmB,QAAQ,EAAE,CAAC,CAAC;aAChJ;YACD,IAAI,CAAC,QAAQ,CAAC,IAAI;gBAChB,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,CAAC,QAAQ,CAAC,OAAO,iBAAiB,IAAI,CAAC,QAAQ,CAAC,OAAO,uBAAuB,CAAC,CAAA;YAC1I,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC;YACnC,IAAI,CAAC,eAAe,EAAE,CAAC;SACxB;IACH,CAAC;IAEO,KAAK,CAAC,aAAa;QACzB,MAAM,MAAM,GAAG,eAAe,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC5F,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;QACnG,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,eAAe;QACrB,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC;QAClD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9C,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;;YAE/B,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACxC,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,GAAW,EAAE,UAAc,EAAE,OAAqB,EAAE,KAAc;QACrF,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACjE,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAE1C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,iBAAiB,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;QAE3F,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,GAAW,EAAE,UAAc,EAAE,OAAqB;QAC1E,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAEhD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;QAEjG,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,QAAgB,EAAE,EAAW,EAAE,OAAqB,EAAE,KAAc;QACzF,IAAI,GAAG,CAAC;QACR,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;YAC/B,IAAI,EAAE,KAAK,SAAS;gBAClB,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAA;YACxE,IAAI,KAAK;gBACP,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAA;YAE1E,GAAG,GAAG,QAAQ,CAAC;SAChB;aACI;YACH,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACjB,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAA;YAEtE,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAClE,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;SAChD;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;QAElF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,QAAkB;QAClC,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ;YACX,MAAM,IAAI,KAAK,CAAC,gBAAgB,QAAQ,6BAA6B,CAAC,CAAC;QACzE,IAAI,CAAC,QAAQ,CAAC,IAAI;YAChB,MAAM,IAAI,KAAK,CAAC,iBAAiB,QAAQ,6BAA6B,CAAC,CAAC;QAE1E,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC;QAC1B,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,eAAe,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE5F,IAAI,QAAQ,CAAC;QACb,QAAQ,MAAM,EAAE;YACd,KAAK,KAAK;gBACR,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;gBACrF,MAAM;YACR,KAAK,MAAM;gBACT,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;gBACtF,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,IAAI,MAAM,qFAAqF,CAAC,CAAC;SACpH;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,QAAkB;QACzC,MAAM,IAAI,GAAG,QAAQ,CAAC,gBAAgB,EAAE,CAAC;QACzC,MAAM,MAAM,GAAG,eAAe,CAAC,aAAa,CAAC,gCAAgC,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACtG,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;QACvG,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC1D,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,QAAkB,EAAE,UAAc;QACpD,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAG,eAAe,CAAC,aAAa,CAAC,gCAAgC,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAEtG,IAAI,QAAQ,CAAC;QACb,QAAQ,MAAM,EAAE;YACd,KAAK,KAAK;gBACR,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;gBAC5F,MAAM;YACR,KAAK,MAAM;gBACT,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;gBAC7F,MAAM;YACR;gBACE,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;SACnF;QAED,OAAO,QAAQ,CAAC;IAElB,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,QAAkB;QACpC,MAAM,UAAU,GAAG,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU;YACb,MAAM,IAAI,KAAK,CAAC,gBAAgB,QAAQ,+BAA+B,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,MAAM,MAAM,GAAG,eAAe,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE5F,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;QAE1E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,mBAAmB;QACxB,IAAI,CAAC,IAAI,CAAC,aAAa;YACrB,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;QAErF,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;IACnC,CAAC;IAEM,eAAe,CAAC,GAAW,EAAE,IAAa,EAAE,KAAc;QAC/D,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAEhD,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAEhE,IAAI,CAAC,IAAI;YACP,MAAM,IAAI,KAAK,CAAC,wDAAwD,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,mBAAmB,IAAI,IAAI,CAAC,CAAA;QAEjI,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,gBAAgB,CAAC,GAAW,EAAE,KAAc;QACjD,IAAI,CAAC,IAAI,CAAC,aAAa;YACrB,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;QAErF,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACjD,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAC9B,MAAM,KAAK,CAAC,wDAAwD,OAAO,IAAI,CAAC,CAAC;QAEnF,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,UAAU,CAAC,GAAW,EAAE,KAAc;QAC5C,iDAAiD;QACjD,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;YACnB,OAAO,GAAG,CAAC;QAEb,uCAAuC;QACvC,IAAI,CAAC,KAAK;YACR,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC;QAE7B,wBAAwB;QACxB,MAAM,OAAO,GAAG,GAAG,KAAK,IAAI,GAAG,EAAE,CAAC;QAElC,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,MAAM,CAAC,aAAa,CAAC,SAAqE,EAAE,OAAgB;QAClH,IAAI,OAAO;YACT,OAAO,IAAI,WAAW,CAAC,EAAE,QAAQ,EAAE,GAAG,SAAS,IAAI,sBAAsB,OAAO,OAAO,EAAE,EAAE,CAAC,CAAC;QAC/F,OAAO,IAAI,WAAW,EAAE,CAAC;IAC3B,CAAC;CACF","sourcesContent":["import { HttpHeaders, HttpResponse } from '@angular/common/http';\r\nimport * as _ from \"lodash\";\r\nimport { FormsResource, HalClient, Link, PagedListResource, Resource, Template } from \"@wertzui/ngx-hal-client\"\r\nimport { LinkNames } from \"../constants/link-names\";\r\nimport { ProblemDetails } from \"../models/problem-details\";\r\nimport { RESTworldOptions } from \"../models/restworld-options\";\r\n\r\nexport class RESTworldClient {\r\n\r\n  private _homeResource?: Resource;\r\n  private _defaultCurie?: string;\r\n  public get halClient() {\r\n    return this._halClient;\r\n  }\r\n\r\n  constructor(\r\n    private _halClient: HalClient,\r\n    private _options: RESTworldOptions\r\n  ) { }\r\n\r\n  public async ensureHomeResourceIsSet(): Promise<void> {\r\n    if (!this._homeResource) {\r\n      const response = await this.getHomeForced();\r\n      if (ProblemDetails.isProblemDetails(response.body)) {\r\n        throw new Error(`Cannot get the home resource from ${this._options.BaseUrl} with Version ${this._options.Version}. Response was: ${response}`);\r\n      }\r\n      if (!response.body)\r\n        throw new Error(`Cannot get the home resource from ${this._options.BaseUrl} with Version ${this._options.Version}. Response was empty.`)\r\n      this._homeResource = response.body;\r\n      this.setDefaultCurie();\r\n    }\r\n  }\r\n\r\n  private async getHomeForced(): Promise<HttpResponse<Resource | ProblemDetails>> {\r\n    const header = RESTworldClient.createHeaders('application/hal+json', this._options.Version);\r\n    const response = await this.halClient.get(this._options.BaseUrl, Resource, ProblemDetails, header);\r\n    return response;\r\n  }\r\n\r\n  private setDefaultCurie(): void {\r\n    const curies = this._homeResource?._links?.curies;\r\n    if (!curies || curies.length === 0 || !curies[0])\r\n      this._defaultCurie = undefined;\r\n    else\r\n      this._defaultCurie = curies[0].name;\r\n  }\r\n\r\n  public async getList(rel: string, parameters: {}, headers?: HttpHeaders, curie?: string): Promise<HttpResponse<PagedListResource | ProblemDetails>>{\r\n    const link = this.getLinkFromHome(rel, LinkNames.getList, curie);\r\n    const uri = link.fillTemplate(parameters);\r\n\r\n    const response = await this.halClient.get(uri, PagedListResource, ProblemDetails, headers);\r\n\r\n    return response;\r\n  }\r\n\r\n  public async getListByUri(uri: string, parameters: {}, headers?: HttpHeaders): Promise<HttpResponse<PagedListResource | ProblemDetails>> {\r\n    const link = new Link();\r\n    link.href = uri;\r\n    const filledUri = link.fillTemplate(parameters);\r\n\r\n    const response = await this.halClient.get(filledUri, PagedListResource, ProblemDetails, headers);\r\n\r\n    return response;\r\n  }\r\n\r\n  public async getSingle(relOrUri: string, id?: number, headers?: HttpHeaders, curie?: string): Promise<HttpResponse<Resource | ProblemDetails>> {\r\n    let uri;\r\n    if (relOrUri.startsWith('http')) {\r\n      if (id !== undefined)\r\n        throw new Error('When supplying a URI, an ID cannot be supplied too.')\r\n      if (curie)\r\n        throw new Error('When supplying a URI, a curie cannot be supplied too.')\r\n\r\n      uri = relOrUri;\r\n    }\r\n    else {\r\n      if (!_.isNumber(id))\r\n        throw new Error('When supplying a rel, an ID must be supplied too.')\r\n\r\n      const link = this.getLinkFromHome(relOrUri, LinkNames.get, curie);\r\n      uri = link.fillTemplate({ id: id.toString() });\r\n    }\r\n    const response = await this.halClient.get(uri, Resource, ProblemDetails, headers);\r\n\r\n    return response;\r\n  }\r\n\r\n  public async save(resource: Resource): Promise<HttpResponse<Resource | ProblemDetails>> {\r\n    const saveLink = resource.findLink('save');\r\n    if (!saveLink)\r\n      throw new Error(`The resource ${resource} does not have a save link.`);\r\n    if (!saveLink.name)\r\n      throw new Error(`The save link ${saveLink} does not have a save name.`);\r\n\r\n    const uri = saveLink.href;\r\n    const method = saveLink.name.toLowerCase();\r\n    const header = RESTworldClient.createHeaders('application/hal+json', this._options.Version);\r\n\r\n    let response;\r\n    switch (method) {\r\n      case 'put':\r\n        response = await this.halClient.put(uri, resource, Resource, ProblemDetails, header);\r\n        break;\r\n      case 'post':\r\n        response = await this.halClient.post(uri, resource, Resource, ProblemDetails, header);\r\n        break;\r\n      default:\r\n        throw new Error(`'${method}' is not allowed as link name for the save link. Only 'POST' and 'PUT' are allowed.`);\r\n    }\r\n\r\n    return response;\r\n  }\r\n\r\n  public async getAllForms(resource: Resource): Promise<HttpResponse<FormsResource | ProblemDetails>[]> {\r\n    const urls = resource.getFormLinkHrefs();\r\n    const header = RESTworldClient.createHeaders('application/prs.hal-forms+json', this._options.Version);\r\n    const formsPromises = urls.map(url => this._halClient.get(url, FormsResource, ProblemDetails, header));\r\n    const formsAndProblems = await Promise.all(formsPromises);\r\n    return formsAndProblems;\r\n  }\r\n\r\n  public async submit(template: Template, formValues: {}): Promise<HttpResponse<FormsResource | ProblemDetails>> {\r\n    const uri = template.target || '';\r\n    const method = template.method?.toLowerCase();\r\n    const header = RESTworldClient.createHeaders('application/prs.hal-forms+json', this._options.Version);\r\n\r\n    let response;\r\n    switch (method) {\r\n      case 'put':\r\n        response = await this.halClient.put(uri, formValues, FormsResource, ProblemDetails, header);\r\n        break;\r\n      case 'post':\r\n        response = await this.halClient.post(uri, formValues, FormsResource, ProblemDetails, header);\r\n        break;\r\n      default:\r\n        response = await this.halClient.get(uri, FormsResource, ProblemDetails, header);\r\n    }\r\n\r\n    return response;\r\n\r\n  }\r\n\r\n  public async delete(resource: Resource): Promise<HttpResponse<void | ProblemDetails>> {\r\n    const deleteLink = resource.findLink('delete');\r\n    if (!deleteLink)\r\n      throw new Error(`The resource ${resource} does not have a delete link.`);\r\n    const uri = deleteLink.href;\r\n    const header = RESTworldClient.createHeaders('application/hal+json', this._options.Version);\r\n\r\n    const response = await this.halClient.delete(uri, ProblemDetails, header);\r\n\r\n    return response;\r\n  }\r\n\r\n  public getAllLinksFromHome(): { [rel: string]: Link[] | undefined } {\r\n    if (!this._homeResource)\r\n      throw new Error('Home resource is not set. Call ensureHomeResourceIsSet() first.');\r\n\r\n    return this._homeResource._links;\r\n  }\r\n\r\n  public getLinkFromHome(rel: string, name?: string, curie?: string): Link {\r\n    const links = this.getLinksFromHome(rel, curie);\r\n\r\n    const link = name ? links.find(l => l.name === name) : links[0];\r\n\r\n    if (!link)\r\n      throw new Error(`The home resource does not have a link with the rel '${this.getFullRel(rel, curie)}' and the name '${name}'.`)\r\n\r\n    return link;\r\n  }\r\n\r\n  public getLinksFromHome(rel: string, curie?: string): Link[] {\r\n    if (!this._homeResource)\r\n      throw new Error('Home resource is not set. Call ensureHomeResourceIsSet() first.');\r\n\r\n    const fullRel = this.getFullRel(rel, curie);\r\n    const links = this._homeResource._links[fullRel];\r\n    if (!links || links.length === 0)\r\n      throw Error(`The home resource does not have a link with the rel '${fullRel}'.`);\r\n\r\n    return links;\r\n  }\r\n\r\n  private getFullRel(rel: string, curie?: string): string {\r\n    // rel already includes a curie => just return it\r\n    if (rel.includes(':'))\r\n      return rel;\r\n\r\n    // No curie given => use default curie.\r\n    if (!curie)\r\n      curie = this._defaultCurie;\r\n\r\n    // Combine curie and rel\r\n    const fullRel = `${curie}:${rel}`;\r\n\r\n    return fullRel;\r\n  }\r\n\r\n  private static createHeaders(mediaType?: 'application/hal+json' | 'application/prs.hal-forms+json', version?: number): HttpHeaders {\r\n    if (version)\r\n      return new HttpHeaders({ 'Accept': `${mediaType || 'application/hal+json'}; v=${version}` });\r\n    return new HttpHeaders();\r\n  }\r\n}\r\n"]}

package/esm2020/lib/services/settings.service.mjs

@@ -0,0 +1,39 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { RESTworldOptions } from "../models/restworld-options";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./restworld-client-collection";
+export class SettingsService {
+    constructor(backend, _clients) {
+        this._clients = _clients;
+        this._client = new HttpClient(backend);
+    }
+    get settings() {
+        return this._settings;
+    }
+    async initialize() {
+        await this.ensureSettingsAreLoaded();
+        await this.populateRESTworldClientCollectionFromSettings();
+    }
+    async ensureSettingsAreLoaded() {
+        this._settings = await this._client
+            .get('/settings')
+            .toPromise();
+    }
+    async populateRESTworldClientCollectionFromSettings() {
+        if (!this._settings?.apiUrls)
+            return;
+        await Promise.all(this._settings.apiUrls
+            .map(api => this._clients.addOrGetExistingClient(api.name, new RESTworldOptions(api.url, api.version))));
+    }
+}
+SettingsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, deps: [{ token: i1.HttpBackend }, { token: i2.RESTworldClientCollection }], target: i0.ɵɵFactoryTarget.Injectable });
+SettingsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i2.RESTworldClientCollection }]; } });
+//# sourceMappingURL=data:application/json;base64,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