@zeniai/client-epic-state 5.0.31 → 5.0.32-betaRD1

package/lib/view/zeniOAuthView/epics/approveOAuthConsentEpic.d.ts

@@ -0,0 +1,14 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { RootState } from '../../../reducer';
+import { ZeniAPI } from '../../../zeniAPI';
+import { approveOAuthConsent, approveOAuthConsentFailure, approveOAuthConsentSuccess } from '../zeniOAuthReducer';
+export type ActionType = ReturnType<typeof approveOAuthConsent> | ReturnType<typeof approveOAuthConsentSuccess> | ReturnType<typeof approveOAuthConsentFailure>;
+export declare const approveOAuthConsentEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => import("rxjs").Observable<{
+    payload: {
+        redirectUrl: string;
+    };
+    type: "zeniOAuthView/approveOAuthConsentSuccess";
+} | {
+    payload: import("../../../responsePayload").ZeniAPIStatus<Record<string, unknown>>;
+    type: "zeniOAuthView/approveOAuthConsentFailure";
+}>;

package/lib/view/zeniOAuthView/epics/approveOAuthConsentEpic.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approveOAuthConsentEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../responsePayload");
+const zeniOAuthReducer_1 = require("../zeniOAuthReducer");
+const approveOAuthConsentEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(zeniOAuthReducer_1.approveOAuthConsent.match), (0, operators_1.switchMap)((action) => {
+    const { userId, zeniSessionId, tenantId, clientId, redirectUri, codeChallenge, codeChallengeMethod, state, responseType, } = action.payload;
+    const authHeaders = {
+        'zeni-user-id': userId,
+        'zeni-tenant-id': tenantId,
+    };
+    if (zeniSessionId != null) {
+        authHeaders['zeni-session-id'] = zeniSessionId;
+    }
+    return zeniAPI
+        .postJSON(`${zeniAPI.apiEndPoints.authMicroServiceBaseUrl}/oauth/authorize/approve`, {
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        code_challenge: codeChallenge,
+        code_challenge_method: codeChallengeMethod,
+        state,
+        response_type: responseType,
+        tenant_id: tenantId,
+    }, authHeaders)
+        .pipe((0, operators_1.concatMap)((response) => (0, rxjs_1.from)(response.json()).pipe((0, operators_1.mergeMap)((responseJson) => {
+        if (!response.ok) {
+            const errBody = responseJson;
+            const errorMessage = errBody?.error ??
+                errBody?.message ??
+                errBody?.status?.message ??
+                `Authorization failed (${response.status})`;
+            return (0, rxjs_1.of)((0, zeniOAuthReducer_1.approveOAuthConsentFailure)((0, responsePayload_1.createZeniAPIStatus)(errorMessage)));
+        }
+        const body = responseJson;
+        const redirectUrl = body?.redirect_url ?? body?.data?.redirect_url;
+        if (redirectUrl == null || redirectUrl === '') {
+            return (0, rxjs_1.of)((0, zeniOAuthReducer_1.approveOAuthConsentFailure)((0, responsePayload_1.createZeniAPIStatus)('No redirect URL returned from authorization server')));
+        }
+        return (0, rxjs_1.of)((0, zeniOAuthReducer_1.approveOAuthConsentSuccess)({ redirectUrl }));
+    }))), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, zeniOAuthReducer_1.approveOAuthConsentFailure)((0, responsePayload_1.createZeniAPIStatus)('OAuth approve request failed: ' + JSON.stringify(error))))));
+}));
+exports.approveOAuthConsentEpic = approveOAuthConsentEpic;

package/lib/view/zeniOAuthView/zeniOAuthParamsParser.d.ts

@@ -0,0 +1,16 @@
+export interface OAuthParams {
+    clientId: string;
+    codeChallenge: string;
+    codeChallengeMethod: string;
+    redirectUri: string;
+    responseType: string;
+    state: string;
+}
+export type ParseOAuthParamsResult = {
+    error: null;
+    params: OAuthParams;
+} | {
+    error: string;
+    params: null;
+};
+export declare function parseOAuthParams(search: string): ParseOAuthParamsResult;

package/lib/view/zeniOAuthView/zeniOAuthParamsParser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOAuthParams = parseOAuthParams;
+function parseOAuthParams(search) {
+    const searchParams = new URLSearchParams(search);
+    const clientId = searchParams.get('client_id');
+    const redirectUri = searchParams.get('redirect_uri');
+    const codeChallenge = searchParams.get('code_challenge');
+    const codeChallengeMethod = searchParams.get('code_challenge_method') ?? 'S256';
+    const state = searchParams.get('state');
+    const responseType = searchParams.get('response_type') ?? 'code';
+    if (clientId == null || clientId === '') {
+        return { params: null, error: 'Missing client_id parameter' };
+    }
+    if (redirectUri == null || redirectUri === '') {
+        return { params: null, error: 'Missing redirect_uri parameter' };
+    }
+    try {
+        void new URL(redirectUri);
+    }
+    catch {
+        return { params: null, error: 'Invalid redirect_uri parameter' };
+    }
+    if (codeChallenge == null || codeChallenge === '') {
+        return {
+            params: null,
+            error: 'Missing code_challenge parameter (PKCE required)',
+        };
+    }
+    if (state == null || state === '') {
+        return { params: null, error: 'Missing state parameter' };
+    }
+    return {
+        params: {
+            clientId,
+            redirectUri,
+            codeChallenge,
+            codeChallengeMethod,
+            state,
+            responseType,
+        },
+        error: null,
+    };
+}

package/lib/view/zeniOAuthView/zeniOAuthReducer.d.ts

@@ -0,0 +1,29 @@
+import { ZeniAPIStatus } from '../../responsePayload';
+import { ZeniOAuthViewState } from './zeniOAuthState';
+export declare const initialState: ZeniOAuthViewState;
+export interface ApproveOAuthConsentPayload {
+    clientId: string;
+    codeChallenge: string;
+    codeChallengeMethod: string;
+    redirectUri: string;
+    responseType: string;
+    state: string;
+    tenantId: string;
+    userId: string;
+    zeniSessionId: string | undefined;
+}
+export declare const approveOAuthConsent: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[userId: string, zeniSessionId: string | undefined, tenantId: string, clientId: string, redirectUri: string, codeChallenge: string, codeChallengeMethod: string, state: string, responseType: string], {
+    userId: string;
+    zeniSessionId: string | undefined;
+    tenantId: string;
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    codeChallengeMethod: string;
+    state: string;
+    responseType: string;
+}, "zeniOAuthView/approveOAuthConsent", never, never>, approveOAuthConsentSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    redirectUrl: string;
+}, "zeniOAuthView/approveOAuthConsentSuccess">, approveOAuthConsentFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "zeniOAuthView/approveOAuthConsentFailure">, clearZeniOAuthView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"zeniOAuthView/clearZeniOAuthView">;
+declare const _default: import("redux").Reducer<ZeniOAuthViewState>;
+export default _default;

package/lib/view/zeniOAuthView/zeniOAuthReducer.js

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearZeniOAuthView = exports.approveOAuthConsentFailure = exports.approveOAuthConsentSuccess = exports.approveOAuthConsent = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    approveRedirectUrl: undefined,
+};
+const zeniOAuthView = (0, toolkit_1.createSlice)({
+    name: 'zeniOAuthView',
+    initialState: exports.initialState,
+    reducers: {
+        approveOAuthConsent: {
+            prepare(userId, zeniSessionId, tenantId, clientId, redirectUri, codeChallenge, codeChallengeMethod, state, responseType) {
+                return {
+                    payload: {
+                        userId,
+                        zeniSessionId,
+                        tenantId,
+                        clientId,
+                        redirectUri,
+                        codeChallenge,
+                        codeChallengeMethod,
+                        state,
+                        responseType,
+                    },
+                };
+            },
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+                draft.error = undefined;
+                draft.approveRedirectUrl = undefined;
+            },
+        },
+        approveOAuthConsentSuccess(draft, action) {
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            draft.approveRedirectUrl = action.payload.redirectUrl;
+        },
+        approveOAuthConsentFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.error = action.payload;
+            draft.approveRedirectUrl = undefined;
+        },
+        clearZeniOAuthView() {
+            return exports.initialState;
+        },
+    },
+});
+_a = zeniOAuthView.actions, exports.approveOAuthConsent = _a.approveOAuthConsent, exports.approveOAuthConsentSuccess = _a.approveOAuthConsentSuccess, exports.approveOAuthConsentFailure = _a.approveOAuthConsentFailure, exports.clearZeniOAuthView = _a.clearZeniOAuthView;
+exports.default = zeniOAuthView.reducer;

package/lib/view/zeniOAuthView/zeniOAuthSelector.d.ts

@@ -0,0 +1,5 @@
+import { RootState } from '../../reducer';
+import { FetchState } from '../../commonStateTypes/common';
+export declare const getZeniOAuthApproveFetchState: (state: RootState) => FetchState;
+export declare const getZeniOAuthApproveRedirectUrl: (state: RootState) => string | undefined;
+export declare const getZeniOAuthApproveError: (state: RootState) => string | null;

package/lib/view/zeniOAuthView/zeniOAuthSelector.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZeniOAuthApproveError = exports.getZeniOAuthApproveRedirectUrl = exports.getZeniOAuthApproveFetchState = void 0;
+const getZeniOAuthApproveFetchState = (state) => state.zeniOAuthViewState.fetchState;
+exports.getZeniOAuthApproveFetchState = getZeniOAuthApproveFetchState;
+const getZeniOAuthApproveRedirectUrl = (state) => state.zeniOAuthViewState.approveRedirectUrl;
+exports.getZeniOAuthApproveRedirectUrl = getZeniOAuthApproveRedirectUrl;
+const getZeniOAuthApproveError = (state) => state.zeniOAuthViewState.error?.message ?? null;
+exports.getZeniOAuthApproveError = getZeniOAuthApproveError;

package/lib/view/zeniOAuthView/zeniOAuthState.d.ts

@@ -0,0 +1,4 @@
+import { FetchStateAndError } from '../../commonStateTypes/common';
+export interface ZeniOAuthViewState extends FetchStateAndError {
+    approveRedirectUrl?: string;
+}

package/lib/view/zeniOAuthView/zeniOAuthState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeniai/client-epic-state",
-  "version": "5.0.31",
+  "version": "5.0.32-betaRD1",
   "description": "Shared module between Web & Mobile containing required abstractions for state management, async network communication. ",
   "main": "lib/index.js",
   "module": "lib/esm/index.js",