@owlmeans/flow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,514 @@
+# @owlmeans/flow
+
+A configurable user flow management system for OwlMeans Common applications. This package provides a comprehensive framework for defining, managing, and executing multi-step user workflows with state management, transitions, and cross-service coordination.
+
+## Overview
+
+The `@owlmeans/flow` package is a workflow orchestration library in the OwlMeans Common ecosystem that enables:
+
+- **Multi-Step Workflows**: Define complex user journeys with multiple steps and decision points
+- **State Management**: Maintain flow state across steps and services
+- **Cross-Service Coordination**: Coordinate workflows across different microservices
+- **Configurable Transitions**: Define conditional transitions between workflow steps
+- **Payload Management**: Handle data passing between workflow steps
+- **Reversible Steps**: Support for backward navigation in workflows
+- **Serialization**: Persistent workflow state through URL parameters or storage
+- **Internationalization**: Built-in i18n support for workflow content
+
+## Installation
+
+```bash
+npm install @owlmeans/flow
+```
+
+## Core Concepts
+
+### Flow Definition
+
+A flow is a structured definition of a multi-step process with:
+- **Steps**: Individual stages in the workflow
+- **Transitions**: Connections between steps with conditions
+- **Configuration**: Global settings and service mappings
+- **Payload Mapping**: Data transformation rules between steps
+
+### Flow State
+
+The current state of a workflow execution including:
+- Current step
+- Previous step (for reversible flows)
+- Payload data
+- Target service
+- Status information
+
+### Flow Model
+
+A runtime instance that provides methods to:
+- Navigate between steps
+- Execute transitions
+- Manage state and payload
+- Serialize/deserialize flow state
+
+## API Reference
+
+### Types
+
+#### `Flow`
+Complete flow definition with configuration and prefabs.
+
+```typescript
+interface Flow extends ShallowFlow {
+  config: FlowConfig
+  prefabs: { [step: string]: string }
+}
+```
+
+#### `ShallowFlow`
+Basic flow structure without configuration.
+
+```typescript
+interface ShallowFlow {
+  flow: string
+  initialStep: string
+  steps: { [key: string]: FlowStep }
+}
+```
+
+#### `FlowStep`
+Individual step definition in a workflow.
+
+```typescript
+interface FlowStep {
+  index: number
+  step: string
+  service: string
+  path?: string
+  module?: string
+  initial?: boolean
+  payloadMap?: { [key: string]: number }
+  transitions: { [key: string]: FlowTransition }
+}
+```
+
+#### `FlowTransition`
+Transition between workflow steps.
+
+```typescript
+interface FlowTransition {
+  transition: string
+  step: string
+  explicit?: boolean      // User can choose this transition
+  reversible?: boolean    // User can go back
+}
+```
+
+#### `FlowState`
+Current state of workflow execution.
+
+```typescript
+interface FlowState {
+  flow: string
+  step: string
+  previous?: string
+  entityId?: string | null
+  service: string
+  payload?: FlowPayload
+  message?: string
+  ok: boolean
+}
+```
+
+#### `FlowConfig`
+Global configuration for flow behavior.
+
+```typescript
+interface FlowConfig {
+  queryParam?: string                    // URL parameter name for flow state
+  services?: { [ref: string]: string }   // Service reference mappings
+  modules?: { [ref: string]: string }    // Module reference mappings
+  pathes?: { [ref: string]: string }     // Path reference mappings
+  defaultFlow?: string                   // Default flow to use
+}
+```
+
+#### `FlowModel`
+Runtime workflow management interface.
+
+```typescript
+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
+}
+```
+
+### Factory Functions
+
+#### `makeFlowModel(flow: string | ShallowFlow, provider?: FlowProvider): Promise<FlowModel>`
+Creates a flow model instance from flow definition or serialized state.
+
+**Parameters:**
+- `flow`: Flow name, definition, or serialized state
+- `provider`: Optional flow provider function
+
+**Returns:** Promise resolving to FlowModel instance
+
+### Helper Functions
+
+#### `flow<C>(cfg: C, flow: ShallowFlow): C`
+Adds a flow definition to configuration.
+
+#### `configureFlows<C>(cfg: C & WithFlowConfig, config: FlowConfig): C & WithFlowConfig`
+Adds flow configuration to application config.
+
+### Error Types
+
+The package provides specialized error types for flow operations:
+
+#### `FlowError`
+Base error class for all flow-related errors.
+
+#### `FlowUnsupported`
+Error for unsupported flow operations.
+
+#### `FlowTargetError`
+Error related to flow target service issues.
+
+#### `UnknownFlow`
+Error when referenced flow doesn't exist.
+
+#### `FlowStepError`
+Base error for step-related issues.
+
+#### `FlowStepMissconfigured`
+Error for misconfigured flow steps.
+
+#### `UnknownFlowStep`
+Error when referenced step doesn't exist.
+
+#### `UnknownTransition`
+Error when referenced transition doesn't exist.
+
+### Constants
+
+```typescript
+// Standard flow types
+const STD_AUTH_FLOW = '_oa'      // Authentication flow
+const STD_OIDC_FLOW = '_oidc'    // OIDC flow
+const STD_STAB_FLOW = '_stb'     // Stabilization flow
+const STD_OIDP_FLOW = '_oidp'    // OIDC Provider flow
+
+// Configuration
+const CFG_FLOW_PREFIX = 'flow'
+const FLOW_RECORD = 'flow'
+const TARGET_SERVICE = '-'
+```
+
+## Usage Examples
+
+### Basic Flow Definition
+
+```typescript
+import { flow, makeFlowModel } from '@owlmeans/flow'
+
+const registrationFlow: ShallowFlow = {
+  flow: 'user-registration',
+  initialStep: 'start',
+  steps: {
+    start: {
+      index: 0,
+      step: 'start',
+      service: 'auth-service',
+      path: '/register/start',
+      initial: true,
+      transitions: {
+        next: { transition: 'next', step: 'credentials' },
+        cancel: { transition: 'cancel', step: 'cancelled' }
+      }
+    },
+    credentials: {
+      index: 1,
+      step: 'credentials',
+      service: 'auth-service', 
+      path: '/register/credentials',
+      transitions: {
+        submit: { transition: 'submit', step: 'verify' },
+        back: { transition: 'back', step: 'start', reversible: true }
+      }
+    },
+    verify: {
+      index: 2,
+      step: 'verify',
+      service: 'auth-service',
+      path: '/register/verify',
+      transitions: {
+        confirmed: { transition: 'confirmed', step: 'complete' },
+        resend: { transition: 'resend', step: 'verify' }
+      }
+    },
+    complete: {
+      index: 3,
+      step: 'complete',
+      service: 'auth-service',
+      path: '/register/complete',
+      transitions: {}
+    }
+  }
+}
+
+// Add to configuration
+const config = flow(baseConfig, registrationFlow)
+```
+
+### Flow Execution
+
+```typescript
+// Create flow model
+const flowModel = await makeFlowModel('user-registration', flowProvider)
+
+// Target a specific service
+flowModel.target('auth-service')
+
+// Set entity context
+flowModel.entity('user123')
+
+// Get current step
+const currentStep = flowModel.step()
+console.log(`Current step: ${currentStep.step}`)
+
+// Get available transitions
+const transitions = flowModel.transitions(true) // Only explicit transitions
+console.log('Available actions:', transitions.map(t => t.transition))
+
+// Execute transition
+const nextState = flowModel.transit('submit', true, 'Success', { 
+  username: 'john_doe',
+  email: 'john@example.com' 
+})
+
+// Serialize state for URL or storage
+const serializedState = flowModel.serialize()
+```
+
+### Flow State Management
+
+```typescript
+// Load from serialized state
+const flowModel = await makeFlowModel(serializedState, flowProvider)
+
+// Check if flow completed successfully
+const state = flowModel.state()
+if (state.ok && state.step === 'complete') {
+  console.log('Registration completed successfully')
+}
+
+// Handle errors
+if (!state.ok && state.message) {
+  console.error('Flow error:', state.message)
+}
+
+// Access payload data
+const payload = flowModel.payload<{username: string, email: string}>()
+console.log('User data:', payload)
+```
+
+### Cross-Service Flow
+
+```typescript
+const crossServiceFlow: ShallowFlow = {
+  flow: 'order-fulfillment',
+  initialStep: 'create-order',
+  steps: {
+    'create-order': {
+      index: 0,
+      step: 'create-order',
+      service: 'order-service',
+      transitions: {
+        created: { transition: 'created', step: 'process-payment' }
+      }
+    },
+    'process-payment': {
+      index: 1,
+      step: 'process-payment',
+      service: 'payment-service',
+      transitions: {
+        paid: { transition: 'paid', step: 'ship-order' },
+        failed: { transition: 'failed', step: 'payment-failed' }
+      }
+    },
+    'ship-order': {
+      index: 2,
+      step: 'ship-order',
+      service: 'shipping-service',
+      transitions: {
+        shipped: { transition: 'shipped', step: 'complete' }
+      }
+    }
+  }
+}
+```
+
+### Configuration Setup
+
+```typescript
+import { configureFlows } from '@owlmeans/flow'
+
+const config = configureFlows(baseConfig, {
+  queryParam: 'flow',
+  defaultFlow: 'user-registration',
+  services: {
+    auth: 'auth-service',
+    payment: 'payment-service'
+  },
+  modules: {
+    login: 'auth:login',
+    register: 'auth:register'
+  },
+  pathes: {
+    home: '/dashboard',
+    login: '/auth/login'
+  }
+})
+```
+
+### Flow Provider Implementation
+
+```typescript
+import { FlowProvider } from '@owlmeans/flow'
+
+const flowProvider: FlowProvider = async (flowName: string) => {
+  // Load from database, configuration, or static definitions
+  const flowRecord = await flowRepository.get(flowName)
+  
+  return {
+    ...flowRecord,
+    config: {
+      queryParam: 'f',
+      services: { auth: 'auth-service' }
+    },
+    prefabs: {
+      start: 'welcome-template',
+      complete: 'success-template'
+    }
+  }
+}
+```
+
+### Error Handling
+
+```typescript
+import { UnknownFlow, FlowStepError } from '@owlmeans/flow'
+
+try {
+  const flowModel = await makeFlowModel('unknown-flow', flowProvider)
+} catch (error) {
+  if (error instanceof UnknownFlow) {
+    console.error('Flow not found')
+  } else if (error instanceof FlowStepError) {
+    console.error('Step configuration error:', error.message)
+  }
+}
+```
+
+## Advanced Features
+
+### Payload Mapping
+
+Configure how data flows between steps:
+
+```typescript
+const step: FlowStep = {
+  index: 1,
+  step: 'credentials',
+  service: 'auth-service',
+  payloadMap: {
+    username: 0,    // Map to first payload parameter
+    email: 1,       // Map to second payload parameter  
+    phone: 2        // Map to third payload parameter
+  },
+  transitions: { /* ... */ }
+}
+```
+
+### Conditional Transitions
+
+Implement business logic in transitions:
+
+```typescript
+const flowModel = await makeFlowModel(flow, flowProvider)
+
+// Custom transition logic
+const canProceed = await validateUserInput(payload)
+const nextState = flowModel.transit(
+  canProceed ? 'submit' : 'error',
+  canProceed,
+  canProceed ? 'Validation passed' : 'Please fix errors'
+)
+```
+
+### URL-Based Flow State
+
+```typescript
+// Extract flow state from URL
+const urlParams = new URLSearchParams(window.location.search)
+const flowState = urlParams.get('flow')
+
+if (flowState) {
+  const flowModel = await makeFlowModel(flowState, flowProvider)
+  // Resume flow from URL state
+}
+
+// Update URL with current flow state
+const currentState = flowModel.serialize()
+const newUrl = `${window.location.pathname}?flow=${currentState}`
+window.history.pushState({}, '', newUrl)
+```
+
+## Integration with OwlMeans Ecosystem
+
+The `@owlmeans/flow` package integrates with:
+
+- **@owlmeans/config**: Configuration management and record storage
+- **@owlmeans/error**: Resilient error handling system
+- **@owlmeans/resource**: Flow state persistence and retrieval
+- **@owlmeans/i18n**: Internationalization for flow content
+- **@owlmeans/client-flow**: Client-side flow execution
+- **@owlmeans/server-flow**: Server-side flow management
+- **@owlmeans/web-flow**: Web-specific flow features
+
+## Best Practices
+
+### Flow Design
+- Keep steps focused on single responsibilities
+- Design for both forward and backward navigation
+- Use meaningful step and transition names
+- Plan for error scenarios and recovery paths
+
+### State Management
+- Minimize payload size for URL serialization
+- Use appropriate TTL for flow state persistence
+- Handle state corruption gracefully
+- Implement proper cleanup for abandoned flows
+
+### Security
+- Validate payload data at each step
+- Implement proper authorization for step access
+- Sanitize flow state when exposing in URLs
+- Use secure channels for sensitive flow data
+
+### Performance
+- Cache flow definitions for better performance
+- Implement efficient flow provider lookups
+- Use pagination for large step lists
+- Optimize serialization for large payloads
+
+Fixes #32.

package/build/consts.d.ts

@@ -0,0 +1,10 @@
+export declare const FLOW_SEP = ":";
+export declare const PAYLOAD_SEP = ",";
+export declare const STD_AUTH_FLOW = "_oa";
+export declare const STD_OIDC_FLOW = "_oidc";
+export declare const STD_STAB_FLOW = "_stb";
+export declare const STD_OIDP_FLOW = "_oidp";
+export declare const TARGET_SERVICE = "-";
+export declare const CFG_FLOW_PREFIX = "flow";
+export declare const FLOW_RECORD = "flow";
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,MAAM,CAAA;AAE3B,eAAO,MAAM,WAAW,MAAM,CAAA;AAE9B,eAAO,MAAM,aAAa,QAAQ,CAAA;AAElC,eAAO,MAAM,aAAa,UAAU,CAAA;AAEpC,eAAO,MAAM,aAAa,SAAS,CAAA;AAEnC,eAAO,MAAM,aAAa,UAAU,CAAA;AAEpC,eAAO,MAAM,cAAc,MAAM,CAAA;AAEjC,eAAO,MAAM,eAAe,SAAS,CAAA;AAErC,eAAO,MAAM,WAAW,SAAS,CAAA"}

package/build/consts.js

@@ -0,0 +1,10 @@
+export const FLOW_SEP = ':';
+export const PAYLOAD_SEP = ',';
+export const STD_AUTH_FLOW = '_oa';
+export const STD_OIDC_FLOW = '_oidc';
+export const STD_STAB_FLOW = '_stb';
+export const STD_OIDP_FLOW = '_oidp';
+export const TARGET_SERVICE = '-';
+export const CFG_FLOW_PREFIX = 'flow';
+export const FLOW_RECORD = 'flow';
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,CAAA;AAE3B,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAA;AAE9B,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAA;AAElC,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAA;AAEpC,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAA;AAEnC,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAA;AAEpC,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAA;AAEjC,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAA;AAErC,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAA"}

package/build/errors.d.ts

@@ -0,0 +1,34 @@
+import { ResilientError } from '@owlmeans/error';
+export declare class FlowError extends ResilientError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FlowUnsupported extends FlowError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FlowTargetError extends FlowError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class UnknownFlow extends FlowError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FlowStepError extends FlowError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FlowStepMissconfigured extends FlowStepError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class UnknownFlowStep extends FlowStepError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class UnknownTransition extends FlowStepError {
+    static typeName: string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,qBAAa,SAAU,SAAQ,cAAc;IAC3C,OAAuB,QAAQ,EAAE,MAAM,CAAc;gBAEzC,OAAO,GAAE,MAAgB;CAGtC;AAED,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,OAAuB,QAAQ,EAAE,MAAM,CAAqC;gBAEhE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,OAAuB,QAAQ,EAAE,MAAM,CAAgC;gBAE3D,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,WAAY,SAAQ,SAAS;IACxC,OAAuB,QAAQ,EAAE,MAAM,CAAiC;gBAE5D,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,aAAc,SAAQ,SAAS;IAC1C,OAAuB,QAAQ,EAAE,MAAM,CAA8B;gBAEzD,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,sBAAuB,SAAQ,aAAa;IACvD,OAAuB,QAAQ,EAAE,MAAM,CAA4C;gBAEvE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,eAAgB,SAAQ,aAAa;IAChD,OAAuB,QAAQ,EAAE,MAAM,CAAqC;gBAEhE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,iBAAkB,SAAQ,aAAa;IAClD,OAAuB,QAAQ,EAAE,MAAM,CAAwC;gBAEnE,OAAO,GAAE,MAAgB;CAItC"}

package/build/errors.js

@@ -0,0 +1,65 @@
+import { ResilientError } from '@owlmeans/error';
+export class FlowError extends ResilientError {
+    static typeName = 'FlowError';
+    constructor(message = 'error') {
+        super(FlowError.typeName, `flow:${message}`);
+    }
+}
+export class FlowUnsupported extends FlowError {
+    static typeName = `${FlowError.typeName}Unsupported`;
+    constructor(message = 'error') {
+        super(`unsupported:${message}`);
+        this.type = FlowUnsupported.typeName;
+    }
+}
+export class FlowTargetError extends FlowError {
+    static typeName = `${FlowError.typeName}Target`;
+    constructor(message = 'error') {
+        super(`target:${message}`);
+        this.type = FlowTargetError.typeName;
+    }
+}
+export class UnknownFlow extends FlowError {
+    static typeName = `${FlowError.typeName}Unknown`;
+    constructor(message = 'error') {
+        super(`unknown:${message}`);
+        this.type = UnknownFlow.typeName;
+    }
+}
+export class FlowStepError extends FlowError {
+    static typeName = `${FlowError.typeName}Step`;
+    constructor(message = 'error') {
+        super(`step:${message}`);
+        this.type = FlowStepError.typeName;
+    }
+}
+export class FlowStepMissconfigured extends FlowStepError {
+    static typeName = `${FlowStepError.typeName}Missconfigured`;
+    constructor(message = 'error') {
+        super(`missconfigured:${message}`);
+        this.type = FlowStepMissconfigured.typeName;
+    }
+}
+export class UnknownFlowStep extends FlowStepError {
+    static typeName = `${FlowStepError.typeName}Unknown`;
+    constructor(message = 'error') {
+        super(`unknown:${message}`);
+        this.type = UnknownFlowStep.typeName;
+    }
+}
+export class UnknownTransition extends FlowStepError {
+    static typeName = `${FlowStepError.typeName}Transition`;
+    constructor(message = 'error') {
+        super(`transition:${message}`);
+        this.type = UnknownTransition.typeName;
+    }
+}
+ResilientError.registerErrorClass(FlowError);
+ResilientError.registerErrorClass(FlowUnsupported);
+ResilientError.registerErrorClass(FlowTargetError);
+ResilientError.registerErrorClass(UnknownFlow);
+ResilientError.registerErrorClass(FlowStepError);
+ResilientError.registerErrorClass(FlowStepMissconfigured);
+ResilientError.registerErrorClass(UnknownFlowStep);
+ResilientError.registerErrorClass(UnknownTransition);
+//# sourceMappingURL=errors.js.map

package/build/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/build/flows/auth.d.ts

@@ -0,0 +1,19 @@
+import type { ShallowFlow } from '../types.js';
+export declare enum StdAuthStep {
+    Choice = "choice",
+    Signup = "signup",
+    Signin = "signin",
+    New = "new",
+    Existing = "existing",
+    Payment = "payment",
+    Success = "success",
+    Target = "target"
+}
+/**
+ * @TODO Actually this thing is kept here for the iteration when
+ * OwlMeans ID account may be used without owlmeans.net account.
+ *
+ * @deprecated
+ */
+export declare const stdAuthFlow: ShallowFlow;
+//# sourceMappingURL=auth.d.ts.map