@kolektor/nucleus-identity 0.0.12-pre.7931 → 0.1.0-pre.128

package/esm2022/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: codeVerifier ? { code_verifier: codeVerifier } : undefined,
+        });
+        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: '',
+            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: '',
+            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: '',
+            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);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenClient, deps: [{ token: i1.AngularRequestor }, { token: i2.OidcConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TokenClient, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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":["../../../../../../../libs/ng/nucleus-identity/src/lib/utils/token-client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wBAAwB,EAIxB,YAAY,GAEb,MAAM,iBAAiB,CAAC;AACzB,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,EACL,0BAA0B,GAE3B,MAAM,+BAA+B,CAAC;;;;AAKvC,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,CACjC,WAAmB,EACnB,IAAY,EACZ,YAAqB;QAErB,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,YAAY,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,SAAS;SACnE,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,CACjC,QAAgB,EAChB,YAAoB,EACpB,KAAa;QAEb,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,EAAE;YAChB,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,CACtB,QAAgB,EAChB,MAAc,EACd,cAAsB,EACtB,KAAa;QAEb,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,EAAE;YAChB,UAAU,EAAE,6BAA6B;YACzC,MAAM,EAAE;gBACN,eAAe,EAAE,QAAQ;gBACzB,YAAY,EAAE,MAAM;gBACpB,qBAAqB,EACnB,wDAAwD;gBAC1D,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,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,EAAE;YAChB,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,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAEpD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAEvC;YACA,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,CACnC,QAA0C,CAC3C,CAAC;SACH;aAAM;YACL,MAAM,IAAI,YAAY,CAAE,QAA2B,CAAC,KAAK,CAAC,CAAC;SAC5D;IACH,CAAC;IAEM,KAAK,CAAC,mBAAmB,CAAC,6BAA4C,IAAI;QAC/E,MAAM,MAAM,GAAG;YACb,aAAa,EAAE,aAAa;YAC5B,oBAAoB,EAAE,0BAA0B;SACjD,CAAC;QAEF,OAAO,IAAI,CAAC,qBAAqB,CAAC,MAAmB,CAAC,CAAC;IACzD,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,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAEpD,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,EAAE,cAAc,EAAE,mCAAmC,EAAE;YAChE,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;+GA5JU,WAAW;mHAAX,WAAW,cAFV,MAAM;;4FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {\n  AppAuthError,\n  BaseTokenRequestHandler,\n  BasicQueryStringUtils,\n  GRANT_TYPE_AUTHORIZATION_CODE,\n  GRANT_TYPE_REFRESH_TOKEN,\n  QueryStringUtils,\n  StringMap,\n  TokenErrorJson,\n  TokenRequest,\n  TokenRequestHandler,\n} from '@openid/appauth';\nimport { OidcConfigurationService } from './oidc-configuration.service';\nimport { AngularRequestor } from './angular-requestor';\nimport { Injectable } from '@angular/core';\nimport { DeviceCode, DeviceCodeJson } from '../models/device-code';\nimport {\n  ClientRegistrationResponse,\n  ClientRegistrationResponseJson,\n} from '../models/client-registration';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TokenClient {\n  constructor(\n    private requestor: AngularRequestor,\n    private config: OidcConfigurationService\n  ) {\n    this._tokenHandler = new BaseTokenRequestHandler(requestor);\n    this._utils = new BasicQueryStringUtils();\n  }\n\n  private _tokenHandler: TokenRequestHandler;\n  private _utils: QueryStringUtils;\n\n  public async getByAuthorizationCode(\n    redirectUrl: string,\n    code: string,\n    codeVerifier?: string\n  ) {\n    const config = await this.config.getConfiguration();\n    const redirectUri = redirectUrl;\n    const req = new TokenRequest({\n      client_id: this.config.clientId,\n      redirect_uri: redirectUri,\n      grant_type: GRANT_TYPE_AUTHORIZATION_CODE,\n      code,\n      extras: codeVerifier ? { code_verifier: codeVerifier } : undefined,\n    });\n    return await this._tokenHandler.performTokenRequest(config, req);\n  }\n\n  public async getByRefreshToken(refreshToken: string) {\n    const config = await this.config.getConfiguration();\n    const redirectUri = this.config.redirectUrl;\n    const req = new TokenRequest({\n      client_id: this.config.clientId,\n      redirect_uri: redirectUri,\n      grant_type: GRANT_TYPE_REFRESH_TOKEN,\n      refresh_token: refreshToken,\n    });\n    return await this._tokenHandler.performTokenRequest(config, req);\n  }\n\n  public async getByClientCredentials(\n    clientId: string,\n    clientSecret: string,\n    scope: string\n  ) {\n    const config = await this.config.getConfiguration();\n    const req = new TokenRequest({\n      client_id: clientId,\n      redirect_uri: '',\n      grant_type: 'client_credentials',\n      extras: {\n        client_secret: clientSecret,\n        scope,\n      },\n    });\n    return await this._tokenHandler.performTokenRequest(config, req);\n  }\n\n  public async getBySecret(\n    provider: string,\n    secret: string,\n    assertionToken: string,\n    scope: string\n  ) {\n    const config = await this.config.getConfiguration();\n    const req = new TokenRequest({\n      client_id: this.config.clientId,\n      redirect_uri: '',\n      grant_type: 'urn:kolektor:nucleus:secret',\n      extras: {\n        secret_provider: provider,\n        secret_value: secret,\n        client_assertion_type:\n          'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\n        client_assertion: assertionToken,\n        scope,\n      },\n    });\n\n    return await this._tokenHandler.performTokenRequest(config, req);\n  }\n\n  public async getByDeviceCode(deviceCode: string) {\n    const config = await this.config.getConfiguration();\n    const req = new TokenRequest({\n      client_id: this.config.clientId,\n      redirect_uri: '',\n      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',\n      extras: {\n        device_code: deviceCode,\n      },\n    });\n    return await this._tokenHandler.performTokenRequest(config, req);\n  }\n\n  public async registerServicePrincipal(token: string) {\n    const config = await this.config.getConfiguration();\n\n    const response = await this.requestor.xhr<\n      ClientRegistrationResponseJson | TokenErrorJson\n    >({\n      url: config.registrationEndpoint,\n      method: 'POST',\n      dataType: 'json',\n      headers: {\n        'Content-Type': 'application/json',\n        Authorization: `Bearer ${token}`,\n      },\n      // data: this._utils.stringify(map)\n    });\n\n    if ((response as TokenErrorJson).error === undefined) {\n      return new ClientRegistrationResponse(\n        response as ClientRegistrationResponseJson\n      );\n    } else {\n      throw new AppAuthError((response as TokenErrorJson).error);\n    }\n  }\n\n  public async getRegistrationCode(existingServicePrincipalId: string | null = null) {\n    const params = {\n      custom_action: 'sp_register',\n      service_principal_id: existingServicePrincipalId,\n    };\n\n    return this.getDeviceCodeInternal(params as StringMap);\n  }\n\n  public async getDeviceCode(scope: string) {\n    const params = {\n      scope,\n    };\n    return this.getDeviceCodeInternal(params);\n  }\n\n  private async getDeviceCodeInternal(params: StringMap) {\n    const config = await this.config.getConfiguration();\n\n    params['client_id'] = this.config.clientId;\n    const map: StringMap = params;\n\n    const response = await this.requestor.xhr<DeviceCodeJson | TokenErrorJson>({\n      url: config.deviceAuthorizationEndpoint,\n      method: 'POST',\n      dataType: 'json',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      data: this._utils.stringify(map),\n    });\n\n    if ((response as TokenErrorJson).error === undefined) {\n      return new DeviceCode(response as DeviceCodeJson);\n    } else {\n      throw new AppAuthError((response as TokenErrorJson).error);\n    }\n  }\n}\n"]}