@memberjunction/core-actions 2.54.0 → 2.55.0

package/dist/custom/integration/graphql-query.action.js

@@ -0,0 +1,251 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadGraphQLQueryAction = exports.GraphQLQueryAction = void 0;
+const global_1 = require("@memberjunction/global");
+const actions_1 = require("@memberjunction/actions");
+const axios_1 = __importDefault(require("axios"));
+const json_param_helper_1 = require("../utilities/json-param-helper");
+/**
+ * Action that executes GraphQL queries and mutations
+ *
+ * @example
+ * ```typescript
+ * // Simple query
+ * await runAction({
+ *   ActionName: 'GraphQL Query',
+ *   Params: [{
+ *     Name: 'Endpoint',
+ *     Value: 'https://api.example.com/graphql'
+ *   }, {
+ *     Name: 'Query',
+ *     Value: `
+ *       query GetUser($id: ID!) {
+ *         user(id: $id) {
+ *           id
+ *           name
+ *           email
+ *         }
+ *       }
+ *     `
+ *   }, {
+ *     Name: 'Variables',
+ *     Value: { id: '123' }
+ *   }]
+ * });
+ *
+ * // Mutation with headers
+ * await runAction({
+ *   ActionName: 'GraphQL Query',
+ *   Params: [{
+ *     Name: 'Endpoint',
+ *     Value: 'https://api.example.com/graphql'
+ *   }, {
+ *     Name: 'Query',
+ *     Value: `
+ *       mutation CreateUser($input: CreateUserInput!) {
+ *         createUser(input: $input) {
+ *           id
+ *           name
+ *         }
+ *       }
+ *     `
+ *   }, {
+ *     Name: 'Variables',
+ *     Value: {
+ *       input: {
+ *         name: 'John Doe',
+ *         email: 'john@example.com'
+ *       }
+ *     }
+ *   }, {
+ *     Name: 'Headers',
+ *     Value: {
+ *       'Authorization': 'Bearer token123'
+ *     }
+ *   }]
+ * });
+ * ```
+ */
+let GraphQLQueryAction = class GraphQLQueryAction extends actions_1.BaseAction {
+    /**
+     * Executes a GraphQL query or mutation
+     *
+     * @param params - The action parameters containing:
+     *   - Endpoint: GraphQL endpoint URL (required)
+     *   - Query: GraphQL query/mutation string (required)
+     *   - Variables: Variables object for the query (optional)
+     *   - Headers: Additional headers for the request (optional)
+     *   - OperationName: For multi-operation documents (optional)
+     *   - Timeout: Request timeout in milliseconds - default: 30000
+     *
+     * @returns GraphQL response data
+     */
+    async InternalRunAction(params) {
+        try {
+            const endpoint = this.getParamValue(params, 'endpoint');
+            const query = this.getParamValue(params, 'query');
+            const variables = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'variables');
+            const headers = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'headers') || {};
+            const operationName = this.getParamValue(params, 'operationname');
+            const timeout = this.getNumericParam(params, 'timeout', 30000);
+            // Validate required parameters
+            if (!endpoint) {
+                return {
+                    Success: false,
+                    Message: "Endpoint parameter is required",
+                    ResultCode: "MISSING_ENDPOINT"
+                };
+            }
+            if (!query) {
+                return {
+                    Success: false,
+                    Message: "Query parameter is required",
+                    ResultCode: "MISSING_QUERY"
+                };
+            }
+            // Validate endpoint URL
+            try {
+                new URL(endpoint);
+            }
+            catch (e) {
+                return {
+                    Success: false,
+                    Message: `Invalid endpoint URL: ${endpoint}`,
+                    ResultCode: "INVALID_URL"
+                };
+            }
+            // Prepare GraphQL request body
+            const requestBody = { query };
+            if (variables) {
+                requestBody.variables = variables;
+            }
+            if (operationName) {
+                requestBody.operationName = operationName;
+            }
+            // Prepare headers
+            const requestHeaders = {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                ...headers
+            };
+            // Make GraphQL request
+            const response = await axios_1.default.post(endpoint, requestBody, {
+                headers: requestHeaders,
+                timeout,
+                validateStatus: () => true // Handle all status codes
+            });
+            // Check for HTTP errors
+            if (response.status < 200 || response.status >= 300) {
+                return {
+                    Success: false,
+                    Message: `HTTP error ${response.status}: ${response.statusText}`,
+                    ResultCode: `HTTP_${response.status}`
+                };
+            }
+            // Check for GraphQL errors
+            const responseData = response.data;
+            const hasErrors = responseData.errors && responseData.errors.length > 0;
+            // Add output parameters
+            if (responseData.data) {
+                params.Params.push({
+                    Name: 'Data',
+                    Type: 'Output',
+                    Value: responseData.data
+                });
+            }
+            if (responseData.errors) {
+                params.Params.push({
+                    Name: 'Errors',
+                    Type: 'Output',
+                    Value: responseData.errors
+                });
+            }
+            if (responseData.extensions) {
+                params.Params.push({
+                    Name: 'Extensions',
+                    Type: 'Output',
+                    Value: responseData.extensions
+                });
+            }
+            // Determine success based on GraphQL response
+            if (hasErrors && !responseData.data) {
+                // Only errors, no data - complete failure
+                return {
+                    Success: false,
+                    Message: `GraphQL errors: ${JSON.stringify(responseData.errors, null, 2)}`,
+                    ResultCode: "GRAPHQL_ERROR"
+                };
+            }
+            else if (hasErrors && responseData.data) {
+                // Partial success - has both data and errors
+                return {
+                    Success: true,
+                    ResultCode: "PARTIAL_SUCCESS",
+                    Message: JSON.stringify({
+                        message: "GraphQL query completed with errors",
+                        data: responseData.data,
+                        errors: responseData.errors,
+                        extensions: responseData.extensions
+                    }, null, 2)
+                };
+            }
+            else {
+                // Complete success
+                return {
+                    Success: true,
+                    ResultCode: "SUCCESS",
+                    Message: JSON.stringify({
+                        message: "GraphQL query executed successfully",
+                        data: responseData.data,
+                        extensions: responseData.extensions
+                    }, null, 2)
+                };
+            }
+        }
+        catch (error) {
+            return {
+                Success: false,
+                Message: `GraphQL request failed: ${error instanceof Error ? error.message : String(error)}`,
+                ResultCode: "REQUEST_FAILED"
+            };
+        }
+    }
+    /**
+     * Get numeric parameter with default
+     */
+    getNumericParam(params, name, defaultValue) {
+        const value = this.getParamValue(params, name);
+        if (value === undefined || value === null)
+            return defaultValue;
+        const num = Number(value);
+        return isNaN(num) ? defaultValue : num;
+    }
+    /**
+     * Get parameter value by name (case-insensitive)
+     */
+    getParamValue(params, name) {
+        const param = params.Params.find(p => p.Name.toLowerCase() === name.toLowerCase());
+        return param?.Value;
+    }
+};
+exports.GraphQLQueryAction = GraphQLQueryAction;
+exports.GraphQLQueryAction = GraphQLQueryAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "GraphQL Query")
+], GraphQLQueryAction);
+/**
+ * Loader function to ensure the GraphQLQueryAction class is included in the bundle
+ */
+function LoadGraphQLQueryAction() {
+    // Stub function to prevent tree shaking
+}
+exports.LoadGraphQLQueryAction = LoadGraphQLQueryAction;
+//# sourceMappingURL=graphql-query.action.js.map

package/dist/custom/integration/graphql-query.action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-query.action.js","sourceRoot":"","sources":["../../../src/custom/integration/graphql-query.action.ts"],"names":[],"mappings":"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"}

package/dist/custom/integration/http-request.action.d.ts

@@ -0,0 +1,96 @@
+import { ActionResultSimple, RunActionParams } from "@memberjunction/actions-base";
+import { BaseAction } from "@memberjunction/actions";
+/**
+ * Action that makes HTTP requests with full control over headers, authentication, and request options
+ *
+ * @example
+ * ```typescript
+ * // Simple GET request
+ * await runAction({
+ *   ActionName: 'HTTP Request',
+ *   Params: [{
+ *     Name: 'URL',
+ *     Value: 'https://api.example.com/data'
+ *   }]
+ * });
+ *
+ * // POST request with JSON body
+ * await runAction({
+ *   ActionName: 'HTTP Request',
+ *   Params: [{
+ *     Name: 'URL',
+ *     Value: 'https://api.example.com/users'
+ *   }, {
+ *     Name: 'Method',
+ *     Value: 'POST'
+ *   }, {
+ *     Name: 'Body',
+ *     Value: { name: 'John Doe', email: 'john@example.com' }
+ *   }, {
+ *     Name: 'Headers',
+ *     Value: { 'Content-Type': 'application/json' }
+ *   }]
+ * });
+ *
+ * // Request with authentication
+ * await runAction({
+ *   ActionName: 'HTTP Request',
+ *   Params: [{
+ *     Name: 'URL',
+ *     Value: 'https://api.example.com/protected'
+ *   }, {
+ *     Name: 'Authentication',
+ *     Value: {
+ *       type: 'bearer',
+ *       token: 'your-api-token'
+ *     }
+ *   }]
+ * });
+ * ```
+ */
+export declare class HTTPRequestAction extends BaseAction {
+    /**
+     * Makes an HTTP request with configurable options
+     *
+     * @param params - The action parameters containing:
+     *   - URL: Target URL (required)
+     *   - Method: HTTP method (GET, POST, PUT, DELETE, etc.) - default: GET
+     *   - Headers: Object with request headers
+     *   - Body: Request body (string or object)
+     *   - BodyType: "json" | "form" | "text" | "binary" - default: "json"
+     *   - Authentication: Auth config object { type: 'basic'|'bearer', username?, password?, token? }
+     *   - Timeout: Request timeout in milliseconds - default: 30000
+     *   - FollowRedirects: Boolean - default: true
+     *   - MaxRedirects: Number - default: 5
+     *   - ValidateStatus: Function string to validate response status
+     *   - ResponseType: "json" | "text" | "arraybuffer" | "stream" - default: "json"
+     *
+     * @returns Response object with status, headers, and body
+     */
+    protected InternalRunAction(params: RunActionParams): Promise<ActionResultSimple>;
+    /**
+     * Configure authentication for the request
+     */
+    private configureAuthentication;
+    /**
+     * Configure request body based on type
+     */
+    private configureRequestBody;
+    /**
+     * Get numeric parameter with default
+     */
+    private getNumericParam;
+    /**
+     * Get boolean parameter with default
+     */
+    private getBooleanParam;
+    /**
+     * Get parameter value by name (case-insensitive)
+     */
+    private getParamValue;
+}
+/**
+ * Loader function to ensure the HTTPRequestAction class is included in the bundle
+ */
+export declare function LoadHTTPRequestAction(): void;
+//# sourceMappingURL=http-request.action.d.ts.map

package/dist/custom/integration/http-request.action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-request.action.d.ts","sourceRoot":"","sources":["../../../src/custom/integration/http-request.action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEnF,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAIrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBACa,iBAAkB,SAAQ,UAAU;IAE7C;;;;;;;;;;;;;;;;;OAiBG;cACa,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8GvF;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA4C/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAkD5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,aAAa;CAIxB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,SAEpC"}

package/dist/custom/integration/http-request.action.js

@@ -0,0 +1,316 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadHTTPRequestAction = exports.HTTPRequestAction = void 0;
+const global_1 = require("@memberjunction/global");
+const actions_1 = require("@memberjunction/actions");
+const axios_1 = __importDefault(require("axios"));
+const json_param_helper_1 = require("../utilities/json-param-helper");
+/**
+ * Action that makes HTTP requests with full control over headers, authentication, and request options
+ *
+ * @example
+ * ```typescript
+ * // Simple GET request
+ * await runAction({
+ *   ActionName: 'HTTP Request',
+ *   Params: [{
+ *     Name: 'URL',
+ *     Value: 'https://api.example.com/data'
+ *   }]
+ * });
+ *
+ * // POST request with JSON body
+ * await runAction({
+ *   ActionName: 'HTTP Request',
+ *   Params: [{
+ *     Name: 'URL',
+ *     Value: 'https://api.example.com/users'
+ *   }, {
+ *     Name: 'Method',
+ *     Value: 'POST'
+ *   }, {
+ *     Name: 'Body',
+ *     Value: { name: 'John Doe', email: 'john@example.com' }
+ *   }, {
+ *     Name: 'Headers',
+ *     Value: { 'Content-Type': 'application/json' }
+ *   }]
+ * });
+ *
+ * // Request with authentication
+ * await runAction({
+ *   ActionName: 'HTTP Request',
+ *   Params: [{
+ *     Name: 'URL',
+ *     Value: 'https://api.example.com/protected'
+ *   }, {
+ *     Name: 'Authentication',
+ *     Value: {
+ *       type: 'bearer',
+ *       token: 'your-api-token'
+ *     }
+ *   }]
+ * });
+ * ```
+ */
+let HTTPRequestAction = class HTTPRequestAction extends actions_1.BaseAction {
+    /**
+     * Makes an HTTP request with configurable options
+     *
+     * @param params - The action parameters containing:
+     *   - URL: Target URL (required)
+     *   - Method: HTTP method (GET, POST, PUT, DELETE, etc.) - default: GET
+     *   - Headers: Object with request headers
+     *   - Body: Request body (string or object)
+     *   - BodyType: "json" | "form" | "text" | "binary" - default: "json"
+     *   - Authentication: Auth config object { type: 'basic'|'bearer', username?, password?, token? }
+     *   - Timeout: Request timeout in milliseconds - default: 30000
+     *   - FollowRedirects: Boolean - default: true
+     *   - MaxRedirects: Number - default: 5
+     *   - ValidateStatus: Function string to validate response status
+     *   - ResponseType: "json" | "text" | "arraybuffer" | "stream" - default: "json"
+     *
+     * @returns Response object with status, headers, and body
+     */
+    async InternalRunAction(params) {
+        try {
+            const url = this.getParamValue(params, 'url');
+            const method = (this.getParamValue(params, 'method') || 'GET').toUpperCase();
+            const headers = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'headers') || {};
+            const body = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'body');
+            const bodyType = this.getParamValue(params, 'bodytype') || 'json';
+            const authentication = json_param_helper_1.JSONParamHelper.getJSONParam(params, 'authentication');
+            const timeout = this.getNumericParam(params, 'timeout', 30000);
+            const followRedirects = this.getBooleanParam(params, 'followredirects', true);
+            const maxRedirects = this.getNumericParam(params, 'maxredirects', 5);
+            const responseType = this.getParamValue(params, 'responsetype') || 'json';
+            // Validate URL
+            if (!url) {
+                return {
+                    Success: false,
+                    Message: "URL parameter is required",
+                    ResultCode: "MISSING_URL"
+                };
+            }
+            // Build request config
+            const config = {
+                url,
+                method,
+                headers: { ...headers },
+                timeout,
+                maxRedirects: followRedirects ? maxRedirects : 0,
+                responseType: responseType,
+                validateStatus: () => true // We'll handle status validation ourselves
+            };
+            // Handle authentication
+            if (authentication) {
+                const authResult = this.configureAuthentication(config, authentication);
+                if (!authResult.success) {
+                    return {
+                        Success: false,
+                        Message: authResult.error,
+                        ResultCode: "AUTH_CONFIG_ERROR"
+                    };
+                }
+            }
+            // Handle request body
+            if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+                const bodyResult = this.configureRequestBody(config, body, bodyType);
+                if (!bodyResult.success) {
+                    return {
+                        Success: false,
+                        Message: bodyResult.error,
+                        ResultCode: "BODY_CONFIG_ERROR"
+                    };
+                }
+            }
+            // Make request
+            const response = await (0, axios_1.default)(config);
+            // Prepare response data
+            let responseData = response.data;
+            if (responseType === 'arraybuffer' && Buffer.isBuffer(responseData)) {
+                responseData = responseData.toString('base64');
+            }
+            // Add output parameters
+            params.Params.push({
+                Name: 'ResponseStatus',
+                Type: 'Output',
+                Value: response.status
+            });
+            params.Params.push({
+                Name: 'ResponseHeaders',
+                Type: 'Output',
+                Value: response.headers
+            });
+            params.Params.push({
+                Name: 'ResponseData',
+                Type: 'Output',
+                Value: responseData
+            });
+            // Check if request was successful (2xx status)
+            const isSuccess = response.status >= 200 && response.status < 300;
+            return {
+                Success: true,
+                ResultCode: isSuccess ? "SUCCESS" : `HTTP_${response.status}`,
+                Message: JSON.stringify({
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                    data: responseData,
+                    requestUrl: url,
+                    requestMethod: method
+                }, null, 2)
+            };
+        }
+        catch (error) {
+            return {
+                Success: false,
+                Message: `HTTP request failed: ${error instanceof Error ? error.message : String(error)}`,
+                ResultCode: "REQUEST_FAILED"
+            };
+        }
+    }
+    /**
+     * Configure authentication for the request
+     */
+    configureAuthentication(config, auth) {
+        if (!auth.type) {
+            return { success: false, error: "Authentication type is required" };
+        }
+        switch (auth.type.toLowerCase()) {
+            case 'basic':
+                if (!auth.username || !auth.password) {
+                    return { success: false, error: "Basic auth requires username and password" };
+                }
+                config.auth = {
+                    username: auth.username,
+                    password: auth.password
+                };
+                break;
+            case 'bearer':
+                if (!auth.token) {
+                    return { success: false, error: "Bearer auth requires token" };
+                }
+                config.headers = config.headers || {};
+                config.headers['Authorization'] = `Bearer ${auth.token}`;
+                break;
+            case 'apikey':
+                if (!auth.key || !auth.value) {
+                    return { success: false, error: "API key auth requires key name and value" };
+                }
+                if (auth.location === 'query') {
+                    config.params = config.params || {};
+                    config.params[auth.key] = auth.value;
+                }
+                else {
+                    config.headers = config.headers || {};
+                    config.headers[auth.key] = auth.value;
+                }
+                break;
+            default:
+                return { success: false, error: `Unsupported authentication type: ${auth.type}` };
+        }
+        return { success: true };
+    }
+    /**
+     * Configure request body based on type
+     */
+    configureRequestBody(config, body, bodyType) {
+        switch (bodyType.toLowerCase()) {
+            case 'json':
+                config.data = body;
+                if (!config.headers['Content-Type']) {
+                    config.headers['Content-Type'] = 'application/json';
+                }
+                break;
+            case 'form':
+                if (typeof body === 'object') {
+                    const formData = new URLSearchParams();
+                    for (const [key, value] of Object.entries(body)) {
+                        formData.append(key, String(value));
+                    }
+                    config.data = formData.toString();
+                    if (!config.headers['Content-Type']) {
+                        config.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                    }
+                }
+                else {
+                    return { success: false, error: "Form body type requires an object" };
+                }
+                break;
+            case 'text':
+                config.data = String(body);
+                if (!config.headers['Content-Type']) {
+                    config.headers['Content-Type'] = 'text/plain';
+                }
+                break;
+            case 'binary':
+                if (typeof body === 'string') {
+                    // Assume base64 encoded
+                    config.data = Buffer.from(body, 'base64');
+                }
+                else {
+                    config.data = body;
+                }
+                if (!config.headers['Content-Type']) {
+                    config.headers['Content-Type'] = 'application/octet-stream';
+                }
+                break;
+            default:
+                return { success: false, error: `Unsupported body type: ${bodyType}` };
+        }
+        return { success: true };
+    }
+    /**
+     * Get numeric parameter with default
+     */
+    getNumericParam(params, name, defaultValue) {
+        const value = this.getParamValue(params, name);
+        if (value === undefined || value === null)
+            return defaultValue;
+        const num = Number(value);
+        return isNaN(num) ? defaultValue : num;
+    }
+    /**
+     * Get boolean parameter with default
+     */
+    getBooleanParam(params, name, defaultValue) {
+        const value = this.getParamValue(params, name);
+        if (value === undefined || value === null)
+            return defaultValue;
+        if (typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string') {
+            return value.toLowerCase() === 'true';
+        }
+        return defaultValue;
+    }
+    /**
+     * Get parameter value by name (case-insensitive)
+     */
+    getParamValue(params, name) {
+        const param = params.Params.find(p => p.Name.toLowerCase() === name.toLowerCase());
+        return param?.Value;
+    }
+};
+exports.HTTPRequestAction = HTTPRequestAction;
+exports.HTTPRequestAction = HTTPRequestAction = __decorate([
+    (0, global_1.RegisterClass)(actions_1.BaseAction, "HTTP Request")
+], HTTPRequestAction);
+/**
+ * Loader function to ensure the HTTPRequestAction class is included in the bundle
+ */
+function LoadHTTPRequestAction() {
+    // Stub function to prevent tree shaking
+}
+exports.LoadHTTPRequestAction = LoadHTTPRequestAction;
+//# sourceMappingURL=http-request.action.js.map