quidproquo-xstate 0.1.0

package/README.md

@@ -0,0 +1 @@
+# quidproquo-xstate

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

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

package/lib/commonjs/actionProcessor/getStateMachineCreateActionProcessor.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateMachineCreateActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const xstate_1 = require("xstate");
+const actions_1 = require("../actions");
+const config_1 = require("../config");
+const getProcessStateMachineCreate = (qpqConfig) => {
+    return (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => __awaiter(void 0, void 0, void 0, function* () {
+        const smConfig = (0, config_1.getStateMachineByName)(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = (0, quidproquo_core_1.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 = (0, xstate_1.createMachine)(smConfig.config, {
+            actions: actionImpls,
+        });
+        const actor = (0, xstate_1.createActor)(machine);
+        actor.start();
+        const initialSnapshot = actor.getPersistedSnapshot();
+        actor.stop();
+        // Build entity with id and machine state
+        const entity = Object.assign(Object.assign({}, payload.item), { id: payload.id });
+        entity[smConfig.stateField] = initialSnapshot;
+        // Persist to KVS
+        const upsertResult = yield resolveStory(function* () { yield* (0, quidproquo_core_1.askKeyValueStoreUpsert)(smConfig.keyValueStoreName, entity); }, []);
+        if (upsertResult.error) {
+            return (0, quidproquo_core_1.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 = yield dynamicModuleLoader(runtime);
+                const storyResult = yield resolveStory(storyModule, [entity]);
+                if (storyResult.error) {
+                    return (0, quidproquo_core_1.actionResultError)(storyResult.error.errorType, storyResult.error.errorText);
+                }
+            }
+        }
+        return (0, quidproquo_core_1.actionResult)(entity);
+    });
+};
+const getStateMachineCreateActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [actions_1.StateMachineActionType.Create]: getProcessStateMachineCreate(qpqConfig),
+    });
+});
+exports.getStateMachineCreateActionProcessor = getStateMachineCreateActionProcessor;

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

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

package/lib/commonjs/actionProcessor/getStateMachineGetActionProcessor.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateMachineGetActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const actions_1 = require("../actions");
+const config_1 = require("../config");
+const getProcessStateMachineGet = (qpqConfig) => {
+    return (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => __awaiter(void 0, void 0, void 0, function* () {
+        const smConfig = (0, config_1.getStateMachineByName)(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = (0, quidproquo_core_1.createImplementationRuntime)(qpqConfig, ['StateMachine Get'], () => new Date().toISOString(), () => `${Date.now()}-${Math.random().toString(36).slice(2)}`, session, actionProcessors, logger, dynamicModuleLoader, streamRegistry);
+        const getResult = yield resolveStory(function* () { return yield* (0, quidproquo_core_1.askKeyValueStoreGet)(smConfig.keyValueStoreName, payload.id); }, []);
+        if (getResult.error) {
+            return (0, quidproquo_core_1.actionResultError)(getResult.error.errorType, getResult.error.errorText);
+        }
+        const entity = getResult.result;
+        if (!entity) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `Entity not found: ${payload.id}`);
+        }
+        return (0, quidproquo_core_1.actionResult)(entity);
+    });
+};
+const getStateMachineGetActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [actions_1.StateMachineActionType.Get]: getProcessStateMachineGet(qpqConfig),
+    });
+});
+exports.getStateMachineGetActionProcessor = getStateMachineGetActionProcessor;

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

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

package/lib/commonjs/actionProcessor/getStateMachineGetStateActionProcessor.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateMachineGetStateActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const xstate_1 = require("xstate");
+const actions_1 = require("../actions");
+const config_1 = require("../config");
+const getProcessStateMachineGetState = (qpqConfig) => {
+    return (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => __awaiter(void 0, void 0, void 0, function* () {
+        const smConfig = (0, config_1.getStateMachineByName)(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = (0, quidproquo_core_1.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 = yield resolveStory(function* () { return yield* (0, quidproquo_core_1.askKeyValueStoreGet)(smConfig.keyValueStoreName, payload.id); }, []);
+        if (getResult.error) {
+            return (0, quidproquo_core_1.actionResultError)(getResult.error.errorType, getResult.error.errorText);
+        }
+        const entity = getResult.result;
+        if (!entity) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `Entity not found: ${payload.id}`);
+        }
+        const persistedSnapshot = entity[smConfig.stateField];
+        if (!persistedSnapshot) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `No state machine state found on entity: ${payload.id}`);
+        }
+        // XState: rehydrate to read current state
+        const machine = (0, xstate_1.createMachine)(smConfig.config);
+        const actor = (0, xstate_1.createActor)(machine, { snapshot: persistedSnapshot });
+        actor.start();
+        const snapshot = actor.getSnapshot();
+        actor.stop();
+        return (0, quidproquo_core_1.actionResult)({
+            value: typeof snapshot.value === 'string' ? snapshot.value : JSON.stringify(snapshot.value),
+            done: snapshot.status === 'done',
+        });
+    });
+};
+const getStateMachineGetStateActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [actions_1.StateMachineActionType.GetState]: getProcessStateMachineGetState(qpqConfig),
+    });
+});
+exports.getStateMachineGetStateActionProcessor = getStateMachineGetStateActionProcessor;

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

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

package/lib/commonjs/actionProcessor/getStateMachineSendEventActionProcessor.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateMachineSendEventActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const xstate_1 = require("xstate");
+const actions_1 = require("../actions");
+const config_1 = require("../config");
+const getProcessStateMachineSendEvent = (qpqConfig) => {
+    return (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => __awaiter(void 0, void 0, void 0, function* () {
+        const smConfig = (0, config_1.getStateMachineByName)(qpqConfig, payload.stateMachineName);
+        if (!smConfig) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `State machine not found: ${payload.stateMachineName}`);
+        }
+        const resolveStory = (0, quidproquo_core_1.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 = yield resolveStory(function* () { return yield* (0, quidproquo_core_1.askKeyValueStoreGet)(smConfig.keyValueStoreName, payload.id); }, []);
+        if (getResult.error) {
+            return (0, quidproquo_core_1.actionResultError)(getResult.error.errorType, getResult.error.errorText);
+        }
+        entity = getResult.result;
+        if (!entity) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.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 = yield dynamicModuleLoader(guardRuntime);
+            const guardResult = yield resolveStory(guardModule, [entity, payload.event]);
+            if (guardResult.error) {
+                return (0, quidproquo_core_1.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 = (0, xstate_1.createMachine)(smConfig.config, {
+            actions: actionImpls,
+            guards: guardImpls,
+        });
+        const persistedSnapshot = entity[smConfig.stateField];
+        const actor = (0, xstate_1.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 (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.BadRequest, `Event '${payload.event.type}' is not valid for current state '${JSON.stringify(previousState)}'`);
+        }
+        // Persist new snapshot
+        entity[smConfig.stateField] = newSnapshot;
+        const upsertResult = yield resolveStory(function* () { yield* (0, quidproquo_core_1.askKeyValueStoreUpsert)(smConfig.keyValueStoreName, entity); }, []);
+        if (upsertResult.error) {
+            return (0, quidproquo_core_1.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 = yield dynamicModuleLoader(runtime);
+                const storyResult = yield resolveStory(storyModule, [entity, payload.event]);
+                if (storyResult.error) {
+                    return (0, quidproquo_core_1.actionResultError)(storyResult.error.errorType, storyResult.error.errorText);
+                }
+            }
+        }
+        return (0, quidproquo_core_1.actionResult)(entity);
+    });
+};
+const getStateMachineSendEventActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [actions_1.StateMachineActionType.SendEvent]: getProcessStateMachineSendEvent(qpqConfig),
+    });
+});
+exports.getStateMachineSendEventActionProcessor = getStateMachineSendEventActionProcessor;

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

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

package/lib/commonjs/actionProcessor/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateMachineActionProcessor = void 0;
+const getStateMachineCreateActionProcessor_1 = require("./getStateMachineCreateActionProcessor");
+const getStateMachineGetActionProcessor_1 = require("./getStateMachineGetActionProcessor");
+const getStateMachineGetStateActionProcessor_1 = require("./getStateMachineGetStateActionProcessor");
+const getStateMachineSendEventActionProcessor_1 = require("./getStateMachineSendEventActionProcessor");
+const getStateMachineActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign(Object.assign(Object.assign(Object.assign({}, (yield (0, getStateMachineCreateActionProcessor_1.getStateMachineCreateActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, getStateMachineGetActionProcessor_1.getStateMachineGetActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, getStateMachineGetStateActionProcessor_1.getStateMachineGetStateActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, getStateMachineSendEventActionProcessor_1.getStateMachineSendEventActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getStateMachineActionProcessor = getStateMachineActionProcessor;

package/lib/commonjs/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/commonjs/actions/StateMachineActionType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineActionType = void 0;
+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 || (exports.StateMachineActionType = StateMachineActionType = {}));

package/lib/commonjs/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/commonjs/actions/StateMachineCreateActionRequester.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askStateMachineCreate = askStateMachineCreate;
+const StateMachineActionType_1 = require("./StateMachineActionType");
+function* askStateMachineCreate(stateMachineName, id, item) {
+    return yield {
+        type: StateMachineActionType_1.StateMachineActionType.Create,
+        payload: {
+            stateMachineName,
+            id,
+            item,
+        },
+    };
+}

package/lib/commonjs/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/commonjs/actions/StateMachineCreateActionTypes.js

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

package/lib/commonjs/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/commonjs/actions/StateMachineGetActionRequester.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askStateMachineGet = askStateMachineGet;
+const StateMachineActionType_1 = require("./StateMachineActionType");
+function* askStateMachineGet(stateMachineName, id) {
+    return yield {
+        type: StateMachineActionType_1.StateMachineActionType.Get,
+        payload: {
+            stateMachineName,
+            id,
+        },
+    };
+}

package/lib/commonjs/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/commonjs/actions/StateMachineGetActionTypes.js

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

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

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

package/lib/commonjs/actions/StateMachineGetStateActionRequester.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askStateMachineGetState = askStateMachineGetState;
+const StateMachineActionType_1 = require("./StateMachineActionType");
+function* askStateMachineGetState(stateMachineName, id) {
+    return yield {
+        type: StateMachineActionType_1.StateMachineActionType.GetState,
+        payload: {
+            stateMachineName,
+            id,
+        },
+    };
+}

package/lib/commonjs/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/commonjs/actions/StateMachineGetStateActionTypes.js

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

package/lib/commonjs/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/commonjs/actions/StateMachineSendEventActionRequester.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askStateMachineSendEvent = askStateMachineSendEvent;
+const StateMachineActionType_1 = require("./StateMachineActionType");
+function* askStateMachineSendEvent(stateMachineName, id, event) {
+    return yield {
+        type: StateMachineActionType_1.StateMachineActionType.SendEvent,
+        payload: {
+            stateMachineName,
+            id,
+            event,
+        },
+    };
+}

package/lib/commonjs/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/commonjs/actions/StateMachineSendEventActionTypes.js

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

package/lib/commonjs/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/commonjs/actions/index.js

@@ -0,0 +1,25 @@
+"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("./StateMachineActionType"), exports);
+__exportStar(require("./StateMachineCreateActionRequester"), exports);
+__exportStar(require("./StateMachineCreateActionTypes"), exports);
+__exportStar(require("./StateMachineGetActionRequester"), exports);
+__exportStar(require("./StateMachineGetActionTypes"), exports);
+__exportStar(require("./StateMachineGetStateActionRequester"), exports);
+__exportStar(require("./StateMachineGetStateActionTypes"), exports);
+__exportStar(require("./StateMachineSendEventActionRequester"), exports);
+__exportStar(require("./StateMachineSendEventActionTypes"), exports);

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

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

package/lib/commonjs/config/QPQConfig.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QPQXStateConfigSettingType = void 0;
+var QPQXStateConfigSettingType;
+(function (QPQXStateConfigSettingType) {
+    QPQXStateConfigSettingType["StateMachine"] = "@quidproquo-xstate/config/StateMachine";
+})(QPQXStateConfigSettingType || (exports.QPQXStateConfigSettingType = QPQXStateConfigSettingType = {}));

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

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

package/lib/commonjs/config/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("./QPQConfig"), exports);
+__exportStar(require("./qpqXStateConfigUtils"), exports);
+__exportStar(require("./settings"), exports);

package/lib/commonjs/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/commonjs/config/qpqXStateConfigUtils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateMachineByName = exports.getAllStateMachines = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const QPQConfig_1 = require("./QPQConfig");
+const getAllStateMachines = (qpqConfig) => {
+    return quidproquo_core_1.qpqCoreUtils.getConfigSettings(qpqConfig, QPQConfig_1.QPQXStateConfigSettingType.StateMachine);
+};
+exports.getAllStateMachines = getAllStateMachines;
+const getStateMachineByName = (qpqConfig, stateMachineName) => {
+    return (0, exports.getAllStateMachines)(qpqConfig).find((sm) => sm.stateMachineName === stateMachineName);
+};
+exports.getStateMachineByName = getStateMachineByName;

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

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

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

@@ -0,0 +1,17 @@
+"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("./stateMachine"), exports);