quidproquo-actionprocessor-js 0.0.251

package/README.md

@@ -0,0 +1,112 @@
+# quidproquo-actionprocessor-js
+
+The `quidproquo-actionprocessor-js` library provides a set of generic action processors for the `quidproquo` framework, allowing you to easily
+integrate common functionality into your Node.js-based applications.
+
+## Key Features
+
+1. **Comprehensive Action Processors**: This library includes a wide range of action processors that cover various common use cases, such as date/time
+   operations, error handling, event processing, GUID generation, logging, math operations, network requests, platform-specific functionality (e.g.,
+   delays), and system-level actions.
+
+2. **Extensibility**: The action processor architecture is designed to be highly extensible, allowing you to easily add custom action processors to
+   meet your specific requirements.
+
+3. **Dependency Injection**: The action processors are integrated with the `quidproquo` dependency injection system, making it easy to compose and
+   test your application components.
+
+4. **Testability**: The action-oriented architecture and asynchronous execution model of `quidproquo-actionprocessor-js` make it highly testable, with
+   support for unit, integration, and end-to-end testing.
+
+5. **Portability**: While the `quidproquo-actionprocessor-js` library is designed to run on Node.js, the underlying `quidproquo-core` library is
+   platform-agnostic, allowing you to potentially use these action processors in other environments as well.
+
+## Getting Started
+
+To use the `quidproquo-actionprocessor-js` library, you'll need to install the package and its dependencies. You can do this using your preferred
+package manager, such as npm or yarn:
+
+```
+npm install quidproquo-actionprocessor-js
+```
+
+Once you have the package installed, you can start using the provided action processors in your `quidproquo`-based application. The library exports a
+set of action processors that you can import and use in your code.
+
+## Action Processors
+
+The `quidproquo-actionprocessor-js` library provides the following action processors:
+
+1. **Date/Time Action Processors**:
+
+- `DateNowActionProcessor`: Retrieves the current date and time as an ISO string.
+
+2. **Error Action Processors**:
+
+- `ErrorThrowErrorActionProcessor`: Throws a custom error with a specified type, text, and stack trace.
+
+3. **Event Action Processors**:
+
+- (No event-specific action processors are currently implemented)
+
+4. **GUID Action Processors**:
+
+- `GuidNewActionProcessor`: Generates a new UUID.
+
+5. **Logging Action Processors**:
+
+- `LogCreateActionProcessor`: Logs a message with a specified log level and optional data.
+
+6. **Math Action Processors**:
+
+- `MathRandomNumberActionProcessor`: Generates a random number.
+
+7. **Network Action Processors**:
+
+- `NetworkRequestActionProcessor`: Performs an HTTP request with various options (method, headers, body, etc.).
+
+8. **Platform Action Processors**:
+
+- `PlatformDelayActionProcessor`: Delays the execution for a specified number of milliseconds.
+
+9. **System Action Processors**:
+
+- `SystemBatchActionProcessor`: Executes a batch of actions and returns the results.
+
+10. **User Directory Action Processors**:
+
+- (No user directory-specific action processors are currently implemented)
+
+## Usage
+
+To use the action processors provided by `quidproquo-actionprocessor-js`, you can import them into your `quidproquo`-based application and integrate
+them with your action processor configuration. Here's an example of how you might use the `DateNowActionProcessor`:
+
+```typescript
+import { DateNowActionProcessor, actionResult, DateActionType } from 'quidproquo-actionprocessor-js';
+
+const processDateNow: DateNowActionProcessor = async () => {
+  return actionResult(new Date().toISOString());
+};
+
+export default {
+  [DateActionType.Now]: processDateNow,
+};
+```
+
+In this example, we define a `DateNowActionProcessor` function that returns the current date and time as an ISO string. We then export this processor
+under the `DateActionType.Now` action type, which can be used in our `quidproquo`-based application.
+
+## Contribution and Development
+
+If you'd like to contribute to the development of `quidproquo-actionprocessor-js`, please refer to the
+[contributing guidelines](https://github.com/joe-coady/quidproquo/blob/main/CONTRIBUTING.md) for more information.
+
+## License
+
+`quidproquo-actionprocessor-js` is licensed under the [MIT License](https://github.com/joe-coady/quidproquo/blob/main/LICENSE).
+
+## Warning: Not for Production
+
+**This project is currently under active development and should not be used in production environments. The APIs and functionality are subject to
+change without notice.**

package/lib/commonjs/actionProcessor/core/claudeAi/getClaudeAiMessagesApiActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/claudeAi/getClaudeAiMessagesApiActionProcessor.js

@@ -0,0 +1,64 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.getClaudeAiMessagesApiActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const sdk_1 = __importStar(require("@anthropic-ai/sdk"));
+const getProcessMessagesApi = (qpqConfig) => {
+    return ({ body, apiKey }) => __awaiter(void 0, void 0, void 0, function* () {
+        const anthropic = new sdk_1.default({ apiKey });
+        try {
+            const msg = yield anthropic.messages.create(body);
+            return (0, quidproquo_core_1.actionResult)(msg);
+        }
+        catch (error) {
+            console.log(error);
+            if (error instanceof sdk_1.AuthenticationError) {
+                return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.Unauthorized, 'Invalid API key.');
+            }
+            else if (error instanceof Error) {
+                return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.GenericError, error.message);
+            }
+            else {
+                return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.GenericError, 'An error occurred while processing your request.');
+            }
+        }
+    });
+};
+const getClaudeAiMessagesApiActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.ClaudeAiActionType.MessagesApi]: getProcessMessagesApi(qpqConfig),
+    });
+});
+exports.getClaudeAiMessagesApiActionProcessor = getClaudeAiMessagesApiActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/claudeAi/index.js

@@ -0,0 +1,17 @@
+"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.getClaudeAiActionProcessor = void 0;
+const getClaudeAiMessagesApiActionProcessor_1 = require("./getClaudeAiMessagesApiActionProcessor");
+const getClaudeAiActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, getClaudeAiMessagesApiActionProcessor_1.getClaudeAiMessagesApiActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getClaudeAiActionProcessor = getClaudeAiActionProcessor;

package/lib/commonjs/actionProcessor/core/config/getConfigGetApplicationInfoActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/config/getConfigGetApplicationInfoActionProcessor.js

@@ -0,0 +1,30 @@
+"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.getConfigGetApplicationInfoActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessConfigGetApplicationConfig = (qpqConfig) => {
+    return () => __awaiter(void 0, void 0, void 0, function* () {
+        const appInfo = {
+            environment: quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+            feature: quidproquo_core_1.qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+            module: quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig),
+            name: quidproquo_core_1.qpqCoreUtils.getApplicationName(qpqConfig),
+        };
+        return (0, quidproquo_core_1.actionResult)(appInfo);
+    });
+};
+const getConfigGetApplicationInfoActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.ConfigActionType.GetApplicationInfo]: getProcessConfigGetApplicationConfig(qpqConfig),
+    });
+});
+exports.getConfigGetApplicationInfoActionProcessor = getConfigGetApplicationInfoActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/config/index.js

@@ -0,0 +1,17 @@
+"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.getConfigActionProcessor = void 0;
+const getConfigGetApplicationInfoActionProcessor_1 = require("./getConfigGetApplicationInfoActionProcessor");
+const getConfigActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, getConfigGetApplicationInfoActionProcessor_1.getConfigGetApplicationInfoActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getConfigActionProcessor = getConfigActionProcessor;

package/lib/commonjs/actionProcessor/core/context/getContextListActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/context/getContextListActionProcessor.js

@@ -0,0 +1,24 @@
+"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.getContextListActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessContextList = (qpqConfig) => {
+    return (payload, session) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(session.context);
+    });
+};
+const getContextListActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.ContextActionType.List]: getProcessContextList(qpqConfig),
+    });
+});
+exports.getContextListActionProcessor = getContextListActionProcessor;

package/lib/commonjs/actionProcessor/core/context/getContextReadActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/context/getContextReadActionProcessor.js

@@ -0,0 +1,27 @@
+"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.getContextReadActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const getContextValue = (context, contextIdentifier) => {
+    return contextIdentifier.uniqueName in context ? context[contextIdentifier.uniqueName] : contextIdentifier.defaultValue;
+};
+const getProcessContextRead = (qpqConfig) => {
+    return ({ contextIdentifier }, session) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(getContextValue(session.context, contextIdentifier));
+    });
+};
+const getContextReadActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.ContextActionType.Read]: getProcessContextRead(qpqConfig),
+    });
+});
+exports.getContextReadActionProcessor = getContextReadActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/context/index.js

@@ -0,0 +1,18 @@
+"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.getContextActionProcessor = void 0;
+const getContextListActionProcessor_1 = require("./getContextListActionProcessor");
+const getContextReadActionProcessor_1 = require("./getContextReadActionProcessor");
+const getContextActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign(Object.assign({}, (yield (0, getContextListActionProcessor_1.getContextListActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, getContextReadActionProcessor_1.getContextReadActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getContextActionProcessor = getContextActionProcessor;

package/lib/commonjs/actionProcessor/core/customActions/getCustomActionActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/customActions/getCustomActionActionProcessor.js

@@ -0,0 +1,58 @@
+"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.getCustomActionActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+function getActionProcessorListLoader(dynamicModuleLoader, qpqConfig) {
+    return function loadModule(qpqFunctionRuntime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const possibleModule = yield dynamicModuleLoader(qpqFunctionRuntime);
+                if (typeof possibleModule !== 'function') {
+                    throw new Error(`Expected module to be a function, but got ${typeof possibleModule}`);
+                }
+                const apl = yield possibleModule(qpqConfig, dynamicModuleLoader);
+                if (typeof apl !== 'object') {
+                    throw new Error(`Expected action processor list to be an object, but got ${typeof apl}`);
+                }
+                if (Object.values(apl).find((aplv) => typeof aplv !== 'function')) {
+                    throw new Error('Expected all action processors to be functions');
+                }
+                return apl;
+            }
+            catch (e) {
+                console.log(`Unable to dynamically load action processors: [${e}] ${JSON.stringify(qpqFunctionRuntime)}`);
+                throw e;
+            }
+        });
+    };
+}
+const getProcessCustomAction = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const actionProcessorListLoader = getActionProcessorListLoader(dynamicModuleLoader, qpqConfig);
+        const getCustomActionProcessors = quidproquo_core_1.qpqCoreUtils.getActionProcessorSources(qpqConfig);
+        const possibleModuleResults = yield Promise.allSettled(getCustomActionProcessors.map(actionProcessorListLoader));
+        // Filter out successfully loaded modules that are functions
+        const actionProcessorLists = possibleModuleResults
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value);
+        return actionProcessorLists.reduce((acc, cur) => (Object.assign(Object.assign({}, acc), cur)), {});
+    }
+    catch (e) {
+        // This should never get hit, but just in case
+        console.log(`Unable to dynamically load action processors: [${e}]`);
+        return {};
+    }
+});
+const getCustomActionActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield getProcessCustomAction(qpqConfig, dynamicModuleLoader))));
+});
+exports.getCustomActionActionProcessor = getCustomActionActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/customActions/index.js

@@ -0,0 +1,18 @@
+"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 });
+// This is a special one because it just has all the custom ones
+__exportStar(require("./getCustomActionActionProcessor"), exports);

package/lib/commonjs/actionProcessor/core/date/getDateNowActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/date/getDateNowActionProcessor.js

@@ -0,0 +1,24 @@
+"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.getDateNowActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessDateNow = (qpqConfig) => {
+    return () => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(new Date().toISOString());
+    });
+};
+const getDateNowActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.DateActionType.Now]: getProcessDateNow(qpqConfig),
+    });
+});
+exports.getDateNowActionProcessor = getDateNowActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/date/index.js

@@ -0,0 +1,17 @@
+"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.getDateActionProcessor = void 0;
+const getDateNowActionProcessor_1 = require("./getDateNowActionProcessor");
+const getDateActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, getDateNowActionProcessor_1.getDateNowActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getDateActionProcessor = getDateActionProcessor;

package/lib/commonjs/actionProcessor/core/error/getErrorThrowErrorActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/error/getErrorThrowErrorActionProcessor.js

@@ -0,0 +1,24 @@
+"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.getErrorThrowErrorActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessErrorThrowError = (qpqConfig) => {
+    return ({ errorStack, errorText, errorType }) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResultError)(errorType, errorText, errorStack);
+    });
+};
+const getErrorThrowErrorActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.ErrorActionType.ThrowError]: getProcessErrorThrowError(qpqConfig),
+    });
+});
+exports.getErrorThrowErrorActionProcessor = getErrorThrowErrorActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/error/index.js

@@ -0,0 +1,17 @@
+"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.getErrorActionProcessor = void 0;
+const getErrorThrowErrorActionProcessor_1 = require("./getErrorThrowErrorActionProcessor");
+const getErrorActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, getErrorThrowErrorActionProcessor_1.getErrorThrowErrorActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getErrorActionProcessor = getErrorActionProcessor;

package/lib/commonjs/actionProcessor/core/guid/getGuidNewActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/guid/getGuidNewActionProcessor.js

@@ -0,0 +1,25 @@
+"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.getGuidNewActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const uuid_1 = require("uuid");
+const getProcessGuidNew = (qpqConfig) => {
+    return () => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)((0, uuid_1.v4)());
+    });
+};
+const getGuidNewActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.GuidActionType.New]: getProcessGuidNew(qpqConfig),
+    });
+});
+exports.getGuidNewActionProcessor = getGuidNewActionProcessor;

package/lib/commonjs/actionProcessor/core/guid/getGuidNewSortableActionProcessor.d.ts

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

package/lib/commonjs/actionProcessor/core/guid/getGuidNewSortableActionProcessor.js

@@ -0,0 +1,25 @@
+"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.getGuidNewSortableActionProcessor = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const uuidv7_1 = require("uuidv7");
+const getProcessGuidNewSortable = (qpqConfig) => {
+    return () => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)((0, uuidv7_1.uuidv7)());
+    });
+};
+const getGuidNewSortableActionProcessor = (qpqConfig) => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        [quidproquo_core_1.GuidActionType.NewSortable]: getProcessGuidNewSortable(qpqConfig),
+    });
+});
+exports.getGuidNewSortableActionProcessor = getGuidNewSortableActionProcessor;

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

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

package/lib/commonjs/actionProcessor/core/guid/index.js

@@ -0,0 +1,18 @@
+"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.getGuidProcessor = void 0;
+const getGuidNewActionProcessor_1 = require("./getGuidNewActionProcessor");
+const getGuidNewSortableActionProcessor_1 = require("./getGuidNewSortableActionProcessor");
+const getGuidProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign(Object.assign({}, (yield (0, getGuidNewActionProcessor_1.getGuidNewActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, getGuidNewSortableActionProcessor_1.getGuidNewSortableActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getGuidProcessor = getGuidProcessor;