signicat-client-ts
Version:
Community TypeScript client for Signicat Authentication REST API with automatic token management
126 lines (125 loc) • 4.78 kB
JavaScript
;
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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuthenticationSessionService = void 0;
const EncryptionService_1 = require("./EncryptionService");
class AuthenticationSessionService {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Set encryption private key for decrypting JWE responses
* @param privateKey The private key in JWK format
*/
setEncryptionPrivateKey(privateKey) {
this.encryptionPrivateKey = privateKey;
}
/**
* Create a new session
* Use this endpoint to create a session. This must contain a JSON object (as described) with all the info needed.
* @param requestBody JSON object with data used necessary for creating the session.
* @returns SessionDataDto OK
* @throws ApiError
*/
createSession(requestBody) {
return this.handleEncryptedResponse(this.httpRequest.request({
method: "POST",
url: "/sessions",
body: requestBody,
mediaType: "application/json",
errors: {
400: `Bad Request`,
401: `Unauthorized`,
403: `Forbidden`,
500: `Internal Server Error`,
},
}));
}
/**
* Get session status
* Use this endpoint to get information regarding a previously created session.
* @param id The session identifier.
* @param sessionNonce The sessionNonce used for the embedded flow
* @returns SessionDataDto OK
* @throws ApiError
*/
getSession(id, sessionNonce) {
return this.handleEncryptedResponse(this.httpRequest.request({
method: "GET",
url: `/sessions/${id}`,
query: {
sessionNonce: sessionNonce,
},
errors: {
400: `Bad Request`,
401: `Unauthorized`,
403: `Forbidden`,
404: `Not Found`,
500: `Internal Server Error`,
},
}));
}
/**
* Cancel Authentication Session
* @param id The session identifier.
* @returns SessionDataDto OK
* @throws ApiError
*/
cancelSession(id) {
return this.handleEncryptedResponse(this.httpRequest.request({
method: "POST",
url: `/sessions/${id}/cancel`,
errors: {
400: `Bad Request`,
401: `Unauthorized`,
403: `Forbidden`,
500: `Internal Server Error`,
},
}));
}
/**
* Handle potentially encrypted responses
* @param promise The original request promise
* @returns Promise with decrypted data if necessary
*/
handleEncryptedResponse(promise) {
if (!this.encryptionPrivateKey) {
// No encryption key set, return original promise
return promise;
}
// Create a new cancelable promise that handles encryption
return new promise.constructor((resolve, reject, onCancel) => {
promise
.then((response) => __awaiter(this, void 0, void 0, function* () {
try {
// Check if response is a JWE token (string)
if (typeof response === "string" && response.includes(".")) {
// Decrypt JWE response
const decryptedData = yield EncryptionService_1.EncryptionService.decryptJWE(response, this.encryptionPrivateKey);
resolve(decryptedData);
}
else {
// Response is not encrypted
resolve(response);
}
}
catch (error) {
reject(error);
}
}))
.catch(reject);
if (onCancel) {
onCancel(() => promise.cancel());
}
});
}
}
exports.AuthenticationSessionService = AuthenticationSessionService;