@kolektor/nucleus-identity 0.0.8-pre.5352 → 0.0.9-pre.5702

package/esm2020/lib/utils/oidc-configuration.service.mjs

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import { NucleusAppService } from '@kolektor/nucleus-common';
+import { NucleusIdentityConfig } from '../nucleus-identity-config';
+import { AngularRequestor } from './angular-requestor';
+import { NucleusAuthorizationServiceConfiguration } from './authorization-service-configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "./angular-requestor";
+import * as i2 from "../nucleus-identity-config";
+import * as i3 from "@kolektor/nucleus-common";
+export class OidcConfigurationService {
+    constructor(requestor, config, appService) {
+        this.requestor = requestor;
+        this.config = config;
+        this.appService = appService;
+        this._configuration = null;
+    }
+    async getConfiguration() {
+        await this.assureConfiguration();
+        return this._configuration;
+    }
+    get clientId() {
+        return this.config.clientId;
+    }
+    get requestedScopes() {
+        return this.config.requestedScopes;
+    }
+    get servicePrincipalRequestedScopes() {
+        return this.config.servicePrincipalRequestedScopes;
+    }
+    get authProviderHint() {
+        return this.config.authProviderHint;
+    }
+    get redirectUrl() {
+        let uri = window.location.href;
+        const platform = this.appService.platform;
+        if (platform === 'android' && this.config.androidRedirectUri) {
+            uri = this.config.androidRedirectUri;
+        }
+        else if (platform === 'ios' && this.config.iOSRedirectUri) {
+            uri = this.config.iOSRedirectUri;
+        }
+        else if (this.config.redirectUri) {
+            uri = this.config.redirectUri;
+        }
+        return this.NormalizeRedirectUri(uri);
+    }
+    getServerUrl(relativeUri = null) {
+        let authority = this.config.authority;
+        if (!authority || authority === 'origin') {
+            authority = window.origin;
+        }
+        let url = new URL(authority);
+        if (relativeUri) {
+            url = new URL(relativeUri, url);
+        }
+        return url.href;
+    }
+    NormalizeRedirectUri(uri) {
+        const i = uri.indexOf('#');
+        if (i > 0) {
+            uri = uri.substring(0, i);
+        }
+        return uri;
+    }
+    async assureConfiguration() {
+        if (this._configuration != null) {
+            return;
+        }
+        let authority = this.getServerUrl();
+        if (authority[authority.length - 1] === '/') {
+            authority = authority.slice(0, -1);
+        }
+        try {
+            this._configuration = await NucleusAuthorizationServiceConfiguration.fetchFromIssuer(authority, this.requestor);
+        }
+        catch (e) {
+            console.error('Nucleus.Identity: Cannot load OIDC configuration: ' + e.message);
+            throw e;
+        }
+    }
+}
+OidcConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OidcConfigurationService, deps: [{ token: i1.AngularRequestor }, { token: i2.NucleusIdentityConfig }, { token: i3.NucleusAppService }], target: i0.ɵɵFactoryTarget.Injectable });
+OidcConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OidcConfigurationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OidcConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AngularRequestor }, { type: i2.NucleusIdentityConfig }, { type: i3.NucleusAppService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/secrets-store.mjs

@@ -0,0 +1,100 @@
+import 'capacitor-secure-storage-plugin';
+import { TokenResponse } from '@openid/appauth';
+import { Identity } from '../models/identity';
+import { SecureStoragePlugin } from 'capacitor-secure-storage-plugin';
+export class SecretsStore {
+    constructor(clientId) {
+        this._tokens = {};
+        this._identities = {};
+        this._tokenStorageKeyPrefix = `Nucleus.Identity.${clientId}`; // do not change this or login fith existing refresh tokens will fail
+        this._servicePrincipalKey = `Nucleus.Identity.${clientId}.SvcP`;
+    }
+    removeServicePrincipal() {
+        this._servicePrincipal = null;
+        return this.clear(this._servicePrincipalKey);
+    }
+    async setServicePrincipal(servicePrincipal) {
+        this._servicePrincipal = servicePrincipal;
+        await this.save(this._servicePrincipalKey, servicePrincipal);
+    }
+    async getServicePrincipal() {
+        if (!this._servicePrincipal) {
+            this._servicePrincipal = await this.load(this._servicePrincipalKey);
+        }
+        return this._servicePrincipal;
+    }
+    setToken(token, id = null) {
+        return this.setTokenInternal(token, true, id);
+    }
+    getIdentity(id = null) {
+        const key = this.getTokenKey(id);
+        return this._identities[key];
+    }
+    async getToken(id = null) {
+        const key = this.getTokenKey(id);
+        // if token is not there or it is invalid we check storage again before returning
+        if (!this._tokens[key] || !this._tokens[key].isValid()) {
+            await this.reloadTokenFromStorage(id);
+        }
+        return this._tokens[key];
+    }
+    removeToken(id = null) {
+        const key = this.getTokenKey(id);
+        delete this._tokens[key];
+        delete this._identities[key];
+        return this.clear(key);
+    }
+    async reloadTokenFromStorage(id) {
+        const key = this.getTokenKey(id);
+        const storedToken = await this.load(key);
+        if (storedToken) {
+            const res = new TokenResponse(storedToken);
+            if (res?.accessToken || res?.idToken) {
+                await this.setTokenInternal(res, false, id);
+            }
+        }
+        return null;
+    }
+    async setTokenInternal(token, save, id = null) {
+        const key = this.getTokenKey(id);
+        if (token == null) {
+            await this.removeToken(id);
+        }
+        else {
+            this._tokens[key] = token;
+            this._identities[key] = Identity.createFromResponse(token);
+            if (save) {
+                try {
+                    await this.save(key, token.toJson());
+                }
+                catch (e) {
+                    console.warn('Nucleus.Identity: Could not save to SecureStorage.');
+                }
+            }
+        }
+    }
+    getTokenKey(id = null) {
+        return id ? `${this._tokenStorageKeyPrefix}.${id}` : this._tokenStorageKeyPrefix;
+    }
+    clear(key) {
+        return SecureStoragePlugin.remove({ key });
+    }
+    save(key, value) {
+        return SecureStoragePlugin.set({ key, value: JSON.stringify(value) });
+    }
+    async load(key) {
+        try {
+            const x = await SecureStoragePlugin.get({ key });
+            if (x?.value) {
+                return JSON.parse(x.value);
+            }
+            else {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secrets-store.js","sourceRoot":"","sources":["../../../../../projects/nucleus-identity/src/lib/utils/secrets-store.ts"],"names":[],"mappings":"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","sourcesContent":["import 'capacitor-secure-storage-plugin';\r\nimport { TokenResponse, TokenResponseJson } from '@openid/appauth';\r\nimport { Identity } from '../models/identity';\r\nimport { ServicePrincipal } from '../models/service-principal';\r\nimport { SecureStoragePlugin } from 'capacitor-secure-storage-plugin';\r\n\r\nexport class SecretsStore {\r\n  constructor(clientId: string) {\r\n    this._tokenStorageKeyPrefix = `Nucleus.Identity.${clientId}`; // do not change this or login fith existing refresh tokens will fail\r\n    this._servicePrincipalKey = `Nucleus.Identity.${clientId}.SvcP`;\r\n  }\r\n\r\n  private _tokenStorageKeyPrefix: string;\r\n  private _tokens: { [id: string]: TokenResponse } = {};\r\n  private _identities: { [id: string]: Identity } = {};\r\n  private _servicePrincipalKey;\r\n  private _servicePrincipal: ServicePrincipal;\r\n\r\n  public removeServicePrincipal() {\r\n    this._servicePrincipal = null;\r\n    return this.clear(this._servicePrincipalKey);\r\n  }\r\n\r\n  public async setServicePrincipal(servicePrincipal: ServicePrincipal) {\r\n    this._servicePrincipal = servicePrincipal;\r\n    await this.save(this._servicePrincipalKey, servicePrincipal);\r\n  }\r\n\r\n  public async getServicePrincipal() {\r\n    if (!this._servicePrincipal) {\r\n      this._servicePrincipal = await this.load<ServicePrincipal>(this._servicePrincipalKey);\r\n    }\r\n    return this._servicePrincipal;\r\n  }\r\n\r\n  public setToken(token: TokenResponse, id: string = null) {\r\n    return this.setTokenInternal(token, true, id);\r\n  }\r\n\r\n  public getIdentity(id: string = null) {\r\n    const key = this.getTokenKey(id);\r\n    return this._identities[key];\r\n  }\r\n\r\n  public async getToken(id: string = null) {\r\n    const key = this.getTokenKey(id);\r\n\r\n    // if token is not there or it is invalid we check storage again before returning\r\n    if (!this._tokens[key] || !this._tokens[key].isValid()) {\r\n      await this.reloadTokenFromStorage(id);\r\n    }\r\n    return this._tokens[key];\r\n  }\r\n\r\n  public removeToken(id: string = null) {\r\n    const key = this.getTokenKey(id);\r\n    delete this._tokens[key];\r\n    delete this._identities[key];\r\n    return this.clear(key);\r\n  }\r\n\r\n  private async reloadTokenFromStorage(id: string) {\r\n    const key = this.getTokenKey(id);\r\n    const storedToken = await this.load<TokenResponseJson>(key);\r\n    if (storedToken) {\r\n      const res = new TokenResponse(storedToken);\r\n      if (res?.accessToken || res?.idToken) {\r\n        await this.setTokenInternal(res, false, id);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  private async setTokenInternal(token: TokenResponse, save: boolean, id: string = null) {\r\n    const key = this.getTokenKey(id);\r\n    if (token == null) {\r\n      await this.removeToken(id);\r\n    } else {\r\n      this._tokens[key] = token;\r\n      this._identities[key] = Identity.createFromResponse(token);\r\n      if (save) {\r\n        try {\r\n          await this.save(key, token.toJson());\r\n        } catch (e) {\r\n          console.warn('Nucleus.Identity: Could not save to SecureStorage.');\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private getTokenKey(id: string = null) {\r\n    return id ? `${this._tokenStorageKeyPrefix}.${id}` : this._tokenStorageKeyPrefix;\r\n  }\r\n\r\n  private clear(key: string) {\r\n    return SecureStoragePlugin.remove({ key });\r\n  }\r\n\r\n  private save<T>(key: string, value: T): Promise<{ value: boolean }> {\r\n    return SecureStoragePlugin.set({ key, value: JSON.stringify(value) });\r\n  }\r\n\r\n  private async load<T>(key: string) {\r\n    try {\r\n      const x = await SecureStoragePlugin.get({ key });\r\n      if (x?.value) {\r\n        return JSON.parse(x.value) as T;\r\n      } else {\r\n        return null;\r\n      }\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/esm2020/lib/utils/token-client.mjs

@@ -0,0 +1,140 @@
+import { AppAuthError, BaseTokenRequestHandler, BasicQueryStringUtils, GRANT_TYPE_AUTHORIZATION_CODE, GRANT_TYPE_REFRESH_TOKEN, TokenRequest } from '@openid/appauth';
+import { OidcConfigurationService } from './oidc-configuration.service';
+import { AngularRequestor } from './angular-requestor';
+import { Injectable } from '@angular/core';
+import { DeviceCode } from '../models/device-code';
+import { ClientRegistrationResponse } from '../models/client-registration';
+import * as i0 from "@angular/core";
+import * as i1 from "./angular-requestor";
+import * as i2 from "./oidc-configuration.service";
+export class TokenClient {
+    constructor(requestor, config) {
+        this.requestor = requestor;
+        this.config = config;
+        this._tokenHandler = new BaseTokenRequestHandler(requestor);
+        this._utils = new BasicQueryStringUtils();
+    }
+    async getByAuthorizationCode(redirectUrl, code, codeVerifier) {
+        const config = await this.config.getConfiguration();
+        const redirectUri = redirectUrl;
+        const req = new TokenRequest({
+            client_id: this.config.clientId,
+            redirect_uri: redirectUri,
+            grant_type: GRANT_TYPE_AUTHORIZATION_CODE,
+            code,
+            extras: { code_verifier: codeVerifier }
+        });
+        return await this._tokenHandler.performTokenRequest(config, req);
+    }
+    async getByRefreshToken(refreshToken) {
+        const config = await this.config.getConfiguration();
+        const redirectUri = this.config.redirectUrl;
+        const req = new TokenRequest({
+            client_id: this.config.clientId,
+            redirect_uri: redirectUri,
+            grant_type: GRANT_TYPE_REFRESH_TOKEN,
+            refresh_token: refreshToken
+        });
+        return await this._tokenHandler.performTokenRequest(config, req);
+    }
+    async getByClientCredentials(clientId, clientSecret, scope) {
+        const config = await this.config.getConfiguration();
+        const req = new TokenRequest({
+            client_id: clientId,
+            redirect_uri: null,
+            grant_type: 'client_credentials',
+            extras: {
+                client_secret: clientSecret,
+                scope,
+            }
+        });
+        return await this._tokenHandler.performTokenRequest(config, req);
+    }
+    async getBySecret(provider, secret, assertionToken, scope) {
+        const config = await this.config.getConfiguration();
+        const req = new TokenRequest({
+            client_id: this.config.clientId,
+            redirect_uri: null,
+            grant_type: 'urn:kolektor:nucleus:secret',
+            extras: {
+                secret_provider: provider,
+                secret_value: secret,
+                client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+                client_assertion: assertionToken,
+                scope,
+            }
+        });
+        return await this._tokenHandler.performTokenRequest(config, req);
+    }
+    async getByDeviceCode(deviceCode) {
+        const config = await this.config.getConfiguration();
+        const req = new TokenRequest({
+            client_id: this.config.clientId,
+            redirect_uri: null,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            extras: {
+                device_code: deviceCode
+            }
+        });
+        return await this._tokenHandler.performTokenRequest(config, req);
+    }
+    async registerServicePrincipal(token) {
+        const config = await this.config.getConfiguration();
+        const response = await this.requestor.xhr({
+            url: config.registrationEndpoint,
+            method: 'POST',
+            dataType: 'json',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`
+            }
+            // data: this._utils.stringify(map)
+        });
+        if (response.error === undefined) {
+            return new ClientRegistrationResponse(response);
+        }
+        else {
+            throw new AppAuthError(response.error);
+        }
+    }
+    async getRegistrationCode(existingServicePrincipalId = null) {
+        const params = {
+            custom_action: 'sp_register',
+            service_principal_id: existingServicePrincipalId
+        };
+        return this.getDeviceCodeInternal(params);
+    }
+    async getDeviceCode(scope) {
+        const params = {
+            scope,
+        };
+        return this.getDeviceCodeInternal(params);
+    }
+    async getDeviceCodeInternal(params) {
+        const config = await this.config.getConfiguration();
+        params['client_id'] = this.config.clientId;
+        const map = params;
+        const response = await this.requestor.xhr({
+            url: config.deviceAuthorizationEndpoint,
+            method: 'POST',
+            dataType: 'json',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            data: this._utils.stringify(map)
+        });
+        if (response.error === undefined) {
+            return new DeviceCode(response);
+        }
+        else {
+            throw new AppAuthError(response.error);
+        }
+    }
+}
+TokenClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: TokenClient, deps: [{ token: i1.AngularRequestor }, { token: i2.OidcConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+TokenClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: TokenClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: TokenClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AngularRequestor }, { type: i2.OidcConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-client.js","sourceRoot":"","sources":["../../../../../projects/nucleus-identity/src/lib/utils/token-client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wBAAwB,EAIxB,YAAY,EACQ,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAkB,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAkC,MAAM,+BAA+B,CAAC;;;;AAK3G,MAAM,OAAO,WAAW;IACtB,YACU,SAA2B,EAC3B,MAAgC;QADhC,cAAS,GAAT,SAAS,CAAkB;QAC3B,WAAM,GAAN,MAAM,CAA0B;QAExC,IAAI,CAAC,aAAa,GAAG,IAAI,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAC5C,CAAC;IAKM,KAAK,CAAC,sBAAsB,CAAC,WAAmB,EAAE,IAAY,EAAE,YAAoB;QACzF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpD,MAAM,WAAW,GAAG,WAAW,CAAC;QAChC,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC;YAC3B,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC/B,YAAY,EAAE,WAAW;YACzB,UAAU,EAAE,6BAA6B;YACzC,IAAI;YACJ,MAAM,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE;SACxC,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAAC,YAAoB;QACjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpD,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QAC5C,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC;YAC3B,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC/B,YAAY,EAAE,WAAW;YACzB,UAAU,EAAE,wBAAwB;YACpC,aAAa,EAAE,YAAY;SAC5B,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,sBAAsB,CAAC,QAAgB,EAAE,YAAoB,EAAE,KAAa;QACvF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpD,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC;YAC3B,SAAS,EAAE,QAAQ;YACnB,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,oBAAoB;YAChC,MAAM,EAAE;gBACN,aAAa,EAAE,YAAY;gBAC3B,KAAK;aACN;SACF,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,QAAgB,EAAE,MAAc,EAAE,cAAsB,EAAE,KAAa;QAC9F,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpD,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC;YAC3B,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC/B,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,6BAA6B;YACzC,MAAM,EAAE;gBACN,eAAe,EAAE,QAAQ;gBACzB,YAAY,EAAE,MAAM;gBACpB,qBAAqB,EAAE,wDAAwD;gBAC/E,gBAAgB,EAAE,cAAc;gBAChC,KAAK;aACN;SACF,CAAC,CAAC;QAEH,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,UAAkB;QAC7C,MAAM,MAAM,GAAI,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACrD,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC;YAC3B,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC/B,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,8CAA8C;YAC1D,MAAM,EAAE;gBACN,WAAW,EAAE,UAAU;aACxB;SACF,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,wBAAwB,CAAC,KAAa;QACjD,MAAM,MAAM,GAAI,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAErD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAkD;YACzF,GAAG,EAAE,MAAM,CAAC,oBAAoB;YAChC,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,MAAM;YAChB,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,aAAa,EAAE,UAAU,KAAK,EAAE;aACjC;YACD,mCAAmC;SACpC,CAAC,CAAC;QAEH,IAAK,QAA2B,CAAC,KAAK,KAAK,SAAS,EAAE;YACpD,OAAO,IAAI,0BAA0B,CAAC,QAA0C,CAAC,CAAC;SACnF;aAAM;YACL,MAAM,IAAI,YAAY,CAAE,QAA2B,CAAC,KAAK,CAAC,CAAC;SAC5D;IACH,CAAC;IAEM,KAAK,CAAC,mBAAmB,CAAC,6BAAqC,IAAI;QACxE,MAAM,MAAM,GAAG;YACb,aAAa,EAAE,aAAa;YAC5B,oBAAoB,EAAE,0BAA0B;SACjD,CAAC;QACF,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,KAAa;QACtC,MAAM,MAAM,GAAG;YACb,KAAK;SACN,CAAC;QACF,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAEO,KAAK,CAAC,qBAAqB,CAAC,MAAiB;QACnD,MAAM,MAAM,GAAI,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAErD,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;QAC3C,MAAM,GAAG,GAAc,MAAM,CAAC;QAE9B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAkC;YACzE,GAAG,EAAE,MAAM,CAAC,2BAA2B;YACvC,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,MAAM;YAChB,OAAO,EAAE,EAAC,cAAc,EAAE,mCAAmC,EAAC;YAC9D,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC;SACjC,CAAC,CAAC;QAEH,IAAK,QAA2B,CAAC,KAAK,KAAK,SAAS,EAAE;YACpD,OAAO,IAAI,UAAU,CAAC,QAA0B,CAAC,CAAC;SACnD;aAAM;YACL,MAAM,IAAI,YAAY,CAAE,QAA2B,CAAC,KAAK,CAAC,CAAC;SAC5D;IACH,CAAC;;wGAzIU,WAAW;4GAAX,WAAW,cAFV,MAAM;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {\r\n  AppAuthError,\r\n  BaseTokenRequestHandler,\r\n  BasicQueryStringUtils,\r\n  GRANT_TYPE_AUTHORIZATION_CODE,\r\n  GRANT_TYPE_REFRESH_TOKEN,\r\n  QueryStringUtils,\r\n  StringMap,\r\n  TokenErrorJson,\r\n  TokenRequest,\r\n  TokenRequestHandler} from '@openid/appauth';\r\nimport { OidcConfigurationService } from './oidc-configuration.service';\r\nimport { AngularRequestor } from './angular-requestor';\r\nimport { Injectable } from '@angular/core';\r\nimport { DeviceCode, DeviceCodeJson } from '../models/device-code';\r\nimport { ClientRegistrationResponse, ClientRegistrationResponseJson } from '../models/client-registration';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TokenClient  {\r\n  constructor(\r\n    private requestor: AngularRequestor,\r\n    private config: OidcConfigurationService\r\n  ) {\r\n    this._tokenHandler = new BaseTokenRequestHandler(requestor);\r\n    this._utils = new BasicQueryStringUtils();\r\n  }\r\n\r\n  private _tokenHandler: TokenRequestHandler;\r\n  private _utils: QueryStringUtils;\r\n\r\n  public async getByAuthorizationCode(redirectUrl: string, code: string, codeVerifier: string) {\r\n    const config = await this.config.getConfiguration();\r\n    const redirectUri = redirectUrl;\r\n    const req = new TokenRequest({\r\n      client_id: this.config.clientId,\r\n      redirect_uri: redirectUri,\r\n      grant_type: GRANT_TYPE_AUTHORIZATION_CODE,\r\n      code,\r\n      extras: { code_verifier: codeVerifier }\r\n    });\r\n    return await this._tokenHandler.performTokenRequest(config, req);\r\n  }\r\n\r\n  public async getByRefreshToken(refreshToken: string) {\r\n    const config = await this.config.getConfiguration();\r\n    const redirectUri = this.config.redirectUrl;\r\n    const req = new TokenRequest({\r\n      client_id: this.config.clientId,\r\n      redirect_uri: redirectUri,\r\n      grant_type: GRANT_TYPE_REFRESH_TOKEN,\r\n      refresh_token: refreshToken\r\n    });\r\n    return await this._tokenHandler.performTokenRequest(config, req);\r\n  }\r\n\r\n  public async getByClientCredentials(clientId: string, clientSecret: string, scope: string) {\r\n    const config = await this.config.getConfiguration();\r\n    const req = new TokenRequest({\r\n      client_id: clientId,\r\n      redirect_uri: null,\r\n      grant_type: 'client_credentials',\r\n      extras: {\r\n        client_secret: clientSecret,\r\n        scope,\r\n      }\r\n    });\r\n    return await this._tokenHandler.performTokenRequest(config, req);\r\n  }\r\n\r\n  public async getBySecret(provider: string, secret: string, assertionToken: string, scope: string) {\r\n    const config = await this.config.getConfiguration();\r\n    const req = new TokenRequest({\r\n      client_id: this.config.clientId,\r\n      redirect_uri: null,\r\n      grant_type: 'urn:kolektor:nucleus:secret',\r\n      extras: {\r\n        secret_provider: provider,\r\n        secret_value: secret,\r\n        client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\r\n        client_assertion: assertionToken,\r\n        scope,\r\n      }\r\n    });\r\n\r\n    return await this._tokenHandler.performTokenRequest(config, req);\r\n  }\r\n\r\n  public async getByDeviceCode(deviceCode: string) {\r\n    const config =  await this.config.getConfiguration();\r\n    const req = new TokenRequest({\r\n      client_id: this.config.clientId,\r\n      redirect_uri: null,\r\n      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',\r\n      extras: {\r\n        device_code: deviceCode\r\n      }\r\n    });\r\n    return await this._tokenHandler.performTokenRequest(config, req);\r\n  }\r\n\r\n  public async registerServicePrincipal(token: string) {\r\n    const config =  await this.config.getConfiguration();\r\n\r\n    const response = await this.requestor.xhr<ClientRegistrationResponseJson | TokenErrorJson>({\r\n      url: config.registrationEndpoint,\r\n      method: 'POST',\r\n      dataType: 'json',\r\n      headers: {\r\n        'Content-Type': 'application/json',\r\n        Authorization: `Bearer ${token}`\r\n      }\r\n      // data: this._utils.stringify(map)\r\n    });\r\n\r\n    if ((response as TokenErrorJson).error === undefined) {\r\n      return new ClientRegistrationResponse(response as ClientRegistrationResponseJson);\r\n    } else {\r\n      throw new AppAuthError((response as TokenErrorJson).error);\r\n    }\r\n  }\r\n\r\n  public async getRegistrationCode(existingServicePrincipalId: string = null) {\r\n    const params = {\r\n      custom_action: 'sp_register',\r\n      service_principal_id: existingServicePrincipalId\r\n    };\r\n    return this.getDeviceCodeInternal(params);\r\n  }\r\n\r\n  public async getDeviceCode(scope: string) {\r\n    const params = {\r\n      scope,\r\n    };\r\n    return this.getDeviceCodeInternal(params);\r\n  }\r\n\r\n  private async getDeviceCodeInternal(params: StringMap) {\r\n    const config =  await this.config.getConfiguration();\r\n\r\n    params['client_id'] = this.config.clientId;\r\n    const map: StringMap = params;\r\n\r\n    const response = await this.requestor.xhr<DeviceCodeJson | TokenErrorJson>({\r\n      url: config.deviceAuthorizationEndpoint,\r\n      method: 'POST',\r\n      dataType: 'json',\r\n      headers: {'Content-Type': 'application/x-www-form-urlencoded'},\r\n      data: this._utils.stringify(map)\r\n    });\r\n\r\n    if ((response as TokenErrorJson).error === undefined) {\r\n      return new DeviceCode(response as DeviceCodeJson);\r\n    } else {\r\n      throw new AppAuthError((response as TokenErrorJson).error);\r\n    }\r\n  }\r\n\r\n\r\n}\r\n"]}