@forgerock/journey-client 0.0.0-beta-20251222204813

package/src/lib/callbacks/factory.ts

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+import { AttributeInputCallback } from './attribute-input-callback.js';
+import { ChoiceCallback } from './choice-callback.js';
+import { ConfirmationCallback } from './confirmation-callback.js';
+import { DeviceProfileCallback } from './device-profile-callback.js';
+import { HiddenValueCallback } from './hidden-value-callback.js';
+import { KbaCreateCallback } from './kba-create-callback.js';
+import { MetadataCallback } from './metadata-callback.js';
+import { NameCallback } from './name-callback.js';
+import { PasswordCallback } from './password-callback.js';
+import { PingOneProtectEvaluationCallback } from './ping-protect-evaluation-callback.js';
+import { PingOneProtectInitializeCallback } from './ping-protect-initialize-callback.js';
+import { PollingWaitCallback } from './polling-wait-callback.js';
+import { ReCaptchaCallback } from './recaptcha-callback.js';
+import { ReCaptchaEnterpriseCallback } from './recaptcha-enterprise-callback.js';
+import { RedirectCallback } from './redirect-callback.js';
+import { SelectIdPCallback } from './select-idp-callback.js';
+import { SuspendedTextOutputCallback } from './suspended-text-output-callback.js';
+import { TermsAndConditionsCallback } from './terms-and-conditions-callback.js';
+import { TextInputCallback } from './text-input-callback.js';
+import { TextOutputCallback } from './text-output-callback.js';
+import { ValidatedCreatePasswordCallback } from './validated-create-password-callback.js';
+import { ValidatedCreateUsernameCallback } from './validated-create-username-callback.js';
+
+export type CallbackFactory = (callback: Callback) => BaseCallback;
+
+/**
+ * @hidden
+ */
+export function createCallback(callback: Callback): BaseCallback {
+  switch (callback.type) {
+    case callbackType.BooleanAttributeInputCallback:
+      return new AttributeInputCallback<boolean>(callback);
+    case callbackType.ChoiceCallback:
+      return new ChoiceCallback(callback);
+    case callbackType.ConfirmationCallback:
+      return new ConfirmationCallback(callback);
+    case callbackType.DeviceProfileCallback:
+      return new DeviceProfileCallback(callback);
+    case callbackType.HiddenValueCallback:
+      return new HiddenValueCallback(callback);
+    case callbackType.KbaCreateCallback:
+      return new KbaCreateCallback(callback);
+    case callbackType.MetadataCallback:
+      return new MetadataCallback(callback);
+    case callbackType.NameCallback:
+      return new NameCallback(callback);
+    case callbackType.NumberAttributeInputCallback:
+      return new AttributeInputCallback<number>(callback);
+    case callbackType.PasswordCallback:
+      return new PasswordCallback(callback);
+    case callbackType.PingOneProtectEvaluationCallback:
+      return new PingOneProtectEvaluationCallback(callback);
+    case callbackType.PingOneProtectInitializeCallback:
+      return new PingOneProtectInitializeCallback(callback);
+    case callbackType.PollingWaitCallback:
+      return new PollingWaitCallback(callback);
+    case callbackType.ReCaptchaCallback:
+      return new ReCaptchaCallback(callback);
+    case callbackType.ReCaptchaEnterpriseCallback:
+      return new ReCaptchaEnterpriseCallback(callback);
+    case callbackType.RedirectCallback:
+      return new RedirectCallback(callback);
+    case callbackType.SelectIdPCallback:
+      return new SelectIdPCallback(callback);
+    case callbackType.StringAttributeInputCallback:
+      return new AttributeInputCallback<string>(callback);
+    case callbackType.SuspendedTextOutputCallback:
+      return new SuspendedTextOutputCallback(callback);
+    case callbackType.TermsAndConditionsCallback:
+      return new TermsAndConditionsCallback(callback);
+    case callbackType.TextInputCallback:
+      return new TextInputCallback(callback);
+    case callbackType.TextOutputCallback:
+      return new TextOutputCallback(callback);
+    case callbackType.ValidatedCreatePasswordCallback:
+      return new ValidatedCreatePasswordCallback(callback);
+    case callbackType.ValidatedCreateUsernameCallback:
+      return new ValidatedCreateUsernameCallback(callback);
+    default:
+      return new BaseCallback(callback);
+  }
+}

package/src/lib/callbacks/hidden-value-callback.test.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+import { describe, it, expect } from 'vitest';
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { HiddenValueCallback } from './hidden-value-callback.js';
+
+describe('HiddenValueCallback', () => {
+  it('should instantiate correctly', () => {
+    const payload: Callback = {
+      type: callbackType.HiddenValueCallback,
+      output: [{ name: 'value', value: 'some-hidden-value' }],
+      input: [{ name: 'IDToken1', value: '' }],
+    };
+    const cb = new HiddenValueCallback(payload);
+    expect(cb).toBeInstanceOf(HiddenValueCallback);
+    expect(cb.getOutputValue('value')).toBe('some-hidden-value');
+  });
+});

package/src/lib/callbacks/hidden-value-callback.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+/**
+ * Represents a callback used to collect information indirectly from the user.
+ */
+export class HiddenValueCallback extends BaseCallback {
+  /**
+   * @param payload The raw payload returned by OpenAM
+   */
+  constructor(public override payload: Callback) {
+    super(payload);
+  }
+}

package/src/lib/callbacks/kba-create-callback.test.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+import { describe, it, expect } from 'vitest';
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { KbaCreateCallback } from './kba-create-callback.js';
+
+describe('KbaCreateCallback', () => {
+  const payload: Callback = {
+    type: callbackType.KbaCreateCallback,
+    output: [
+      {
+        name: 'prompt',
+        value: 'What is your favorite color?',
+      },
+      {
+        name: 'predefinedQuestions',
+        value: ['Question 1', 'Question 2'],
+      },
+      {
+        name: 'allowUserDefinedQuestions',
+        value: true,
+      },
+    ],
+    input: [
+      {
+        name: 'IDToken1question',
+        value: '',
+      },
+      {
+        name: 'IDToken1answer',
+        value: '',
+      },
+    ],
+  };
+
+  it('should allow getting the prompt and questions', () => {
+    const cb = new KbaCreateCallback(payload);
+    expect(cb.getPrompt()).toBe('What is your favorite color?');
+    expect(cb.getPredefinedQuestions()).toEqual(['Question 1', 'Question 2']);
+  });
+
+  it('should allow setting the question and answer', () => {
+    const cb = new KbaCreateCallback(payload);
+    cb.setQuestion('My custom question');
+    cb.setAnswer('Blue');
+    expect(cb.getInputValue('IDToken1question')).toBe('My custom question');
+    expect(cb.getInputValue('IDToken1answer')).toBe('Blue');
+  });
+
+  it('should indicate if user-defined questions are allowed', () => {
+    const cb = new KbaCreateCallback(payload);
+    expect(cb.isAllowedUserDefinedQuestions()).toBe(true);
+  });
+});

package/src/lib/callbacks/kba-create-callback.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+/**
+ * Represents a callback used to collect KBA-style security questions and answers.
+ */
+export class KbaCreateCallback extends BaseCallback {
+  /**
+   * @param payload The raw payload returned by OpenAM
+   */
+  constructor(public override payload: Callback) {
+    super(payload);
+  }
+
+  /**
+   * Gets the callback prompt.
+   */
+  public getPrompt(): string {
+    return this.getOutputByName<string>('prompt', '');
+  }
+
+  /**
+   * Gets the callback's list of pre-defined security questions.
+   */
+  public getPredefinedQuestions(): string[] {
+    return this.getOutputByName<string[]>('predefinedQuestions', []);
+  }
+
+  /**
+   * Gets whether the user can define questions.
+   */
+  public isAllowedUserDefinedQuestions(): boolean {
+    return this.getOutputByName<boolean>('allowUserDefinedQuestions', false);
+  }
+
+  /**
+   * Sets the callback's security question.
+   */
+  public setQuestion(question: string): void {
+    this.setValue('question', question);
+  }
+
+  /**
+   * Sets the callback's security question answer.
+   */
+  public setAnswer(answer: string): void {
+    this.setValue('answer', answer);
+  }
+
+  private setValue(type: 'question' | 'answer', value: string): void {
+    if (!this.payload.input) {
+      throw new Error('KBA payload is missing input');
+    }
+
+    const input = this.payload.input.find((x) => x.name.endsWith(type));
+    if (!input) {
+      throw new Error(`No input has name ending in "${type}"`);
+    }
+    input.value = value;
+  }
+}

package/src/lib/callbacks/metadata-callback.test.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+import { describe, it, expect } from 'vitest';
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { MetadataCallback } from './metadata-callback.js';
+
+describe('MetadataCallback', () => {
+  it('should allow getting the data', () => {
+    const mockData = { foo: 'bar', baz: 123 };
+    const payload: Callback = {
+      type: callbackType.MetadataCallback,
+      output: [
+        {
+          name: 'data',
+          value: mockData,
+        },
+      ],
+      input: [],
+    };
+    const cb = new MetadataCallback(payload);
+    expect(cb.getData()).toEqual(mockData);
+  });
+});

package/src/lib/callbacks/metadata-callback.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+/**
+ * Represents a callback used to deliver and collect miscellaneous data.
+ */
+export class MetadataCallback extends BaseCallback {
+  /**
+   * @param payload The raw payload returned by OpenAM
+   */
+  constructor(public override payload: Callback) {
+    super(payload);
+  }
+
+  /**
+   * Gets the callback's data.
+   */
+  public getData<T>(): T {
+    return this.getOutputByName<T>('data', {} as T);
+  }
+}

package/src/lib/callbacks/name-callback.test.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+import { describe, it, expect } from 'vitest';
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { NameCallback } from './name-callback.js';
+
+describe('NameCallback', () => {
+  const payload: Callback = {
+    type: callbackType.NameCallback,
+    output: [
+      {
+        name: 'prompt',
+        value: 'Username',
+      },
+    ],
+    input: [
+      {
+        name: 'IDToken1',
+        value: '',
+      },
+    ],
+  };
+
+  it('should allow getting the prompt', () => {
+    const cb = new NameCallback(payload);
+    expect(cb.getPrompt()).toBe('Username');
+  });
+
+  it('should allow setting the name', () => {
+    const cb = new NameCallback(payload);
+    cb.setName('test-user');
+    expect(cb.getInputValue()).toBe('test-user');
+  });
+});

package/src/lib/callbacks/name-callback.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+/**
+ * Represents a callback used to collect a username.
+ */
+export class NameCallback extends BaseCallback {
+  /**
+   * @param payload The raw payload returned by OpenAM
+   */
+  constructor(public override payload: Callback) {
+    super(payload);
+  }
+
+  /**
+   * Gets the callback's prompt.
+   */
+  public getPrompt(): string {
+    return this.getOutputByName<string>('prompt', '');
+  }
+
+  /**
+   * Sets the username.
+   */
+  public setName(name: string): void {
+    this.setInputValue(name);
+  }
+}

package/src/lib/callbacks/password-callback.test.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+import { describe, it, expect } from 'vitest';
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { PasswordCallback } from './password-callback.js';
+
+describe('PasswordCallback', () => {
+  const payload: Callback = {
+    type: callbackType.PasswordCallback,
+    output: [
+      {
+        name: 'prompt',
+        value: 'Password',
+      },
+      {
+        name: 'policies',
+        value: ['policy1', 'policy2'],
+      },
+      {
+        name: 'failedPolicies',
+        value: ['failedPolicy1'],
+      },
+    ],
+    input: [
+      {
+        name: 'IDToken1',
+        value: '',
+      },
+    ],
+  };
+
+  it('should allow getting the prompt', () => {
+    const cb = new PasswordCallback(payload);
+    expect(cb.getPrompt()).toBe('Password');
+  });
+
+  it('should allow getting policies', () => {
+    const cb = new PasswordCallback(payload);
+    expect(cb.getPolicies()).toEqual(['policy1', 'policy2']);
+  });
+
+  it('should allow getting failed policies', () => {
+    const cb = new PasswordCallback(payload);
+    expect(cb.getFailedPolicies()).toEqual(['failedPolicy1']);
+  });
+
+  it('should allow setting the password', () => {
+    const cb = new PasswordCallback(payload);
+    cb.setPassword('new-password');
+    expect(cb.getInputValue()).toBe('new-password');
+  });
+});

package/src/lib/callbacks/password-callback.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { Callback, PolicyRequirement } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+/**
+ * Represents a callback used to collect a password.
+ */
+export class PasswordCallback extends BaseCallback {
+  /**
+   * @param payload The raw payload returned by OpenAM
+   */
+  constructor(public override payload: Callback) {
+    super(payload);
+  }
+
+  /**
+   * Gets the callback's failed policies.
+   */
+  public getFailedPolicies(): PolicyRequirement[] {
+    return this.getOutputByName<PolicyRequirement[]>('failedPolicies', []);
+  }
+
+  /**
+   * Gets the callback's applicable policies.
+   */
+  public getPolicies(): string[] {
+    return this.getOutputByName<string[]>('policies', []);
+  }
+
+  /**
+   * Gets the callback's prompt.
+   */
+  public getPrompt(): string {
+    return this.getOutputByName<string>('prompt', '');
+  }
+
+  /**
+   * Sets the password.
+   */
+  public setPassword(password: string): void {
+    this.setInputValue(password);
+  }
+}

package/src/lib/callbacks/ping-protect-evaluation-callback.test.ts

@@ -0,0 +1,69 @@
+/*
+ * @forgerock/ping-javascript-sdk
+ *
+ * ping-protect-evaluation-callback.test.ts
+ *
+ * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+import { vi, describe, it, expect } from 'vitest';
+
+import { PingOneProtectEvaluationCallback } from './ping-protect-evaluation-callback.js';
+
+describe('PingOneProtectEvaluationCallback', () => {
+  it('should be defined', () => {
+    expect(PingOneProtectEvaluationCallback).toBeDefined();
+  });
+  it('should test that the pauseBehavior method can be called', () => {
+    const callback = new PingOneProtectEvaluationCallback({
+      type: callbackType.PingOneProtectEvaluationCallback,
+      output: [{ name: 'pauseBehavioralData', value: true }],
+    });
+    const mock = vi.spyOn(callback, 'getPauseBehavioralData');
+    callback.getPauseBehavioralData();
+    expect(mock).toHaveBeenCalled();
+  });
+  it('should test setData method', () => {
+    const callback = new PingOneProtectEvaluationCallback({
+      type: callbackType.PingOneProtectEvaluationCallback,
+      output: [{ name: 'signals', value: '' }],
+      input: [
+        {
+          name: 'IDToken1signals',
+          value: '',
+        },
+        {
+          name: 'IDToken1clientError',
+          value: '',
+        },
+      ],
+    });
+    const mock = vi.spyOn(callback, 'setData');
+    callback.setData('data');
+    expect(mock).toHaveBeenCalledWith('data');
+    expect(callback.getInputValue('IDToken1signals')).toBe('data');
+  });
+  it('should test setClientError method', () => {
+    const callback = new PingOneProtectEvaluationCallback({
+      type: callbackType.PingOneProtectEvaluationCallback,
+      output: [{ name: 'signals', value: '' }],
+      input: [
+        {
+          name: 'IDToken1signals',
+          value: '',
+        },
+        {
+          name: 'IDToken1clientError',
+          value: '',
+        },
+      ],
+    });
+    const mock = vi.spyOn(callback, 'setClientError');
+    callback.setClientError('error i just set');
+    expect(mock).toHaveBeenCalledWith('error i just set');
+    expect(callback.getInputValue('IDToken1clientError')).toBe('error i just set');
+  });
+});

package/src/lib/callbacks/ping-protect-evaluation-callback.ts

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { Callback } from '@forgerock/sdk-types';
+
+import { BaseCallback } from './base-callback.js';
+
+/**
+ * @class - Represents a callback used to complete and package up device and behavioral data.
+ */
+export class PingOneProtectEvaluationCallback extends BaseCallback {
+  /**
+   * @param payload The raw payload returned by OpenAM
+   */
+  constructor(public override payload: Callback) {
+    super(payload);
+  }
+
+  /**
+   * Gets the callback's pauseBehavioralData value.
+   * @returns {boolean}
+   */
+  public getPauseBehavioralData(): boolean {
+    return this.getOutputByName<boolean>('pauseBehavioralData', false);
+  }
+
+  /**
+   * @method setData - Set the result of data collection
+   * @param {string} data - Data from calling pingProtect.get()
+   * @returns {void}
+   */
+  public setData(data: string): void {
+    this.setInputValue(data, /signals/);
+  }
+
+  /**
+   * @method setClientError - Set the client error message
+   * @param {string} errorMessage - Error message
+   * @returns {void}
+   */
+  public setClientError(errorMessage: string): void {
+    this.setInputValue(errorMessage, /clientError/);
+  }
+}
+
+/**
+  * Example of callback:
+{
+  "type": "PingOneProtectEvaluationCallback",
+  "output": [
+    {
+      "name": "pauseBehavioralData",
+      "value": true
+    }
+  ],
+  "input": [
+    {
+      "name": "IDToken1signals",
+      "value": ""
+    },
+    {
+      "name": "IDToken1clientError",
+      "value": ""
+    }
+  ]
+}
+*/