polarity-integration-utils 3.1.7 → 4.0.0

package/dist/es/lib/testing/enhanced-utils/create-entity.js

@@ -1,22 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEntity = void 0;
+function toEntityTypeIdentifier(type) {
+    if (type === 'IP')
+        return 'IPv4';
+    if (type.startsWith('custom.'))
+        return 'custom';
+    return type;
+}
+/**
+ * Creates a mock `Entity` for use in tests.
+ *
+ * Automatically detects whether the value is a domain or IPv4 address and sets
+ * the corresponding boolean flags. All other flags default to `false`.
+ *
+ * @param type - An `EntityType` string (e.g., `'IPv4'`, `'domain'`, `'MD5'`)
+ * @param value - The entity value string
+ * @returns A fully populated `Entity` object
+ *
+ * @example
+ * ```typescript
+ * const ip = createEntity('IPv4', '8.8.8.8');
+ * const domain = createEntity('domain', 'example.com');
+ * ```
+ */
 const createEntity = (type, value) => {
     const isDomain = /^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9](?:\.[a-zA-Z]{2,})+$/.test(value);
     const isIPv4 = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(value);
+    const isIPv6 = /^[\da-fA-F:]+$/.test(value) && value.includes(':');
     return {
         value,
+        rawValue: value,
         displayValue: value,
-        type,
+        type: toEntityTypeIdentifier(type),
         types: [type],
         isDomain,
         isIPv4,
-        isIP: isIPv4,
+        isIP: isIPv4 || isIPv6,
         isEmail: false,
         isHash: false,
         isHex: false,
         isHTMLTag: false,
-        isIPv6: false,
+        isIPv6,
         isMD5: false,
         isPrivateIP: false,
         isSHA1: false,
@@ -25,11 +50,12 @@ const createEntity = (type, value) => {
         isURL: false,
         latitude: 0,
         longitude: 0,
+        IPLong: 0,
         hashType: '',
-        IPType: isIPv4 ? 'IPv4' : '',
+        IPType: isIPv4 ? 'IPv4' : isIPv6 ? 'IPv6' : '',
         channels: [],
         requestContext: {
-            requestType: 'onDemand',
+            requestType: 'OnDemand',
             isUserInitiated: true
         }
     };

package/dist/es/lib/testing/enhanced-utils/create-mock-integration-context.js

@@ -1,36 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMockIntegrationContext = void 0;
-const createMockIntegrationContext = () => {
-    const cache = {
-        global: {
-            get: jest.fn(),
-            set: jest.fn(),
-            delete: jest.fn()
-        },
-        integration: {
-            get: jest.fn(),
-            set: jest.fn(),
-            delete: jest.fn()
-        },
-        user: {
-            get: jest.fn(),
-            set: jest.fn(),
-            delete: jest.fn()
-        }
+const noOp = () => () => undefined;
+/**
+ * Creates a mock `IntegrationContext`
+ * with stubbed logger, cache, and polling methods.
+ *
+ * Pass your testing framework's mock function factory to enable spy capabilities
+ * (e.g., `toHaveBeenCalledWith()`). When omitted, plain no-op stubs are used.
+ *
+ * @param createMockFn - A factory that creates mock functions (e.g., `vi.fn` or `jest.fn`)
+ * @returns A fully populated `IntegrationContext` with stubbed methods
+ *
+ * @example
+ * ```typescript
+ * // Vitest
+ * const ctx = createMockIntegrationContext(vi.fn);
+ *
+ * // Jest
+ * const ctx = createMockIntegrationContext(jest.fn);
+ *
+ * // No framework — plain no-ops
+ * const ctx = createMockIntegrationContext();
+ * ```
+ */
+const createMockIntegrationContext = (createMockFn = noOp) => {
+    const createCacheScope = () => ({
+        get: createMockFn(),
+        set: createMockFn(),
+        delete: createMockFn()
+    });
+    const childFn = createMockFn();
+    const logger = {
+        child: childFn,
+        info: createMockFn(),
+        debug: createMockFn(),
+        trace: createMockFn(),
+        warn: createMockFn(),
+        error: createMockFn(),
+        fatal: createMockFn()
     };
+    // Make child() return the logger for method chaining
+    if (typeof childFn.mockReturnValue === 'function') {
+        childFn.mockReturnValue(logger);
+    }
+    else {
+        logger.child = () => logger;
+    }
     return {
-        cache,
+        cache: {
+            global: createCacheScope(),
+            integration: createCacheScope(),
+            user: createCacheScope()
+        },
         integrationId: 'test-integration',
-        userId: 'test-user',
-        logger: {
-            info: jest.fn(),
-            debug: jest.fn(),
-            trace: jest.fn(),
-            warn: jest.fn(),
-            error: jest.fn(),
-            fatal: jest.fn()
-        }
+        userId: 1,
+        logger,
+        startPolling: createMockFn(),
+        stopPolling: createMockFn()
     };
 };
 exports.createMockIntegrationContext = createMockIntegrationContext;

package/dist/es/lib/testing/index.js

@@ -14,8 +14,5 @@ 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/es/lib/types.js

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

package/dist/lib/errors/integration-error.js

@@ -31,7 +31,7 @@ class IntegrationError extends Error {
     code;
     /**
      * The `cause` property is used to specify the `cause` of the error.  Typically,
-     * this property is used to pass through a related Error instance.
+     * this property is used to pass through a related Error instance but can be any value.
      */
     cause;
     /**
@@ -63,7 +63,7 @@ class IntegrationError extends Error {
         if (typeof properties.status !== 'undefined') {
             this.status = properties.status;
         }
-        if (properties.cause && properties.cause instanceof Error) {
+        if (typeof properties.cause !== 'undefined') {
             this.cause = properties.cause;
         }
         if (typeof properties.requestOptions !== 'undefined') {
@@ -101,8 +101,11 @@ class IntegrationError extends Error {
         if (this.help) {
             props.help = this.help;
         }
-        if (this.cause) {
-            props.cause = (0, parse_error_to_readable_json_1.parseErrorToReadableJson)(this.cause);
+        if (this.cause !== undefined) {
+            props.cause =
+                this.cause instanceof Error
+                    ? (0, parse_error_to_readable_json_1.parseErrorToReadableJson)(this.cause)
+                    : this.cause;
         }
         if (this.requestOptions) {
             props.requestOptions = this.requestOptions;

package/dist/lib/index.docs.js

@@ -22,4 +22,4 @@ __exportStar(require("./errors"), exports);
 __exportStar(require("./requests"), exports);
 __exportStar(require("./logging"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./context"), exports);
+__exportStar(require("./testing"), exports);

package/dist/lib/index.js

@@ -36,15 +36,11 @@ 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 });
-exports.types = exports.context = exports.logging = exports.requests = exports.errors = void 0;
+exports.logging = exports.requests = exports.errors = void 0;
 const errors = __importStar(require("./errors"));
 exports.errors = errors;
 const requests = __importStar(require("./requests"));
 exports.requests = requests;
 const logging = __importStar(require("./logging"));
 exports.logging = logging;
-const context = __importStar(require("./context"));
-exports.context = context;
-const types = __importStar(require("./types"));
-exports.types = types;
 __exportStar(require("./types"), exports);

package/dist/lib/logging/logger.js

@@ -5,13 +5,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogger = exports.setLogger = void 0;
 const fs_1 = __importDefault(require("fs"));
-const loggingLevels = ['info', 'debug', 'trace', 'warn', 'error', 'fatal'];
-const writeToDevRunnerResults = (loggingLevel) => (...content) => fs_1.default.appendFileSync('devRunnerResults.json', '\n' + JSON.stringify({ SOURCE: `Logger.${loggingLevel}`, content }, null, 2));
-const defaultLogger = loggingLevels.reduce((agg, level) => ({
-    ...agg,
-    [level]: writeToDevRunnerResults(level)
-}), {});
-let _logger = defaultLogger;
+const createLogMethod = (loggingLevel) => (...content) => {
+    if (content.length === 0)
+        return true;
+    fs_1.default.appendFileSync('devRunnerResults.json', '\n' + JSON.stringify({ SOURCE: `Logger.${loggingLevel}`, content }, null, 2));
+};
+function createDefaultLogger() {
+    const logger = {
+        child: () => logger,
+        trace: createLogMethod('trace'),
+        debug: createLogMethod('debug'),
+        info: createLogMethod('info'),
+        warn: createLogMethod('warn'),
+        error: createLogMethod('error'),
+        fatal: createLogMethod('fatal')
+    };
+    return logger;
+}
+let _logger = createDefaultLogger();
 /**
  * Set the logger object used by the integration.
  *

package/dist/lib/requests/polarity-request.js

@@ -6,10 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolarityRequest = void 0;
 const fs_1 = __importDefault(require("fs"));
 const util_1 = require("util");
-const bottleneck_1 = __importDefault(require("bottleneck"));
 const postman_request_1 = __importDefault(require("postman-request"));
 const parallel_limit_1 = require("../internal/helpers/parallel-limit");
-const node_util_1 = require("node:util");
 const get_js_1 = __importDefault(require("lodash/get.js"));
 const has_js_1 = __importDefault(require("lodash/has.js"));
 const errors_1 = require("../errors");
@@ -20,12 +18,10 @@ const sanitize_request_options_1 = require("./sanitize-request-options");
  * @public
  */
 class PolarityRequest {
-    bottleneckLimiter;
     /**
      * Instance of a Bunyan logger
      */
     logger;
-    internalThrottlingOptions;
     /**
      * postman-request library request object with default values set.  Used internally for
      * making HTTP requests directly via the postman-request library
@@ -75,80 +71,25 @@ class PolarityRequest {
     requestOptionsToSanitize = [];
     userOptions = null;
     /**
-     * Optional middleware method for modifying {@link HttpRequestOptions} before a request is made
-     * via the {@link PolarityRequest.run} method or {@link PolarityRequest.runInParallel} method.
-     * The returned `requestOptions` object will be used for the request.  This method is passed
-     * a copy of the original `requestOptions` object so it can be modified without side effects.
-     *
-     * This method is typically used for adding authentication (e.g., auth headers, or basic auth) to every request.
-     * It can also be used to add headers that are required on every request or conditionally add headers based
-     * on the passed in `userOptions`.
-     *
-     * This method can be set as part of the {@link PolarityRequestOptions} when creating a new instance of the
-     * {@link PolarityRequest} class or can be set after the fact.
-     *
-     * @param requestOptions - A copy of the request options used for the request.  This object can be modified
-     * without side effects.
-     * @param userOptions - The user options passed into the `doLookup` method.
-     * @returns The modified request options to use for the request.
+     * An optional rate limiter instance used to throttle HTTP requests.
+     * When set, all requests made via {@link PolarityRequest.run} are scheduled
+     * through this limiter. Typically provided by the Polarity server via the
+     * integration context.
      */
-    preprocessRequestOptions = async (requestOptions, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    userOptions) => requestOptions;
+    limiter = null;
     /**
-     * Optional middleware method for modifying the {@link HttpRequestResponse} after a successful request.
-     * The passed in {@link HttpRequestResponse} object is not a copy but can be safely modified without
-     * side effects.  The returned `HttpRequestResponse` object will be used for the response.
+     * Lifecycle hooks for customizing request behavior. Hooks are configured via the
+     * {@link PolarityRequestOptions.hooks} property when creating a new instance of the
+     * {@link PolarityRequest} class.
      *
-     * @param response - The HTTP response from the request.
-     * @param requestOptions - The request options used for the request.
-     * @param userOptions - The user options passed into the `doLookup` method.
+     * @see {@link PolarityRequestHooks} for hook type details.
      */
-    postprocessRequestSuccess = async (response, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    requestOptions, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    userOptions) => response;
-    /**
-     * Method that can be implemented to post-process the HTTP response after a failed request.
-     * This method is typically used to inspect the error thrown and either alter the error
-     * object (e.g., to change the error message property to something more specific), to ignore
-     * the error (by not rethrowing it), or to take a specific action based on the error (e.g.,
-     * in the case of a RetryRequestError you may want to retry the request or return a special
-     * payload to the integration front end).
-     *
-     * @param error - The error thrown during the request.
-     * @param requestOptions - The request options used for the request.
-     * @param userOptions - The user options passed into the `doLookup` method.
-     */
-    postprocessRequestFailure = (error, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    requestOptions, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    userOptions) => {
-        throw error;
+    hooks = {
+        beforeRequest: [],
+        afterResponse: [],
+        onApiError: [],
+        onNetworkError: []
     };
-    get throttlingOptions() {
-        return this.internalThrottlingOptions;
-    }
-    // REVIEW: Do we want to tie our throttling specifically to Bottleneck or do we want to make
-    // it more generic and independent of Bottleneck?
-    set throttlingOptions(throttlingOptions) {
-        if ((0, node_util_1.isDeepStrictEqual)(this.internalThrottlingOptions, throttlingOptions))
-            return;
-        this.bottleneckLimiter = new bottleneck_1.default({
-            ...throttlingOptions,
-            maxConcurrent: typeof throttlingOptions.maxConcurrent === 'string'
-                ? Number.parseInt(throttlingOptions.maxConcurrent, 10)
-                : throttlingOptions.maxConcurrent,
-            minTime: typeof throttlingOptions.minTime === 'string'
-                ? Number.parseInt(throttlingOptions.minTime, 10)
-                : throttlingOptions.minTime,
-            highWater: throttlingOptions.highWater || 50,
-            strategy: throttlingOptions.strategy || bottleneck_1.default.strategy.OVERFLOW
-        });
-        this.internalThrottlingOptions = throttlingOptions;
-    }
     constructor(options = {}) {
         const defaults = options.defaults || {};
         const { ca, cert, key, passphrase, proxy, rejectUnauthorized = true, json = true } = defaults;
@@ -177,17 +118,19 @@ class PolarityRequest {
         if (options.requestOptionsToSanitize) {
             this.requestOptionsToSanitize = options.requestOptionsToSanitize;
         }
-        if (options.postprocessRequestFailure) {
-            this.postprocessRequestFailure = options.postprocessRequestFailure;
+        if (options.hooks) {
+            const h = options.hooks;
+            if (h.beforeRequest)
+                this.hooks.beforeRequest = h.beforeRequest;
+            if (h.afterResponse)
+                this.hooks.afterResponse = h.afterResponse;
+            if (h.onApiError)
+                this.hooks.onApiError = h.onApiError;
+            if (h.onNetworkError)
+                this.hooks.onNetworkError = h.onNetworkError;
         }
-        if (options.postprocessRequestSuccess) {
-            this.postprocessRequestSuccess = options.postprocessRequestSuccess;
-        }
-        if (options.preprocessRequestOptions) {
-            this.preprocessRequestOptions = options.preprocessRequestOptions;
-        }
-        if (options.throttlingOptions) {
-            this.throttlingOptions = options.throttlingOptions;
+        if (options.limiter) {
+            this.limiter = options.limiter;
         }
         const defaultRequestOptions = {
             ...(this.configFieldIsValid(ca) && { ca: fs_1.default.readFileSync(ca) }),
@@ -211,58 +154,87 @@ class PolarityRequest {
         if (!this.userOptions) {
             throw new errors_1.LibraryUsageError('PolarityRequest property `userOptions` must be set before calling `run` method');
         }
-        // Note that we specifically pass a copy of requestOptions to `preprocessRequestOptions`
-        // which lets the user modify the requestOptions object without affecting the original
-        const postprocessedRequestOptions = await this.preprocessRequestOptions({
-            ...requestOptions
-        }, this.userOptions);
-        let postprocessRequestResults;
-        try {
-            const httpResponse = await (this.bottleneckLimiter
-                ? this.bottleneckLimiter.schedule(this.requestWithDefaults, postprocessedRequestOptions)
-                : this.requestWithDefaults(postprocessedRequestOptions));
-            if (this.bottleneckLimiter) {
-                this.logger.trace({ httpResponse }, 'HTTP Response via Bottleneck');
-            }
-            else {
-                this.logger.trace({ httpResponse }, 'HTTP Response');
+        // Run beforeRequest hooks — each receives previous hook's output
+        let processedOptions = { ...requestOptions };
+        for (const hook of this.hooks.beforeRequest) {
+            const hookResult = await hook(processedOptions, this.userOptions);
+            if (!hookResult || typeof hookResult !== 'object' || Array.isArray(hookResult)) {
+                throw new errors_1.LibraryUsageError('Each `beforeRequest` hook must return an `HttpRequestOptions` object.');
             }
-            this.maybeThrowApiRequestError(httpResponse, postprocessedRequestOptions);
-            postprocessRequestResults = await this.postprocessRequestSuccess(httpResponse, postprocessedRequestOptions, this.userOptions);
+            processedOptions = hookResult;
+        }
+        let httpResponse;
+        try {
+            httpResponse = await (this.limiter
+                ? this.limiter.schedule(this.requestWithDefaults, processedOptions)
+                : this.requestWithDefaults(processedOptions));
         }
         catch (requestError) {
-            let transformedError = requestError;
             if (requestError instanceof errors_1.LibraryUsageError) {
                 throw requestError;
             }
-            if (!(requestError instanceof errors_1.ApiRequestError)) {
-                transformedError = new errors_1.NetworkError('Network error encountered during request', {
-                    cause: requestError,
-                    requestOptions: postprocessedRequestOptions,
+            let transformedError;
+            if (requestError instanceof Error &&
+                requestError.constructor.name === 'BottleneckError') {
+                transformedError = new errors_1.RetryRequestError('This request has been dropped for going over Integration Configured API Throttling Limits', {
+                    requestOptions: processedOptions,
                     requestOptionsToSanitize: this.requestOptionsToSanitize
                 });
             }
-            if (requestError instanceof bottleneck_1.default.BottleneckError) {
-                transformedError = new errors_1.RetryRequestError('This request has been dropped for going over Integration Configured API Throttling Limits', {
-                    requestOptions: postprocessedRequestOptions,
+            else {
+                transformedError = new errors_1.NetworkError('Network error encountered during request', {
+                    cause: requestError,
+                    requestOptions: processedOptions,
                     requestOptionsToSanitize: this.requestOptionsToSanitize
                 });
             }
-            // Possibly throws an error
-            await this.postprocessRequestFailure(transformedError, postprocessedRequestOptions, this.userOptions);
+            if (this.hooks.onNetworkError.length > 0) {
+                for (const hook of this.hooks.onNetworkError) {
+                    await hook(transformedError, processedOptions, this.userOptions);
+                }
+                return undefined;
+            }
+            throw transformedError;
         }
-        return postprocessRequestResults;
+        if (this.limiter) {
+            this.logger.trace({ httpResponse }, 'HTTP Response via limiter');
+        }
+        else {
+            this.logger.trace({ httpResponse }, 'HTTP Response');
+        }
+        // Check for API-level errors
+        const apiError = this.detectApiError(httpResponse, processedOptions);
+        if (apiError) {
+            if (this.hooks.onApiError.length > 0) {
+                for (const hook of this.hooks.onApiError) {
+                    await hook(apiError, httpResponse, processedOptions, this.userOptions);
+                }
+                return httpResponse;
+            }
+            throw apiError;
+        }
+        // Run afterResponse hooks — each receives previous hook's output
+        let result = httpResponse;
+        for (const hook of this.hooks.afterResponse) {
+            const hookResult = await hook(result, processedOptions, this.userOptions);
+            if (!hookResult || typeof hookResult !== 'object' || Array.isArray(hookResult)) {
+                throw new errors_1.LibraryUsageError('Each `afterResponse` hook must return an `HttpRequestResponse` object.');
+            }
+            result = hookResult;
+        }
+        return result;
     }
     /**
-     * Checks whether the HTTP response is an API error and throws an ApiRequestError if it is.
+     * Checks whether the HTTP response is an API error and returns an ApiRequestError if it is.
      *
      * @param httpResponse - The HTTP response from the Postman request.
      * @param requestOptions - The options used for the request.
+     * @returns An ApiRequestError if the response indicates an API error, undefined otherwise.
      *
-     * @throws {@link ApiRequestError}
-     * Throws an error if the response indicates an API error.
+     * @throws {@link LibraryUsageError}
+     * Throws if the `isApiError` function returns an invalid result.
      */
-    maybeThrowApiRequestError(httpResponse, requestOptions) {
+    detectApiError(httpResponse, requestOptions) {
         const { statusCode, body } = httpResponse;
         const requestOptionsWithoutSensitiveData = (0, sanitize_request_options_1.sanitizeRequestOptions)(requestOptions, this.requestOptionsToSanitize);
         this.logger.trace({
@@ -291,7 +263,7 @@ class PolarityRequest {
             message = this.getErrorMessageFromHttpResponse(body, 'Unexpected Error HTTP Response Received');
         }
         if (hasApiError) {
-            throw new errors_1.ApiRequestError(message, {
+            return new errors_1.ApiRequestError(message, {
                 status: statusCode.toString(),
                 requestOptions: requestOptionsWithoutSensitiveData,
                 requestOptionsToSanitize: this.requestOptionsToSanitize,
@@ -300,6 +272,7 @@ class PolarityRequest {
                 }
             });
         }
+        return undefined;
     }
     /**
      * Returns true if the `httpStatusCode` is not one of the rounded HTTP status codes
@@ -380,8 +353,10 @@ class PolarityRequest {
      * `requestId` property.
      *
      * @param options - An array of request options for running requests in parallel.
-     * @returns A promise that resolves to an array of responses.  If the `returnErrors` property is set to `true`
-     * then the response objects will have their `error` property set to the thrown error.
+     * @returns A promise that resolves to an array of responses in the same order as the input
+     * request options. If the `returnErrors` property is set to `true`, the response objects will
+     * have their `error` property set to the thrown error. If `onNetworkError` hooks are configured
+     * and suppress an error (return without throwing), the corresponding entry will be `undefined`.
      */
     async runInParallel(options) {
         const allRequestOptions = options.allRequestOptions;
@@ -396,14 +371,16 @@ class PolarityRequest {
             return async () => {
                 try {
                     const response = await this.run(requestOptions);
-                    if (requestOptions.entity) {
-                        response.entity = requestOptions.entity;
-                    }
-                    else if (requestOptions.entities) {
-                        response.entities = requestOptions.entities;
-                    }
-                    else if (requestOptions.requestId) {
-                        response.requestId = requestOptions.requestId;
+                    if (response) {
+                        if (requestOptions.entity) {
+                            response.entity = requestOptions.entity;
+                        }
+                        else if (requestOptions.entities) {
+                            response.entities = requestOptions.entities;
+                        }
+                        else if (requestOptions.requestId) {
+                            response.requestId = requestOptions.requestId;
+                        }
                     }
                     return response;
                 }

package/dist/lib/testing/enhanced-utils/create-entity.js

@@ -1,22 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEntity = void 0;
+function toEntityTypeIdentifier(type) {
+    if (type === 'IP')
+        return 'IPv4';
+    if (type.startsWith('custom.'))
+        return 'custom';
+    return type;
+}
+/**
+ * Creates a mock `Entity` for use in tests.
+ *
+ * Automatically detects whether the value is a domain or IPv4 address and sets
+ * the corresponding boolean flags. All other flags default to `false`.
+ *
+ * @param type - An `EntityType` string (e.g., `'IPv4'`, `'domain'`, `'MD5'`)
+ * @param value - The entity value string
+ * @returns A fully populated `Entity` object
+ *
+ * @example
+ * ```typescript
+ * const ip = createEntity('IPv4', '8.8.8.8');
+ * const domain = createEntity('domain', 'example.com');
+ * ```
+ */
 const createEntity = (type, value) => {
     const isDomain = /^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9](?:\.[a-zA-Z]{2,})+$/.test(value);
     const isIPv4 = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(value);
+    const isIPv6 = /^[\da-fA-F:]+$/.test(value) && value.includes(':');
     return {
         value,
+        rawValue: value,
         displayValue: value,
-        type,
+        type: toEntityTypeIdentifier(type),
         types: [type],
         isDomain,
         isIPv4,
-        isIP: isIPv4,
+        isIP: isIPv4 || isIPv6,
         isEmail: false,
         isHash: false,
         isHex: false,
         isHTMLTag: false,
-        isIPv6: false,
+        isIPv6,
         isMD5: false,
         isPrivateIP: false,
         isSHA1: false,
@@ -25,11 +50,12 @@ const createEntity = (type, value) => {
         isURL: false,
         latitude: 0,
         longitude: 0,
+        IPLong: 0,
         hashType: '',
-        IPType: isIPv4 ? 'IPv4' : '',
+        IPType: isIPv4 ? 'IPv4' : isIPv6 ? 'IPv6' : '',
         channels: [],
         requestContext: {
-            requestType: 'onDemand',
+            requestType: 'OnDemand',
             isUserInitiated: true
         }
     };