@forgerock/davinci-client 0.0.0-beta-20251124184351 → 0.0.0-beta-20251222204813

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import { davinci } from './lib/client.store.js';
+import { fido } from './lib/fido/fido.js';
+export { davinci, fido };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,10 @@
+/*
+ * 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 { davinci } from './lib/client.store.js';
+import { fido } from './lib/fido/fido.js';
+export { davinci, fido };
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/src/lib/client.store.d.ts

@@ -0,0 +1,352 @@
+/**
+ * Import RTK slices and api
+ */
+import { CustomLogger, LogLevel } from '@forgerock/sdk-logger';
+import type { ActionTypes, RequestMiddleware } from '@forgerock/sdk-request-middleware';
+/**
+ * Import the DaVinciRequest types
+ */
+import type { DaVinciConfig } from './config.types.js';
+import type { DaVinciAction, DaVinciRequest, OutgoingQueryParams, StartOptions } from './davinci.types.js';
+import type { SingleValueCollectors, MultiSelectCollector, ObjectValueCollectors, AutoCollectors, MultiValueCollectors } from './collector.types.js';
+import type { InitFlow, InternalErrorResponse, NodeStates, Updater, Validator } from './client.types.js';
+import type { ContinueNode, StartNode } from './node.types.js';
+/**
+ * Create a client function that returns a set of methods
+ * to interact with and normalize the DaVinci API.
+ *
+ * @function davinciClient - returns an "observable" client for DaVinci flows
+ * @param {ConfigurationOptions} options - the configuration options for the client
+ * @returns {Observable} - an observable client for DaVinci flows
+ */
+export declare function davinci<ActionType extends ActionTypes = ActionTypes>({ config, requestMiddleware, logger, }: {
+    config: DaVinciConfig;
+    requestMiddleware?: RequestMiddleware<ActionType>[];
+    logger?: {
+        level: LogLevel;
+        custom?: CustomLogger;
+    };
+}): Promise<{
+    subscribe: (listener: () => void) => import("@reduxjs/toolkit").Unsubscribe;
+    /**
+     * Social Login Handler
+     * Use this as part of an event when clicking on
+     * a social login button. Pass in the collector responsible
+     * for the social login being started.
+     *
+     * This method will save the `continueUrl`
+     * and then the app developer can use the url
+     * from the collector to redirect their application
+     *
+     * Can return an error when no continue url is found
+     * or no authenticate url is found in the collectors
+     *
+     * @method: externalIdp
+     * @param collector IdpCollector
+     * @returns {function}
+     */
+    externalIdp: () => (() => Promise<void | InternalErrorResponse>);
+    /**
+     * @method flow - Method for initiating a new flow, different than current flow
+     * @param {DaVinciAction} action - the action to initiate the flow
+     * @returns {function} - an async function to call the flow
+     */
+    flow: (action: DaVinciAction) => InitFlow;
+    /**
+     * @method next - Method for initiating the next node in the current flow
+     * @param {DaVinciRequest} args - the arguments to pass to the next
+     * @returns {Promise} - a promise that resolves to the next node
+     */
+    next: (args?: DaVinciRequest) => Promise<NodeStates>;
+    /**
+     * @method: resume - Resume a social login flow when returned to application
+     * @returns unknown
+     */
+    resume: ({ continueToken, }: {
+        continueToken: string;
+    }) => Promise<InternalErrorResponse | NodeStates>;
+    /**
+     * @method start - Method for initiating a DaVinci flow
+     * @returns {Promise} - a promise that initiates a DaVinci flow and returns a node
+     */
+    start: <QueryParams extends OutgoingQueryParams = OutgoingQueryParams>(options?: StartOptions<QueryParams> | undefined) => Promise<ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | StartNode | import("./node.types.js").SuccessNode>;
+    /**
+     * @method update - Exclusive method for updating the current node with user provided values
+     * @param {SingleValueCollector | MultiSelectCollector | ObjectValueCollectors | AutoCollectors} collector - the collector to update
+     * @returns {function} - a function to call for updating collector value
+     */
+    update: <T extends SingleValueCollectors | MultiSelectCollector | ObjectValueCollectors | AutoCollectors>(collector: T) => Updater<T>;
+    /**
+     * @method validate - Method for validating the value against validation rules
+     * @param {SingleValueCollectors | ObjectValueCollectors | MultiValueCollectors | AutoCollectors} collector - the collector to validate
+     * @returns {function} - a function to call for validating collector value
+     * @throws {Error} - if the collector cannot be validated
+     */
+    validate: (collector: SingleValueCollectors | ObjectValueCollectors | MultiValueCollectors | AutoCollectors) => Validator;
+    /**
+     * @method client - Selector to get the node.client from state
+     * @returns {Node.client} - the client property from the current node
+     */
+    getClient: () => {
+        action: string;
+        collectors: import("./node.types.js").Collectors[];
+        description?: string;
+        name?: string;
+        status: "continue";
+    } | {
+        action: string;
+        collectors: import("./node.types.js").Collectors[];
+        description?: string;
+        name?: string;
+        status: "error";
+    } | {
+        status: "failure";
+    } | {
+        status: "start";
+    } | {
+        authorization?: {
+            code?: string;
+            state?: string;
+        };
+        status: "success";
+    } | null;
+    /**
+     * @method collectors - Selector to get the collectors from state
+     * @returns {Collector[]} - The collectors from the current node in state
+     */
+    getCollectors: () => import("./node.types.js").Collectors[];
+    getError: () => import("./node.types.js").DaVinciError | null;
+    getErrorCollectors: () => import("./node.types.js").CollectorErrors[];
+    /**
+     * @method node - Selector to get the node from state
+     * @returns {Node} - the current node from state
+     */
+    getNode: () => ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | StartNode | import("./node.types.js").SuccessNode;
+    /**
+     * @method server - Selector to get the node.server from state
+     * @returns {Node.server} - the server property from the current node
+     */
+    getServer: () => {
+        _links?: import("./davinci.types.js").Links;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        href?: string;
+        eventName?: string;
+        status: "continue";
+    } | {
+        _links?: import("./davinci.types.js").Links;
+        eventName?: string;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        status: "error";
+    } | {
+        _links?: import("./davinci.types.js").Links;
+        eventName?: string;
+        href?: string;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        status: "failure";
+    } | {
+        status: "start";
+    } | {
+        _links?: import("./davinci.types.js").Links;
+        eventName?: string;
+        id?: string;
+        interactionId?: string;
+        interactionToken?: string;
+        href?: string;
+        session?: string;
+        status: "success";
+    } | null;
+    /**
+     * Utilities to help query cached responses from server
+     */
+    cache: {
+        getLatestResponse: () => ((state: import("@reduxjs/toolkit/query").RootState<{
+            flow: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", any>;
+            next: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", any>;
+            start: import("@reduxjs/toolkit/query").MutationDefinition<StartOptions<OutgoingQueryParams> | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", unknown>;
+            resume: import("@reduxjs/toolkit/query").QueryDefinition<{
+                serverInfo: ContinueNode["server"];
+                continueToken: string;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", unknown>;
+        }, never, "davinci">) => ({
+            requestId?: undefined;
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            data?: undefined;
+            error?: undefined;
+            endpointName?: string;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp">> & {
+            error: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+        } & {
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        } & {
+            data?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error">> & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) | {
+            error: {
+                message: string;
+                type: string;
+            };
+        };
+        getResponseWithId: (requestId: string) => ((state: import("@reduxjs/toolkit/query").RootState<{
+            flow: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", any>;
+            next: import("@reduxjs/toolkit/query").MutationDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", any>;
+            start: import("@reduxjs/toolkit/query").MutationDefinition<StartOptions<OutgoingQueryParams> | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", unknown>;
+            resume: import("@reduxjs/toolkit/query").QueryDefinition<{
+                serverInfo: ContinueNode["server"];
+                continueToken: string;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@reduxjs/toolkit/query").FetchArgs, unknown, import("@reduxjs/toolkit/query").FetchBaseQueryError, {}, import("@reduxjs/toolkit/query").FetchBaseQueryMeta>, never, unknown, "davinci", unknown>;
+        }, never, "davinci">) => ({
+            requestId?: undefined;
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            data?: undefined;
+            error?: undefined;
+            endpointName?: string;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "data" | "fulfilledTimeStamp">> & {
+            error: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+        } & {
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        } & {
+            data?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+        } & Omit<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error"> & Required<Pick<{
+            requestId: string;
+            data?: unknown;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number;
+        }, "error">> & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) | {
+            error: {
+                message: string;
+                type: string;
+            };
+        };
+    };
+}>;
+//# sourceMappingURL=client.store.d.ts.map

package/dist/src/lib/client.store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.store.d.ts","sourceRoot":"","sources":["../../../src/lib/client.store.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,OAAO,EAAE,YAAY,EAAsB,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AASnF,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACxF;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EAErB,cAAc,EACd,oBAAoB,EAGrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EACrB,UAAU,EACV,OAAO,EACP,SAAS,EACV,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,UAAU,SAAS,WAAW,GAAG,WAAW,EAAE,EAC1E,MAAM,EACN,iBAAiB,EACjB,MAAM,GACP,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC;IACpD,MAAM,CAAC,EAAE;QACP,KAAK,EAAE,QAAQ,CAAC;QAChB,MAAM,CAAC,EAAE,YAAY,CAAC;KACvB,CAAC;CACH;;IAqCG;;;;;;;;;;;;;;;;OAgBG;uBACc,CAAC,MAAM,OAAO,CAAC,IAAI,GAAG,qBAAqB,CAAC,CAAC;IAoB9D;;;;OAIG;mBACY,aAAa,KAAG,QAAQ;IAkBvC;;;;OAIG;kBACiB,cAAc,KAAG,OAAO,CAAC,UAAU,CAAC;IAkBxD;;;OAGG;iCAGA;QACD,aAAa,EAAE,MAAM,CAAC;KACvB,KAAG,OAAO,CAAC,qBAAqB,GAAG,UAAU,CAAC;IAwB/C;;;OAGG;YACW,WAAW,SAAS,mBAAmB,kCACzC,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS;IAMjD;;;;OAIG;aAED,CAAC,SACG,qBAAqB,GACrB,oBAAoB,GACpB,qBAAqB,GACrB,cAAc,aAEP,CAAC,KACX,OAAO,CAAC,CAAC,CAAC;IA4Db;;;;;OAKG;0BAGG,qBAAqB,GACrB,qBAAqB,GACrB,oBAAoB,GACpB,cAAc,KACjB,SAAS;IA+CZ;;;OAGG;;;;;;;;;;;;;;;;;;;gBA3QqB,CAAC;iBAAqB,CAAC;;;;IA8Q/C;;;OAGG;;;;IAgCH;;;OAGG;;IAKH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAgB8B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAc1C"}