@rudderstack/integrations-lib 0.1.0

package/build/utils/sem.d.ts

@@ -0,0 +1,29 @@
+import { RudderStackEvent } from '../types';
+export declare class SemanticUtil {
+    /**
+     * Retrieves the `integrations` object for a specific destination in a given `RudderStackEvent` message.
+     * @param message - The RudderStackEvent message object.
+     * @param intgName - The destination name.
+     * @returns The `integrations` object for the specified destination, or null if not found.
+     */
+    static getIntegrationsObj(message: RudderStackEvent, intgName?: string): null;
+    /**
+     * Retrieves a destination-specific external ID from a given *message object.
+     * {
+     *    "context": {
+     *      "externalId": [
+     *        {
+     *          "type": "kustomerId",
+     *          "id": "12345678"
+     *        }
+     *      ]
+     *    }
+     * }
+     *
+     * @param {RudderStackEvent} message - The message object containing the external ID.
+     * @param {string} type - The type of the external ID to retrieve.
+     * @returns {unknown} - The destination-specific external ID, or null if not found.
+     */
+    static getDestinationExternalID(message: RudderStackEvent, type: string): unknown;
+}
+//# sourceMappingURL=sem.d.ts.map

package/build/utils/sem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sem.d.ts","sourceRoot":"","sources":["../../src/utils/sem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAwIxD,qBAAa,YAAY;IACvB;;;;;OAKG;WACW,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,QAAQ,GAAE,MAAW;IAoBjF;;;;;;;;;;;;;;;;OAgBG;WACW,wBAAwB,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;CAYzF"}

package/build/utils/sem.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticUtil = void 0;
+const lodash_1 = require("lodash");
+const get_value_1 = __importDefault(require("get-value"));
+const INTEGRATION_CANONICAL_NAMES = {
+    fb_pixel: [
+        'fb_pixel',
+        'fb pixel',
+        'FacebookPixel',
+        'Facebook Pixel',
+        'FB Pixel',
+        'Facebook_Pixel',
+    ],
+    ometria: ['Ometria', 'ometria', 'OMETRIA'],
+    sendgrid: ['sendgrid', 'Sendgrid', 'SENDGRID'],
+    dcm_floodlight: [
+        'dcm floodlight',
+        'dcm_floodlight',
+        'DCM Floodlight',
+        'DCM_Floodlight',
+        'DCMFloodlight',
+        'dcmfloodlight',
+    ],
+    new_relic: ['new relic', 'new_relic', 'New Relic', 'New_Relic', 'NewRelic', 'newrelic'],
+    attentive_tag: [
+        'attentive tag',
+        'attentive_tag',
+        'Attentive Tag',
+        'Attentive_Tag',
+        'AttentiveTag',
+        'attentivetag',
+    ],
+    webhook: ['webhook', 'Webhook', 'WebHook', 'WEBHOOK'],
+    mailchimp: ['mailchimp', 'MailChimp', 'MAILCHIMP'],
+    mautic: ['MAUTIC', 'mautic', 'Mautic'],
+    mailjet: ['MAILJET', 'MailJet', 'mailjet', 'Mailjet'],
+    kafka: ['KAFKA', 'kafka', 'Kafka'],
+    azure_event_hub: ['AZURE_EVENT_HUB', 'azure_event_hub', 'AzureEventHub'],
+    confluent_cloud: ['CONFLUENT_CLOUD', 'confluent_cloud', 'ConfluentCloud'],
+    vero: ['vero', 'Vero', 'VERO'],
+    pinterest: ['pinterest', 'Pinterest', 'PINTEREST', 'pinterestConversion'],
+    rockerbox: ['rockerbox', 'ROCKERBOX', 'Rockerbox', 'RockerBox', 'rockerBox'],
+    canny: ['canny', 'Canny', 'CANNY'],
+    one_signal: ['one signal', 'one_signal', 'One Signal', 'One_Signal', 'OneSignal', 'onesignal'],
+    wootric: ['wootric', 'Wootric', 'WOOTRIC'],
+    clickup: ['ClickUp', 'clickup', 'CLICKUP', 'clickUp', 'Clickup'],
+    zapier: ['zapier', 'Zapier', 'ZAPIER'],
+    shynet: ['shynet', 'SHYNET', 'shyNet', 'ShyNet'],
+    woopra: ['WOOPRA', 'Woopra', 'woopra'],
+    monday: ['monday', 'MONDAY', 'monDay', 'MonDay'],
+    mailmodo: [
+        'mail modo',
+        'mail_modo',
+        'Mail Modo',
+        'Mail_Modo',
+        'MailModo',
+        'mailmodo',
+        'MAILMODO',
+        'mailModo',
+    ],
+    user: ['user', 'USER', 'User', 'User.com', 'user.com', 'USER.com'],
+    engage: ['engage', 'Engage', 'ENGAGE'],
+    june: ['june', 'JUNE', 'June'],
+    factorsai: ['FACTORSAI', 'factorsAI', 'FactorsAi', 'factorsAi'],
+    snapchat_custom_audience: [
+        'snapchat custom audience',
+        'snap chat custom audience',
+        'snapchat_custom_audience',
+        'snapchatCustomAudience',
+        'Snapchat Custom Audience',
+        'snapchatcustomaudience',
+        'SNAPCHAT CUSTOM AUDIENCE',
+        'SNAPCHAT_CUSTOM_AUDIENCE',
+        'SNAPCHATCUSTOMAUDIENCE',
+    ],
+    CAMPAIGN_MANAGER: [
+        'campaign manager',
+        'campain Manager',
+        'CAMPAIGN MANAGER',
+        'campaignManager',
+        'campaign_manager',
+        'CAMPAIGN_MANAGER',
+    ],
+    gainsight_px: [
+        'GAINSIGHT_PX',
+        'GAINSIGHTPX',
+        'gainsightPx',
+        'Gainsight PX',
+        'gainsight px',
+        'Gainsight Px',
+    ],
+    awin: ['awin', 'Awin', 'AWIN'],
+    sendinblue: ['sendinblue', 'SENDINBLUE', 'Sendinblue', 'SendinBlue'],
+    ga4: ['GA4', 'ga4', 'Ga4', 'Google Analytics 4', 'googleAnalytics4'],
+    pipedream: ['Pipedream', 'PipeDream', 'pipedream', 'PIPEDREAM'],
+    pagerduty: ['pagerduty', 'PAGERDUTY', 'PagerDuty', 'Pagerduty', 'pagerDuty'],
+    adobe_analytics: [
+        'adobe_analytics',
+        'ADOBE_ANALYTICS',
+        'adobe analytics',
+        'adobeAnalytics',
+        'Adobe Analytics',
+        'adobeanalytics',
+        'ADOBE ANALYTICS',
+        'ADOBEANALYTICS',
+    ],
+    criteo_audience: [
+        'criteo audience',
+        'criteoAudience',
+        'Criteo Audience',
+        'criteoaudience',
+        'CRITEO AUDIENCE',
+        'CRITEO_AUDIENCE',
+        'CRITEOAUDIENCE',
+    ],
+    optimizely_fullstack: [
+        'Optimizely Fullstack',
+        'OPTIMIZELY FULLSTACK',
+        'optimizely fullstack',
+        'OptimizelyFullstack',
+        'Optimizely_Fullstack',
+        'optimizely_fullstack',
+    ],
+    vitally: ['vitally', 'Vitally', 'VITALLY'],
+    courier: ['Courier', 'courier', 'COURIER'],
+    TWITTER_ADS: [
+        'twitter ads',
+        'twitter Manager',
+        'TWITTER ADS',
+        'twitterADS',
+        'twitter_ads',
+        'TWITTER_ADS',
+    ],
+    BRAZE: ['BRAZE', 'Braze', 'braze'],
+};
+class SemanticUtil {
+    /**
+     * Retrieves the `integrations` object for a specific destination in a given `RudderStackEvent` message.
+     * @param message - The RudderStackEvent message object.
+     * @param intgName - The destination name.
+     * @returns The `integrations` object for the specified destination, or null if not found.
+     */
+    static getIntegrationsObj(message, intgName = '') {
+        if (!(0, lodash_1.isEmpty)(intgName)) {
+            const intgCanonicalNames = INTEGRATION_CANONICAL_NAMES[intgName];
+            if (!intgCanonicalNames) {
+                return null;
+            }
+            const intgObj = intgCanonicalNames.reduce((acc, canonicalName) => {
+                if ((0, get_value_1.default)(message, `integrations.${canonicalName}`)) {
+                    return (0, get_value_1.default)(message, `integrations.${canonicalName}`);
+                }
+                return acc;
+            }, null);
+            if (intgObj) {
+                return intgObj;
+            }
+        }
+        return null;
+    }
+    /**
+     * Retrieves a destination-specific external ID from a given *message object.
+     * {
+     *    "context": {
+     *      "externalId": [
+     *        {
+     *          "type": "kustomerId",
+     *          "id": "12345678"
+     *        }
+     *      ]
+     *    }
+     * }
+     *
+     * @param {RudderStackEvent} message - The message object containing the external ID.
+     * @param {string} type - The type of the external ID to retrieve.
+     * @returns {unknown} - The destination-specific external ID, or null if not found.
+     */
+    static getDestinationExternalID(message, type) {
+        const { context } = message;
+        const externalIdArray = context?.externalId ?? [];
+        let externalIdObj;
+        if (Array.isArray(externalIdArray)) {
+            externalIdObj = externalIdArray.find((extIdObj) => extIdObj?.type === type);
+        }
+        if (!externalIdObj) {
+            return null;
+        }
+        return externalIdObj.id;
+    }
+}
+exports.SemanticUtil = SemanticUtil;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sem.js","sourceRoot":"","sources":["../../src/utils/sem.ts"],"names":[],"mappings":"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","sourcesContent":["import { ExternalId, RudderStackEvent } from '../types';\nimport { isEmpty } from 'lodash';\nimport get from 'get-value';\n\nconst INTEGRATION_CANONICAL_NAMES: { [key: string]: string[] } = {\n  fb_pixel: [\n    'fb_pixel',\n    'fb pixel',\n    'FacebookPixel',\n    'Facebook Pixel',\n    'FB Pixel',\n    'Facebook_Pixel',\n  ],\n  ometria: ['Ometria', 'ometria', 'OMETRIA'],\n  sendgrid: ['sendgrid', 'Sendgrid', 'SENDGRID'],\n  dcm_floodlight: [\n    'dcm floodlight',\n    'dcm_floodlight',\n    'DCM Floodlight',\n    'DCM_Floodlight',\n    'DCMFloodlight',\n    'dcmfloodlight',\n  ],\n  new_relic: ['new relic', 'new_relic', 'New Relic', 'New_Relic', 'NewRelic', 'newrelic'],\n  attentive_tag: [\n    'attentive tag',\n    'attentive_tag',\n    'Attentive Tag',\n    'Attentive_Tag',\n    'AttentiveTag',\n    'attentivetag',\n  ],\n  webhook: ['webhook', 'Webhook', 'WebHook', 'WEBHOOK'],\n  mailchimp: ['mailchimp', 'MailChimp', 'MAILCHIMP'],\n  mautic: ['MAUTIC', 'mautic', 'Mautic'],\n  mailjet: ['MAILJET', 'MailJet', 'mailjet', 'Mailjet'],\n  kafka: ['KAFKA', 'kafka', 'Kafka'],\n  azure_event_hub: ['AZURE_EVENT_HUB', 'azure_event_hub', 'AzureEventHub'],\n  confluent_cloud: ['CONFLUENT_CLOUD', 'confluent_cloud', 'ConfluentCloud'],\n  vero: ['vero', 'Vero', 'VERO'],\n  pinterest: ['pinterest', 'Pinterest', 'PINTEREST', 'pinterestConversion'],\n  rockerbox: ['rockerbox', 'ROCKERBOX', 'Rockerbox', 'RockerBox', 'rockerBox'],\n  canny: ['canny', 'Canny', 'CANNY'],\n  one_signal: ['one signal', 'one_signal', 'One Signal', 'One_Signal', 'OneSignal', 'onesignal'],\n  wootric: ['wootric', 'Wootric', 'WOOTRIC'],\n  clickup: ['ClickUp', 'clickup', 'CLICKUP', 'clickUp', 'Clickup'],\n  zapier: ['zapier', 'Zapier', 'ZAPIER'],\n  shynet: ['shynet', 'SHYNET', 'shyNet', 'ShyNet'],\n  woopra: ['WOOPRA', 'Woopra', 'woopra'],\n  monday: ['monday', 'MONDAY', 'monDay', 'MonDay'],\n  mailmodo: [\n    'mail modo',\n    'mail_modo',\n    'Mail Modo',\n    'Mail_Modo',\n    'MailModo',\n    'mailmodo',\n    'MAILMODO',\n    'mailModo',\n  ],\n  user: ['user', 'USER', 'User', 'User.com', 'user.com', 'USER.com'],\n  engage: ['engage', 'Engage', 'ENGAGE'],\n  june: ['june', 'JUNE', 'June'],\n  factorsai: ['FACTORSAI', 'factorsAI', 'FactorsAi', 'factorsAi'],\n  snapchat_custom_audience: [\n    'snapchat custom audience',\n    'snap chat custom audience',\n    'snapchat_custom_audience',\n    'snapchatCustomAudience',\n    'Snapchat Custom Audience',\n    'snapchatcustomaudience',\n    'SNAPCHAT CUSTOM AUDIENCE',\n    'SNAPCHAT_CUSTOM_AUDIENCE',\n    'SNAPCHATCUSTOMAUDIENCE',\n  ],\n  CAMPAIGN_MANAGER: [\n    'campaign manager',\n    'campain Manager',\n    'CAMPAIGN MANAGER',\n    'campaignManager',\n    'campaign_manager',\n    'CAMPAIGN_MANAGER',\n  ],\n  gainsight_px: [\n    'GAINSIGHT_PX',\n    'GAINSIGHTPX',\n    'gainsightPx',\n    'Gainsight PX',\n    'gainsight px',\n    'Gainsight Px',\n  ],\n  awin: ['awin', 'Awin', 'AWIN'],\n  sendinblue: ['sendinblue', 'SENDINBLUE', 'Sendinblue', 'SendinBlue'],\n  ga4: ['GA4', 'ga4', 'Ga4', 'Google Analytics 4', 'googleAnalytics4'],\n  pipedream: ['Pipedream', 'PipeDream', 'pipedream', 'PIPEDREAM'],\n  pagerduty: ['pagerduty', 'PAGERDUTY', 'PagerDuty', 'Pagerduty', 'pagerDuty'],\n  adobe_analytics: [\n    'adobe_analytics',\n    'ADOBE_ANALYTICS',\n    'adobe analytics',\n    'adobeAnalytics',\n    'Adobe Analytics',\n    'adobeanalytics',\n    'ADOBE ANALYTICS',\n    'ADOBEANALYTICS',\n  ],\n  criteo_audience: [\n    'criteo audience',\n    'criteoAudience',\n    'Criteo Audience',\n    'criteoaudience',\n    'CRITEO AUDIENCE',\n    'CRITEO_AUDIENCE',\n    'CRITEOAUDIENCE',\n  ],\n  optimizely_fullstack: [\n    'Optimizely Fullstack',\n    'OPTIMIZELY FULLSTACK',\n    'optimizely fullstack',\n    'OptimizelyFullstack',\n    'Optimizely_Fullstack',\n    'optimizely_fullstack',\n  ],\n  vitally: ['vitally', 'Vitally', 'VITALLY'],\n  courier: ['Courier', 'courier', 'COURIER'],\n  TWITTER_ADS: [\n    'twitter ads',\n    'twitter Manager',\n    'TWITTER ADS',\n    'twitterADS',\n    'twitter_ads',\n    'TWITTER_ADS',\n  ],\n  BRAZE: ['BRAZE', 'Braze', 'braze'],\n};\n\nexport class SemanticUtil {\n  /**\n   * Retrieves the `integrations` object for a specific destination in a given `RudderStackEvent` message.\n   * @param message - The RudderStackEvent message object.\n   * @param intgName - The destination name.\n   * @returns The `integrations` object for the specified destination, or null if not found.\n   */\n  public static getIntegrationsObj(message: RudderStackEvent, intgName: string = '') {\n    if (!isEmpty(intgName)) {\n      const intgCanonicalNames = INTEGRATION_CANONICAL_NAMES[intgName];\n      if (!intgCanonicalNames) {\n        return null;\n      }\n      const intgObj = intgCanonicalNames.reduce((acc, canonicalName) => {\n        if (get(message, `integrations.${canonicalName}`)) {\n          return get(message, `integrations.${canonicalName}`);\n        }\n        return acc;\n      }, null);\n\n      if (intgObj) {\n        return intgObj;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Retrieves a destination-specific external ID from a given *message object.\n   * {\n   *    \"context\": {\n   *      \"externalId\": [\n   *        {\n   *          \"type\": \"kustomerId\",\n   *          \"id\": \"12345678\"\n   *        }\n   *      ]\n   *    }\n   * }\n   *\n   * @param {RudderStackEvent} message - The message object containing the external ID.\n   * @param {string} type - The type of the external ID to retrieve.\n   * @returns {unknown} - The destination-specific external ID, or null if not found.\n   */\n  public static getDestinationExternalID(message: RudderStackEvent, type: string): unknown {\n    const { context } = message;\n    const externalIdArray = context?.externalId ?? [];\n    let externalIdObj: ExternalId | undefined;\n    if (Array.isArray(externalIdArray)) {\n      externalIdObj = externalIdArray.find((extIdObj) => extIdObj?.type === type);\n    }\n    if (!externalIdObj) {\n      return null;\n    }\n    return externalIdObj.id;\n  }\n}\n"]}

package/build/utils/sem.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sem.test.d.ts.map

package/build/utils/sem.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sem.test.d.ts","sourceRoot":"","sources":["../../src/utils/sem.test.ts"],"names":[],"mappings":""}

package/build/utils/sem.test.js

@@ -0,0 +1,237 @@
+"use strict";
+// Generated by CodiumAI
+Object.defineProperty(exports, "__esModule", { value: true });
+const sem_1 = require("./sem");
+describe('SemanticUtil', () => {
+    describe('getIntegrationsObj', () => {
+        // Tests that 'getIntegrationsObj' returns the integrations object for a valid integration name
+        it('should return the integrations object for a valid integration name', () => {
+            const message = {
+                integrations: {
+                    fb_pixel: {
+                        key: 'value',
+                    },
+                },
+            };
+            const intgName = 'fb_pixel';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toEqual({ key: 'value' });
+        });
+        // Tests that 'getIntegrationsObj' returns null for an empty integration name
+        it('should return null for an empty integration name', () => {
+            const message = {
+                integrations: {
+                    fb_pixel: {
+                        key: 'value',
+                    },
+                },
+            };
+            const intgName = '';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toBeNull();
+        });
+        // Tests that 'getIntegrationsObj' returns null for an invalid integration name
+        it('should return null for an invalid integration name', () => {
+            const message = {
+                integrations: {
+                    fb_pixel: {
+                        key: 'value',
+                    },
+                },
+            };
+            const intgName = 'invalid_integration';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toBeNull();
+        });
+        // Tests that 'getIntegrationsObj' returns null when the integration name has multiple canonical names but none of them exist in the message.integrations object
+        it('should return null when the integration name has multiple canonical names but none of them exist in the message.integrations object', () => {
+            const message = {
+                integrations: {
+                    fb_pixel: {
+                        key: 'value',
+                    },
+                },
+            };
+            const intgName = 'invalid_integration';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toBeNull();
+        });
+        // Tests that 'getIntegrationsObj' returns null when the message object has no integrations object
+        it('should return null when the message object has no integrations object', () => {
+            const message = {};
+            const intgName = 'fb_pixel';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toBeNull();
+        });
+        // Tests that 'getIntegrationsObj' returns null when none of the canonical names for the integration name exist in the integrations object
+        it('should return null when none of the canonical names for the integration name exist in the integrations object', () => {
+            const message = {
+                integrations: {
+                    some_integration: {
+                        key: 'value',
+                    },
+                },
+            };
+            const intgName = 'fb_pixel';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toBeNull();
+        });
+        // Tests that 'getIntegrationsObj' returns null when the canonical name for the integration name exists in the integrations object but its value is null
+        it('should return null when the canonical name for the integration name exists in the integrations object but its value is null', () => {
+            const message = {
+                integrations: {
+                    fb_pixel: null,
+                },
+            };
+            const intgName = 'fb_pixel';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toBeNull();
+        });
+        // Tests that 'getIntegrationsObj' returns the integrations object for a valid integration name when the value is a number
+        it('should return the integrations object for a valid integration name when the value is a number', () => {
+            const message = {
+                integrations: {
+                    fb_pixel: 123,
+                },
+            };
+            const intgName = 'fb_pixel';
+            const result = sem_1.SemanticUtil.getIntegrationsObj(message, intgName);
+            expect(result).toEqual(123);
+        });
+    });
+    describe('getDestinationExternalID', () => {
+        // Returns the destination-specific external ID when it exists in the message context.
+        it('should return the destination-specific external ID when it exists in the message context', () => {
+            const message = {
+                context: {
+                    externalId: [
+                        {
+                            type: 'kustomerId',
+                            id: '12345678',
+                        },
+                    ],
+                },
+            };
+            const type = 'kustomerId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBe('12345678');
+        });
+        // Returns null when the destination-specific external ID does not exist in the message context.
+        it('should return null when the destination-specific external ID does not exist in the message context', () => {
+            const message = {
+                context: {
+                    externalId: [
+                        {
+                            type: 'kustomerId',
+                            id: '12345678',
+                        },
+                    ],
+                },
+            };
+            const type = 'otherId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeNull();
+        });
+        // Returns null when the message context is undefined.
+        it('should return null when the message context is undefined', () => {
+            const message = {};
+            const type = 'kustomerId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeNull();
+        });
+        // Returns null when the externalId array is not an array.
+        it('should return null when the externalId array is not an array', () => {
+            const message = {
+                context: {
+                    externalId: '12345678',
+                },
+            };
+            const type = 'kustomerId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeNull();
+        });
+        // Returns null when the externalId array is an empty array.
+        it('should return null when the externalId array is an empty array', () => {
+            const message = {
+                context: {
+                    externalId: [],
+                },
+            };
+            const type = 'kustomerId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeNull();
+        });
+        // Returns null when the externalId array does not contain an object with the specified type.
+        it('should return null when the externalId array does not contain an object with the specified type', () => {
+            const message = {
+                context: {
+                    externalId: [
+                        {
+                            type: 'kustomerId',
+                            id: '12345678',
+                        },
+                    ],
+                },
+            };
+            const type = 'nonExistentType';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeNull();
+        });
+        // Returns the first destination-specific external ID object with the specified type when multiple objects with the same type exist in the externalId array.
+        it('should return the destination-specific external ID when multiple objects with the same type exist in the externalId array', () => {
+            const message = {
+                context: {
+                    externalId: [
+                        {
+                            type: 'kustomerId',
+                            id: '12345678',
+                        },
+                        {
+                            type: 'kustomerId',
+                            id: '87654321',
+                        },
+                    ],
+                },
+            };
+            const type = 'kustomerId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBe('12345678');
+        });
+        // Returns null when the destination-specific external ID object does not have an id property.
+        it('should return null when the destination-specific external ID object does not have an id property', () => {
+            const message = {
+                context: {
+                    externalId: [
+                        {
+                            type: 'kustomerId',
+                            id: '12345678',
+                        },
+                        {
+                            type: 'otherId',
+                            // id property is missing
+                        },
+                    ],
+                },
+            };
+            const type = 'otherId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeUndefined();
+        });
+        // Returns null when the destination-specific external ID object does not have a type property.
+        it('should return null when the destination-specific external ID object does not have a type property', () => {
+            const message = {
+                context: {
+                    externalId: [
+                        {
+                            id: '12345678',
+                        },
+                    ],
+                },
+            };
+            const type = 'kustomerId';
+            const result = sem_1.SemanticUtil.getDestinationExternalID(message, type);
+            expect(result).toBeNull();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sem.test.js","sourceRoot":"","sources":["../../src/utils/sem.test.ts"],"names":[],"mappings":";AAAA,wBAAwB;;AAExB,+BAAqC;AAErC,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;IAC5B,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;QAClC,+FAA+F;QAC/F,EAAE,CAAC,oEAAoE,EAAE,GAAG,EAAE;YAC5E,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,QAAQ,EAAE;wBACR,GAAG,EAAE,OAAO;qBACb;iBACF;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,UAAU,CAAC;YAC5B,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,6EAA6E;QAC7E,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,QAAQ,EAAE;wBACR,GAAG,EAAE,OAAO;qBACb;iBACF;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,EAAE,CAAC;YACpB,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,+EAA+E;QAC/E,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,QAAQ,EAAE;wBACR,GAAG,EAAE,OAAO;qBACb;iBACF;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,qBAAqB,CAAC;YACvC,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,gKAAgK;QAChK,EAAE,CAAC,qIAAqI,EAAE,GAAG,EAAE;YAC7I,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,QAAQ,EAAE;wBACR,GAAG,EAAE,OAAO;qBACb;iBACF;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,qBAAqB,CAAC;YACvC,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,kGAAkG;QAClG,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;YAC/E,MAAM,OAAO,GAAG,EAAE,CAAC;YACnB,MAAM,QAAQ,GAAG,UAAU,CAAC;YAC5B,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,0IAA0I;QAC1I,EAAE,CAAC,+GAA+G,EAAE,GAAG,EAAE;YACvH,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,gBAAgB,EAAE;wBAChB,GAAG,EAAE,OAAO;qBACb;iBACF;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,UAAU,CAAC;YAC5B,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,wJAAwJ;QACxJ,EAAE,CAAC,6HAA6H,EAAE,GAAG,EAAE;YACrI,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,QAAQ,EAAE,IAAI;iBACf;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,UAAU,CAAC;YAC5B,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,0HAA0H;QAC1H,EAAE,CAAC,+FAA+F,EAAE,GAAG,EAAE;YACvG,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE;oBACZ,QAAQ,EAAE,GAAG;iBACd;aACF,CAAC;YACF,MAAM,QAAQ,GAAG,UAAU,CAAC;YAC5B,MAAM,MAAM,GAAG,kBAAY,CAAC,kBAAkB,CAAC,OAAc,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACxC,sFAAsF;QACtF,EAAE,CAAC,0FAA0F,EAAE,GAAG,EAAE;YAClG,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV;4BACE,IAAI,EAAE,YAAY;4BAClB,EAAE,EAAE,UAAU;yBACf;qBACF;iBACF;aACF,CAAC;YACF,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QAEH,gGAAgG;QAChG,EAAE,CAAC,oGAAoG,EAAE,GAAG,EAAE;YAC5G,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV;4BACE,IAAI,EAAE,YAAY;4BAClB,EAAE,EAAE,UAAU;yBACf;qBACF;iBACF;aACF,CAAC;YACF,MAAM,IAAI,GAAG,SAAS,CAAC;YACvB,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,sDAAsD;QACtD,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;YAClE,MAAM,OAAO,GAAG,EAAE,CAAC;YACnB,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,0DAA0D;QAC1D,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;YACtE,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE,UAAU;iBACvB;aACF,CAAC;YACF,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,4DAA4D;QAC5D,EAAE,CAAC,gEAAgE,EAAE,GAAG,EAAE;YACxE,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE,EAAE;iBACf;aACF,CAAC;YACF,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,6FAA6F;QAC7F,EAAE,CAAC,iGAAiG,EAAE,GAAG,EAAE;YACzG,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV;4BACE,IAAI,EAAE,YAAY;4BAClB,EAAE,EAAE,UAAU;yBACf;qBACF;iBACF;aACF,CAAC;YACF,MAAM,IAAI,GAAG,iBAAiB,CAAC;YAC/B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,4JAA4J;QAC5J,EAAE,CAAC,2HAA2H,EAAE,GAAG,EAAE;YACnI,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV;4BACE,IAAI,EAAE,YAAY;4BAClB,EAAE,EAAE,UAAU;yBACf;wBACD;4BACE,IAAI,EAAE,YAAY;4BAClB,EAAE,EAAE,UAAU;yBACf;qBACF;iBACF;aACF,CAAC;YACF,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QAEH,8FAA8F;QAC9F,EAAE,CAAC,kGAAkG,EAAE,GAAG,EAAE;YAC1G,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV;4BACE,IAAI,EAAE,YAAY;4BAClB,EAAE,EAAE,UAAU;yBACf;wBACD;4BACE,IAAI,EAAE,SAAS;4BACf,yBAAyB;yBAC1B;qBACF;iBACF;aACF,CAAC;YACF,MAAM,IAAI,GAAG,SAAS,CAAC;YACvB,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,+FAA+F;QAC/F,EAAE,CAAC,mGAAmG,EAAE,GAAG,EAAE;YAC3G,MAAM,OAAO,GAAG;gBACd,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV;4BACE,EAAE,EAAE,UAAU;yBACf;qBACF;iBACF;aACF,CAAC;YACF,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,kBAAY,CAAC,wBAAwB,CAAC,OAAc,EAAE,IAAI,CAAC,CAAC;YAC3E,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["// Generated by CodiumAI\n\nimport { SemanticUtil } from './sem';\n\ndescribe('SemanticUtil', () => {\n  describe('getIntegrationsObj', () => {\n    // Tests that 'getIntegrationsObj' returns the integrations object for a valid integration name\n    it('should return the integrations object for a valid integration name', () => {\n      const message = {\n        integrations: {\n          fb_pixel: {\n            key: 'value',\n          },\n        },\n      };\n      const intgName = 'fb_pixel';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toEqual({ key: 'value' });\n    });\n\n    // Tests that 'getIntegrationsObj' returns null for an empty integration name\n    it('should return null for an empty integration name', () => {\n      const message = {\n        integrations: {\n          fb_pixel: {\n            key: 'value',\n          },\n        },\n      };\n      const intgName = '';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toBeNull();\n    });\n\n    // Tests that 'getIntegrationsObj' returns null for an invalid integration name\n    it('should return null for an invalid integration name', () => {\n      const message = {\n        integrations: {\n          fb_pixel: {\n            key: 'value',\n          },\n        },\n      };\n      const intgName = 'invalid_integration';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toBeNull();\n    });\n\n    // Tests that 'getIntegrationsObj' returns null when the integration name has multiple canonical names but none of them exist in the message.integrations object\n    it('should return null when the integration name has multiple canonical names but none of them exist in the message.integrations object', () => {\n      const message = {\n        integrations: {\n          fb_pixel: {\n            key: 'value',\n          },\n        },\n      };\n      const intgName = 'invalid_integration';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toBeNull();\n    });\n\n    // Tests that 'getIntegrationsObj' returns null when the message object has no integrations object\n    it('should return null when the message object has no integrations object', () => {\n      const message = {};\n      const intgName = 'fb_pixel';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toBeNull();\n    });\n\n    // Tests that 'getIntegrationsObj' returns null when none of the canonical names for the integration name exist in the integrations object\n    it('should return null when none of the canonical names for the integration name exist in the integrations object', () => {\n      const message = {\n        integrations: {\n          some_integration: {\n            key: 'value',\n          },\n        },\n      };\n      const intgName = 'fb_pixel';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toBeNull();\n    });\n\n    // Tests that 'getIntegrationsObj' returns null when the canonical name for the integration name exists in the integrations object but its value is null\n    it('should return null when the canonical name for the integration name exists in the integrations object but its value is null', () => {\n      const message = {\n        integrations: {\n          fb_pixel: null,\n        },\n      };\n      const intgName = 'fb_pixel';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toBeNull();\n    });\n\n    // Tests that 'getIntegrationsObj' returns the integrations object for a valid integration name when the value is a number\n    it('should return the integrations object for a valid integration name when the value is a number', () => {\n      const message = {\n        integrations: {\n          fb_pixel: 123,\n        },\n      };\n      const intgName = 'fb_pixel';\n      const result = SemanticUtil.getIntegrationsObj(message as any, intgName);\n      expect(result).toEqual(123);\n    });\n  });\n\n  describe('getDestinationExternalID', () => {\n    // Returns the destination-specific external ID when it exists in the message context.\n    it('should return the destination-specific external ID when it exists in the message context', () => {\n      const message = {\n        context: {\n          externalId: [\n            {\n              type: 'kustomerId',\n              id: '12345678',\n            },\n          ],\n        },\n      };\n      const type = 'kustomerId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBe('12345678');\n    });\n\n    // Returns null when the destination-specific external ID does not exist in the message context.\n    it('should return null when the destination-specific external ID does not exist in the message context', () => {\n      const message = {\n        context: {\n          externalId: [\n            {\n              type: 'kustomerId',\n              id: '12345678',\n            },\n          ],\n        },\n      };\n      const type = 'otherId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeNull();\n    });\n\n    // Returns null when the message context is undefined.\n    it('should return null when the message context is undefined', () => {\n      const message = {};\n      const type = 'kustomerId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeNull();\n    });\n\n    // Returns null when the externalId array is not an array.\n    it('should return null when the externalId array is not an array', () => {\n      const message = {\n        context: {\n          externalId: '12345678',\n        },\n      };\n      const type = 'kustomerId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeNull();\n    });\n\n    // Returns null when the externalId array is an empty array.\n    it('should return null when the externalId array is an empty array', () => {\n      const message = {\n        context: {\n          externalId: [],\n        },\n      };\n      const type = 'kustomerId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeNull();\n    });\n\n    // Returns null when the externalId array does not contain an object with the specified type.\n    it('should return null when the externalId array does not contain an object with the specified type', () => {\n      const message = {\n        context: {\n          externalId: [\n            {\n              type: 'kustomerId',\n              id: '12345678',\n            },\n          ],\n        },\n      };\n      const type = 'nonExistentType';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeNull();\n    });\n\n    // Returns the first destination-specific external ID object with the specified type when multiple objects with the same type exist in the externalId array.\n    it('should return the destination-specific external ID when multiple objects with the same type exist in the externalId array', () => {\n      const message = {\n        context: {\n          externalId: [\n            {\n              type: 'kustomerId',\n              id: '12345678',\n            },\n            {\n              type: 'kustomerId',\n              id: '87654321',\n            },\n          ],\n        },\n      };\n      const type = 'kustomerId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBe('12345678');\n    });\n\n    // Returns null when the destination-specific external ID object does not have an id property.\n    it('should return null when the destination-specific external ID object does not have an id property', () => {\n      const message = {\n        context: {\n          externalId: [\n            {\n              type: 'kustomerId',\n              id: '12345678',\n            },\n            {\n              type: 'otherId',\n              // id property is missing\n            },\n          ],\n        },\n      };\n      const type = 'otherId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeUndefined();\n    });\n\n    // Returns null when the destination-specific external ID object does not have a type property.\n    it('should return null when the destination-specific external ID object does not have a type property', () => {\n      const message = {\n        context: {\n          externalId: [\n            {\n              id: '12345678',\n            },\n          ],\n        },\n      };\n      const type = 'kustomerId';\n      const result = SemanticUtil.getDestinationExternalID(message as any, type);\n      expect(result).toBeNull();\n    });\n  });\n});\n"]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@rudderstack/integrations-lib",
+  "version": "0.1.0",
+  "description": "",
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "copy": "find ./src -name '*.yaml' -o -name '*.csv' | cpio -pdm ./build",
+    "build:ci": "tsc -p tsconfig.json",
+    "build": "npm run build:ci && npm run copy",
+    "clean": "rm -rf ./build",
+    "clean:build": "npm run clean && npm run build",
+    "test": "jest --coverage --verbose"
+  },
+  "pre-commit": [
+    "clean:build",
+    "test"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rudderlabs/rudder-integrations-lib"
+  },
+  "keywords": [
+    "rudder",
+    "rudderstack",
+    "cdp",
+    "workflow",
+    "engine"
+  ],
+  "author": "RudderStack",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.4.0",
+    "crypto": "^1.0.1",
+    "get-value": "^3.0.1",
+    "handlebars": "^4.7.8",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.4",
+    "moment-timezone": "^0.5.43",
+    "rudder-workflow-engine": "file:../rudder-workflow-engine",
+    "set-value": "^4.1.0",
+    "sha256": "^0.2.0",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@types/get-value": "^3.0.3",
+    "@types/jest": "^29.5.4",
+    "@types/lodash": "^4.14.195",
+    "@types/node": "^20.3.3",
+    "@types/set-value": "^4.0.1",
+    "@types/sha256": "^0.2.0",
+    "axios-mock-adapter": "^1.21.5",
+    "jest": "^29.4.3",
+    "pre-commit": "^1.2.2",
+    "prettier": "^2.8.4",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  },
+  "files": [
+    "build",
+    "LICENSE",
+    "README.md"
+  ]
+}