@owlmeans/flow 0.1.0

package/src/flows/oidc.ts

@@ -0,0 +1,148 @@
+import type { ShallowFlow } from '../types.js'
+import { STD_OIDC_FLOW, TARGET_SERVICE } from '../consts.js'
+import { AUTH_QUERY } from '@owlmeans/auth'
+
+export enum OidcAuthStep {
+  Dispatch = 'dispatch',
+  Authen = 'authen',
+  PostAuthen = 'post-authen',
+  OrgChoice = 'org-choice',
+  Payment = 'payment',
+  Success = 'success',
+  Target = 'target',
+  Ephemeral = 'ephemeral'
+}
+
+export const PURPOSE_PAYLOAD = 'purpose'
+
+// OwlMeans OIDC Based Auth Flow 
+export const stdOidcFlow: ShallowFlow = {
+  // naming - preserve space in serialized state
+  flow: STD_OIDC_FLOW,
+  initialStep: OidcAuthStep.Dispatch,
+
+  steps: {
+
+    [OidcAuthStep.Dispatch]: {
+      index: 0,
+      step: OidcAuthStep.Dispatch,
+      service: '$auth',
+      initial: true,
+      module: '$auth.choice',
+      transitions: {
+        [OidcAuthStep.Authen]: {
+          transition: OidcAuthStep.Authen,
+          step: OidcAuthStep.Authen,
+        },
+        [OidcAuthStep.Ephemeral]: {
+          transition: OidcAuthStep.Ephemeral,
+          step: OidcAuthStep.Ephemeral,
+        },
+      },
+    },
+
+    [OidcAuthStep.Authen]: {
+      index: 1,
+      step: OidcAuthStep.Authen,
+      service: '$iam',
+      module: '$iam.authen',
+      transitions: {
+        [OidcAuthStep.PostAuthen]: {
+          transition: OidcAuthStep.PostAuthen,
+          step: OidcAuthStep.PostAuthen,
+        },
+      }
+    },
+
+    [OidcAuthStep.PostAuthen]: {
+      index: 2,
+      step: OidcAuthStep.PostAuthen,
+      service: '$auth',
+      module: '$auth.flow-param',
+      transitions: {
+        [OidcAuthStep.OrgChoice]: {
+          transition: OidcAuthStep.OrgChoice,
+          step: OidcAuthStep.OrgChoice,
+        },
+        [OidcAuthStep.Payment]: {
+          transition: OidcAuthStep.Payment,
+          step: OidcAuthStep.Payment,
+        },
+        [OidcAuthStep.Target]: {
+          transition: OidcAuthStep.Target,
+          step: OidcAuthStep.Target,
+        },
+      },
+      payloadMap: { [PURPOSE_PAYLOAD]: 0 }
+    },
+
+    [OidcAuthStep.OrgChoice]: {
+      index: 3,
+      step: OidcAuthStep.OrgChoice,
+      service: '$auth',
+      module: '$auth.flow',
+      transitions: {
+        [OidcAuthStep.Payment]: {
+          transition: OidcAuthStep.Payment,
+          step: OidcAuthStep.Payment,
+        },
+        [OidcAuthStep.Target]: {
+          transition: OidcAuthStep.Target,
+          step: OidcAuthStep.Target,
+        },
+      },
+      payloadMap: { 
+        [AUTH_QUERY]: 0,
+        [PURPOSE_PAYLOAD]: 1,
+      }
+    },
+
+    [OidcAuthStep.Payment]: {
+      index: 4,
+      step: OidcAuthStep.Payment,
+      service: '$payment',
+      module: '$payment.plan',
+      transitions: {
+        [OidcAuthStep.Success]: {
+          transition: OidcAuthStep.Success,
+          step: OidcAuthStep.Success,
+        }
+      }
+    },
+
+    [OidcAuthStep.Success]: {
+      index: 5,
+      step: OidcAuthStep.Success,
+      service: '$payment',
+      module: '$payment.success',
+      transitions: {
+        [OidcAuthStep.Target]: {
+          transition: OidcAuthStep.Target,
+          step: OidcAuthStep.Target,
+        }
+      }
+    },
+
+    [OidcAuthStep.Target]: {
+      index: 6,
+      step: OidcAuthStep.Target,
+      service: '$auth',
+      module: '$auth.flow',
+      transitions: {
+        [OidcAuthStep.Ephemeral]: {
+          transition: OidcAuthStep.Ephemeral,
+          step: OidcAuthStep.Ephemeral,
+        }
+      }
+    },
+
+    [OidcAuthStep.Ephemeral]: {
+      index: 7,
+      step: OidcAuthStep.Ephemeral,
+      service: TARGET_SERVICE,
+      module: '$dispatcher',
+      transitions: {}
+    }
+
+  }
+}

package/src/flows/oidp.ts

@@ -0,0 +1,205 @@
+
+import type { ShallowFlow } from '../types.js'
+import { STD_OIDP_FLOW, TARGET_SERVICE } from '../consts.js'
+
+export enum OidpAuthStep {
+  Unknown = 'unknown',
+
+  CreateId = 'create-id',
+
+  Auth = 'auth',
+  PostAuth = 'post-auth',
+  LinkId = 'link-id',
+  Denied = 'denied',
+  Dispatch = 'dispatch',
+
+  Target = 'target',
+
+  // Compatibility
+  // MasterAuth = 'authentication',
+  // MasterReg = 'registration',
+}
+
+export const stdOidpFlow: ShallowFlow = {
+  flow: STD_OIDP_FLOW,
+  initialStep: OidpAuthStep.Unknown,
+
+  steps: {
+    [OidpAuthStep.Unknown]: {
+      index: 0,
+      step: OidpAuthStep.Unknown,
+      service: '$auth',
+      module: '$auth.interaction',
+      initial: true,
+      transitions: {
+        [OidpAuthStep.Dispatch]: {
+          transition: OidpAuthStep.Dispatch,
+          step: OidpAuthStep.Dispatch,
+        },
+        [OidpAuthStep.Auth]: {
+          transition: OidpAuthStep.Auth,
+          step: OidpAuthStep.Auth,
+        },
+        [OidpAuthStep.LinkId]: {
+          transition: OidpAuthStep.LinkId,
+          step: OidpAuthStep.LinkId,
+        },
+        [OidpAuthStep.Denied]: {
+          transition: OidpAuthStep.LinkId,
+          step: OidpAuthStep.LinkId,
+        },
+        [OidpAuthStep.CreateId]: {
+          transition: OidpAuthStep.CreateId,
+          step: OidpAuthStep.CreateId,
+        },
+      },
+      payloadMap: {
+        ["uid"]: 0
+      }
+    },
+
+    [OidpAuthStep.CreateId]: {
+      index: 1,
+      step: OidpAuthStep.CreateId,
+      service: '$auth',
+      module: '$auth.interaction',
+      initial: true,
+      transitions: {
+        [OidpAuthStep.Dispatch]: {
+          transition: OidpAuthStep.Dispatch,
+          step: OidpAuthStep.Dispatch,
+        },
+        // [OidpAuthStep.MasterReg]: {
+        //   transition: OidpAuthStep.MasterReg,
+        //   step: OidpAuthStep.MasterReg,
+        //   explicit: true,
+        // }
+      },
+      payloadMap: {
+        ["uid"]: 0
+      }
+    },
+
+    // [OidpAuthStep.MasterReg]: {
+    //   index: 2,
+    //   step: OidpAuthStep.MasterReg,
+    //   service: '$auth',
+    //   module: '$auth.interaction',
+    //   initial: true,
+    //   transitions: {
+    //     [OidpAuthStep.Dispatch]: {
+    //       transition: OidpAuthStep.Dispatch,
+    //       step: OidpAuthStep.Dispatch,
+    //     },
+    //     [OidpAuthStep.MasterAuth]: {
+    //       transition: OidpAuthStep.MasterAuth,
+    //       step: OidpAuthStep.MasterAuth,
+    //       explicit: true,
+    //     }
+    //   },
+    //   payloadMap: {
+    //     ["uid"]: 0
+    //   }
+    // },
+
+    [OidpAuthStep.Auth]: {
+      index: 2,
+      step: OidpAuthStep.Auth,
+      service: '$auth',
+      module: '$auth.interaction',
+      transitions: {
+        // In case of owlmeans.net classic idp chaining
+        [OidpAuthStep.PostAuth]: {
+          transition: OidpAuthStep.PostAuth,
+          step: OidpAuthStep.PostAuth,
+        },
+        // In case of successfull authentication
+        [OidpAuthStep.Dispatch]: {
+          transition: OidpAuthStep.Dispatch,
+          step: OidpAuthStep.Dispatch,
+        },
+        // In case new account is created an resitration denied
+        [OidpAuthStep.Denied]: {
+          transition: OidpAuthStep.Denied,
+          step: OidpAuthStep.Denied,
+        },
+      }
+    },
+
+    [OidpAuthStep.PostAuth]: {
+      index: 3,
+      step: OidpAuthStep.PostAuth,
+      service: '$auth',
+      module: '$auth.int-with-flow',
+      transitions: {
+        [OidpAuthStep.Dispatch]: {
+          transition: OidpAuthStep.Dispatch,
+          step: OidpAuthStep.Dispatch,
+        },
+        [OidpAuthStep.LinkId]: {
+          transition: OidpAuthStep.LinkId,
+          step: OidpAuthStep.LinkId,
+        },
+        [OidpAuthStep.Denied]: {
+          transition: OidpAuthStep.Denied,
+          step: OidpAuthStep.Denied,
+        }
+      }
+    },
+
+    [OidpAuthStep.LinkId]: {
+      index: 4,
+      step: OidpAuthStep.LinkId,
+      service: '$auth',
+      module: '$auth.interaction',
+      transitions: {
+        [OidpAuthStep.Dispatch]: {
+          transition: OidpAuthStep.Dispatch,
+          step: OidpAuthStep.Dispatch,
+        },
+      }
+    },
+
+    [OidpAuthStep.Denied]: {
+      index: 5,
+      step: OidpAuthStep.Denied,
+      service: '$auth',
+      module: '$auth.interaction',
+      transitions: {
+      }
+    },
+
+    [OidpAuthStep.Dispatch]: {
+      index: 6,
+      step: OidpAuthStep.Dispatch,
+      service: '$auth',
+      module: '$auth.interaction',
+      transitions: {
+        [OidpAuthStep.Target]: {
+          transition: OidpAuthStep.Target,
+          step: OidpAuthStep.Target,
+        },
+        // It's unclear if these transitions are really required
+        [OidpAuthStep.LinkId]: {
+          transition: OidpAuthStep.LinkId,
+          step: OidpAuthStep.LinkId,
+        },
+        [OidpAuthStep.Denied]: {
+          transition: OidpAuthStep.Denied,
+          step: OidpAuthStep.Denied,
+        }
+      },
+      payloadMap: {
+        ["uid"]: 0
+      }
+    },
+
+    [OidpAuthStep.Target]: {
+      index: 7,
+      step: OidpAuthStep.Target,
+      service: TARGET_SERVICE,
+      module: '$dispatcher',
+      transitions: {}
+    }
+  }
+}

package/src/flows/stab.ts

@@ -0,0 +1,17 @@
+import type { ShallowFlow } from '../types.js'
+import { STD_STAB_FLOW } from '../consts.js'
+
+export const stdStabFlow: ShallowFlow = {
+  flow: STD_STAB_FLOW,
+  initialStep: STD_STAB_FLOW,
+  steps: {
+    [STD_STAB_FLOW]: {
+      index: 0,
+      step: STD_STAB_FLOW,
+      service: STD_STAB_FLOW,
+      module: STD_STAB_FLOW,
+      initial: true,
+      transitions: {}
+    }
+  }
+}

package/src/helper.ts

@@ -0,0 +1,19 @@
+import type { CommonConfig } from '@owlmeans/config'
+import { toConfigRecord } from '@owlmeans/config'
+import type { FlowConfig, ShallowFlow, WithFlowConfig } from './types.js'
+import { CFG_FLOW_PREFIX, FLOW_RECORD } from './consts.js'
+
+export const flow = <C extends CommonConfig>(cfg: C, flow: ShallowFlow): C => {
+  if (cfg.records == null) {
+    cfg.records = []
+  }
+  cfg.records.push({ ...toConfigRecord(flow), id: `${CFG_FLOW_PREFIX}:${flow.flow}`, recordType: FLOW_RECORD })
+
+  return cfg
+}
+
+export const configureFlows = <C extends CommonConfig>(cfg: C & WithFlowConfig, config: FlowConfig): C & WithFlowConfig => {
+  cfg.flowConfig = config
+
+  return cfg
+}

package/src/i18n/en.json

@@ -0,0 +1,8 @@
+{
+  "_oa": {
+    "signup": "Sign Up",
+    "signin": "Sign In",
+    "new": "Create new organization",
+    "existing": "Use existing organization"
+  }
+}

package/src/i18n.ts

@@ -0,0 +1,5 @@
+import { addI18nLib } from '@owlmeans/i18n'
+
+import en from './i18n/en.json'
+
+addI18nLib('en', 'flow', en)

package/src/index.ts

@@ -0,0 +1,8 @@
+
+export type * from './types.js'
+export * from './errors.js'
+export * from './consts.js'
+export * from './state.js'
+export * from './helper.js'
+export * from './i18n.js'
+export * from './flows/index.js'

package/src/state.ts

@@ -0,0 +1,138 @@
+import { FlowStepError, UnknownFlow, UnknownFlowStep, UnknownTransition } from './errors.js'
+import type { FlowModel, FlowProvider, FlowState, ShallowFlow } from './types.js'
+import { serializeState, unserializeState } from './utils/flow.js'
+
+export const makeFlowModel = async (flow: string | ShallowFlow, provider?: FlowProvider): Promise<FlowModel> => {
+  let state: FlowState | null = null
+  if (typeof flow === 'string') {
+    if (provider == null) {
+      throw new UnknownFlow('_provider')
+    }
+    try {
+      flow = await provider(flow)
+      state = {
+        flow: flow.flow,
+        step: flow.initialStep,
+        service: '',
+        ok: true
+      }
+    } catch {
+      state = await unserializeState(flow as string, provider)
+      flow = await provider(state.flow)
+    }
+  } else {
+    state = {
+      flow: flow.flow,
+      step: flow.initialStep,
+      service: '',
+      ok: true
+    }
+  }
+
+  const model: FlowModel = {
+    target: service => {
+      state!.service = service
+      return model
+    },
+
+    entity: entityId => {
+      state!.entityId = entityId
+
+      return model
+    },
+
+    state: () => state!,
+
+    setState: _state => {
+      state = _state
+      return model 
+    },
+
+    payload: () => state!.payload ?? {} as any,
+
+    step: step => flow.steps[step ?? state!.step],
+
+    enter: step => {
+      step = step ?? flow.initialStep
+      const info = flow.steps[step]
+      if (info.initial !== true) {
+        throw new FlowStepError(`initial:${step}`)
+      }
+
+      state!.step = step
+      return model
+    },
+
+    steps: enter => {
+      if (enter == null) {
+        return Object.values(flow.steps)
+      }
+      if (enter) {
+        return Object.values(flow.steps).filter(s => s.initial)
+      }
+
+      return Object.values(flow.steps).filter(s => !s.initial)
+    },
+
+    transitions: explicit => {
+      if (explicit == null) {
+        return Object.values(flow.steps[state!.step].transitions)
+      }
+      if (explicit) {
+        return Object.values(flow.steps[state!.step].transitions).filter(t => t.explicit)
+      }
+
+      return Object.values(flow.steps[state!.step].transitions).filter(t => !t.explicit)
+    },
+
+    transition: transition => {
+      const t = flow.steps[state!.step].transitions[transition]
+      if (t == null) {
+        throw new UnknownTransition(transition)
+      }
+
+      return t
+    },
+
+    next: () => {
+      const transition = model.transitions().find(t => t.explicit !== true)
+      if (transition == null) {
+        throw new UnknownFlowStep('next')
+      }
+
+      return transition
+    },
+
+    transit: (transition, ok, message, payload) => {
+      const t = model.transition(transition)
+      state!.previous = state!.step
+
+      if (t.reversible !== true) {
+        delete state!.previous
+      }
+
+      state!.step = t.step
+      state!.ok = ok
+      if (typeof message !== 'string') {
+        payload = message
+        message = undefined
+      }
+      if (message != null) {
+        state!.message = message
+      } else if (state!.message != null) {
+        delete state!.message
+      }
+      if (payload != null) {
+        state!.payload = payload
+      } else if (state!.payload != null) {
+        delete state!.payload
+      }
+
+      return serializeState(flow, state!)
+    },
+
+    serialize: () => serializeState(flow, state!)
+  }
+
+  return model
+}

package/src/types.ts

@@ -0,0 +1,103 @@
+import type { ResourceRecord } from '@owlmeans/resource'
+import type { FLOW_RECORD } from './consts.js'
+
+export interface Flow extends ShallowFlow {
+  config: FlowConfig
+  prefabs: { [step: string]: string }
+}
+
+export interface ShallowFlow {
+  flow: string
+  initialStep: string
+  steps: { [key: string]: FlowStep }
+}
+
+export interface FlowConfig {
+  queryParam?: string
+  services?: { [ref: string]: string }
+  modules?: { [ref: string]: string }
+  pathes?: { [ref: string]: string }
+  defaultFlow?: string
+}
+
+export interface FlowStep {
+  index: number
+  step: string
+  service: string
+  path?: string
+  module?: string
+  initial?: boolean
+  payloadMap?: { [key: string]: number }
+  transitions: { [key: string]: FlowTransition }
+}
+
+export interface FlowTransition {
+  transition: string
+  step: string
+  /**
+   * Whether user can choose this transition as one of possibilities
+   */
+  explicit?: boolean
+  /**
+   * Whether user may get back
+   */
+  reversible?: boolean
+}
+
+export interface FlowState {
+  flow: string
+  step: string
+  // Previous step if reversible
+  previous?: string
+  entityId?: string | null
+  service: string
+  payload?: FlowPayload
+  message?: string
+  ok: boolean
+}
+
+export interface FlowPayload extends Record<symbol | string, string | number | boolean | undefined | null> { }
+
+export interface SerializedFlow {
+  // {flow}:{step}:{prev setp}
+  f: string
+  // Entity
+  e?: string
+  // Target service
+  s: string
+  // Payload serialized according to transition palyoadMap
+  p?: string
+  // Message
+  m?: string
+  // Is everything ok (true) or error false
+  o: number
+}
+
+export interface FlowModel {
+  target: (service: string) => FlowModel
+  entity: (entityId: string) => FlowModel
+  enter: (step?: string) => FlowModel
+  steps: (enter?: boolean) => FlowStep[]
+  state: () => FlowState
+  setState: (state: FlowState | null) => FlowModel
+  payload: <T extends FlowPayload>() => T
+  step: (step?: string) => FlowStep
+  transitions: (explicit?: boolean) => FlowTransition[]
+  transition: (transition: string) => FlowTransition
+  next: () => FlowTransition
+  transit: (transition: string, ok: boolean, message?: string | FlowPayload, payload?: FlowPayload) => string
+  serialize: () => string
+}
+
+export interface FlowProvider {
+  (flow: string): Promise<Flow>
+}
+
+export interface WithFlowConfig {
+  flowConfig?: FlowConfig
+}
+
+export interface FlowConfigRecord extends ResourceRecord, ShallowFlow {
+  id: string
+  recordType: typeof FLOW_RECORD
+}