quidproquo-actionprocessor-web 0.0.251

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

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

package/lib/commonjs/actionProcessor/webserver/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.getWebserverActionProcessor = void 0;
+const dns_1 = require("./dns");
+const getWebserverActionProcessor = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign({}, (yield (0, dns_1.getDnsActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getWebserverActionProcessor = getWebserverActionProcessor;

package/lib/commonjs/getWebActionProcessors.d.ts

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

package/lib/commonjs/getWebActionProcessors.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.getWebActionProcessors = void 0;
+const quidproquo_actionprocessor_js_1 = require("quidproquo-actionprocessor-js");
+const actionProcessor_1 = require("./actionProcessor");
+const getWebActionProcessors = (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
+    return (Object.assign(Object.assign(Object.assign(Object.assign({}, (yield (0, quidproquo_actionprocessor_js_1.getCoreActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, quidproquo_actionprocessor_js_1.getWebserverActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, actionProcessor_1.getCoreActionProcessor)(qpqConfig, dynamicModuleLoader))), (yield (0, actionProcessor_1.getWebserverActionProcessor)(qpqConfig, dynamicModuleLoader))));
+});
+exports.getWebActionProcessors = getWebActionProcessors;

package/lib/commonjs/insdex.d.ts

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

package/lib/commonjs/insdex.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("./getWebActionProcessors"), exports);

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

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

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

@@ -0,0 +1,26 @@
+import { actionResult, actionResultError, ClaudeAiActionType, ErrorTypeEnum, } from 'quidproquo-core';
+import Anthropic, { AuthenticationError } from '@anthropic-ai/sdk';
+const getProcessMessagesApi = (qpqConfig) => {
+    return async ({ body, apiKey }) => {
+        const anthropic = new Anthropic({ apiKey });
+        try {
+            const msg = await anthropic.messages.create(body);
+            return actionResult(msg);
+        }
+        catch (error) {
+            console.log(error);
+            if (error instanceof AuthenticationError) {
+                return actionResultError(ErrorTypeEnum.Unauthorized, 'Invalid API key.');
+            }
+            else if (error instanceof Error) {
+                return actionResultError(ErrorTypeEnum.GenericError, error.message);
+            }
+            else {
+                return actionResultError(ErrorTypeEnum.GenericError, 'An error occurred while processing your request.');
+            }
+        }
+    };
+};
+export const getClaudeAiMessagesApiActionProcessor = async (qpqConfig) => ({
+    [ClaudeAiActionType.MessagesApi]: getProcessMessagesApi(qpqConfig),
+});

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

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

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

@@ -0,0 +1,4 @@
+import { getClaudeAiMessagesApiActionProcessor } from './getClaudeAiMessagesApiActionProcessor';
+export const getClaudeAiActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getClaudeAiMessagesApiActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

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

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

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

@@ -0,0 +1,15 @@
+import { actionResult, ConfigActionType, qpqCoreUtils, } from 'quidproquo-core';
+const getProcessConfigGetApplicationConfig = (qpqConfig) => {
+    return async () => {
+        const appInfo = {
+            environment: qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+            feature: qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+            module: qpqCoreUtils.getApplicationModuleName(qpqConfig),
+            name: qpqCoreUtils.getApplicationName(qpqConfig),
+        };
+        return actionResult(appInfo);
+    };
+};
+export const getConfigGetApplicationInfoActionProcessor = async (qpqConfig) => ({
+    [ConfigActionType.GetApplicationInfo]: getProcessConfigGetApplicationConfig(qpqConfig),
+});

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

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

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

@@ -0,0 +1,4 @@
+import { getConfigGetApplicationInfoActionProcessor } from './getConfigGetApplicationInfoActionProcessor';
+export const getConfigActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getConfigGetApplicationInfoActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

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

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

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

@@ -0,0 +1,9 @@
+import { actionResult, ContextActionType, } from 'quidproquo-core';
+const getProcessContextList = (qpqConfig) => {
+    return async (payload, session) => {
+        return actionResult(session.context);
+    };
+};
+export const getContextListActionProcessor = async (qpqConfig) => ({
+    [ContextActionType.List]: getProcessContextList(qpqConfig),
+});

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

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

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

@@ -0,0 +1,12 @@
+import { actionResult, ContextActionType, } from 'quidproquo-core';
+const getContextValue = (context, contextIdentifier) => {
+    return contextIdentifier.uniqueName in context ? context[contextIdentifier.uniqueName] : contextIdentifier.defaultValue;
+};
+const getProcessContextRead = (qpqConfig) => {
+    return async ({ contextIdentifier }, session) => {
+        return actionResult(getContextValue(session.context, contextIdentifier));
+    };
+};
+export const getContextReadActionProcessor = async (qpqConfig) => ({
+    [ContextActionType.Read]: getProcessContextRead(qpqConfig),
+});

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

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

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

@@ -0,0 +1,6 @@
+import { getContextListActionProcessor } from './getContextListActionProcessor';
+import { getContextReadActionProcessor } from './getContextReadActionProcessor';
+export const getContextActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getContextListActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getContextReadActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

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

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

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

@@ -0,0 +1,43 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+function getActionProcessorListLoader(dynamicModuleLoader, qpqConfig) {
+    return async function loadModule(qpqFunctionRuntime) {
+        try {
+            const possibleModule = await dynamicModuleLoader(qpqFunctionRuntime);
+            if (typeof possibleModule !== 'function') {
+                throw new Error(`Expected module to be a function, but got ${typeof possibleModule}`);
+            }
+            const apl = await 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 = async (qpqConfig, dynamicModuleLoader) => {
+    try {
+        const actionProcessorListLoader = getActionProcessorListLoader(dynamicModuleLoader, qpqConfig);
+        const getCustomActionProcessors = qpqCoreUtils.getActionProcessorSources(qpqConfig);
+        const possibleModuleResults = await 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) => ({ ...acc, ...cur }), {});
+    }
+    catch (e) {
+        // This should never get hit, but just in case
+        console.log(`Unable to dynamically load action processors: [${e}]`);
+        return {};
+    }
+};
+export const getCustomActionActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getProcessCustomAction(qpqConfig, dynamicModuleLoader)),
+});

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

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

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

@@ -0,0 +1,2 @@
+// This is a special one because it just has all the custom ones
+export * from './getCustomActionActionProcessor';

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

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

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

@@ -0,0 +1,9 @@
+import { actionResult, DateActionType } from 'quidproquo-core';
+const getProcessDateNow = (qpqConfig) => {
+    return async () => {
+        return actionResult(new Date().toISOString());
+    };
+};
+export const getDateNowActionProcessor = async (qpqConfig) => ({
+    [DateActionType.Now]: getProcessDateNow(qpqConfig),
+});

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

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

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

@@ -0,0 +1,4 @@
+import { getDateNowActionProcessor } from './getDateNowActionProcessor';
+export const getDateActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getDateNowActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

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

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

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

@@ -0,0 +1,9 @@
+import { actionResultError, ErrorActionType, } from 'quidproquo-core';
+const getProcessErrorThrowError = (qpqConfig) => {
+    return async ({ errorStack, errorText, errorType }) => {
+        return actionResultError(errorType, errorText, errorStack);
+    };
+};
+export const getErrorThrowErrorActionProcessor = async (qpqConfig) => ({
+    [ErrorActionType.ThrowError]: getProcessErrorThrowError(qpqConfig),
+});

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

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

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

@@ -0,0 +1,4 @@
+import { getErrorThrowErrorActionProcessor } from './getErrorThrowErrorActionProcessor';
+export const getErrorActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getErrorThrowErrorActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

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

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

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

@@ -0,0 +1,10 @@
+import { actionResult, GuidActionType } from 'quidproquo-core';
+import { v4 as uuidV4 } from 'uuid';
+const getProcessGuidNew = (qpqConfig) => {
+    return async () => {
+        return actionResult(uuidV4());
+    };
+};
+export const getGuidNewActionProcessor = async (qpqConfig) => ({
+    [GuidActionType.New]: getProcessGuidNew(qpqConfig),
+});

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

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

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

@@ -0,0 +1,10 @@
+import { actionResult, GuidActionType, } from 'quidproquo-core';
+import { uuidv7 } from 'uuidv7';
+const getProcessGuidNewSortable = (qpqConfig) => {
+    return async () => {
+        return actionResult(uuidv7());
+    };
+};
+export const getGuidNewSortableActionProcessor = async (qpqConfig) => ({
+    [GuidActionType.NewSortable]: getProcessGuidNewSortable(qpqConfig),
+});

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

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

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

@@ -0,0 +1,6 @@
+import { getGuidNewActionProcessor } from './getGuidNewActionProcessor';
+import { getGuidNewSortableActionProcessor } from './getGuidNewSortableActionProcessor';
+export const getGuidProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getGuidNewActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getGuidNewSortableActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

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

@@ -0,0 +1,14 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export * from './claudeAi';
+export * from './config';
+export * from './context';
+export * from './date';
+export * from './error';
+export * from './guid';
+export * from './log';
+export * from './math';
+export * from './network';
+export * from './platform';
+export * from './system';
+export * from './customActions';
+export declare const getCoreActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/index.js

@@ -0,0 +1,37 @@
+import { getClaudeAiActionProcessor } from './claudeAi';
+import { getConfigActionProcessor } from './config';
+import { getContextActionProcessor } from './context';
+import { getDateActionProcessor } from './date';
+import { getErrorActionProcessor } from './error';
+import { getGuidProcessor } from './guid';
+import { getLogActionProcessor } from './log';
+import { getMathActionProcessor } from './math';
+import { getNetworkActionProcessor } from './network';
+import { getPlatformActionProcessor } from './platform';
+import { getSystemActionProcessor } from './system';
+export * from './claudeAi';
+export * from './config';
+export * from './context';
+export * from './date';
+export * from './error';
+export * from './guid';
+export * from './log';
+export * from './math';
+export * from './network';
+export * from './platform';
+export * from './system';
+// Custom actions is not done here, as it has to be done last after all
+export * from './customActions';
+export const getCoreActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getConfigActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getContextActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getClaudeAiActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getDateActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getErrorActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getGuidProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getLogActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getMathActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getNetworkActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getPlatformActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getSystemActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actionProcessor/core/log/getLogCreateActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/log/getLogCreateActionProcessor.js

@@ -0,0 +1,15 @@
+import { actionResult, LogActionType } from 'quidproquo-core';
+const getProcessLogCreate = (qpqConfig) => {
+    return async ({ msg, logLevel, data }) => {
+        if (data) {
+            console.log(`${logLevel}: ${msg}`, data);
+        }
+        else {
+            console.log(`${logLevel}: ${msg}`);
+        }
+        return actionResult(void 0);
+    };
+};
+export const getLogCreateActionProcessor = async (qpqConfig) => ({
+    [LogActionType.Create]: getProcessLogCreate(qpqConfig),
+});

package/lib/esm/actionProcessor/core/log/getLogDisableEventHistoryActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/log/getLogDisableEventHistoryActionProcessor.js

@@ -0,0 +1,10 @@
+import { actionResult, LogActionType, } from 'quidproquo-core';
+const getProcessLogDisableEventHistory = (qpqConfig) => {
+    return async ({ enable, reason }, session, _actionProcessors, logger) => {
+        await logger.enableLogs(enable, reason, session.correlation || '');
+        return actionResult(void 0);
+    };
+};
+export const getLogDisableEventHistoryActionProcessor = async (qpqConfig) => ({
+    [LogActionType.DisableEventHistory]: getProcessLogDisableEventHistory(qpqConfig),
+});

package/lib/esm/actionProcessor/core/log/getLogTemplateLiteralActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/log/getLogTemplateLiteralActionProcessor.js

@@ -0,0 +1,11 @@
+import { actionResult, decomposedStringToString, LogActionType, } from 'quidproquo-core';
+const getProcessLogTemplateLiteral = (qpqConfig) => {
+    return async ({ messageParts }) => {
+        const message = decomposedStringToString(messageParts);
+        console.log(message);
+        return actionResult(void 0);
+    };
+};
+export const getLogTemplateLiteralActionProcessor = async (qpqConfig) => ({
+    [LogActionType.TemplateLiteral]: getProcessLogTemplateLiteral(qpqConfig),
+});

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

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

package/lib/esm/actionProcessor/core/log/index.js

@@ -0,0 +1,8 @@
+import { getLogCreateActionProcessor } from './getLogCreateActionProcessor';
+import { getLogDisableEventHistoryActionProcessor } from './getLogDisableEventHistoryActionProcessor';
+import { getLogTemplateLiteralActionProcessor } from './getLogTemplateLiteralActionProcessor';
+export const getLogActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getLogCreateActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getLogDisableEventHistoryActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getLogTemplateLiteralActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actionProcessor/core/math/getMathRandomNumberActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/math/getMathRandomNumberActionProcessor.js

@@ -0,0 +1,9 @@
+import { actionResult, MathActionType, } from 'quidproquo-core';
+const getProcessMathRandomNumber = (qpqConfig) => {
+    return async () => {
+        return actionResult(Math.random());
+    };
+};
+export const getMathRandomNumberActionProcessor = async (qpqConfig) => ({
+    [MathActionType.RandomNumber]: getProcessMathRandomNumber(qpqConfig),
+});

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

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

package/lib/esm/actionProcessor/core/math/index.js

@@ -0,0 +1,4 @@
+import { getMathRandomNumberActionProcessor } from './getMathRandomNumberActionProcessor';
+export const getMathActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getMathRandomNumberActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actionProcessor/core/network/getNetworkRequestActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/network/getNetworkRequestActionProcessor.js

@@ -0,0 +1,134 @@
+import { actionResult, actionResultError, ErrorTypeEnum, NetworkActionType, } from 'quidproquo-core';
+import axios from 'axios';
+import { extension } from 'mime-types';
+const getAxiosResponseType = (responseType) => {
+    if (responseType === 'binary') {
+        return 'arraybuffer';
+    }
+    return 'json';
+};
+const transformResponse = (payload, response) => {
+    if (payload.responseType === 'binary') {
+        const headers = response.headers || {};
+        const mimeType = headers['content-type'] || 'application/octet-stream';
+        const filename = headers['content-disposition']?.match(/filename="([^"]+)"/)?.[1] || `file.${extension(mimeType)}`;
+        return {
+            ...response,
+            data: {
+                base64Data: Buffer.from(response.data).toString('base64'),
+                mimetype: mimeType,
+                filename,
+            },
+        };
+    }
+    return response;
+};
+const axiosInstance = axios.create({
+    timeout: 25000,
+    headers: {
+        // Fixes: https://github.com/axios/axios/issues/5346
+        'Accept-Encoding': 'gzip,deflate,compress',
+    },
+    validateStatus: () => true,
+});
+const processNetworkRequestGet = async (payload) => {
+    const response = await axiosInstance.get(payload.url, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestPost = async (payload) => {
+    const response = await axiosInstance.post(payload.url, payload.body, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestDelete = async (payload) => {
+    const response = await axiosInstance.delete(payload.url, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestHead = async (payload) => {
+    const response = await axiosInstance.head(payload.url, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestOptions = async (payload) => {
+    const response = await axiosInstance.options(payload.url, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestPut = async (payload) => {
+    const response = await axiosInstance.put(payload.url, payload.body, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestPatch = async (payload) => {
+    const response = await axiosInstance.patch(payload.url, payload.body, {
+        baseURL: payload.basePath,
+        headers: payload.headers,
+        params: payload.params,
+        responseType: getAxiosResponseType(payload.responseType),
+    });
+    return transformResponse(payload, response);
+};
+const processNetworkRequestConnect = async (payload) => {
+    throw new Error('Function not implemented.');
+};
+const requestMethodMap = {
+    GET: processNetworkRequestGet,
+    POST: processNetworkRequestPost,
+    DELETE: processNetworkRequestDelete,
+    HEAD: processNetworkRequestHead,
+    OPTIONS: processNetworkRequestOptions,
+    PUT: processNetworkRequestPut,
+    PATCH: processNetworkRequestPatch,
+    CONNECT: processNetworkRequestConnect,
+};
+const getProcessNetworkRequest = (qpqConfig) => {
+    return async (payload) => {
+        const requestMethod = requestMethodMap[payload.method];
+        if (!requestMethod) {
+            return actionResultError(ErrorTypeEnum.NotImplemented, `${payload.method}: Not implemented`);
+        }
+        console.log(payload.url);
+        try {
+            const response = await requestMethod(payload);
+            return actionResult({
+                headers: response.headers,
+                status: response.status,
+                statusText: response.statusText,
+                data: response.data,
+            });
+        }
+        catch (err) {
+            console.log(err);
+            return actionResultError(ErrorTypeEnum.GenericError, err.stack);
+        }
+    };
+};
+export const getNetworkRequestActionProcessor = async (qpqConfig) => ({
+    [NetworkActionType.Request]: getProcessNetworkRequest(qpqConfig),
+});

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

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