polarity-integration-utils 0.1.0 → 3.1.3

package/dist/lib/testing/enhanced-utils/validate-integration.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIntegration = void 0;
+const zod_types_1 = require("../../zod-types");
+const create_mock_integration_context_1 = require("./create-mock-integration-context");
+const zod_1 = __importDefault(require("zod"));
+const validateIntegration = (integration, config) => {
+    const result = {
+        isValid: true,
+        errors: [],
+        warnings: []
+    };
+    // Check required functions
+    checkStartupFunction(integration, result);
+    checkDoLookupFunction(integration, result);
+    checkOnMessageFunction(integration, result);
+    // Check function signatures
+    validateFunctionSignatures(integration, result);
+    // Check exported integration object structure (e.g. if it's wrapped in an 'integration' property)
+    checkIntegrationObject(integration, result);
+    if (config) {
+        const configResult = zod_types_1.IntegrationConfigSchema.safeParse(config);
+        if (!configResult.success) {
+            result.errors.push(`Invalid config.json: ${JSON.stringify(zod_1.default.treeifyError(configResult.error), null, 2)}`);
+        }
+    }
+    result.isValid = result.errors.length === 0;
+    if (!result.isValid) {
+        throw new Error(`Integration validation failed:\n${result.errors.map((e) => `• ${e}`).join('\n')}`);
+    }
+    return result;
+};
+exports.validateIntegration = validateIntegration;
+function checkStartupFunction(integration, result) {
+    if (typeof integration.startup !== 'function') {
+        result.errors.push('Missing required startup function');
+    }
+    else {
+        if (integration.startup.length !== 1) {
+            result.warnings.push(`startup function should accept exactly 1 parameter (logger), found ${integration.startup.length}`);
+        }
+    }
+}
+function checkDoLookupFunction(integration, result) {
+    if (typeof integration.doLookup !== 'function') {
+        result.errors.push('Missing required doLookup function');
+    }
+    else {
+        if (integration.doLookup.length !== 3) {
+            result.warnings.push(`doLookup function should accept exactly 3 parameters (entities, options, context), found ${integration.doLookup.length}`);
+        }
+    }
+}
+function checkOnMessageFunction(integration, result) {
+    if (integration.onMessage !== undefined) {
+        if (typeof integration.onMessage !== 'function') {
+            result.errors.push('onMessage must be a function if present');
+        }
+        else if (integration.onMessage.length !== 3) {
+            result.warnings.push(`onMessage function should accept exactly 3 parameters (payload, options, context), found ${integration.onMessage.length}`);
+        }
+    }
+}
+function validateFunctionSignatures(integration, result) {
+    const mockLogger = {
+        info: () => { },
+        debug: () => { },
+        warn: () => { },
+        error: () => { },
+        trace: () => { },
+        fatal: () => { }
+    };
+    const mockContext = (0, create_mock_integration_context_1.createMockIntegrationContext)();
+    // Test startup return type
+    if (typeof integration.startup === 'function') {
+        try {
+            const startupResult = integration.startup(mockLogger);
+            if (!startupResult || typeof startupResult.then !== 'function') {
+                result.errors.push('startup function must return a Promise');
+            }
+            else {
+                // Prevent unhandled rejection if startup throws asynchronously
+                startupResult.catch(() => { });
+            }
+        }
+        catch (error) {
+            result.warnings.push(`startup function threw error during validation: ${error}`);
+        }
+    }
+    // Test doLookup return type
+    if (typeof integration.doLookup === 'function') {
+        try {
+            const doLookupResult = integration.doLookup([], { validatePayload: false }, mockContext);
+            const isValidReturn = Array.isArray(doLookupResult) ||
+                doLookupResult === null ||
+                doLookupResult === undefined ||
+                (doLookupResult &&
+                    typeof doLookupResult === 'object' &&
+                    'name' in doLookupResult &&
+                    doLookupResult.name === 'IntegrationError') ||
+                // Check for promise
+                (doLookupResult &&
+                    typeof doLookupResult.then === 'function');
+            if (!isValidReturn) {
+                // It might be a promise that resolves to the valid return types, so checking if it's a promise is important.
+                // The original code checked constructor name IntegrationError.
+                // Let's refine this. doLookup MUST return a Promise.
+                if (doLookupResult &&
+                    typeof doLookupResult.then === 'function') {
+                    // It's a promise, which is good.
+                    doLookupResult.catch(() => { });
+                }
+                else {
+                    result.warnings.push(`doLookup should return a Promise, returned: ${typeof doLookupResult}`);
+                }
+            }
+            else if (doLookupResult &&
+                typeof doLookupResult.then === 'function') {
+                doLookupResult.catch(() => { });
+            }
+        }
+        catch (error) {
+            result.warnings.push(`doLookup function threw error during validation: ${error}`);
+        }
+    }
+    // Test onMessage return type
+    if (typeof integration.onMessage === 'function') {
+        try {
+            const onMessageResult = integration.onMessage({}, { validatePayload: false }, mockContext);
+            if (!onMessageResult || typeof onMessageResult.then !== 'function') {
+                result.errors.push('onMessage function must return a Promise');
+            }
+            else {
+                // Prevent unhandled rejection if onMessage throws asynchronously
+                onMessageResult.catch(() => { });
+            }
+        }
+        catch (error) {
+            result.warnings.push(`onMessage function threw error during validation: ${error}`);
+        }
+    }
+}
+function checkIntegrationObject(integration, result) {
+    // Check if someone accidentally exported { integration: { ... } } instead of { ... }
+    if ('integration' in integration) {
+        const integrationObj = integration.integration;
+        if (integrationObj &&
+            typeof integrationObj === 'object' &&
+            'startup' in integrationObj &&
+            typeof integrationObj.startup === 'function' &&
+            'doLookup' in integrationObj &&
+            typeof integrationObj.doLookup === 'function') {
+            result.warnings.push('Detected potential incorrect export structure. The integration seems to be nested under an "integration" property. Ensure you are exporting the integration object directly (e.g. export = { ... }).');
+        }
+    }
+}

package/dist/lib/testing/index.js

@@ -0,0 +1,21 @@
+"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("./test-factory/create-integration-tests"), exports);
+__exportStar(require("./enhanced-utils/create-entity"), exports);
+__exportStar(require("./enhanced-utils/create-mock-integration-context"), exports);
+__exportStar(require("./enhanced-utils/mock-request"), exports);
+__exportStar(require("./enhanced-utils/validate-integration"), exports);

package/dist/lib/testing/test-factory/create-integration-tests.js

@@ -0,0 +1,53 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIntegrationTests = void 0;
+const validate_integration_1 = require("../enhanced-utils/validate-integration");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const test_do_lookup_1 = require("./test-do-lookup");
+const test_on_message_1 = require("./test-on-message");
+const createIntegrationTests = (integration) => {
+    const configPath = path.join(process.cwd(), 'config', 'config.json');
+    const config = fs.existsSync(configPath)
+        ? JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+        : undefined;
+    (0, validate_integration_1.validateIntegration)(integration, config);
+    return {
+        testDoLookup: test_do_lookup_1.testDoLookup.bind(null, integration),
+        testOnMessage: test_on_message_1.testOnMessage.bind(null, integration)
+    };
+};
+exports.createIntegrationTests = createIntegrationTests;

package/dist/lib/testing/test-factory/test-do-lookup.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testDoLookup = void 0;
+const zod_types_1 = require("../../zod-types");
+const create_mock_integration_context_1 = require("../enhanced-utils/create-mock-integration-context");
+const testDoLookup = (integration, description, { entities, options, expected }) => {
+    test(description, async () => {
+        const mockLogger = {
+            info: jest.fn(),
+            debug: jest.fn(),
+            trace: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            fatal: jest.fn()
+        };
+        await integration.startup(mockLogger);
+        const context = (0, create_mock_integration_context_1.createMockIntegrationContext)();
+        const result = await integration.doLookup(entities, options, context);
+        const validationResult = zod_types_1.DoLookupResultSchema.safeParse(result);
+        expect(validationResult.success).toBe(true);
+        expect(result).toEqual(expected);
+    });
+};
+exports.testDoLookup = testDoLookup;

package/dist/lib/testing/test-factory/test-on-message.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testOnMessage = void 0;
+const create_mock_integration_context_1 = require("../enhanced-utils/create-mock-integration-context");
+const testOnMessage = (integration, description, { command, args, expected, options = {} }) => {
+    test(description, async () => {
+        const mockLogger = {
+            info: jest.fn(),
+            debug: jest.fn(),
+            trace: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            fatal: jest.fn()
+        };
+        await integration.startup(mockLogger);
+        const context = (0, create_mock_integration_context_1.createMockIntegrationContext)();
+        if (typeof integration.onMessage !== 'function') {
+            throw new Error('Integration does not have an onMessage method.');
+        }
+        const result = await integration.onMessage({ command, ...args }, options, context);
+        expect(result).toEqual(expected);
+    });
+};
+exports.testOnMessage = testOnMessage;

package/dist/lib/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationError = void 0;
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "IntegrationError", { enumerable: true, get: function () { return errors_1.IntegrationError; } });

package/dist/lib/zod-types.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationConfigSchema = exports.DoLookupResultSchema = exports.ResultSchema = exports.EntitySchema = exports.EntityTypeSchema = exports.StandardEntityTypeSchema = exports.ChannelSchema = exports.ValidateOptionsUserOptionsSchema = exports.ValidateOptionsUserOptionSchema = exports.DoLookupUserOptionsSchema = exports.PossibleUserOptionValueSchema = exports.DropdownUserOptionValueSchema = exports.ValidationErrorSchema = void 0;
+const zod_1 = require("zod");
+exports.ValidationErrorSchema = zod_1.z.object({
+    key: zod_1.z.string(),
+    message: zod_1.z.string()
+});
+exports.DropdownUserOptionValueSchema = zod_1.z.object({
+    display: zod_1.z.string(),
+    value: zod_1.z.string()
+});
+exports.PossibleUserOptionValueSchema = zod_1.z.union([
+    zod_1.z.undefined(),
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    exports.DropdownUserOptionValueSchema,
+    zod_1.z.array(exports.DropdownUserOptionValueSchema)
+]);
+exports.DoLookupUserOptionsSchema = zod_1.z.record(zod_1.z.string(), exports.PossibleUserOptionValueSchema);
+exports.ValidateOptionsUserOptionSchema = zod_1.z.object({
+    integration_id: zod_1.z.string().optional(),
+    key: zod_1.z.string(),
+    value: exports.PossibleUserOptionValueSchema,
+    user_can_edit: zod_1.z.boolean().optional(),
+    admin_only: zod_1.z.boolean().optional()
+});
+exports.ValidateOptionsUserOptionsSchema = zod_1.z.record(zod_1.z.string(), exports.ValidateOptionsUserOptionSchema);
+exports.ChannelSchema = zod_1.z.object({
+    channel_name: zod_1.z.string(),
+    id: zod_1.z.number()
+});
+exports.StandardEntityTypeSchema = zod_1.z.union([
+    zod_1.z.literal('IP'),
+    zod_1.z.literal('IPv4'),
+    zod_1.z.literal('IPv4CIDR'),
+    zod_1.z.literal('IPv6'),
+    zod_1.z.literal('MAC'),
+    zod_1.z.literal('MD5'),
+    zod_1.z.literal('SHA1'),
+    zod_1.z.literal('SHA256'),
+    zod_1.z.literal('cve'),
+    zod_1.z.literal('domain'),
+    zod_1.z.literal('email'),
+    zod_1.z.literal('hash'),
+    zod_1.z.literal('string'),
+    zod_1.z.literal('url')
+]);
+exports.EntityTypeSchema = zod_1.z.union([
+    exports.StandardEntityTypeSchema,
+    zod_1.z.literal('*'),
+    zod_1.z.literal('custom'),
+    zod_1.z.custom((val) => /^custom\..+$/.test(val))
+]);
+exports.EntitySchema = zod_1.z.object({
+    value: zod_1.z.string(),
+    types: zod_1.z.array(exports.EntityTypeSchema),
+    type: exports.EntityTypeSchema,
+    requestContext: zod_1.z.object({
+        requestType: zod_1.z.literal('onDemand'),
+        isUserInitiated: zod_1.z.boolean()
+    }),
+    longitude: zod_1.z.number(),
+    latitude: zod_1.z.number(),
+    isURL: zod_1.z.boolean(),
+    isSHA512: zod_1.z.boolean(),
+    isSHA256: zod_1.z.boolean(),
+    isSHA1: zod_1.z.boolean(),
+    isPrivateIP: zod_1.z.boolean(),
+    isMD5: zod_1.z.boolean(),
+    isIPv6: zod_1.z.boolean(),
+    isIPv4: zod_1.z.boolean(),
+    isIP: zod_1.z.boolean(),
+    isHex: zod_1.z.boolean(),
+    isHash: zod_1.z.boolean(),
+    isHTMLTag: zod_1.z.boolean(),
+    isEmail: zod_1.z.boolean(),
+    isDomain: zod_1.z.boolean(),
+    hashType: zod_1.z.union([
+        zod_1.z.literal('md5'),
+        zod_1.z.literal('sha1'),
+        zod_1.z.literal('sha256'),
+        zod_1.z.literal('sha512'),
+        zod_1.z.literal('')
+    ]),
+    displayValue: zod_1.z.string(),
+    channels: zod_1.z.array(exports.ChannelSchema),
+    IPType: zod_1.z.union([zod_1.z.literal('IPv4'), zod_1.z.literal('IPv6'), zod_1.z.literal('')])
+});
+exports.ResultSchema = zod_1.z.object({
+    entity: exports.EntitySchema,
+    displayValue: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        summary: zod_1.z.array(zod_1.z.string()),
+        details: zod_1.z.unknown()
+    })
+});
+exports.DoLookupResultSchema = zod_1.z.array(exports.ResultSchema);
+const SelectOptionItemSchema = zod_1.z.object({
+    value: zod_1.z.string(),
+    display: zod_1.z.string()
+});
+// Schema for the 'options' array items (User Configuration)
+const OptionSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({
+        type: zod_1.z.enum(['text', 'password']),
+        key: zod_1.z.string(),
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        default: zod_1.z.string().nullable(),
+        userCanEdit: zod_1.z.boolean().optional(),
+        adminOnly: zod_1.z.boolean().optional()
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('boolean'),
+        key: zod_1.z.string(),
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        default: zod_1.z.boolean().nullable(),
+        userCanEdit: zod_1.z.boolean().optional(),
+        adminOnly: zod_1.z.boolean().optional()
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('number'),
+        key: zod_1.z.string(),
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        default: zod_1.z.number().nullable(),
+        userCanEdit: zod_1.z.boolean().optional(),
+        adminOnly: zod_1.z.boolean().optional()
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('select'),
+        key: zod_1.z.string(),
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        // Default can be a single object or an array of objects depending on 'multiple'
+        default: zod_1.z
+            .union([
+            SelectOptionItemSchema,
+            zod_1.z.array(SelectOptionItemSchema),
+            zod_1.z.string() // Occasionally a simple string value is used for default
+        ])
+            .nullable(),
+        options: zod_1.z.array(SelectOptionItemSchema),
+        multiple: zod_1.z.boolean().optional(),
+        userCanEdit: zod_1.z.boolean(),
+        adminOnly: zod_1.z.boolean()
+    })
+]);
+// Schema for custom data types defined within the config
+const CustomTypeSchema = zod_1.z.object({
+    type: zod_1.z.literal('custom').optional(), // Sometimes present in dataTypes
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    key: zod_1.z.string(),
+    regex: zod_1.z.string(),
+    editable: zod_1.z.boolean().optional(),
+    enabled: zod_1.z.boolean().optional()
+});
+// Component definition for block/summary
+const ComponentPathSchema = zod_1.z.object({
+    file: zod_1.z.string()
+});
+const ViewComponentSchema = zod_1.z.object({
+    component: ComponentPathSchema,
+    template: ComponentPathSchema
+});
+exports.IntegrationConfigSchema = zod_1.z.object({
+    polarityIntegrationUuid: zod_1.z.uuid(),
+    name: zod_1.z.string(),
+    acronym: zod_1.z.string().max(10),
+    description: zod_1.z.string().optional(),
+    defaultColor: zod_1.z.string().optional(),
+    // Entity and Data types
+    entityTypes: zod_1.z.array(zod_1.z.string()).optional(),
+    dataTypes: zod_1.z.array(zod_1.z.union([zod_1.z.string(), CustomTypeSchema])).optional(),
+    customTypes: zod_1.z.array(CustomTypeSchema).optional(),
+    supportsAdditionalCustomTypes: zod_1.z.boolean().optional(),
+    // UI/View Configuration
+    styles: zod_1.z.array(zod_1.z.string()).optional(),
+    block: ViewComponentSchema,
+    summary: ViewComponentSchema.optional(),
+    // Behavior Configuration
+    onDemandOnly: zod_1.z.boolean().optional(),
+    copyOnDemand: zod_1.z.boolean().optional(),
+    // Logging and Networking
+    logging: zod_1.z
+        .object({
+        level: zod_1.z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal'])
+    })
+        .optional(),
+    request: zod_1.z
+        .object({
+        cert: zod_1.z.string().optional(),
+        key: zod_1.z.string().optional(),
+        passphrase: zod_1.z.string().optional(),
+        ca: zod_1.z.string().optional(),
+        proxy: zod_1.z.string().optional(),
+        rejectUnauthorized: zod_1.z.boolean().optional()
+    })
+        .optional(),
+    // User Options
+    options: zod_1.z.array(OptionSchema).optional()
+});