quidproquo-actionprocessor-node 0.0.254 → 0.0.255

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

@@ -1,134 +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),
-});
+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

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

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

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

package/lib/esm/actionProcessor/core/platform/getPlatformDelayActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/platform/getPlatformDelayActionProcessor.js

@@ -1,9 +1,9 @@
-import { actionResult, PlatformActionType, } from 'quidproquo-core';
-const getProcessPlatformDelay = (qpqConfig) => {
-    return async ({ timeMs }) => {
-        return new Promise((resolve) => setTimeout(() => resolve(actionResult(undefined)), timeMs));
-    };
-};
-export const getPlatformDelayActionProcessor = async (qpqConfig) => ({
-    [PlatformActionType.Delay]: getProcessPlatformDelay(qpqConfig),
-});
+import { actionResult, PlatformActionType, } from 'quidproquo-core';
+const getProcessPlatformDelay = (qpqConfig) => {
+    return async ({ timeMs }) => {
+        return new Promise((resolve) => setTimeout(() => resolve(actionResult(undefined)), timeMs));
+    };
+};
+export const getPlatformDelayActionProcessor = async (qpqConfig) => ({
+    [PlatformActionType.Delay]: getProcessPlatformDelay(qpqConfig),
+});

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

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

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

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

package/lib/esm/actionProcessor/core/system/getSystemBatchActionProcessor.d.ts

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

package/lib/esm/actionProcessor/core/system/getSystemBatchActionProcessor.js

@@ -1,36 +1,36 @@
-import { actionResult, actionResultError, isErroredActionResult, processAction, resolveActionResult, resolveActionResultError, SystemActionType, } from 'quidproquo-core';
-const getProcessSystemBatch = (qpqConfig) => {
-    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader) => {
-        // console.log('~~~~~~~~~~~ RUNNING BATCH ~~~~~~~~~: ', payload);
-        const batchRes = await Promise.all(payload.actions.map((a) => processAction(a, actionProcessors, session, logger, updateSession, dynamicModuleLoader)));
-        // console.log('~~~~~~~~~~~ RESULT BATCH ~~~~~~~~~: ', batchRes);
-        // If there was an error, that does not want to be returned, throw that error back
-        const erroredBatchItem = batchRes.find((br, i) => isErroredActionResult(br) && !payload.actions[i].returnErrors);
-        if (erroredBatchItem) {
-            const error = resolveActionResultError(erroredBatchItem);
-            return actionResultError(error.errorType, error.errorText, error.errorStack);
-        }
-        // unwrap the values
-        return actionResult(batchRes.map((br, i) => {
-            // If we want to return errors, return the either result.
-            if (payload.actions[i].returnErrors) {
-                const isSuccess = !isErroredActionResult(br);
-                const result = isSuccess
-                    ? {
-                        success: true,
-                        result: resolveActionResult(br),
-                    }
-                    : {
-                        success: false,
-                        error: resolveActionResultError(br),
-                    };
-                return result;
-            }
-            // return the resolved result
-            return resolveActionResult(br);
-        }));
-    };
-};
-export const getSystemBatchActionProcessor = async (qpqConfig) => ({
-    [SystemActionType.Batch]: getProcessSystemBatch(qpqConfig),
-});
+import { actionResult, actionResultError, isErroredActionResult, processAction, resolveActionResult, resolveActionResultError, SystemActionType, } from 'quidproquo-core';
+const getProcessSystemBatch = (qpqConfig) => {
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader) => {
+        // console.log('~~~~~~~~~~~ RUNNING BATCH ~~~~~~~~~: ', payload);
+        const batchRes = await Promise.all(payload.actions.map((a) => processAction(a, actionProcessors, session, logger, updateSession, dynamicModuleLoader)));
+        // console.log('~~~~~~~~~~~ RESULT BATCH ~~~~~~~~~: ', batchRes);
+        // If there was an error, that does not want to be returned, throw that error back
+        const erroredBatchItem = batchRes.find((br, i) => isErroredActionResult(br) && !payload.actions[i].returnErrors);
+        if (erroredBatchItem) {
+            const error = resolveActionResultError(erroredBatchItem);
+            return actionResultError(error.errorType, error.errorText, error.errorStack);
+        }
+        // unwrap the values
+        return actionResult(batchRes.map((br, i) => {
+            // If we want to return errors, return the either result.
+            if (payload.actions[i].returnErrors) {
+                const isSuccess = !isErroredActionResult(br);
+                const result = isSuccess
+                    ? {
+                        success: true,
+                        result: resolveActionResult(br),
+                    }
+                    : {
+                        success: false,
+                        error: resolveActionResultError(br),
+                    };
+                return result;
+            }
+            // return the resolved result
+            return resolveActionResult(br);
+        }));
+    };
+};
+export const getSystemBatchActionProcessor = async (qpqConfig) => ({
+    [SystemActionType.Batch]: getProcessSystemBatch(qpqConfig),
+});

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

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

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

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

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

@@ -1,2 +1,2 @@
-export * from './core';
-export * from './webserver';
+export * from './core';
+export * from './webserver';

package/lib/esm/actionProcessor/index.js

@@ -1,2 +1,2 @@
-export * from './core';
-export * from './webserver';
+export * from './core';
+export * from './webserver';

package/lib/esm/actionProcessor/webserver/dns/getDnsListActionProcessor.d.ts

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

package/lib/esm/actionProcessor/webserver/dns/getDnsListActionProcessor.js

@@ -1,11 +1,11 @@
-import { actionResult } from 'quidproquo-core';
-import { DnsActionType, qpqWebServerUtils } from 'quidproquo-webserver';
-const getProcessDnsList = (qpqConfig) => {
-    return async () => {
-        const dnsList = qpqWebServerUtils.getDnsConfigs(qpqConfig).map((dc) => dc.dnsBase);
-        return actionResult(dnsList);
-    };
-};
-export const getDnsListActionProcessor = async (qpqConfig) => ({
-    [DnsActionType.List]: getProcessDnsList(qpqConfig),
-});
+import { actionResult } from 'quidproquo-core';
+import { DnsActionType, qpqWebServerUtils } from 'quidproquo-webserver';
+const getProcessDnsList = (qpqConfig) => {
+    return async () => {
+        const dnsList = qpqWebServerUtils.getDnsConfigs(qpqConfig).map((dc) => dc.dnsBase);
+        return actionResult(dnsList);
+    };
+};
+export const getDnsListActionProcessor = async (qpqConfig) => ({
+    [DnsActionType.List]: getProcessDnsList(qpqConfig),
+});

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

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

package/lib/esm/actionProcessor/webserver/dns/index.js

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

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

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

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

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

package/lib/esm/index.d.ts

@@ -1 +1 @@
-export * from './actionProcessor';
+export * from './actionProcessor';

package/lib/esm/index.js

@@ -1 +1 @@
-export * from './actionProcessor';
+export * from './actionProcessor';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quidproquo-actionprocessor-node",
-  "version": "0.0.254",
+  "version": "0.0.255",
   "description": "",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/esm/index.js",
@@ -35,15 +35,15 @@
     "@anthropic-ai/sdk": "^0.19.1",
     "axios": "^1.2.1",
     "mime-types": "^2.1.35",
-    "quidproquo-core": "0.0.254",
-    "quidproquo-webserver": "0.0.254",
+    "quidproquo-core": "0.0.255",
+    "quidproquo-webserver": "0.0.255",
     "uuid": "^9.0.0",
     "uuidv7": "^1.0.1"
   },
   "devDependencies": {
     "@types/mime-types": "^2.1.1",
     "@types/uuid": "^9.0.0",
-    "quidproquo-tsconfig": "0.0.254",
-    "typescript": "^4.9.3"
+    "quidproquo-tsconfig": "0.0.255",
+    "typescript": "^5.8.2"
   }
 }