@forgerock/davinci-client 1.1.0 → 1.3.0

package/dist/src/index.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"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

@@ -5,5 +5,6 @@
  * of the MIT license. See the LICENSE file for details.
  */
 import { davinci } from './lib/client.store.js';
-export { davinci };
+import { fido } from './lib/fido/fido.js';
+export { davinci, fido };
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"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

@@ -1,11 +1,16 @@
+/**
+ * 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, IdpCollector, MultiSelectCollector } from './collector.types.js';
-import type { InitFlow, Updater, Validator } from './client.types.js';
-import type { RequestMiddleware } from './effects/request.effect.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.
@@ -14,9 +19,13 @@ import type { RequestMiddleware } from './effects/request.effect.types.js';
  * @param {ConfigurationOptions} options - the configuration options for the client
  * @returns {Observable} - an observable client for DaVinci flows
  */
-export declare function davinci({ config, requestMiddleware, }: {
+export declare function davinci<ActionType extends ActionTypes = ActionTypes>({ config, requestMiddleware, logger, }: {
     config: DaVinciConfig;
-    requestMiddleware?: RequestMiddleware[];
+    requestMiddleware?: RequestMiddleware<ActionType>[];
+    logger?: {
+        level: LogLevel;
+        custom?: CustomLogger;
+    };
 }): Promise<{
     subscribe: (listener: () => void) => import("@reduxjs/toolkit").Unsubscribe;
     /**
@@ -26,8 +35,8 @@ export declare function davinci({ config, requestMiddleware, }: {
      * for the social login being started.
      *
      * This method will save the `continueUrl`
-     * and then replace the window with the authenticate
-     * url from the collector
+     * 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
@@ -36,7 +45,7 @@ export declare function davinci({ config, requestMiddleware, }: {
      * @param collector IdpCollector
      * @returns {function}
      */
-    externalIdp: (collector: IdpCollector) => () => void | import("./client.types.js").InternalErrorResponse;
+    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
@@ -48,42 +57,32 @@ export declare function davinci({ config, requestMiddleware, }: {
      * @param {DaVinciRequest} args - the arguments to pass to the next
      * @returns {Promise} - a promise that resolves to the next node
      */
-    next: (args?: DaVinciRequest) => Promise<import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode | {
-        error: string;
-        cache: null;
-        client: {
-            status: "start";
-        };
-        server: {
-            status: "start";
-        };
-        status: "start";
-    }>;
+    next: (args?: DaVinciRequest) => Promise<NodeStates>;
     /**
      * @method: resume - Resume a social login flow when returned to application
      * @returns unknown
      */
-    resume: ({ continueToken }: {
+    resume: ({ continueToken, }: {
         continueToken: string;
-    }) => Promise<import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode>;
+    }) => 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<import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode>;
+    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} collector - the collector to update
+     * @param {SingleValueCollector | MultiSelectCollector | ObjectValueCollectors | AutoCollectors} collector - the collector to update
      * @returns {function} - a function to call for updating collector value
      */
-    update: (collector: SingleValueCollectors | MultiSelectCollector) => Updater;
+    update: <T extends SingleValueCollectors | MultiSelectCollector | ObjectValueCollectors | AutoCollectors>(collector: T) => Updater<T>;
     /**
      * @method validate - Method for validating the value against validation rules
-     * @param {SingleValueCollector} collector - the collector to validate
+     * @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 is not a SingleValueCollector
+     * @throws {Error} - if the collector cannot be validated
      */
-    validate: (collector: SingleValueCollectors) => Validator;
+    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
@@ -122,7 +121,7 @@ export declare function davinci({ config, requestMiddleware, }: {
      * @method node - Selector to get the node from state
      * @returns {Node} - the current node from state
      */
-    getNode: () => import("./node.types.js").ContinueNode | import("./node.types.js").ErrorNode | import("./node.types.js").FailureNode | import("./node.types.js").StartNode | import("./node.types.js").SuccessNode;
+    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
@@ -167,12 +166,13 @@ export declare function davinci({ config, requestMiddleware, }: {
      */
     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">;
-            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">;
-            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">;
+            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">;
+            }, 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;
@@ -192,14 +192,14 @@ export declare function davinci({ config, requestMiddleware, }: {
         } & Omit<{
             requestId: string;
             data?: unknown;
-            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            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/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
             endpointName: string;
             startedTimeStamp: number;
             fulfilledTimeStamp?: number;
@@ -216,7 +216,7 @@ export declare function davinci({ config, requestMiddleware, }: {
         } & {
             requestId: string;
             data?: unknown;
-            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
             endpointName: string;
             startedTimeStamp: number;
             fulfilledTimeStamp?: number;
@@ -233,14 +233,14 @@ export declare function davinci({ config, requestMiddleware, }: {
         } & Omit<{
             requestId: string;
             data?: unknown;
-            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            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/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
             endpointName: string;
             startedTimeStamp: number;
             fulfilledTimeStamp?: number;
@@ -257,12 +257,13 @@ export declare function davinci({ config, requestMiddleware, }: {
             };
         };
         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">;
-            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">;
-            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">;
+            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">;
+            }, 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;
@@ -282,14 +283,14 @@ export declare function davinci({ config, requestMiddleware, }: {
         } & Omit<{
             requestId: string;
             data?: unknown;
-            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            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/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
             endpointName: string;
             startedTimeStamp: number;
             fulfilledTimeStamp?: number;
@@ -306,7 +307,7 @@ export declare function davinci({ config, requestMiddleware, }: {
         } & {
             requestId: string;
             data?: unknown;
-            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
             endpointName: string;
             startedTimeStamp: number;
             fulfilledTimeStamp?: number;
@@ -323,14 +324,14 @@ export declare function davinci({ config, requestMiddleware, }: {
         } & Omit<{
             requestId: string;
             data?: unknown;
-            error?: import("@reduxjs/toolkit/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            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/query").FetchBaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+            error?: import("@reduxjs/toolkit").SerializedError | import("@reduxjs/toolkit/query").FetchBaseQueryError | undefined;
             endpointName: string;
             startedTimeStamp: number;
             fulfilledTimeStamp?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"client.store.d.ts","sourceRoot":"","sources":["../../../src/lib/client.store.ts"],"names":[],"mappings":"AAeA;;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,YAAY,EACZ,oBAAoB,EACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,EAC5B,MAAM,EACN,iBAAiB,GAClB,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACzC;;IAyBG;;;;;;;;;;;;;;;;OAgBG;6BACsB,YAAY;IAQrC;;;;OAIG;mBACY,aAAa,KAAG,QAAQ;IAkBvC;;;;OAIG;kBACiB,cAAc;;;;;;;;;;;IAclC;;;OAGG;gCAC+B;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE;IAQ3D;;;OAGG;YACW,WAAW,SAAS,mBAAmB,kCACzC,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS;IAMjD;;;;OAIG;wBACiB,qBAAqB,GAAG,oBAAoB,KAAG,OAAO;IA6D1E;;;;;OAKG;0BACmB,qBAAqB,KAAG,SAAS;IAkDvD;;;OAGG;;;;;;;;;;;;;;;;;;;gBA/MC,CAAC;iBACJ,CAAJ;;;;IAiNG;;;OAGG;;;;IAsBH;;;OAGG;;IAKH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAgB8B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAc1C"}
+{"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"}

package/dist/src/lib/client.store.js

@@ -7,13 +7,14 @@
 /**
  * Import RTK slices and api
  */
-import { createClientStore } from './client.store.utils.js';
+import { logger as loggerFn } from '@forgerock/sdk-logger';
+import { createStorage } from '@forgerock/storage';
+import { createClientStore, handleUpdateValidateError } from './client.store.utils.js';
 import { nodeSlice } from './node.slice.js';
 import { davinciApi } from './davinci.api.js';
 import { configSlice } from './config.slice.js';
 import { wellknownApi } from './wellknown.api.js';
 import { returnValidator } from './collector.utils.js';
-import { authorize } from './davinci.utils.js';
 /**
  * Create a client function that returns a set of methods
  * to interact with and normalize the DaVinci API.
@@ -22,17 +23,28 @@ import { authorize } from './davinci.utils.js';
  * @param {ConfigurationOptions} options - the configuration options for the client
  * @returns {Observable} - an observable client for DaVinci flows
  */
-export async function davinci({ config, requestMiddleware, }) {
-    const store = createClientStore({ requestMiddleware });
+export async function davinci({ config, requestMiddleware, logger, }) {
+    const log = loggerFn({ level: logger?.level || 'error', custom: logger?.custom });
+    const store = createClientStore({ requestMiddleware, logger: log });
+    const serverInfo = createStorage({
+        type: 'localStorage',
+        name: 'serverInfo',
+    });
     if (!config.serverConfig.wellknown) {
-        throw new Error('`wellknown` property is a required as part of the `config.serverOptions`');
+        const error = new Error('`wellknown` property is a required as part of the `config.serverConfig`');
+        log.error(error.message);
+        throw error;
     }
     if (!config.clientId) {
-        throw new Error('`clientId` property is a required as part of the `config`');
+        const error = new Error('`clientId` property is a required as part of the `config`');
+        log.error(error.message);
+        throw error;
     }
     const { data: openIdResponse } = await store.dispatch(wellknownApi.endpoints.wellknown.initiate(config.serverConfig.wellknown));
     if (!openIdResponse) {
-        throw new Error('error fetching `wellknown` response for OpenId Configuration');
+        const error = new Error('error fetching `wellknown` response for OpenId Configuration');
+        log.error(error.message);
+        throw error;
     }
     store.dispatch(configSlice.actions.set({ ...config, wellknownResponse: openIdResponse }));
     return {
@@ -45,8 +57,8 @@ export async function davinci({ config, requestMiddleware, }) {
          * for the social login being started.
          *
          * This method will save the `continueUrl`
-         * and then replace the window with the authenticate
-         * url from the collector
+         * 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
@@ -55,10 +67,22 @@ export async function davinci({ config, requestMiddleware, }) {
          * @param collector IdpCollector
          * @returns {function}
          */
-        externalIdp: (collector) => {
+        externalIdp: () => {
             const rootState = store.getState();
             const serverSlice = nodeSlice.selectors.selectServer(rootState);
-            return () => authorize(serverSlice, collector);
+            if (serverSlice && serverSlice.status === 'continue') {
+                return async () => {
+                    await serverInfo.set(serverSlice);
+                };
+            }
+            return async () => {
+                return {
+                    error: {
+                        message: 'Not in a continue node state, must be in a continue node to use external idp method',
+                        type: 'state_error',
+                    },
+                };
+            };
         },
         /**
          * @method flow - Method for initiating a new flow, different than current flow
@@ -67,7 +91,7 @@ export async function davinci({ config, requestMiddleware, }) {
          */
         flow: (action) => {
             if (!action.action) {
-                console.error('Missing `argument.action`');
+                log.error('Missing `argument.action`');
                 return async function () {
                     return {
                         error: { message: 'Missing argument.action', type: 'argument_error' },
@@ -91,7 +115,11 @@ export async function davinci({ config, requestMiddleware, }) {
             if (nodeCheck.status === 'start') {
                 return {
                     ...nodeCheck,
-                    error: 'Please use `start` before calling `next`',
+                    error: {
+                        status: 'error',
+                        type: 'state_error',
+                        message: 'Please use `start` before calling `next`',
+                    },
                 };
             }
             await store.dispatch(davinciApi.endpoints.next.initiate(args));
@@ -102,10 +130,24 @@ export async function davinci({ config, requestMiddleware, }) {
          * @method: resume - Resume a social login flow when returned to application
          * @returns unknown
          */
-        resume: async ({ continueToken }) => {
-            await store.dispatch(davinciApi.endpoints.resume.initiate({ continueToken }));
-            const node = nodeSlice.selectSlice(store.getState());
-            return node;
+        resume: async ({ continueToken, }) => {
+            try {
+                const storedServerInfo = (await serverInfo.get());
+                await store.dispatch(davinciApi.endpoints.resume.initiate({ continueToken, serverInfo: storedServerInfo }));
+                await serverInfo.remove();
+                const node = nodeSlice.selectSlice(store.getState());
+                return node;
+            }
+            catch {
+                // logger.error('No url found in collector, social login needs a url in the collector');
+                return {
+                    error: {
+                        message: 'No url found in storage, social login needs a continue url which is saved in local storage. You may have cleared your browser data',
+                        type: 'internal_error',
+                    },
+                    type: 'internal_error',
+                };
+            }
         },
         /**
          * @method start - Method for initiating a DaVinci flow
@@ -117,46 +159,28 @@ export async function davinci({ config, requestMiddleware, }) {
         },
         /**
          * @method update - Exclusive method for updating the current node with user provided values
-         * @param {SingleValueCollector} collector - the collector to update
+         * @param {SingleValueCollector | MultiSelectCollector | ObjectValueCollectors | AutoCollectors} collector - the collector to update
          * @returns {function} - a function to call for updating collector value
          */
         update: (collector) => {
             if (!collector.id) {
-                console.error('Argument for `collector` has no ID');
-                return function () {
-                    return {
-                        error: {
-                            message: 'Argument for `collector` has no ID',
-                            type: 'argument_error',
-                        },
-                        type: 'internal_error',
-                    };
-                };
+                return handleUpdateValidateError('Argument for `collector` has no ID', 'argument_error', log.error);
             }
             const { id } = collector;
-            const collectorToUpdate = nodeSlice.selectors.selectCollector(store.getState(), id);
+            const { error, state: collectorToUpdate } = nodeSlice.selectors.selectCollector(store.getState(), id);
+            if (error) {
+                return handleUpdateValidateError(error.message, 'state_error', log.error);
+            }
             if (!collectorToUpdate) {
-                return function () {
-                    console.error('Collector not found');
-                    return {
-                        type: 'internal_error',
-                        error: { message: 'Collector not found', type: 'state_error' },
-                    };
-                };
+                return handleUpdateValidateError('Collector not found', 'state_error', log.error);
             }
             if (collectorToUpdate.category !== 'MultiValueCollector' &&
                 collectorToUpdate.category !== 'SingleValueCollector' &&
-                collectorToUpdate.category !== 'ValidatedSingleValueCollector') {
-                console.error('Collector is not a MultiValueCollector, SingleValueCollector or ValidatedSingleValueCollector and cannot be updated');
-                return function () {
-                    return {
-                        type: 'internal_error',
-                        error: {
-                            message: 'Collector is not a SingleValueCollector or ValidatedSingleValueCollector and cannot be updated',
-                            type: 'state_error',
-                        },
-                    };
-                };
+                collectorToUpdate.category !== 'ValidatedSingleValueCollector' &&
+                collectorToUpdate.category !== 'ObjectValueCollector' &&
+                collectorToUpdate.category !== 'SingleValueAutoCollector' &&
+                collectorToUpdate.category !== 'ObjectValueAutoCollector') {
+                return handleUpdateValidateError('Collector does not fall into a category that can be updated', 'state_error', log.error);
             }
             return function (value, index) {
                 try {
@@ -174,51 +198,30 @@ export async function davinci({ config, requestMiddleware, }) {
         },
         /**
          * @method validate - Method for validating the value against validation rules
-         * @param {SingleValueCollector} collector - the collector to validate
+         * @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 is not a SingleValueCollector
+         * @throws {Error} - if the collector cannot be validated
          */
         validate: (collector) => {
             if (!collector.id) {
-                console.error('Argument for `collector` has no ID');
-                return function () {
-                    return {
-                        error: { message: 'Argument for `collector` has no ID', type: 'argument_error' },
-                        type: 'internal_error',
-                    };
-                };
+                return handleUpdateValidateError('Argument for `collector` has no ID', 'argument_error', log.error);
             }
             const { id } = collector;
-            const collectorToUpdate = nodeSlice.selectors.selectCollector(store.getState(), id);
+            const { error, state: collectorToUpdate } = nodeSlice.selectors.selectCollector(store.getState(), id);
+            if (error) {
+                return handleUpdateValidateError(error.message, 'state_error', log.error);
+            }
             if (!collectorToUpdate) {
-                return function () {
-                    console.error('Collector not found');
-                    return {
-                        type: 'internal_error',
-                        error: { message: 'Collector not found', type: 'state_error' },
-                    };
-                };
+                return handleUpdateValidateError('Collector not found', 'state_error', log.error);
             }
-            if (collectorToUpdate.category !== 'ValidatedSingleValueCollector') {
-                console.error('Collector is not a SingleValueCollector and cannot be validated');
-                return function () {
-                    return {
-                        type: 'internal_error',
-                        error: {
-                            message: 'Collector is not a SingleValueCollector and cannot be validated',
-                            type: 'state_error',
-                        },
-                    };
-                };
+            if (collectorToUpdate.category !== 'ValidatedSingleValueCollector' &&
+                collectorToUpdate.category !== 'ObjectValueCollector' &&
+                collectorToUpdate.category !== 'MultiValueCollector' &&
+                collectorToUpdate.category !== 'ObjectValueAutoCollector') {
+                return handleUpdateValidateError('Collector does not fall into a category that can be validated', 'state_error', log.error);
             }
             if (!('validation' in collectorToUpdate.input)) {
-                console.error('Collector has no validation rules');
-                return function () {
-                    return {
-                        type: 'internal_error',
-                        error: { message: 'Collector has no validation rules', type: 'state_error' },
-                    };
-                };
+                return handleUpdateValidateError('Collector has no validation rules', 'state_error', log.error);
             }
             return returnValidator(collectorToUpdate);
         },
@@ -236,7 +239,12 @@ export async function davinci({ config, requestMiddleware, }) {
             const client = nodeSlice.selectors.selectClient(state);
             // Let's check if the node has a client and collectors
             if (client && 'collectors' in client) {
-                return nodeSlice.selectors.selectCollectors(state) || [];
+                const { error, state: collectors } = nodeSlice.selectors.selectCollectors(state) || [];
+                if (error) {
+                    log.error(error.message);
+                    return [];
+                }
+                return collectors;
             }
             // Return an empty array if no client or collectors are found
             return [];
@@ -247,7 +255,12 @@ export async function davinci({ config, requestMiddleware, }) {
         },
         getErrorCollectors: () => {
             const state = store.getState();
-            return nodeSlice.selectors.selectErrorCollectors(state);
+            const { error, state: collectors } = nodeSlice.selectors.selectErrorCollectors(state);
+            if (error) {
+                log.error(error.message);
+                return [];
+            }
+            return collectors;
         },
         /**
          * @method node - Selector to get the node from state
@@ -271,7 +284,7 @@ export async function davinci({ config, requestMiddleware, }) {
             getLatestResponse: () => {
                 const node = nodeSlice.selectSlice(store.getState());
                 if (!node.cache?.key) {
-                    console.error(`Cannot find current node's cache key or no current node`);
+                    log.error(`Cannot find current node's cache key or no current node`);
                     return { error: { message: 'Cannot find current node', type: 'state_error' } };
                 }
                 const flowItem = davinciApi.endpoints.flow.select(node.cache.key);
@@ -281,7 +294,7 @@ export async function davinci({ config, requestMiddleware, }) {
             },
             getResponseWithId: (requestId) => {
                 if (!requestId) {
-                    console.error('Please provide the cache key');
+                    log.error('Please provide the cache key');
                     return { error: { message: 'Please provide the cache key', type: 'argument_error' } };
                 }
                 const flowItem = davinciApi.endpoints.flow.select(requestId);