Minimal idx factory for SIW gen3 (v2)

lib/core/options.ts

@@ -10,7 +10,7 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 
-import { createOAuthOptionsConstructor } from '../oidc';
+import { createOAuthOptionsConstructor } from '../oidc/options';
 import { AuthState, OktaAuthCoreInterface, OktaAuthCoreOptions, ServiceManagerOptions } from './types';
 
 

lib/exports/cdn/idx-minimal.ts

@@ -0,0 +1,4 @@
+import { OktaAuth } from '../idx-minimal';
+
+// Export only a single object
+export default OktaAuth;

lib/exports/idx-minimal.ts

@@ -0,0 +1,43 @@
+import type {
+  OktaAuthOptionsConstructor,
+} from '../base/types';
+
+import {
+  IdxStorageManagerConstructor,
+  IdxTransactionManagerConstructor,
+  OktaAuthIdxOptions,
+} from '../idx/types';
+import { createIdxTransactionManager } from '../idx/IdxTransactionManager';
+import { createMinimalOktaAuthIdx } from '../idx/factory/MinimalOktaAuthIdx';
+import { createIdxStorageManager } from '../idx/storage';
+import { createIdxOptionsConstructor } from '../idx/options';
+
+const OptionsConstructor: OktaAuthOptionsConstructor<OktaAuthIdxOptions> = createIdxOptionsConstructor();
+const StorageManager: IdxStorageManagerConstructor = createIdxStorageManager();
+const TransactionManager: IdxTransactionManagerConstructor = createIdxTransactionManager();
+
+const OktaAuthIdx = createMinimalOktaAuthIdx(StorageManager, OptionsConstructor, TransactionManager);
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface OktaAuthOptions extends OktaAuthIdxOptions {}
+
+class OktaAuth extends OktaAuthIdx {
+  constructor(options: OktaAuthOptions) {
+    super(options);
+  }
+}
+
+export default OktaAuth;
+export { OktaAuth };
+
+export * from '../base/types';
+export * from '../constants';
+export * from '../core/types';
+export * from '../errors';
+export * from '../http/types';
+export * from '../oidc/types';
+export * from '../session/types';
+export * from '../storage/types';
+export * from '../util/types';
+
+export * from '../idx/types';

lib/exports/idx.ts

@@ -1,6 +1,6 @@
 import {
   OktaAuthOptionsConstructor,
-} from '../base';
+} from '../base/types';
 
 import {
   IdxStorageManagerConstructor,

lib/idx/factory/MinimalOktaAuthIdx.ts

@@ -0,0 +1,37 @@
+import { OktaAuthOptionsConstructor } from '../../base/types';
+import { StorageManagerConstructor } from '../../storage/types';
+import { IdxTransactionManagerInterface, MinimalOktaAuthIdxInterface, OktaAuthIdxConstructor } from '../types/api';
+import { IdxTransactionMeta } from '../types/meta';
+import { IdxStorageManagerInterface } from '../types/storage';
+import { OktaAuthIdxOptions } from '../types/options';
+import { TransactionManagerConstructor, OktaAuthBaseOAuthInterface } from '../../oidc/types';
+import { mixinMinimalIdx } from '../mixinMinimal';
+import { createOktaAuthBase } from '../../base/factory';
+import { mixinStorage } from '../../storage/mixin';
+import { mixinHttp } from '../../http/mixin';
+import { mixinSession } from '../../session/mixin';
+import { mixinMinimalOAuth } from '../../oidc/mixin/minimal';
+
+export function createMinimalOktaAuthIdx<
+  M extends IdxTransactionMeta = IdxTransactionMeta,
+  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,
+  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,
+  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface
+>(
+  StorageManagerConstructor: StorageManagerConstructor<S>,
+  OptionsConstructor: OktaAuthOptionsConstructor<O>,
+  TransactionManagerConstructor: TransactionManagerConstructor<TM>
+)
+: OktaAuthIdxConstructor<
+  MinimalOktaAuthIdxInterface<M, S, O, TM> & OktaAuthBaseOAuthInterface<M, S, O, TM>
+>
+{
+  const Base = createOktaAuthBase(OptionsConstructor);
+  const WithStorage = mixinStorage<S, O>(Base, StorageManagerConstructor);
+  const WithHttp = mixinHttp<S, O>(WithStorage);
+  const WithSession = mixinSession<S, O>(WithHttp);
+  const WithOAuth = mixinMinimalOAuth<M, S, O, TM>(WithSession, TransactionManagerConstructor);
+  // do not mixin core
+  const WithIdx = mixinMinimalIdx(WithOAuth);
+  return WithIdx;
+}

lib/idx/factory/api.ts

@@ -39,9 +39,16 @@ import {
 } from '../transactionMeta';
 import { FlowIdentifier, IdxAPI, OktaAuthIdxInterface } from '../types';
 import { unlockAccount } from '../unlockAccount';
+import * as remediators from '../remediators';
+import { getFlowSpecification } from '../flow/FlowSpecification';
+import { setRemediatorsCtx } from '../util';
 
 // Factory
 export function createIdxAPI(sdk: OktaAuthIdxInterface): IdxAPI {
+  setRemediatorsCtx({
+    remediators,
+    getFlowSpecification,
+  });
   const boundStartTransaction = startTransaction.bind(null, sdk);
   const idx = {
     interact: interact.bind(null, sdk),

lib/idx/factory/index.ts

@@ -1,2 +1,3 @@
 export * from './api';
 export * from './OktaAuthIdx';
+export * from './MinimalOktaAuthIdx';

lib/idx/factory/minimalApi.ts

@@ -0,0 +1,47 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ *
+ */
+
+import { makeIdxState } from '../idxState';
+import { canProceed, proceed } from '../proceed';
+import { startTransaction } from '../startTransaction';
+import {
+  clearTransactionMeta,
+  createTransactionMeta,
+  getSavedTransactionMeta,
+  getTransactionMeta,
+  isTransactionMetaValid,
+  saveTransactionMeta
+} from '../transactionMeta';
+import { MinimalIdxAPI, MinimalOktaAuthIdxInterface } from '../types';
+
+// Factory
+export function createMinimalIdxAPI(sdk: MinimalOktaAuthIdxInterface): MinimalIdxAPI {
+  const boundStartTransaction = startTransaction.bind(null, sdk);
+  const idx = {
+    makeIdxResponse: makeIdxState.bind(null, sdk),
+
+    start: boundStartTransaction,
+    startTransaction: boundStartTransaction, // Use `start` instead. `startTransaction` will be removed in 7.0
+    proceed: proceed.bind(null, sdk),
+    canProceed: canProceed.bind(null, sdk),
+
+    getSavedTransactionMeta: getSavedTransactionMeta.bind(null, sdk),
+    createTransactionMeta: createTransactionMeta.bind(null, sdk),
+    getTransactionMeta: getTransactionMeta.bind(null, sdk),
+    saveTransactionMeta: saveTransactionMeta.bind(null, sdk),
+    clearTransactionMeta: clearTransactionMeta.bind(null, sdk),
+    isTransactionMetaValid,
+  };
+  return idx;
+}
+

lib/idx/flow/FlowSpecification.ts

@@ -1,16 +1,8 @@
-import { OktaAuthIdxInterface, FlowIdentifier } from '../types';
+import { OktaAuthIdxInterface, FlowIdentifier, FlowSpecification } from '../types';
 import { AuthenticationFlow } from './AuthenticationFlow';
 import { PasswordRecoveryFlow } from './PasswordRecoveryFlow';
 import { RegistrationFlow } from './RegistrationFlow';
 import { AccountUnlockFlow } from './AccountUnlockFlow';
-import { RemediationFlow } from './RemediationFlow';
-
-export interface FlowSpecification {
-  flow: FlowIdentifier;
-  remediators: RemediationFlow;
-  actions?: string[];
-  withCredentials?: boolean;
-}
 
 // eslint-disable-next-line complexity
 export function getFlowSpecification(

lib/idx/idxState/index.ts

@@ -1,4 +1,4 @@
-import { OktaAuthIdxInterface } from '../types';    // auth-js/types
+import { MinimalOktaAuthIdxInterface } from '../types';    // auth-js/types
 import { IdxResponse, IdxToPersist, RawIdxResponse } from '../types/idx-js';      // idx/types
 import { IDX_API_VERSION } from '../../constants';
 import v1 from './v1/parsers';
@@ -30,7 +30,7 @@ export function validateVersionConfig(version) {
 }
 
 export function makeIdxState ( 
-  authClient: OktaAuthIdxInterface,
+  authClient: MinimalOktaAuthIdxInterface,
   rawIdxResponse: RawIdxResponse,
   toPersist: IdxToPersist,
   requestDidSucceed: boolean,

lib/idx/idxState/v1/generateIdxAction.ts

@@ -12,12 +12,12 @@
 
 /* eslint-disable max-len, complexity */
 import { httpRequest } from '../../../http';
-import { OktaAuthIdxInterface } from '../../types';    // auth-js/types
+import { MinimalOktaAuthIdxInterface } from '../../types';    // auth-js/types
 import { IdxActionFunction, IdxActionParams, IdxResponse, IdxToPersist } from '../../types/idx-js';
 import { divideActionParamsByMutability } from './actionParser';
 import AuthApiError from '../../../errors/AuthApiError';
 
-const generateDirectFetch = function generateDirectFetch(authClient: OktaAuthIdxInterface, { 
+const generateDirectFetch = function generateDirectFetch(authClient: MinimalOktaAuthIdxInterface, { 
   actionDefinition, 
   defaultParamsForAction = {}, 
   immutableParamsForAction = {}, 
@@ -86,7 +86,7 @@ const generateDirectFetch = function generateDirectFetch(authClient: OktaAuthIdx
 //   };
 // };
 
-const generateIdxAction = function generateIdxAction( authClient: OktaAuthIdxInterface, actionDefinition, toPersist ): IdxActionFunction {
+const generateIdxAction = function generateIdxAction( authClient: MinimalOktaAuthIdxInterface, actionDefinition, toPersist ): IdxActionFunction {
   // TODO: leaving this here to see where the polling is EXPECTED to drop into the code, but removing any accidental trigger of incomplete code
   // const generator =  actionDefinition.refresh ? generatePollingFetch : generateDirectFetch;
   const generator = generateDirectFetch;

lib/idx/idxState/v1/idxResponseParser.ts

@@ -11,22 +11,22 @@
  */
 
 /* eslint-disable max-len */
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import { OktaAuthIdxInterface } from '../../types';    // auth-js/types
+
+import { MinimalOktaAuthIdxInterface, IdxResponse, IdxRemediation, IdxContext } from '../../types';    // auth-js/types
+import { IdxActions } from '../../types/idx-js';
 import { generateRemediationFunctions } from './remediationParser';
 import generateIdxAction from './generateIdxAction';
 import { jsonpath } from '../../../util/jsonpath';
 import { AuthSdkError } from '../../../errors';
 
-const SKIP_FIELDS = Object.fromEntries([
-  'remediation', // remediations are put into proceed/neededToProceed
-  'context', // the API response of 'context' isn't externally useful.  We ignore it and put all non-action (contextual) info into idxState.context
-].map( (field) => [ field, !!'skip this field' ] ));
+const SKIP_FIELDS = {
+  'remediation': true, // remediations are put into proceed/neededToProceed
+  'context': true, // the API response of 'context' isn't externally useful.  We ignore it and put all non-action (contextual) info into idxState.context
+};
 
-export const parseNonRemediations = function parseNonRemediations( authClient: OktaAuthIdxInterface, idxResponse, toPersist = {} ) {
+export const parseNonRemediations = function parseNonRemediations( authClient: MinimalOktaAuthIdxInterface, idxResponse: IdxResponse, toPersist = {} ) {
   const actions = {};
-  const context = {};
+  const context = {} as IdxContext;
 
   Object.keys(idxResponse)
     .filter( field => !SKIP_FIELDS[field])
@@ -56,10 +56,12 @@ export const parseNonRemediations = function parseNonRemediations( authClient: O
 
       // We are an object field containing an object value
       context[field].value = {};
-      Object.entries(fieldValue)
+      Object.entries<IdxRemediation>(fieldValue)
         .forEach( ([subField, value]) => {
           if (value.rel) { // is [field].value[subField] an action?
             // add any "action" value subfields to actions
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
             actions[`${field}-${subField.name || subField}`] = generateIdxAction(authClient, value, toPersist);
           } else {
             // add non-action value subfields to context
@@ -91,7 +93,7 @@ const expandRelatesTo = (idxResponse, value) => {
   });
 };
 
-const convertRemediationAction = (authClient: OktaAuthIdxInterface, remediation, toPersist) => {
+const convertRemediationAction = (authClient: MinimalOktaAuthIdxInterface, remediation, toPersist) => {
   // Only remediation that has `rel` field (indicator for form submission) can have http action
   if (remediation.rel) {
     const remediationActions = generateRemediationFunctions( authClient, [remediation], toPersist );
@@ -105,7 +107,7 @@ const convertRemediationAction = (authClient: OktaAuthIdxInterface, remediation,
   return remediation;
 };
 
-export const parseIdxResponse = function parseIdxResponse( authClient: OktaAuthIdxInterface, idxResponse, toPersist = {} ): {
+export const parseIdxResponse = function parseIdxResponse( authClient: MinimalOktaAuthIdxInterface, idxResponse, toPersist = {} ): {
   remediations: IdxRemediation[];
   context: IdxContext;
   actions: IdxActions;

lib/idx/idxState/v1/makeIdxState.ts

@@ -10,12 +10,12 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 
-import { IdxResponse, IdxToPersist } from '../../types/idx-js';
-import { OktaAuthIdxInterface, RawIdxResponse } from '../../types';    // auth-js/types
+import { IdxResponse, IdxToPersist, IdxActionParams } from '../../types/idx-js';
+import { MinimalOktaAuthIdxInterface, RawIdxResponse } from '../../types';    // auth-js/types
 import { parseIdxResponse } from './idxResponseParser';
 
 export function makeIdxState( 
-  authClient: OktaAuthIdxInterface,
+  authClient: MinimalOktaAuthIdxInterface,
   idxResponse: RawIdxResponse,
   toPersist: IdxToPersist,
   requestDidSucceed: boolean
@@ -41,7 +41,7 @@ export function makeIdxState(
       return Promise.reject(`Current remediation cannot make form submit action: [${remediationChoice}]`);
     }
 
-    return remediationChoiceObject.action(paramsFromUser);
+    return remediationChoiceObject.action!(paramsFromUser as IdxActionParams);
   };
 
   const findCode = item => item.name === 'interaction_code';

lib/idx/idxState/v1/parsers.ts

@@ -10,8 +10,6 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
 import { makeIdxState } from './makeIdxState';
 
 export default {

lib/idx/idxState/v1/remediationParser.ts

@@ -10,20 +10,16 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import { OktaAuthIdxInterface } from '../../types';    // auth-js/types
+import { MinimalOktaAuthIdxInterface, IdxRemediation } from '../../types';    // auth-js/types
 import generateIdxAction from './generateIdxAction';
 
 export const generateRemediationFunctions = function generateRemediationFunctions(
-  authClient: OktaAuthIdxInterface,
-  remediationValue,
+  authClient: MinimalOktaAuthIdxInterface,
+  remediationValue: IdxRemediation[],
   toPersist = {}
 ) {
-  return Object.fromEntries( remediationValue.map( remediation => {
-    return [
-      remediation.name,
-      generateIdxAction(authClient, remediation, toPersist),
-    ];
-  }) );
+  return remediationValue.reduce((obj, remediation) => ({
+    ...obj,
+    [remediation.name]: generateIdxAction(authClient, remediation, toPersist)
+  }), {});
 };

lib/idx/interact.ts

@@ -13,7 +13,7 @@
 /* eslint complexity:[0,8] */
 import { OktaAuthIdxInterface, IdxTransactionMeta, InteractOptions, InteractResponse } from './types';
 import { getSavedTransactionMeta, saveTransactionMeta, createTransactionMeta } from './transactionMeta';
-import { getOAuthBaseUrl } from '../oidc';
+import { getOAuthBaseUrl } from '../oidc/util';
 import { removeNils } from '../util';
 import { httpRequest } from '../http';
 

lib/idx/introspect.ts

@@ -14,7 +14,7 @@
 import { makeIdxState, validateVersionConfig } from './idxState';
 import { IntrospectOptions, OktaAuthIdxInterface } from './types';
 import { IdxResponse, isRawIdxResponse } from './types/idx-js';
-import { getOAuthDomain } from '../oidc';
+import { getOAuthDomain } from '../oidc/util';
 import { IDX_API_VERSION } from '../constants';
 import { httpRequest } from '../http';
 import { isAuthApiError } from '../errors';