quidproquo-xstate 0.1.0

package/lib/commonjs/config/settings/stateMachine.d.ts

@@ -0,0 +1,22 @@
+import { CrossModuleOwner, QPQConfigAdvancedSettings, QPQConfigSetting, QpqFunctionRuntime } from 'quidproquo-core';
+import { EventObject, MachineConfig, MachineContext } from 'xstate';
+export interface StateMachineRuntimeMap {
+    [name: string]: QpqFunctionRuntime;
+}
+export interface QPQConfigAdvancedStateMachineSettings extends QPQConfigAdvancedSettings {
+    config: MachineConfig<MachineContext, EventObject>;
+    actions?: StateMachineRuntimeMap;
+    guards?: StateMachineRuntimeMap;
+    stateField?: string;
+    owner?: CrossModuleOwner;
+}
+export interface StateMachineQPQConfigSetting extends QPQConfigSetting {
+    stateMachineName: string;
+    keyValueStoreName: string;
+    config: MachineConfig<MachineContext, EventObject>;
+    actions: StateMachineRuntimeMap;
+    guards: StateMachineRuntimeMap;
+    stateField: string;
+}
+export declare const getStateMachineStoreName: (stateMachineName: string) => string;
+export declare const defineStateMachine: (stateMachineName: string, options: QPQConfigAdvancedStateMachineSettings) => QPQConfigSetting[];

package/lib/commonjs/config/settings/stateMachine.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStateMachine = exports.getStateMachineStoreName = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const QPQConfig_1 = require("../QPQConfig");
+const getStateMachineStoreName = (stateMachineName) => `qpq-sm-${stateMachineName}`;
+exports.getStateMachineStoreName = getStateMachineStoreName;
+const defineStateMachine = (stateMachineName, options) => {
+    var _a, _b, _c;
+    const keyValueStoreName = (0, exports.getStateMachineStoreName)(stateMachineName);
+    const stateMachineConfig = {
+        configSettingType: QPQConfig_1.QPQXStateConfigSettingType.StateMachine,
+        uniqueKey: stateMachineName,
+        stateMachineName,
+        keyValueStoreName,
+        config: options.config,
+        actions: (_a = options.actions) !== null && _a !== void 0 ? _a : {},
+        guards: (_b = options.guards) !== null && _b !== void 0 ? _b : {},
+        stateField: (_c = options.stateField) !== null && _c !== void 0 ? _c : '__machineState',
+        owner: options.owner,
+    };
+    return [
+        (0, quidproquo_core_1.defineKeyValueStore)(keyValueStoreName, 'id'),
+        stateMachineConfig
+    ];
+};
+exports.defineStateMachine = defineStateMachine;

package/lib/commonjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './actionProcessor';
+export * from './actions';
+export * from './config';

package/lib/commonjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./actionProcessor"), exports);
+__exportStar(require("./actions"), exports);
+__exportStar(require("./config"), exports);

package/lib/esm/actionProcessor/getStateMachineCreateActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getStateMachineCreateActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/getStateMachineCreateActionProcessor.js

@@ -0,0 +1,51 @@
+import { actionResult, actionResultError, askKeyValueStoreUpsert, createImplementationRuntime, ErrorTypeEnum, } from 'quidproquo-core';
+import { createActor, createMachine } from 'xstate';
+import { StateMachineActionType } from '../actions';
+import { getStateMachineByName } from '../config';
+const getProcessStateMachineCreate = (qpqConfig) => {
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const smConfig = getStateMachineByName(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return actionResultError(ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = createImplementationRuntime(qpqConfig, ['StateMachine Create'], () => new Date().toISOString(), () => `${Date.now()}-${Math.random().toString(36).slice(2)}`, session, actionProcessors, logger, dynamicModuleLoader, streamRegistry);
+        // XState: determine initial state and which entry actions fire
+        const firedActions = [];
+        const actionImpls = {};
+        for (const actionName of Object.keys(smConfig.actions)) {
+            actionImpls[actionName] = () => {
+                firedActions.push(actionName);
+            };
+        }
+        const machine = createMachine(smConfig.config, {
+            actions: actionImpls,
+        });
+        const actor = createActor(machine);
+        actor.start();
+        const initialSnapshot = actor.getPersistedSnapshot();
+        actor.stop();
+        // Build entity with id and machine state
+        const entity = { ...payload.item, id: payload.id };
+        entity[smConfig.stateField] = initialSnapshot;
+        // Persist to KVS
+        const upsertResult = await resolveStory(function* () { yield* askKeyValueStoreUpsert(smConfig.keyValueStoreName, entity); }, []);
+        if (upsertResult.error) {
+            return actionResultError(upsertResult.error.errorType, upsertResult.error.errorText);
+        }
+        // Execute side-effect stories for any initial entry actions
+        for (const actionName of firedActions) {
+            const runtime = smConfig.actions[actionName];
+            if (runtime) {
+                const storyModule = await dynamicModuleLoader(runtime);
+                const storyResult = await resolveStory(storyModule, [entity]);
+                if (storyResult.error) {
+                    return actionResultError(storyResult.error.errorType, storyResult.error.errorText);
+                }
+            }
+        }
+        return actionResult(entity);
+    };
+};
+export const getStateMachineCreateActionProcessor = async (qpqConfig) => ({
+    [StateMachineActionType.Create]: getProcessStateMachineCreate(qpqConfig),
+});

package/lib/esm/actionProcessor/getStateMachineGetActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getStateMachineGetActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/getStateMachineGetActionProcessor.js

@@ -0,0 +1,24 @@
+import { actionResult, actionResultError, askKeyValueStoreGet, createImplementationRuntime, ErrorTypeEnum, } from 'quidproquo-core';
+import { StateMachineActionType } from '../actions';
+import { getStateMachineByName } from '../config';
+const getProcessStateMachineGet = (qpqConfig) => {
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const smConfig = getStateMachineByName(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return actionResultError(ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = createImplementationRuntime(qpqConfig, ['StateMachine Get'], () => new Date().toISOString(), () => `${Date.now()}-${Math.random().toString(36).slice(2)}`, session, actionProcessors, logger, dynamicModuleLoader, streamRegistry);
+        const getResult = await resolveStory(function* () { return yield* askKeyValueStoreGet(smConfig.keyValueStoreName, payload.id); }, []);
+        if (getResult.error) {
+            return actionResultError(getResult.error.errorType, getResult.error.errorText);
+        }
+        const entity = getResult.result;
+        if (!entity) {
+            return actionResultError(ErrorTypeEnum.NotFound, `Entity not found: ${payload.id}`);
+        }
+        return actionResult(entity);
+    };
+};
+export const getStateMachineGetActionProcessor = async (qpqConfig) => ({
+    [StateMachineActionType.Get]: getProcessStateMachineGet(qpqConfig),
+});

package/lib/esm/actionProcessor/getStateMachineGetStateActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getStateMachineGetStateActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/getStateMachineGetStateActionProcessor.js

@@ -0,0 +1,39 @@
+import { actionResult, actionResultError, askKeyValueStoreGet, createImplementationRuntime, ErrorTypeEnum, } from 'quidproquo-core';
+import { createActor, createMachine } from 'xstate';
+import { StateMachineActionType } from '../actions';
+import { getStateMachineByName } from '../config';
+const getProcessStateMachineGetState = (qpqConfig) => {
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const smConfig = getStateMachineByName(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return actionResultError(ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = createImplementationRuntime(qpqConfig, ['StateMachine GetState'], () => new Date().toISOString(), () => `${Date.now()}-${Math.random().toString(36).slice(2)}`, session, actionProcessors, logger, dynamicModuleLoader, streamRegistry);
+        // Load entity from KVS
+        const getResult = await resolveStory(function* () { return yield* askKeyValueStoreGet(smConfig.keyValueStoreName, payload.id); }, []);
+        if (getResult.error) {
+            return actionResultError(getResult.error.errorType, getResult.error.errorText);
+        }
+        const entity = getResult.result;
+        if (!entity) {
+            return actionResultError(ErrorTypeEnum.NotFound, `Entity not found: ${payload.id}`);
+        }
+        const persistedSnapshot = entity[smConfig.stateField];
+        if (!persistedSnapshot) {
+            return actionResultError(ErrorTypeEnum.NotFound, `No state machine state found on entity: ${payload.id}`);
+        }
+        // XState: rehydrate to read current state
+        const machine = createMachine(smConfig.config);
+        const actor = createActor(machine, { snapshot: persistedSnapshot });
+        actor.start();
+        const snapshot = actor.getSnapshot();
+        actor.stop();
+        return actionResult({
+            value: typeof snapshot.value === 'string' ? snapshot.value : JSON.stringify(snapshot.value),
+            done: snapshot.status === 'done',
+        });
+    };
+};
+export const getStateMachineGetStateActionProcessor = async (qpqConfig) => ({
+    [StateMachineActionType.GetState]: getProcessStateMachineGetState(qpqConfig),
+});

package/lib/esm/actionProcessor/getStateMachineSendEventActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getStateMachineSendEventActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/getStateMachineSendEventActionProcessor.js

@@ -0,0 +1,85 @@
+import { actionResult, actionResultError, askKeyValueStoreGet, askKeyValueStoreUpsert, createImplementationRuntime, ErrorTypeEnum, } from 'quidproquo-core';
+import { createActor, createMachine } from 'xstate';
+import { StateMachineActionType } from '../actions';
+import { getStateMachineByName } from '../config';
+const getProcessStateMachineSendEvent = (qpqConfig) => {
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const smConfig = getStateMachineByName(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return actionResultError(ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = createImplementationRuntime(qpqConfig, ['StateMachine SendEvent'], () => new Date().toISOString(), () => `${Date.now()}-${Math.random().toString(36).slice(2)}`, session, actionProcessors, logger, dynamicModuleLoader, streamRegistry);
+        // Load entity from KVS
+        let entity;
+        const getResult = await resolveStory(function* () { return yield* askKeyValueStoreGet(smConfig.keyValueStoreName, payload.id); }, []);
+        if (getResult.error) {
+            return actionResultError(getResult.error.errorType, getResult.error.errorText);
+        }
+        entity = getResult.result;
+        if (!entity) {
+            return actionResultError(ErrorTypeEnum.NotFound, `Entity not found: ${payload.id}`);
+        }
+        // Pre-evaluate guards via QPQ stories
+        const guardResults = {};
+        for (const [guardName, guardRuntime] of Object.entries(smConfig.guards)) {
+            const guardModule = await dynamicModuleLoader(guardRuntime);
+            const guardResult = await resolveStory(guardModule, [entity, payload.event]);
+            if (guardResult.error) {
+                return actionResultError(guardResult.error.errorType, guardResult.error.errorText);
+            }
+            guardResults[guardName] = guardResult.result;
+        }
+        const guardImpls = {};
+        for (const [guardName, result] of Object.entries(guardResults)) {
+            guardImpls[guardName] = () => result;
+        }
+        // Track which actions fire during the transition
+        const firedActions = [];
+        const actionImpls = {};
+        for (const actionName of Object.keys(smConfig.actions)) {
+            actionImpls[actionName] = () => {
+                firedActions.push(actionName);
+            };
+        }
+        // XState: build machine, rehydrate, send event
+        const machine = createMachine(smConfig.config, {
+            actions: actionImpls,
+            guards: guardImpls,
+        });
+        const persistedSnapshot = entity[smConfig.stateField];
+        const actor = createActor(machine, {
+            snapshot: persistedSnapshot || undefined,
+        });
+        const previousState = actor.getSnapshot().value;
+        actor.start();
+        actor.send(payload.event);
+        const newSnapshot = actor.getPersistedSnapshot();
+        const currentState = actor.getSnapshot().value;
+        const isDone = actor.getSnapshot().status === 'done';
+        actor.stop();
+        if (previousState === currentState && !isDone) {
+            return actionResultError(ErrorTypeEnum.BadRequest, `Event '${payload.event.type}' is not valid for current state '${JSON.stringify(previousState)}'`);
+        }
+        // Persist new snapshot
+        entity[smConfig.stateField] = newSnapshot;
+        const upsertResult = await resolveStory(function* () { yield* askKeyValueStoreUpsert(smConfig.keyValueStoreName, entity); }, []);
+        if (upsertResult.error) {
+            return actionResultError(upsertResult.error.errorType, upsertResult.error.errorText);
+        }
+        // Execute side-effect stories for fired actions
+        for (const actionName of firedActions) {
+            const runtime = smConfig.actions[actionName];
+            if (runtime) {
+                const storyModule = await dynamicModuleLoader(runtime);
+                const storyResult = await resolveStory(storyModule, [entity, payload.event]);
+                if (storyResult.error) {
+                    return actionResultError(storyResult.error.errorType, storyResult.error.errorText);
+                }
+            }
+        }
+        return actionResult(entity);
+    };
+};
+export const getStateMachineSendEventActionProcessor = async (qpqConfig) => ({
+    [StateMachineActionType.SendEvent]: getProcessStateMachineSendEvent(qpqConfig),
+});

package/lib/esm/actionProcessor/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getStateMachineActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/index.js

@@ -0,0 +1,10 @@
+import { getStateMachineCreateActionProcessor } from './getStateMachineCreateActionProcessor';
+import { getStateMachineGetActionProcessor } from './getStateMachineGetActionProcessor';
+import { getStateMachineGetStateActionProcessor } from './getStateMachineGetStateActionProcessor';
+import { getStateMachineSendEventActionProcessor } from './getStateMachineSendEventActionProcessor';
+export const getStateMachineActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getStateMachineCreateActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getStateMachineGetActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getStateMachineGetStateActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getStateMachineSendEventActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actions/StateMachineActionType.d.ts

@@ -0,0 +1,6 @@
+export declare enum StateMachineActionType {
+    Create = "@quidproquo-core/StateMachine/Create",
+    Get = "@quidproquo-core/StateMachine/Get",
+    GetState = "@quidproquo-core/StateMachine/GetState",
+    SendEvent = "@quidproquo-core/StateMachine/SendEvent"
+}

package/lib/esm/actions/StateMachineActionType.js

@@ -0,0 +1,7 @@
+export var StateMachineActionType;
+(function (StateMachineActionType) {
+    StateMachineActionType["Create"] = "@quidproquo-core/StateMachine/Create";
+    StateMachineActionType["Get"] = "@quidproquo-core/StateMachine/Get";
+    StateMachineActionType["GetState"] = "@quidproquo-core/StateMachine/GetState";
+    StateMachineActionType["SendEvent"] = "@quidproquo-core/StateMachine/SendEvent";
+})(StateMachineActionType || (StateMachineActionType = {}));

package/lib/esm/actions/StateMachineCreateActionRequester.d.ts

@@ -0,0 +1,2 @@
+import { StateMachineCreateActionRequester } from './StateMachineCreateActionTypes';
+export declare function askStateMachineCreate<T>(stateMachineName: string, id: string, item: T): StateMachineCreateActionRequester<T>;

package/lib/esm/actions/StateMachineCreateActionRequester.js

@@ -0,0 +1,11 @@
+import { StateMachineActionType } from './StateMachineActionType';
+export function* askStateMachineCreate(stateMachineName, id, item) {
+    return yield {
+        type: StateMachineActionType.Create,
+        payload: {
+            stateMachineName,
+            id,
+            item,
+        },
+    };
+}

package/lib/esm/actions/StateMachineCreateActionTypes.d.ts

@@ -0,0 +1,13 @@
+import { Action, ActionProcessor, ActionRequester } from 'quidproquo-core';
+import { StateMachineActionType } from './StateMachineActionType';
+export interface StateMachineCreateActionPayload<T> {
+    stateMachineName: string;
+    id: string;
+    item: T;
+}
+export interface StateMachineCreateAction<T> extends Action<StateMachineCreateActionPayload<T>> {
+    type: StateMachineActionType.Create;
+    payload: StateMachineCreateActionPayload<T>;
+}
+export type StateMachineCreateActionProcessor<T> = ActionProcessor<StateMachineCreateAction<T>, T>;
+export type StateMachineCreateActionRequester<T> = ActionRequester<StateMachineCreateAction<T>, T>;

package/lib/esm/actions/StateMachineCreateActionTypes.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/actions/StateMachineGetActionRequester.d.ts

@@ -0,0 +1,2 @@
+import { StateMachineGetActionRequester } from './StateMachineGetActionTypes';
+export declare function askStateMachineGet<T>(stateMachineName: string, id: string): StateMachineGetActionRequester<T>;

package/lib/esm/actions/StateMachineGetActionRequester.js

@@ -0,0 +1,10 @@
+import { StateMachineActionType } from './StateMachineActionType';
+export function* askStateMachineGet(stateMachineName, id) {
+    return yield {
+        type: StateMachineActionType.Get,
+        payload: {
+            stateMachineName,
+            id,
+        },
+    };
+}

package/lib/esm/actions/StateMachineGetActionTypes.d.ts

@@ -0,0 +1,12 @@
+import { Action, ActionProcessor, ActionRequester } from 'quidproquo-core';
+import { StateMachineActionType } from './StateMachineActionType';
+export interface StateMachineGetActionPayload {
+    stateMachineName: string;
+    id: string;
+}
+export interface StateMachineGetAction<T> extends Action<StateMachineGetActionPayload> {
+    type: StateMachineActionType.Get;
+    payload: StateMachineGetActionPayload;
+}
+export type StateMachineGetActionProcessor<T> = ActionProcessor<StateMachineGetAction<T>, T>;
+export type StateMachineGetActionRequester<T> = ActionRequester<StateMachineGetAction<T>, T>;

package/lib/esm/actions/StateMachineGetActionTypes.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/actions/StateMachineGetStateActionRequester.d.ts

@@ -0,0 +1,2 @@
+import { StateMachineGetStateActionRequester } from './StateMachineGetStateActionTypes';
+export declare function askStateMachineGetState(stateMachineName: string, id: string): StateMachineGetStateActionRequester;

package/lib/esm/actions/StateMachineGetStateActionRequester.js

@@ -0,0 +1,10 @@
+import { StateMachineActionType } from './StateMachineActionType';
+export function* askStateMachineGetState(stateMachineName, id) {
+    return yield {
+        type: StateMachineActionType.GetState,
+        payload: {
+            stateMachineName,
+            id,
+        },
+    };
+}

package/lib/esm/actions/StateMachineGetStateActionTypes.d.ts

@@ -0,0 +1,16 @@
+import { Action, ActionProcessor, ActionRequester } from 'quidproquo-core';
+import { StateMachineActionType } from './StateMachineActionType';
+export interface StateMachineGetStateActionPayload {
+    stateMachineName: string;
+    id: string;
+}
+export interface StateMachineStateInfo {
+    value: string;
+    done: boolean;
+}
+export interface StateMachineGetStateAction extends Action<StateMachineGetStateActionPayload> {
+    type: StateMachineActionType.GetState;
+    payload: StateMachineGetStateActionPayload;
+}
+export type StateMachineGetStateActionProcessor = ActionProcessor<StateMachineGetStateAction, StateMachineStateInfo>;
+export type StateMachineGetStateActionRequester = ActionRequester<StateMachineGetStateAction, StateMachineStateInfo>;

package/lib/esm/actions/StateMachineGetStateActionTypes.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/actions/StateMachineSendEventActionRequester.d.ts

@@ -0,0 +1,2 @@
+import { StateMachineEvent, StateMachineSendEventActionRequester } from './StateMachineSendEventActionTypes';
+export declare function askStateMachineSendEvent<T>(stateMachineName: string, id: string, event: StateMachineEvent): StateMachineSendEventActionRequester<T>;

package/lib/esm/actions/StateMachineSendEventActionRequester.js

@@ -0,0 +1,11 @@
+import { StateMachineActionType } from './StateMachineActionType';
+export function* askStateMachineSendEvent(stateMachineName, id, event) {
+    return yield {
+        type: StateMachineActionType.SendEvent,
+        payload: {
+            stateMachineName,
+            id,
+            event,
+        },
+    };
+}

package/lib/esm/actions/StateMachineSendEventActionTypes.d.ts

@@ -0,0 +1,17 @@
+import { Action, ActionProcessor, ActionRequester } from 'quidproquo-core';
+import { StateMachineActionType } from './StateMachineActionType';
+export interface StateMachineEvent {
+    type: string;
+    [key: string]: any;
+}
+export interface StateMachineSendEventActionPayload {
+    stateMachineName: string;
+    id: string;
+    event: StateMachineEvent;
+}
+export interface StateMachineSendEventAction<T> extends Action<StateMachineSendEventActionPayload> {
+    type: StateMachineActionType.SendEvent;
+    payload: StateMachineSendEventActionPayload;
+}
+export type StateMachineSendEventActionProcessor<T> = ActionProcessor<StateMachineSendEventAction<T>, T>;
+export type StateMachineSendEventActionRequester<T> = ActionRequester<StateMachineSendEventAction<T>, T>;

package/lib/esm/actions/StateMachineSendEventActionTypes.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/actions/index.d.ts

@@ -0,0 +1,9 @@
+export * from './StateMachineActionType';
+export * from './StateMachineCreateActionRequester';
+export * from './StateMachineCreateActionTypes';
+export * from './StateMachineGetActionRequester';
+export * from './StateMachineGetActionTypes';
+export * from './StateMachineGetStateActionRequester';
+export * from './StateMachineGetStateActionTypes';
+export * from './StateMachineSendEventActionRequester';
+export * from './StateMachineSendEventActionTypes';

package/lib/esm/actions/index.js

@@ -0,0 +1,9 @@
+export * from './StateMachineActionType';
+export * from './StateMachineCreateActionRequester';
+export * from './StateMachineCreateActionTypes';
+export * from './StateMachineGetActionRequester';
+export * from './StateMachineGetActionTypes';
+export * from './StateMachineGetStateActionRequester';
+export * from './StateMachineGetStateActionTypes';
+export * from './StateMachineSendEventActionRequester';
+export * from './StateMachineSendEventActionTypes';

package/lib/esm/config/QPQConfig.d.ts

@@ -0,0 +1,3 @@
+export declare enum QPQXStateConfigSettingType {
+    StateMachine = "@quidproquo-xstate/config/StateMachine"
+}

package/lib/esm/config/QPQConfig.js

@@ -0,0 +1,4 @@
+export var QPQXStateConfigSettingType;
+(function (QPQXStateConfigSettingType) {
+    QPQXStateConfigSettingType["StateMachine"] = "@quidproquo-xstate/config/StateMachine";
+})(QPQXStateConfigSettingType || (QPQXStateConfigSettingType = {}));

package/lib/esm/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './QPQConfig';
+export * from './qpqXStateConfigUtils';
+export * from './settings';

package/lib/esm/config/index.js

@@ -0,0 +1,3 @@
+export * from './QPQConfig';
+export * from './qpqXStateConfigUtils';
+export * from './settings';

package/lib/esm/config/qpqXStateConfigUtils.d.ts

@@ -0,0 +1,4 @@
+import { QPQConfig } from 'quidproquo-core';
+import { StateMachineQPQConfigSetting } from './settings/stateMachine';
+export declare const getAllStateMachines: (qpqConfig: QPQConfig) => StateMachineQPQConfigSetting[];
+export declare const getStateMachineByName: (qpqConfig: QPQConfig, stateMachineName: string) => StateMachineQPQConfigSetting | undefined;

package/lib/esm/config/qpqXStateConfigUtils.js

@@ -0,0 +1,8 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+import { QPQXStateConfigSettingType } from './QPQConfig';
+export const getAllStateMachines = (qpqConfig) => {
+    return qpqCoreUtils.getConfigSettings(qpqConfig, QPQXStateConfigSettingType.StateMachine);
+};
+export const getStateMachineByName = (qpqConfig, stateMachineName) => {
+    return getAllStateMachines(qpqConfig).find((sm) => sm.stateMachineName === stateMachineName);
+};

package/lib/esm/config/settings/index.d.ts

@@ -0,0 +1 @@
+export * from './stateMachine';

package/lib/esm/config/settings/index.js

@@ -0,0 +1 @@
+export * from './stateMachine';

package/lib/esm/config/settings/stateMachine.d.ts

@@ -0,0 +1,22 @@
+import { CrossModuleOwner, QPQConfigAdvancedSettings, QPQConfigSetting, QpqFunctionRuntime } from 'quidproquo-core';
+import { EventObject, MachineConfig, MachineContext } from 'xstate';
+export interface StateMachineRuntimeMap {
+    [name: string]: QpqFunctionRuntime;
+}
+export interface QPQConfigAdvancedStateMachineSettings extends QPQConfigAdvancedSettings {
+    config: MachineConfig<MachineContext, EventObject>;
+    actions?: StateMachineRuntimeMap;
+    guards?: StateMachineRuntimeMap;
+    stateField?: string;
+    owner?: CrossModuleOwner;
+}
+export interface StateMachineQPQConfigSetting extends QPQConfigSetting {
+    stateMachineName: string;
+    keyValueStoreName: string;
+    config: MachineConfig<MachineContext, EventObject>;
+    actions: StateMachineRuntimeMap;
+    guards: StateMachineRuntimeMap;
+    stateField: string;
+}
+export declare const getStateMachineStoreName: (stateMachineName: string) => string;
+export declare const defineStateMachine: (stateMachineName: string, options: QPQConfigAdvancedStateMachineSettings) => QPQConfigSetting[];

package/lib/esm/config/settings/stateMachine.js

@@ -0,0 +1,21 @@
+import { defineKeyValueStore, } from 'quidproquo-core';
+import { QPQXStateConfigSettingType } from '../QPQConfig';
+export const getStateMachineStoreName = (stateMachineName) => `qpq-sm-${stateMachineName}`;
+export const defineStateMachine = (stateMachineName, options) => {
+    const keyValueStoreName = getStateMachineStoreName(stateMachineName);
+    const stateMachineConfig = {
+        configSettingType: QPQXStateConfigSettingType.StateMachine,
+        uniqueKey: stateMachineName,
+        stateMachineName,
+        keyValueStoreName,
+        config: options.config,
+        actions: options.actions ?? {},
+        guards: options.guards ?? {},
+        stateField: options.stateField ?? '__machineState',
+        owner: options.owner,
+    };
+    return [
+        defineKeyValueStore(keyValueStoreName, 'id'),
+        stateMachineConfig
+    ];
+};

package/lib/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './actionProcessor';
+export * from './actions';
+export * from './config';

package/lib/esm/index.js

@@ -0,0 +1,3 @@
+export * from './actionProcessor';
+export * from './actions';
+export * from './config';