@strivacity/sdk-angular 3.0.3 → 4.0.0-beta.0

package/testing/tests/server/utils.spec.ts

@@ -0,0 +1,112 @@
+import type { Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { Readable, Writable } from 'node:stream';
+import { describe, test, expect, vi } from 'vitest';
+import { applyResponse, toWebRequest } from '../../../src/server/utils';
+
+function fakeExpressRequest(overrides: Partial<ExpressRequest> = {}): ExpressRequest {
+	return {
+		originalUrl: '/callback?code=abc',
+		protocol: 'https',
+		method: 'GET',
+		headers: {},
+		get: (name: string) => (name.toLowerCase() === 'host' ? 'brandtegrity.io' : undefined),
+		...overrides,
+	} as ExpressRequest;
+}
+
+describe('toWebRequest', () => {
+	test('returns a standard Request unchanged', () => {
+		const request = new Request('https://brandtegrity.io');
+
+		expect(toWebRequest(request)).toBe(request);
+	});
+
+	test('converts an Express request into an equivalent standard Request', () => {
+		const req = fakeExpressRequest({ headers: { 'x-foo': 'bar', 'x-multi': ['a', 'b'], 'x-missing': undefined } });
+
+		const request = toWebRequest(req);
+
+		expect(request.url).toBe('https://brandtegrity.io/callback?code=abc');
+		expect(request.method).toBe('GET');
+		expect(request.headers.get('x-foo')).toBe('bar');
+		expect(request.headers.get('x-multi')).toBe('a, b');
+		expect(request.headers.has('x-missing')).toBe(false);
+		expect(request.body).toBeNull();
+	});
+
+	test('does not attach a body for a HEAD request', () => {
+		const request = toWebRequest(fakeExpressRequest({ method: 'HEAD' }));
+
+		expect(request.body).toBeNull();
+	});
+
+	test('streams the request body for non-GET/HEAD requests', async () => {
+		const req = Object.assign(Readable.from(['{"a":1}']), fakeExpressRequest({ method: 'POST' })) as unknown as ExpressRequest;
+
+		const request = toWebRequest(req);
+
+		expect(request.method).toBe('POST');
+		expect(request.body).not.toBeNull();
+		await expect(request.text()).resolves.toBe('{"a":1}');
+	});
+});
+
+describe('applyResponse', () => {
+	function fakeExpressResponse() {
+		const chunks: Array<Buffer> = [];
+		const stream = new Writable({
+			write(chunk, _encoding, callback) {
+				chunks.push(chunk as Buffer);
+				callback();
+			},
+		}) as Writable & ExpressResponse;
+
+		stream.status = vi.fn().mockReturnValue(stream) as never;
+		stream.setHeader = vi.fn().mockReturnValue(stream) as never;
+		stream.end = vi.fn(Writable.prototype.end.bind(stream)) as never;
+
+		return { res: stream, chunks };
+	}
+
+	test('sets the status and copies headers other than set-cookie', async () => {
+		const response = new Response(null, { status: 204, headers: { 'x-foo': 'bar' } });
+		const { res } = fakeExpressResponse();
+
+		await applyResponse(response, res);
+
+		expect(res.status).toHaveBeenCalledWith(204);
+		expect(res.setHeader).toHaveBeenCalledWith('x-foo', 'bar');
+		expect(res.setHeader).not.toHaveBeenCalledWith('set-cookie', expect.anything());
+	});
+
+	test('collects multiple set-cookie headers onto a single set-cookie header', async () => {
+		// appended after construction rather than passed via the Response init - this test environment's fetch
+		// polyfill silently drops every header when a set-cookie entry is present in the constructor's `headers` init
+		const response = new Response(null, { status: 200 });
+		response.headers.append('set-cookie', 'a=1');
+		response.headers.append('set-cookie', 'b=2');
+		const { res } = fakeExpressResponse();
+
+		await applyResponse(response, res);
+
+		expect(res.setHeader).toHaveBeenCalledWith('set-cookie', ['a=1', 'b=2']);
+	});
+
+	test('ends the response immediately when there is no body', async () => {
+		const response = new Response(null, { status: 204 });
+		const { res } = fakeExpressResponse();
+
+		await applyResponse(response, res);
+
+		expect(res.end).toHaveBeenCalledTimes(1);
+	});
+
+	test('streams a present body onto the express response', async () => {
+		const response = new Response('hello world', { status: 200 });
+		const { res, chunks } = fakeExpressResponse();
+
+		await applyResponse(response, res);
+
+		expect(Buffer.concat(chunks).toString()).toBe('hello world');
+	});
+});

package/testing/tests/storages.spec.ts

@@ -0,0 +1,31 @@
+import { test, expect } from 'vitest';
+import * as angularStorages from '../../src/lib/storages';
+import * as coreStorages from '@strivacity/sdk-core/storages';
+
+test('re-exports the client-safe storages verbatim from the core sdk', () => {
+	const expectedExports = [
+		'COOKIE_CONTEXT',
+		'COOKIE_CHUNK_SIZE',
+		'createCacheAPIStorage',
+		'createIndexedDBStorage',
+		'createLocalStorage',
+		'createMemoryStorage',
+		'createServerMemoryStorage',
+		'createSessionStorage',
+		'createWorkerStorage',
+		'handleWorkerStorageRequests',
+	];
+
+	expect(Object.keys(angularStorages).sort()).toEqual([...expectedExports].sort());
+
+	for (const key of expectedExports) {
+		expect(angularStorages[key as keyof typeof angularStorages]).toBe(coreStorages[key as keyof typeof coreStorages]);
+	}
+});
+
+test('deliberately omits the server-only storages that need a request/cookie adapter', () => {
+	// these live in @strivacity/sdk-angular/server instead, where a request adapter is available
+	expect(angularStorages).not.toHaveProperty('createEncryptedCookieStorage');
+	expect(angularStorages).not.toHaveProperty('createServerStateStorage');
+	expect(angularStorages).not.toHaveProperty('createSessionIdCookieStorage');
+});

package/testing/tests/utils.spec.ts

@@ -0,0 +1,24 @@
+import type { AngularSDKInitConfig } from '../../src/types';
+import { describe, test, expect } from 'vitest';
+import { StrivacityAuthService } from '../../src/lib/services/auth.service';
+import { STRIVACITY_SDK, provideStrivacity, StrivacityAuthModule } from '../../src/lib/utils';
+import { createOptions } from '@strivacity/testing/mocks/sdk';
+
+describe('provideStrivacity', () => {
+	test('provides the config under STRIVACITY_SDK and registers StrivacityAuthService', () => {
+		const config = createOptions() as AngularSDKInitConfig;
+
+		expect(provideStrivacity(config)).toEqual([{ provide: STRIVACITY_SDK, useValue: config }, StrivacityAuthService]);
+	});
+});
+
+describe('StrivacityAuthModule', () => {
+	test('forRoot wraps provideStrivacity into a ModuleWithProviders', () => {
+		const config = createOptions() as AngularSDKInitConfig;
+
+		expect(StrivacityAuthModule.forRoot(config)).toEqual({
+			ngModule: StrivacityAuthModule,
+			providers: [[{ provide: STRIVACITY_SDK, useValue: config }, StrivacityAuthService]],
+		});
+	});
+});

package/testing/utils/testbed.ts

@@ -0,0 +1,26 @@
+import type { Provider } from '@angular/core';
+import { Component } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+
+/**
+ * Provides `providers` at a throwaway standalone component's own injector (not the TestBed module injector), and
+ * runs `read` synchronously during that component's construction, i.e. within its injection context - so `inject(...)`
+ * calls inside `read` resolve services scoped to that component. This is what makes `fixture.destroy()` actually fire
+ * `DestroyRef.onDestroy` callbacks registered by those services: a service provided at the TestBed module level lives
+ * in the root environment injector, which `fixture.destroy()` never tears down.
+ */
+export function mountWithProviders<T>(providers: Provider[], read: () => T): { value: T; destroy: () => void } {
+	let value!: T;
+
+	@Component({ selector: 'test-host', template: '', standalone: true, providers })
+	class TestHostComponent {
+		constructor() {
+			value = read();
+		}
+	}
+
+	const fixture = TestBed.createComponent(TestHostComponent);
+	fixture.detectChanges();
+
+	return { value, destroy: () => fixture.destroy() };
+}

package/tsconfig.lib.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "allowImportingTsExtensions": false,
+    "outDir": "./out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "types": []
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./**/*.spec.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/spec",
+    "types": ["vitest/globals"]
+  },
+  "include": ["./src/**/*.d.ts", "./src/**/*.spec.ts"]
+}

package/vite.config.mts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+import { getVitestConfig } from '@strivacity/testing/vitest/config';
+
+const vitestConfig = getVitestConfig('angular');
+
+export default defineConfig({
+	test: {
+		...vitestConfig,
+		setupFiles: [...vitestConfig.setupFiles!, './testing/setup.ts'],
+	},
+});

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@strivacity/sdk-angular" />
-export * from './public-api';

package/dist/lib/components/login-renderer.component.d.ts

@@ -1,38 +0,0 @@
-import type { OnInit, OnDestroy } from '@angular/core';
-import type { NativeFlow } from '@strivacity/sdk-core/flows/NativeFlow';
-import type { IdTokenClaims, NativeParams, WidgetType, LoginFlowState } from '@strivacity/sdk-core';
-import { EventEmitter, Type, ViewContainerRef } from '@angular/core';
-import { FallbackError } from '@strivacity/sdk-core';
-import { StrivacityAuthService } from '../services/auth.service';
-import { StrivacityWidgetService } from '../services/widget.service';
-import * as i0 from "@angular/core";
-export declare class StyLoginRenderer implements OnInit, OnDestroy {
-    protected authService: StrivacityAuthService<NativeFlow>;
-    protected widgetService: StrivacityWidgetService;
-    private subscriptions;
-    private createdComponentRefs;
-    loginHandler: ReturnType<StrivacityAuthService<NativeFlow>['sdk']['login']>;
-    widgets: Record<WidgetType, Type<any>>;
-    sessionId?: string | null;
-    language?: string | null;
-    params: NativeParams;
-    readonly onLogin: EventEmitter<IdTokenClaims>;
-    readonly onFallback: EventEmitter<FallbackError>;
-    readonly onClose: EventEmitter<any>;
-    readonly onError: EventEmitter<any>;
-    readonly onGlobalMessage: EventEmitter<string>;
-    readonly onBlockReady: EventEmitter<{
-        previousState: LoginFlowState;
-        state: LoginFlowState;
-    }>;
-    readonly onLanguageChange: EventEmitter<string>;
-    readonly $containerRef: ViewContainerRef;
-    constructor(authService: StrivacityAuthService<NativeFlow>, widgetService: StrivacityWidgetService);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    init(): Promise<void>;
-    private render;
-    private clearAndDestroyComponents;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StyLoginRenderer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<StyLoginRenderer, "sty-login-renderer", never, { "widgets": { "alias": "widgets"; "required": true; }; "sessionId": { "alias": "sessionId"; "required": false; }; "language": { "alias": "language"; "required": false; }; "params": { "alias": "params"; "required": false; }; }, { "onLogin": "login"; "onFallback": "fallback"; "onClose": "close"; "onError": "error"; "onGlobalMessage": "globalMessage"; "onBlockReady": "blockReady"; "onLanguageChange": "languageChange"; }, never, never, true, never>;
-}

package/dist/lib/components/widget-renderer.component.d.ts

@@ -1,16 +0,0 @@
-import type { Type, SimpleChanges, OnChanges } from '@angular/core';
-import type { WidgetType, LayoutWidget } from '@strivacity/sdk-core';
-import { ViewContainerRef } from '@angular/core';
-import { StrivacityWidgetService } from '../services/widget.service';
-import * as i0 from "@angular/core";
-export declare class StyWidgetRenderer implements OnChanges {
-    protected widgetService: StrivacityWidgetService;
-    items: LayoutWidget['items'];
-    widgets: Record<WidgetType, Type<any>>;
-    readonly $containerRef: ViewContainerRef;
-    constructor(widgetService: StrivacityWidgetService);
-    ngOnChanges(changes: SimpleChanges): void;
-    render(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StyWidgetRenderer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<StyWidgetRenderer, "sty-widget-renderer", never, { "items": { "alias": "items"; "required": false; }; "widgets": { "alias": "widgets"; "required": true; }; }, {}, never, never, true, never>;
-}

package/dist/lib/services/auth.service.d.ts

@@ -1,93 +0,0 @@
-import { type Observable } from 'rxjs';
-import type { PopupFlow } from '@strivacity/sdk-core/flows/PopupFlow';
-import type { RedirectFlow } from '@strivacity/sdk-core/flows/RedirectFlow';
-import type { NativeFlow } from '@strivacity/sdk-core/flows/NativeFlow';
-import { type SDKOptions } from '@strivacity/sdk-core';
-import type { Session } from '../utils/types';
-import * as i0 from "@angular/core";
-/**
- * Service that manages Strivacity authentication flows.
- * Supports either PopupFlow or RedirectFlow types.
- *
- * @template Flow Type of authentication flow (PopupFlow or RedirectFlow).
- * @template Options Type of SDK options (defaults to SDKOptions).
- */
-export declare class StrivacityAuthService<Flow extends PopupFlow | RedirectFlow | NativeFlow = PopupFlow | RedirectFlow | NativeFlow, Options extends SDKOptions = SDKOptions> {
-    options: Options;
-    /**
-     * Instance of the authentication flow (PopupFlow or RedirectFlow).
-     */
-    sdk: Flow;
-    /**
-     * BehaviorSubject that holds the current session state.
-     * @protected
-     * @readonly
-     */
-    private readonly sessionSubject;
-    /**
-     * Observable that emits the session state changes.
-     * @readonly
-     */
-    readonly session$: Observable<Session>;
-    /**
-     * Creates an instance of StrivacityAuthService.
-     *
-     * @param {Options} options SDK configuration options injected via STRIVACITY_SDK.
-     */
-    constructor(options: Options);
-    /**
-     * Checks if the user is authenticated.
-     *
-     * @returns {Observable<boolean>} An observable that emits the authentication status.
-     */
-    isAuthenticated(): Observable<boolean>;
-    /**
-     * Logs the user in using the specified options.
-     *
-     * @param {Parameters<Flow['login']>[0]} [options] Options to customize the login behavior.
-     * @returns {Observable<void>} An observable that completes when the login process is done.
-     */
-    login(options?: Parameters<Flow['login']>[0]): import("@strivacity/sdk-core/dist/handlers/NativeFlowHandler").NativeFlowHandler | Observable<void>;
-    /**
-     * Initiates the entry process using the provided challenge.
-     *
-     * @param {string} [url] Optional URL to use for the entry process. If not provided, the current window location will be used.
-     * @returns {Observable<void>} An observable that completes when the entry process is done.
-     */
-    entry(url?: string): Observable<void | Record<string, string>>;
-    /**
-     * Registers a new user using the specified options.
-     *
-     * @param {Parameters<Flow['register']>[0]} [options] Options to customize the registration behavior.
-     * @returns {Observable<void>} An observable that completes when the registration process is done.
-     */
-    register(options?: Parameters<Flow['register']>[0]): import("@strivacity/sdk-core/dist/handlers/NativeFlowHandler").NativeFlowHandler | Observable<void>;
-    /**
-     * Refreshes the current authentication session.
-     *
-     * @returns {Observable<void>} An observable that completes when the session is refreshed.
-     */
-    refresh(): Observable<void>;
-    /**
-     * Revokes the current session tokens.
-     *
-     * @returns {Observable<void>} An observable that completes when the tokens are revoked.
-     */
-    revoke(): Observable<void>;
-    /**
-     * Logs the user out using the specified options.
-     *
-     * @param {Parameters<Flow['logout']>[0]} [options] Options to customize the logout behavior.
-     * @returns {Observable<void>} An observable that completes when the logout process is done.
-     */
-    logout(options?: Parameters<Flow['logout']>[0]): Observable<void>;
-    /**
-     * Handles the authentication callback (e.g., after a redirect or popup flow).
-     *
-     * @param {Parameters<Flow['handleCallback']>[0]} [url] The URL to handle for the callback.
-     * @returns {Observable<void>} An observable that completes when the callback is handled.
-     */
-    handleCallback(url?: Parameters<Flow['handleCallback']>[0]): Observable<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StrivacityAuthService<any, any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StrivacityAuthService<any, any>>;
-}

package/dist/lib/services/widget.service.d.ts

@@ -1,25 +0,0 @@
-import type { LoginFlowMessage, LoginFlowState } from '@strivacity/sdk-core';
-import { BehaviorSubject } from 'rxjs';
-import * as i0 from "@angular/core";
-export interface NativeFlowState {
-    loading: boolean;
-    formContexts: Record<string, Record<string, unknown>>;
-    messageContexts: Record<string, Record<string, string | null>>;
-    state: LoginFlowState;
-}
-/**
- * Service that manages Strivacity native widgets.
- */
-export declare class StrivacityWidgetService {
-    readonly loading$: BehaviorSubject<boolean>;
-    readonly forms$: BehaviorSubject<Record<string, Record<string, unknown>>>;
-    readonly messages$: BehaviorSubject<Record<string, Record<string, LoginFlowMessage>>>;
-    readonly state$: BehaviorSubject<LoginFlowState>;
-    triggerFallback: (hostedUrl?: string, message?: string) => void;
-    triggerClose: () => void;
-    submitForm: (formId: string) => Promise<void>;
-    setFormValue(formId: string, widgetId: string, value: unknown): void;
-    setMessage(formId: string, widgetId: string, value: LoginFlowMessage): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StrivacityWidgetService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StrivacityWidgetService>;
-}

package/dist/lib/strivacity-auth.module.d.ts

@@ -1,10 +0,0 @@
-import { type ModuleWithProviders } from '@angular/core';
-import type { SDKOptions } from '@strivacity/sdk-core';
-import * as i0 from "@angular/core";
-import * as i1 from "./components/login-renderer.component";
-export declare class StrivacityAuthModule {
-    static forRoot(options: SDKOptions): ModuleWithProviders<StrivacityAuthModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StrivacityAuthModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<StrivacityAuthModule, never, [typeof i1.StyLoginRenderer], [typeof i1.StyLoginRenderer]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<StrivacityAuthModule>;
-}

package/dist/lib/utils/helpers.d.ts

@@ -1,16 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import type { SDKOptions } from '@strivacity/sdk-core';
-export declare const STRIVACITY_SDK: InjectionToken<SDKOptions>;
-/**
- * Provides the Strivacity SDK configuration as a dependency injection token.
- *
- * This function is used to supply the Strivacity SDK configuration to the application
- * by binding it to the `STRIVACITY_SDK` token.
- *
- * @param {SDKOptions} config The SDK configuration options.
- * @returns {{ provide: InjectionToken<SDKOptions>, useValue: SDKOptions }} An object that provides the SDK configuration using the `STRIVACITY_SDK` token.
- */
-export declare function provideStrivacity(config: SDKOptions): {
-    provide: InjectionToken<SDKOptions>;
-    useValue: SDKOptions;
-};

package/dist/lib/utils/types.d.ts

@@ -1,41 +0,0 @@
-import type { IdTokenClaims } from '@strivacity/sdk-core';
-/**
- * Represents the current authentication session state.
- */
-export type Session = {
-    /**
-     * Reactive reference to the loading state of the session.
-     * `true` when the session is initializing, otherwise `false`.
-     */
-    loading: boolean;
-    /**
-     * Reactive reference to the user's authentication status.
-     * `true` if the user is authenticated, otherwise `false`.
-     */
-    isAuthenticated: boolean;
-    /**
-     * Reactive reference to the claims contained in the ID token.
-     * Contains user identity and other information, or `null` if not authenticated.
-     */
-    idTokenClaims: IdTokenClaims | null;
-    /**
-     * Reactive reference to the current access token for API authorization.
-     * `null` if the user is not authenticated or the token is unavailable.
-     */
-    accessToken: string | null;
-    /**
-     * Reactive reference to the refresh token, used to refresh the access token.
-     * `null` if the user is not authenticated or the refresh token is unavailable.
-     */
-    refreshToken: string | null;
-    /**
-     * Reactive reference indicating if the access token has expired.
-     * `true` if expired, otherwise `false`.
-     */
-    accessTokenExpired: boolean;
-    /**
-     * Reactive reference to the expiration date of the access token in Unix time (milliseconds).
-     * `null` if no token is available or the session is not authenticated.
-     */
-    accessTokenExpirationDate: number | null;
-};

package/dist/public-api.d.ts

@@ -1,16 +0,0 @@
-export { type SDKOptions, SDKStorage, type IdTokenClaims } from '@strivacity/sdk-core';
-export type { PopupFlow } from '@strivacity/sdk-core/flows/PopupFlow';
-export type { RedirectFlow } from '@strivacity/sdk-core/flows/RedirectFlow';
-export type { NativeFlow } from '@strivacity/sdk-core/flows/NativeFlow';
-export * from '@strivacity/sdk-core';
-export type * from './lib/utils/types';
-export { HttpClient } from '@strivacity/sdk-core/utils/HttpClient';
-export { DefaultLogging } from '@strivacity/sdk-core/utils/Logging';
-export { LocalStorage } from '@strivacity/sdk-core/storages/LocalStorage';
-export { SessionStorage } from '@strivacity/sdk-core/storages/SessionStorage';
-export { createCredential, getCredential } from '@strivacity/sdk-core/utils/credentials';
-export { StyLoginRenderer } from './lib/components/login-renderer.component';
-export { StrivacityAuthService } from './lib/services/auth.service';
-export { StrivacityWidgetService } from './lib/services/widget.service';
-export { STRIVACITY_SDK, provideStrivacity } from './lib/utils/helpers';
-export { StrivacityAuthModule } from './lib/strivacity-auth.module';