@rudderstack/integrations-lib 0.2.34 → 0.2.35

package/build/sdks/sfmc/index.d.ts

@@ -1,4 +1,4 @@
-import { AuthObject, BusinessUnit, ContactAttributesResponse, CreateDataExtensionResponse, DataExtension, DataExtensionBody, DataFolder } from './type';
+import { AuthObject, BusinessUnit, ContactAttributesResponse, CreateDataExtensionResponse, DataExtension, DataExtensionBody, DataFolder, EventDefinition, ContactAttributes, DataExtensionApiResponse } from './type';
 import { RestError, SoapError } from './utils';
 export default class SFMC {
     authObject: AuthObject;
@@ -17,9 +17,12 @@ export default class SFMC {
     getDestinationFields(dataExtensionId: string): Promise<DataExtensionBody | RestError>;
     /**
      * This method fetches the contact attributes. The method returns the contact attributes. If the contact attributes are not found, it returns a RestError.
-     * @returns
+     * @param page Page number
+     * @param pageSize Page size
+     * @returns {Promise<ContactAttributesResponse | RestError>}
      */
-    getContactAttributes(): Promise<ContactAttributesResponse | RestError>;
+    getContactAttributesItems(page: number, pageSize: number): Promise<ContactAttributesResponse | RestError>;
+    getContactAttributes(): Promise<ContactAttributes[] | RestError>;
     /**
      * This method creates a data extension. It requires the data extension fields. The method returns the data extension created. If the data extension is not created, it returns a RestError.
      * @param body DataExtension fields
@@ -43,5 +46,25 @@ export default class SFMC {
      * @returns
      */
     getDataExtensions(dataFolderId?: string): Promise<DataExtension[] | SoapError>;
+    private static mapDataExtension;
+    /**
+     * This function fetches the data extension by id. It returns the data extension. If the data extension is not found, it returns a RestError.
+     * @param dataExtensionId Id of the data extension
+     * @returns {Promise<DataExtension | RestError>}
+     */
+    getDataExtensionById(dataExtensionId: string): Promise<DataExtensionApiResponse | RestError>;
+    /**
+     * This function fetches the event definitions. It returns the event definitions. If the event definitions are not found, it returns a RestError.
+     * @param page Page number
+     * @param pageSize Page size
+     * @returns {Promise<EventDefinitionsResponse | RestError>}
+     */
+    private getEventDefinitions;
+    /**
+     * This function fetches all the event definitions. It returns the event definitions. If the event definitions are not found, it returns a RestError.
+     * @returns {Promise<EventDefinition[] | RestError>}
+     */
+    getAllEventDefinitions(): Promise<EventDefinition[] | RestError>;
+    private static getAllItemFromPages;
 }
 //# sourceMappingURL=index.d.ts.map

package/build/sdks/sfmc/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdks/sfmc/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,YAAY,EAEZ,yBAAyB,EACzB,2BAA2B,EAC3B,aAAa,EACb,iBAAiB,EAEjB,UAAU,EAEX,MAAM,QAAQ,CAAC;AAChB,OAAO,EAML,SAAS,EACT,SAAS,EAEV,MAAM,SAAS,CAAC;AAEjB,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,UAAU,EAAE,UAAU,CAAC;gBAEX,UAAU,EAAE,UAAU;IAKlC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAiCjC;;;OAGG;IACG,cAAc;IAWpB;;;;OAIG;IACG,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAsB3F;;;OAGG;IACG,oBAAoB,IAAI,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IAsB5E;;;;OAIG;IACG,mBAAmB,CACvB,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;IAmBnD;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,GAAG,SAAS,CAAC;IAqD7D;;;;OAIG;IACG,cAAc,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,GAAG,SAAS,CAAC;IAwChF;;;;OAIG;IACG,iBAAiB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,GAAG,SAAS,CAAC;CAiDrF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdks/sfmc/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,YAAY,EAEZ,yBAAyB,EACzB,2BAA2B,EAC3B,aAAa,EACb,iBAAiB,EAEjB,UAAU,EAEV,eAAe,EAEf,iBAAiB,EAEjB,wBAAwB,EACzB,MAAM,QAAQ,CAAC;AAChB,OAAO,EAML,SAAS,EACT,SAAS,EAEV,MAAM,SAAS,CAAC;AAEjB,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,UAAU,EAAE,UAAU,CAAC;gBAEX,UAAU,EAAE,UAAU;IAKlC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAiCjC;;;OAGG;IACG,cAAc;IAWpB;;;;OAIG;IACG,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAsB3F;;;;;OAKG;IACG,yBAAyB,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IAsB3C,oBAAoB,IAAI,OAAO,CAAC,iBAAiB,EAAE,GAAG,SAAS,CAAC;IAOtE;;;;OAIG;IACG,mBAAmB,CACvB,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;IAmBnD;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,GAAG,SAAS,CAAC;IAqD7D;;;;OAIG;IACG,cAAc,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,GAAG,SAAS,CAAC;IAwChF;;;;OAIG;IACG,iBAAiB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,GAAG,SAAS,CAAC;IA8CpF,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAyB/B;;;;OAIG;IACG,oBAAoB,CACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,wBAAwB,GAAG,SAAS,CAAC;IAsBhD;;;;;OAKG;YACW,mBAAmB;IAuBjC;;;OAGG;IACG,sBAAsB,IAAI,OAAO,CAAC,eAAe,EAAE,GAAG,SAAS,CAAC;mBAOjD,mBAAmB;CA6BzC"}

package/build/sdks/sfmc/index.js

@@ -83,9 +83,11 @@ class SFMC {
     }
     /**
      * This method fetches the contact attributes. The method returns the contact attributes. If the contact attributes are not found, it returns a RestError.
-     * @returns
+     * @param page Page number
+     * @param pageSize Page size
+     * @returns {Promise<ContactAttributesResponse | RestError>}
      */
-    async getContactAttributes() {
+    async getContactAttributesItems(page, pageSize) {
         try {
             const restHeaders = {
                 Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,
@@ -93,7 +95,7 @@ class SFMC {
             const requestOptions = {
                 method: 'GET',
                 baseURL: (0, utils_1.getUrl)(this.authObject.subDomain),
-                url: '/contacts/v1/attributeSetDefinitions',
+                url: `/contacts/v1/attributeSetDefinitions?$page=${page}&$pageSize=${pageSize}`,
                 headers: restHeaders,
             };
             const resp = await (0, axios_1.default)(requestOptions);
@@ -107,6 +109,10 @@ class SFMC {
             throw err;
         }
     }
+    async getContactAttributes() {
+        const contactAttributes = await SFMC.getAllItemFromPages(this.getContactAttributesItems.bind(this));
+        return contactAttributes;
+    }
     /**
      * This method creates a data extension. It requires the data extension fields. The method returns the data extension created. If the data extension is not created, it returns a RestError.
      * @param body DataExtension fields
@@ -244,8 +250,8 @@ class SFMC {
                     'Content-Type': 'text/xml',
                 },
                 data: dataFolderId
-                    ? await (0, utils_1.xmlBuilder)('DataExtension', ['NAME', 'ObjectId', 'CategoryId'], accessToken, (0, utils_1.parseFilter)({ leftOperand: 'CategoryId', rightOperand: dataFolderId }))
-                    : await (0, utils_1.xmlBuilder)('DataExtension', ['NAME', 'ObjectId', 'CategoryId'], accessToken),
+                    ? await (0, utils_1.xmlBuilder)('DataExtension', ['NAME', 'ObjectId', 'CategoryId', 'CustomerKey', 'IsSendable'], accessToken, (0, utils_1.parseFilter)({ leftOperand: 'CategoryId', rightOperand: dataFolderId }))
+                    : await (0, utils_1.xmlBuilder)('DataExtension', ['NAME', 'ObjectId', 'CategoryId', 'CustomerKey', 'IsSendable'], accessToken),
             };
             const resp = await (0, axios_1.default)(requestOptions);
             const parsedData = (0, utils_1.parseXML)(resp.data);
@@ -254,19 +260,11 @@ class SFMC {
             if (res) {
                 if (Array.isArray(res)) {
                     res.forEach((eachRes) => {
-                        dataExtensions.push({
-                            ObjectId: eachRes.PartnerProperties[0].Value,
-                            Name: eachRes.PartnerProperties[1].Value,
-                            CategoryId: eachRes.PartnerProperties[2].Value,
-                        });
+                        dataExtensions.push(SFMC.mapDataExtension(eachRes));
                     });
                 }
                 else {
-                    dataExtensions.push({
-                        ObjectId: res.PartnerProperties[0].Value,
-                        Name: res.PartnerProperties[1].Value,
-                        CategoryId: res.PartnerProperties[2].Value,
-                    });
+                    dataExtensions.push(SFMC.mapDataExtension(res));
                 }
                 return dataExtensions;
             }
@@ -276,6 +274,100 @@ class SFMC {
             throw new utils_1.SoapError(err);
         }
     }
+    static mapDataExtension(dataExtension) {
+        const getProperty = (props, name) => {
+            const property = props.find((prop) => prop.Name === name);
+            if (!property) {
+                throw new Error(`Missing required property: ${name}`);
+            }
+            return property.Value;
+        };
+        const { PartnerProperties } = dataExtension;
+        return {
+            ObjectId: getProperty(PartnerProperties, 'ObjectId'),
+            Name: getProperty(PartnerProperties, 'NAME'),
+            CategoryId: getProperty(PartnerProperties, 'CategoryId'),
+            ExternalKey: dataExtension.CustomerKey,
+            IsSendable: dataExtension.IsSendable,
+        };
+    }
+    /**
+     * This function fetches the data extension by id. It returns the data extension. If the data extension is not found, it returns a RestError.
+     * @param dataExtensionId Id of the data extension
+     * @returns {Promise<DataExtension | RestError>}
+     */
+    async getDataExtensionById(dataExtensionId) {
+        try {
+            const accessToken = (await this.getAccessToken()).access_token;
+            const requestOptions = {
+                method: 'GET',
+                baseURL: (0, utils_1.getUrl)(this.authObject.subDomain),
+                url: `/data/v1/customobjects/${dataExtensionId}`,
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            };
+            const resp = await (0, axios_1.default)(requestOptions);
+            return resp.data;
+        }
+        catch (err) {
+            if (axios_1.default.isAxiosError(err)) {
+                const axiosError = err;
+                throw new utils_1.RestError(axiosError);
+            }
+            throw err;
+        }
+    }
+    /**
+     * This function fetches the event definitions. It returns the event definitions. If the event definitions are not found, it returns a RestError.
+     * @param page Page number
+     * @param pageSize Page size
+     * @returns {Promise<EventDefinitionsResponse | RestError>}
+     */
+    async getEventDefinitions(page, pageSize) {
+        try {
+            const accessToken = (await this.getAccessToken()).access_token;
+            const requestOptions = {
+                method: 'GET',
+                baseURL: (0, utils_1.getUrl)(this.authObject.subDomain),
+                url: `/interaction/v1/eventDefinitions?$page=${page}&$pageSize=${pageSize}`,
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            };
+            const resp = await (0, axios_1.default)(requestOptions);
+            return resp.data;
+        }
+        catch (err) {
+            throw new utils_1.RestError(err);
+        }
+    }
+    /**
+     * This function fetches all the event definitions. It returns the event definitions. If the event definitions are not found, it returns a RestError.
+     * @returns {Promise<EventDefinition[] | RestError>}
+     */
+    async getAllEventDefinitions() {
+        const eventDefinitions = await SFMC.getAllItemFromPages(this.getEventDefinitions.bind(this));
+        return eventDefinitions;
+    }
+    static async getAllItemFromPages(getItems, pageSize = 50) {
+        // Get first page to determine total count
+        const firstPage = await getItems(1, pageSize);
+        if (firstPage instanceof utils_1.RestError) {
+            throw firstPage;
+        }
+        const totalPages = Math.ceil(firstPage.count / pageSize);
+        const remainingPages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+        const remainingResults = await Promise.all(remainingPages.map(async (page) => {
+            const result = await getItems(page, pageSize);
+            if (result instanceof utils_1.RestError) {
+                throw result;
+            }
+            return result;
+        }));
+        const allResults = [firstPage, ...remainingResults];
+        return allResults.flatMap((result) => (result instanceof utils_1.RestError ? [] : result.items));
+    }
 }
 exports.default = SFMC;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/sdks/sfmc/index.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosError } from 'axios';\nimport {\n  AuthObject,\n  BusinessUnit,\n  BusinessUnitResponse,\n  ContactAttributesResponse,\n  CreateDataExtensionResponse,\n  DataExtension,\n  DataExtensionBody,\n  DataExtensionResponse,\n  DataFolder,\n  SFMCErrorResponse,\n} from './type';\nimport {\n  getUrl,\n  isExpired,\n  parseFilter,\n  parseXML,\n  getToken,\n  RestError,\n  SoapError,\n  xmlBuilder,\n} from './utils';\n\nexport default class SFMC {\n  authObject: AuthObject;\n\n  constructor(authObject: AuthObject) {\n    SFMC.validateAuthObject(authObject);\n    this.authObject = authObject;\n  }\n\n  private static validateAuthObject(authObject: any): any {\n    if (!authObject) {\n      throw new Error('authObject is required. See the readme.');\n    }\n\n    const validations = [\n      { key: 'clientId', type: 'string', required: true },\n      { key: 'clientSecret', type: 'string', required: true },\n      {\n        key: 'subDomain',\n        type: 'string',\n        required: true,\n        regex: /^\\w{28}$/gm,\n        regexMessage: 'subDomain must be a string of length 28',\n      },\n    ];\n\n    validations.forEach(({ key, type, required, regex, regexMessage }) => {\n      const value = authObject[key];\n      if (required && !value) {\n        throw new Error(`${key} is missing or invalid`);\n      }\n      if (typeof value !== type) {\n        throw new TypeError(`${key} must be a ${type}`);\n      }\n      if (regex && !regex.test(value)) {\n        throw new Error(regexMessage || `${key} does not match the required format`);\n      }\n    });\n\n    return authObject;\n  }\n\n  /**\n   * This function returns the access token. If the token is expired, it will generate a new token.\n   * @returns {Promise<AuthObject>}  It returns the access token or error\n   */\n  async getAccessToken() {\n    if (isExpired(this.authObject)) {\n      try {\n        await getToken(this.authObject);\n      } catch (e) {\n        throw new Error(`Unable to generate token, with error:${e}`);\n      }\n    }\n    return this.authObject;\n  }\n\n  /**\n   * This method fetches the fields of a data extension. It requires the data extension id. The method returns the fields of the data extension. If the data extension is not found, it returns a RestError.\n   * @param dataExtensionId Id of the data extension whose fields are to be fetched\n   * @returns\n   */\n  async getDestinationFields(dataExtensionId: string): Promise<DataExtensionBody | RestError> {\n    try {\n      const restHeaders = {\n        Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,\n      };\n      const requestOptions = {\n        method: 'GET',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: `/data/v1/customobjects/${dataExtensionId}/fields`,\n        headers: restHeaders,\n      };\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err) {\n      if (axios.isAxiosError(err)) {\n        const axiosError = err as AxiosError<SFMCErrorResponse>;\n        throw new RestError(axiosError);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * This method fetches the contact attributes. The method returns the contact attributes. If the contact attributes are not found, it returns a RestError.\n   * @returns\n   */\n  async getContactAttributes(): Promise<ContactAttributesResponse | RestError> {\n    try {\n      const restHeaders = {\n        Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,\n      };\n      const requestOptions = {\n        method: 'GET',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: '/contacts/v1/attributeSetDefinitions',\n        headers: restHeaders,\n      };\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err) {\n      if (axios.isAxiosError(err)) {\n        const axiosError = err as AxiosError<SFMCErrorResponse>;\n        throw new RestError(axiosError);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * This method creates a data extension. It requires the data extension fields. The method returns the data extension created. If the data extension is not created, it returns a RestError.\n   * @param body DataExtension fields\n   * @returns\n   */\n  async createDataExtension(\n    body: DataExtensionBody,\n  ): Promise<CreateDataExtensionResponse | RestError> {\n    try {\n      const restHeaders = {\n        Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,\n      };\n      const requestOptions = {\n        method: 'POST',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: '/data/v1/customobjects',\n        headers: restHeaders,\n        data: body,\n      };\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err: any) {\n      throw new RestError(err);\n    }\n  }\n\n  /**\n   * This method fetches the business units. The method returns the business units. If the business units are not found, it returns a SoapError.\n   * @returns\n   */\n  async getBusinessUnits(): Promise<BusinessUnit[] | SoapError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'POST',\n        baseURL: `https://${this.authObject.subDomain}.soap.marketingcloudapis.com`,\n        url: '/Service.asmx',\n        headers: {\n          SOAPAction: 'Retrieve',\n          'Content-Type': 'text/xml',\n        },\n        data: await xmlBuilder('BusinessUnit', ['name', 'id'], accessToken),\n      };\n      const resp = await axios(requestOptions);\n      const parsedData = parseXML(resp.data);\n      const res = parsedData.RetrieveResponseMsg?.Results as\n        | BusinessUnitResponse\n        | BusinessUnitResponse[];\n      const businessUnits: BusinessUnit[] = [];\n      if (res) {\n        const createBusinessUnit = (response: BusinessUnitResponse) => {\n          const { PartnerProperties } = response;\n          const entry = {} as BusinessUnit;\n          PartnerProperties.forEach((prop) => {\n            switch (prop.Name) {\n              case 'name':\n                entry.Name = prop.Value as string;\n                break;\n              case 'id':\n                entry.ID = prop.Value as number;\n                break;\n              default:\n                throw new SoapError(`Unknown property: ${prop}`);\n            }\n          });\n          return entry;\n        };\n\n        if (Array.isArray(res)) {\n          res.forEach((eachRes) => {\n            businessUnits.push(createBusinessUnit(eachRes));\n          });\n        } else {\n          businessUnits.push(createBusinessUnit(res));\n        }\n        return businessUnits;\n      }\n      throw new SoapError('No Business Units found');\n    } catch (err) {\n      throw new SoapError(err);\n    }\n  }\n\n  /**\n   * This method fetches the data folders. It business unit id is provided all data folder under that business id would be retrieved otherwise all the data folder will be retrieved. The method returns the data folders. If the data folders are not found, it returns a SoapError.\n   * @param businessUnitId this is the id of the business unit\n   * @returns\n   */\n  async getDataFolders(businessUnitId?: string): Promise<DataFolder[] | SoapError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'POST',\n        baseURL: `https://${this.authObject.subDomain}.soap.marketingcloudapis.com`,\n        url: '/Service.asmx',\n        headers: {\n          SOAPAction: 'Retrieve',\n          'Content-Type': 'text/xml',\n        },\n        data: businessUnitId\n          ? await xmlBuilder(\n              'DataFolder',\n              ['Name', 'ID', 'ParentFolder.ID'],\n              accessToken,\n              parseFilter({ leftOperand: 'Client.ID', rightOperand: businessUnitId }),\n            )\n          : await xmlBuilder('DataFolder', ['Name', 'ID', 'ParentFolder.ID'], accessToken),\n      };\n      const resp = await axios(requestOptions);\n      const parsedData = parseXML(resp.data);\n      const res = parsedData.RetrieveResponseMsg?.Results as DataFolder | DataFolder[];\n      const dataFolders: DataFolder[] = [];\n      if (res) {\n        if (Array.isArray(res)) {\n          res.forEach((eachRes) => {\n            dataFolders.push(eachRes);\n          });\n        } else {\n          dataFolders.push(res);\n        }\n        return dataFolders;\n      }\n      throw new SoapError('No Data Folder found');\n    } catch (err) {\n      throw new SoapError(err);\n    }\n  }\n\n  /**\n   * This function fetches the data extensions. It the data folder id is provided all the data extension under that data folder will be retrieved otherwise all the data extensions under the access token will be fetched. The method returns the data extensions. If the data extensions are not found, it returns a SoapError.\n   * @param dataFolderId Id of the data folder\n   * @returns\n   */\n  async getDataExtensions(dataFolderId?: string): Promise<DataExtension[] | SoapError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'POST',\n        baseURL: `https://${this.authObject.subDomain}.soap.marketingcloudapis.com`,\n        url: '/Service.asmx',\n        headers: {\n          SOAPAction: 'Retrieve',\n          'Content-Type': 'text/xml',\n        },\n        data: dataFolderId\n          ? await xmlBuilder(\n              'DataExtension',\n              ['NAME', 'ObjectId', 'CategoryId'],\n              accessToken,\n              parseFilter({ leftOperand: 'CategoryId', rightOperand: dataFolderId }),\n            )\n          : await xmlBuilder('DataExtension', ['NAME', 'ObjectId', 'CategoryId'], accessToken),\n      };\n      const resp = await axios(requestOptions);\n      const parsedData = parseXML(resp.data);\n      const res = parsedData.RetrieveResponseMsg?.Results as\n        | DataExtensionResponse\n        | DataExtensionResponse[];\n      const dataExtensions: DataExtension[] = [];\n      if (res) {\n        if (Array.isArray(res)) {\n          res.forEach((eachRes) => {\n            dataExtensions.push({\n              ObjectId: eachRes.PartnerProperties[0].Value,\n              Name: eachRes.PartnerProperties[1].Value,\n              CategoryId: eachRes.PartnerProperties[2].Value,\n            });\n          });\n        } else {\n          dataExtensions.push({\n            ObjectId: res.PartnerProperties[0].Value,\n            Name: res.PartnerProperties[1].Value,\n            CategoryId: res.PartnerProperties[2].Value,\n          });\n        }\n        return dataExtensions;\n      }\n      throw new SoapError('No Data Extension found');\n    } catch (err) {\n      throw new SoapError(err);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/sdks/sfmc/index.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosError } from 'axios';\nimport {\n  AuthObject,\n  BusinessUnit,\n  BusinessUnitResponse,\n  ContactAttributesResponse,\n  CreateDataExtensionResponse,\n  DataExtension,\n  DataExtensionBody,\n  DataExtensionResponse,\n  DataFolder,\n  SFMCErrorResponse,\n  EventDefinition,\n  EventDefinitionsResponse,\n  ContactAttributes,\n  DataExtensionPartnerProperty,\n  DataExtensionApiResponse,\n} from './type';\nimport {\n  getUrl,\n  isExpired,\n  parseFilter,\n  parseXML,\n  getToken,\n  RestError,\n  SoapError,\n  xmlBuilder,\n} from './utils';\n\nexport default class SFMC {\n  authObject: AuthObject;\n\n  constructor(authObject: AuthObject) {\n    SFMC.validateAuthObject(authObject);\n    this.authObject = authObject;\n  }\n\n  private static validateAuthObject(authObject: any): any {\n    if (!authObject) {\n      throw new Error('authObject is required. See the readme.');\n    }\n\n    const validations = [\n      { key: 'clientId', type: 'string', required: true },\n      { key: 'clientSecret', type: 'string', required: true },\n      {\n        key: 'subDomain',\n        type: 'string',\n        required: true,\n        regex: /^\\w{28}$/gm,\n        regexMessage: 'subDomain must be a string of length 28',\n      },\n    ];\n\n    validations.forEach(({ key, type, required, regex, regexMessage }) => {\n      const value = authObject[key];\n      if (required && !value) {\n        throw new Error(`${key} is missing or invalid`);\n      }\n      if (typeof value !== type) {\n        throw new TypeError(`${key} must be a ${type}`);\n      }\n      if (regex && !regex.test(value)) {\n        throw new Error(regexMessage || `${key} does not match the required format`);\n      }\n    });\n\n    return authObject;\n  }\n\n  /**\n   * This function returns the access token. If the token is expired, it will generate a new token.\n   * @returns {Promise<AuthObject>}  It returns the access token or error\n   */\n  async getAccessToken() {\n    if (isExpired(this.authObject)) {\n      try {\n        await getToken(this.authObject);\n      } catch (e) {\n        throw new Error(`Unable to generate token, with error:${e}`);\n      }\n    }\n    return this.authObject;\n  }\n\n  /**\n   * This method fetches the fields of a data extension. It requires the data extension id. The method returns the fields of the data extension. If the data extension is not found, it returns a RestError.\n   * @param dataExtensionId Id of the data extension whose fields are to be fetched\n   * @returns\n   */\n  async getDestinationFields(dataExtensionId: string): Promise<DataExtensionBody | RestError> {\n    try {\n      const restHeaders = {\n        Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,\n      };\n      const requestOptions = {\n        method: 'GET',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: `/data/v1/customobjects/${dataExtensionId}/fields`,\n        headers: restHeaders,\n      };\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err) {\n      if (axios.isAxiosError(err)) {\n        const axiosError = err as AxiosError<SFMCErrorResponse>;\n        throw new RestError(axiosError);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * This method fetches the contact attributes. The method returns the contact attributes. If the contact attributes are not found, it returns a RestError.\n   * @param page Page number\n   * @param pageSize Page size\n   * @returns {Promise<ContactAttributesResponse | RestError>}\n   */\n  async getContactAttributesItems(\n    page: number,\n    pageSize: number,\n  ): Promise<ContactAttributesResponse | RestError> {\n    try {\n      const restHeaders = {\n        Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,\n      };\n      const requestOptions = {\n        method: 'GET',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: `/contacts/v1/attributeSetDefinitions?$page=${page}&$pageSize=${pageSize}`,\n        headers: restHeaders,\n      };\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err) {\n      if (axios.isAxiosError(err)) {\n        const axiosError = err as AxiosError<SFMCErrorResponse>;\n        throw new RestError(axiosError);\n      }\n      throw err;\n    }\n  }\n\n  async getContactAttributes(): Promise<ContactAttributes[] | RestError> {\n    const contactAttributes = await SFMC.getAllItemFromPages<ContactAttributes>(\n      this.getContactAttributesItems.bind(this),\n    );\n    return contactAttributes;\n  }\n\n  /**\n   * This method creates a data extension. It requires the data extension fields. The method returns the data extension created. If the data extension is not created, it returns a RestError.\n   * @param body DataExtension fields\n   * @returns\n   */\n  async createDataExtension(\n    body: DataExtensionBody,\n  ): Promise<CreateDataExtensionResponse | RestError> {\n    try {\n      const restHeaders = {\n        Authorization: `Bearer ${(await this.getAccessToken()).access_token}`,\n      };\n      const requestOptions = {\n        method: 'POST',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: '/data/v1/customobjects',\n        headers: restHeaders,\n        data: body,\n      };\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err: any) {\n      throw new RestError(err);\n    }\n  }\n\n  /**\n   * This method fetches the business units. The method returns the business units. If the business units are not found, it returns a SoapError.\n   * @returns\n   */\n  async getBusinessUnits(): Promise<BusinessUnit[] | SoapError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'POST',\n        baseURL: `https://${this.authObject.subDomain}.soap.marketingcloudapis.com`,\n        url: '/Service.asmx',\n        headers: {\n          SOAPAction: 'Retrieve',\n          'Content-Type': 'text/xml',\n        },\n        data: await xmlBuilder('BusinessUnit', ['name', 'id'], accessToken),\n      };\n      const resp = await axios(requestOptions);\n      const parsedData = parseXML(resp.data);\n      const res = parsedData.RetrieveResponseMsg?.Results as\n        | BusinessUnitResponse\n        | BusinessUnitResponse[];\n      const businessUnits: BusinessUnit[] = [];\n      if (res) {\n        const createBusinessUnit = (response: BusinessUnitResponse) => {\n          const { PartnerProperties } = response;\n          const entry = {} as BusinessUnit;\n          PartnerProperties.forEach((prop) => {\n            switch (prop.Name) {\n              case 'name':\n                entry.Name = prop.Value as string;\n                break;\n              case 'id':\n                entry.ID = prop.Value as number;\n                break;\n              default:\n                throw new SoapError(`Unknown property: ${prop}`);\n            }\n          });\n          return entry;\n        };\n\n        if (Array.isArray(res)) {\n          res.forEach((eachRes) => {\n            businessUnits.push(createBusinessUnit(eachRes));\n          });\n        } else {\n          businessUnits.push(createBusinessUnit(res));\n        }\n        return businessUnits;\n      }\n      throw new SoapError('No Business Units found');\n    } catch (err) {\n      throw new SoapError(err);\n    }\n  }\n\n  /**\n   * This method fetches the data folders. It business unit id is provided all data folder under that business id would be retrieved otherwise all the data folder will be retrieved. The method returns the data folders. If the data folders are not found, it returns a SoapError.\n   * @param businessUnitId this is the id of the business unit\n   * @returns\n   */\n  async getDataFolders(businessUnitId?: string): Promise<DataFolder[] | SoapError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'POST',\n        baseURL: `https://${this.authObject.subDomain}.soap.marketingcloudapis.com`,\n        url: '/Service.asmx',\n        headers: {\n          SOAPAction: 'Retrieve',\n          'Content-Type': 'text/xml',\n        },\n        data: businessUnitId\n          ? await xmlBuilder(\n              'DataFolder',\n              ['Name', 'ID', 'ParentFolder.ID'],\n              accessToken,\n              parseFilter({ leftOperand: 'Client.ID', rightOperand: businessUnitId }),\n            )\n          : await xmlBuilder('DataFolder', ['Name', 'ID', 'ParentFolder.ID'], accessToken),\n      };\n      const resp = await axios(requestOptions);\n      const parsedData = parseXML(resp.data);\n      const res = parsedData.RetrieveResponseMsg?.Results as DataFolder | DataFolder[];\n      const dataFolders: DataFolder[] = [];\n      if (res) {\n        if (Array.isArray(res)) {\n          res.forEach((eachRes) => {\n            dataFolders.push(eachRes);\n          });\n        } else {\n          dataFolders.push(res);\n        }\n        return dataFolders;\n      }\n      throw new SoapError('No Data Folder found');\n    } catch (err) {\n      throw new SoapError(err);\n    }\n  }\n\n  /**\n   * This function fetches the data extensions. It the data folder id is provided all the data extension under that data folder will be retrieved otherwise all the data extensions under the access token will be fetched. The method returns the data extensions. If the data extensions are not found, it returns a SoapError.\n   * @param dataFolderId Id of the data folder\n   * @returns\n   */\n  async getDataExtensions(dataFolderId?: string): Promise<DataExtension[] | SoapError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'POST',\n        baseURL: `https://${this.authObject.subDomain}.soap.marketingcloudapis.com`,\n        url: '/Service.asmx',\n        headers: {\n          SOAPAction: 'Retrieve',\n          'Content-Type': 'text/xml',\n        },\n        data: dataFolderId\n          ? await xmlBuilder(\n              'DataExtension',\n              ['NAME', 'ObjectId', 'CategoryId', 'CustomerKey', 'IsSendable'],\n              accessToken,\n              parseFilter({ leftOperand: 'CategoryId', rightOperand: dataFolderId }),\n            )\n          : await xmlBuilder(\n              'DataExtension',\n              ['NAME', 'ObjectId', 'CategoryId', 'CustomerKey', 'IsSendable'],\n              accessToken,\n            ),\n      };\n      const resp = await axios(requestOptions);\n      const parsedData = parseXML(resp.data);\n      const res = parsedData.RetrieveResponseMsg?.Results as\n        | DataExtensionResponse\n        | DataExtensionResponse[];\n      const dataExtensions: DataExtension[] = [];\n      if (res) {\n        if (Array.isArray(res)) {\n          res.forEach((eachRes) => {\n            dataExtensions.push(SFMC.mapDataExtension(eachRes));\n          });\n        } else {\n          dataExtensions.push(SFMC.mapDataExtension(res));\n        }\n        return dataExtensions;\n      }\n      throw new SoapError('No Data Extension found');\n    } catch (err) {\n      throw new SoapError(err);\n    }\n  }\n\n  private static mapDataExtension(dataExtension: DataExtensionResponse): DataExtension {\n    const getProperty = <T extends DataExtensionPartnerProperty>(\n      props: DataExtensionPartnerProperty[],\n      name: T['Name'],\n    ): T['Value'] => {\n      const property = props.find((prop): prop is T => prop.Name === name);\n      if (!property) {\n        throw new Error(`Missing required property: ${name}`);\n      }\n      return property.Value as T['Value'];\n    };\n\n    const { PartnerProperties } = dataExtension;\n    return {\n      ObjectId: getProperty<DataExtensionPartnerProperty>(PartnerProperties, 'ObjectId') as string,\n      Name: getProperty<DataExtensionPartnerProperty>(PartnerProperties, 'NAME') as string,\n      CategoryId: getProperty<DataExtensionPartnerProperty>(\n        PartnerProperties,\n        'CategoryId',\n      ) as number,\n      ExternalKey: dataExtension.CustomerKey,\n      IsSendable: dataExtension.IsSendable,\n    };\n  }\n\n  /**\n   * This function fetches the data extension by id. It returns the data extension. If the data extension is not found, it returns a RestError.\n   * @param dataExtensionId Id of the data extension\n   * @returns {Promise<DataExtension | RestError>}\n   */\n  async getDataExtensionById(\n    dataExtensionId: string,\n  ): Promise<DataExtensionApiResponse | RestError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n      const requestOptions = {\n        method: 'GET',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: `/data/v1/customobjects/${dataExtensionId}`,\n        headers: {\n          Authorization: `Bearer ${accessToken}`,\n        },\n      };\n      const resp = await axios<DataExtensionApiResponse>(requestOptions);\n      return resp.data;\n    } catch (err: any) {\n      if (axios.isAxiosError(err)) {\n        const axiosError = err as AxiosError<SFMCErrorResponse>;\n        throw new RestError(axiosError);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * This function fetches the event definitions. It returns the event definitions. If the event definitions are not found, it returns a RestError.\n   * @param page Page number\n   * @param pageSize Page size\n   * @returns {Promise<EventDefinitionsResponse | RestError>}\n   */\n  private async getEventDefinitions(\n    page: number,\n    pageSize: number,\n  ): Promise<EventDefinitionsResponse | RestError> {\n    try {\n      const accessToken = (await this.getAccessToken()).access_token;\n\n      const requestOptions = {\n        method: 'GET',\n        baseURL: getUrl(this.authObject.subDomain),\n        url: `/interaction/v1/eventDefinitions?$page=${page}&$pageSize=${pageSize}`,\n        headers: {\n          Authorization: `Bearer ${accessToken}`,\n        },\n      };\n\n      const resp = await axios(requestOptions);\n      return resp.data;\n    } catch (err: any) {\n      throw new RestError(err);\n    }\n  }\n\n  /**\n   * This function fetches all the event definitions. It returns the event definitions. If the event definitions are not found, it returns a RestError.\n   * @returns {Promise<EventDefinition[] | RestError>}\n   */\n  async getAllEventDefinitions(): Promise<EventDefinition[] | RestError> {\n    const eventDefinitions = await SFMC.getAllItemFromPages<EventDefinition>(\n      this.getEventDefinitions.bind(this),\n    );\n    return eventDefinitions;\n  }\n\n  private static async getAllItemFromPages<T>(\n    getItems: (\n      page: number,\n      pageSize: number,\n    ) => Promise<{ items: T[]; count: number } | RestError>,\n    pageSize: number = 50,\n  ): Promise<T[] | RestError> {\n    // Get first page to determine total count\n    const firstPage = await getItems(1, pageSize);\n    if (firstPage instanceof RestError) {\n      throw firstPage;\n    }\n\n    const totalPages = Math.ceil(firstPage.count / pageSize);\n    const remainingPages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);\n\n    const remainingResults = await Promise.all(\n      remainingPages.map(async (page) => {\n        const result = await getItems(page, pageSize);\n        if (result instanceof RestError) {\n          throw result;\n        }\n        return result;\n      }),\n    );\n\n    const allResults = [firstPage, ...remainingResults];\n    return allResults.flatMap((result) => (result instanceof RestError ? [] : result.items));\n  }\n}\n"]}

package/build/sdks/sfmc/type.d.ts

@@ -28,6 +28,9 @@ export interface Fields {
 export interface DataExtensionBody {
     name: string;
     categoryID: string;
+    isSendable?: boolean;
+    sendableCustomObjectField?: string;
+    sendableSubscriberField?: string;
     dataRetentionProperties?: {
         isDeleteAtEndOfRetentionPeriod?: boolean;
         isRowBasedRetention?: boolean;
@@ -54,18 +57,22 @@ export interface DataExtension {
     Name: string;
     ObjectId: string;
     CategoryId: number;
+    ExternalKey: string;
+    IsSendable: boolean;
+}
+export interface ContactAttributes {
+    isReadOnly: boolean;
+    attributes: [{
+        isReadOnly: boolean;
+        fullyQualifiedName: string;
+        dataType: string;
+    }];
 }
 export interface ContactAttributesResponse {
-    items: [
-        {
-            isReadOnly: boolean;
-            attributes: [{
-                isReadOnly: boolean;
-                fullyQualifiedName: string;
-                dataType: string;
-            }];
-        }
-    ];
+    items: ContactAttributes[];
+    count: number;
+    page: number;
+    pageSize: number;
 }
 export interface DataExtensionFields {
     fields: Fields[];
@@ -90,21 +97,14 @@ export type PartnerProperty = PartnerPropertyName | PartnerPropertyID;
 export interface BusinessUnitResponse {
     PartnerProperties: PartnerProperty[];
 }
+export type DataExtensionPartnerProperty = {
+    Name: 'NAME' | 'ObjectId' | 'CategoryId';
+    Value: string | number;
+};
 export interface DataExtensionResponse {
-    PartnerProperties: [
-        {
-            Name: string;
-            Value: string;
-        },
-        {
-            Name: string;
-            Value: string;
-        },
-        {
-            Name: string;
-            Value: number;
-        }
-    ];
+    PartnerProperties: DataExtensionPartnerProperty[];
+    CustomerKey: string;
+    IsSendable: boolean;
 }
 export interface SoapResponseBody {
     RetrieveResponseMsg: {
@@ -116,5 +116,25 @@ export interface SFMCErrorResponse {
     documentation: string;
     message: string;
 }
+export interface EventDefinitionsResponse {
+    items: EventDefinition[];
+    count: number;
+    page: number;
+    pageSize: number;
+}
+export interface EventDefinition {
+    id: string;
+    name: string;
+    description: string;
+    eventDefinitionKey: string;
+    dataExtensionId: string;
+    dataExtensionName: string;
+}
+export interface DataExtensionApiResponse {
+    id: string;
+    name: string;
+    key: string;
+    isSendable: boolean;
+}
 export {};
 //# sourceMappingURL=type.d.ts.map

package/build/sdks/sfmc/type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/sdks/sfmc/type.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/sdks/sfmc/type.ts"],"names":[],"mappings":"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"}

package/build/sdks/sfmc/type.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZGtzL3NmbWMvdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBBdXRoT2JqZWN0IHtcbiAgY2xpZW50SWQ6IHN0cmluZztcbiAgY2xpZW50U2VjcmV0OiBzdHJpbmc7XG4gIHN1YkRvbWFpbjogc3RyaW5nO1xuICBleHBpcmF0aW9uPzogbnVtYmVyO1xuICBhY2Nlc3NfdG9rZW4/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRmlsdGVyT2JqIHtcbiAgbGVmdE9wZXJhbmQ6IHN0cmluZztcbiAgcmlnaHRPcGVyYW5kOiBzdHJpbmc7XG59XG5leHBvcnQgaW50ZXJmYWNlIEZpZWxkcyB7XG4gIG5hbWU6IHN0cmluZztcbiAgdHlwZTogc3RyaW5nO1xuICBzY2FsZT86IG51bWJlcjtcbiAgcHJlY2lzaW9uPzogbnVtYmVyO1xuICBsZW5ndGg6IG51bWJlcjtcbiAgaXNOdWxsYWJsZTogYm9vbGVhbjtcbiAgaXNQcmltYXJ5S2V5OiBib29sZWFuO1xuICBpc0hpZGRlbjogYm9vbGVhbjtcbiAgaXNSZWFkT25seTogYm9vbGVhbjtcbiAgaXNPdmVycmlkYWJsZTogYm9vbGVhbjtcbiAgaXNUZW1wbGF0ZUZpZWxkOiBib29sZWFuO1xuICBpc0luaGVyaXRhYmxlOiBib29sZWFuO1xuICBtdXN0T3ZlcnJpZGU6IGJvb2xlYW47XG4gIG9yZGluYWw6IDA7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUV4dGVuc2lvbkJvZHkge1xuICBuYW1lOiBzdHJpbmc7XG4gIGNhdGVnb3J5SUQ6IHN0cmluZztcbiAgZGF0YVJldGVudGlvblByb3BlcnRpZXM/OiB7XG4gICAgaXNEZWxldGVBdEVuZE9mUmV0ZW50aW9uUGVyaW9kPzogYm9vbGVhbjtcbiAgICBpc1Jvd0Jhc2VkUmV0ZW50aW9uPzogYm9vbGVhbjtcbiAgICBpc1Jlc2V0UmV0ZW50aW9uUGVyaW9kT25JbXBvcnQ/OiBib29sZWFuO1xuICB9O1xuICBmaWVsZHM6IEZpZWxkc1tdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJ1c2luZXNzVW5pdCB7XG4gIE5hbWU6IHN0cmluZztcbiAgSUQ6IG51bWJlcjtcbn1cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUZvbGRlciB7XG4gIFBhcnRuZXJLZXk6IHN0cmluZztcbiAgSUQ6IG51bWJlcjtcbiAgT2JqZWN0SUQ6IHN0cmluZztcbiAgUGFyZW50Rm9sZGVyOiB7XG4gICAgUGFydG5lcktleTogc3RyaW5nO1xuICAgIElEOiBudW1iZXI7XG4gICAgT2JqZWN0SUQ6IHN0cmluZztcbiAgfTtcbiAgTmFtZTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIERhdGFFeHRlbnNpb24ge1xuICBOYW1lOiBzdHJpbmc7XG4gIE9iamVjdElkOiBzdHJpbmc7XG4gIENhdGVnb3J5SWQ6IG51bWJlcjtcbn1cbmV4cG9ydCBpbnRlcmZhY2UgQ29udGFjdEF0dHJpYnV0ZXNSZXNwb25zZSB7XG4gIGl0ZW1zOiBbXG4gICAge1xuICAgICAgaXNSZWFkT25seTogYm9vbGVhbjtcbiAgICAgIGF0dHJpYnV0ZXM6IFt7IGlzUmVhZE9ubHk6IGJvb2xlYW47IGZ1bGx5UXVhbGlmaWVkTmFtZTogc3RyaW5nOyBkYXRhVHlwZTogc3RyaW5nIH1dO1xuICAgIH0sXG4gIF07XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUV4dGVuc2lvbkZpZWxkcyB7XG4gIGZpZWxkczogRmllbGRzW107XG4gIGZpZWxkQ291bnQ6IG51bWJlcjtcbiAgZmllbGRQYWdlOiBudW1iZXI7XG4gIGZpZWxkUGFnZVNpemU6IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDcmVhdGVEYXRhRXh0ZW5zaW9uUmVzcG9uc2VcbiAgZXh0ZW5kcyBPbWl0PERhdGFFeHRlbnNpb25GaWVsZHMsICdmaWVsc1BhZ2UnIHwgJ2ZpZWxkUGFnZVNpemUnPiB7XG4gIGlkOiBzdHJpbmc7XG4gIGtleTogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG59XG5cbmludGVyZmFjZSBQYXJ0bmVyUHJvcGVydHlJRCB7XG4gIE5hbWU6ICdpZCc7XG4gIFZhbHVlOiBudW1iZXI7XG59XG5pbnRlcmZhY2UgUGFydG5lclByb3BlcnR5TmFtZSB7XG4gIE5hbWU6ICduYW1lJztcbiAgVmFsdWU6IHN0cmluZztcbn1cblxuZXhwb3J0IHR5cGUgUGFydG5lclByb3BlcnR5ID0gUGFydG5lclByb3BlcnR5TmFtZSB8IFBhcnRuZXJQcm9wZXJ0eUlEO1xuZXhwb3J0IGludGVyZmFjZSBCdXNpbmVzc1VuaXRSZXNwb25zZSB7XG4gIFBhcnRuZXJQcm9wZXJ0aWVzOiBQYXJ0bmVyUHJvcGVydHlbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEYXRhRXh0ZW5zaW9uUmVzcG9uc2Uge1xuICBQYXJ0bmVyUHJvcGVydGllczogW1xuICAgIHsgTmFtZTogc3RyaW5nOyBWYWx1ZTogc3RyaW5nIH0sXG4gICAgeyBOYW1lOiBzdHJpbmc7IFZhbHVlOiBzdHJpbmcgfSxcbiAgICB7IE5hbWU6IHN0cmluZzsgVmFsdWU6IG51bWJlciB9LFxuICBdO1xufVxuZXhwb3J0IGludGVyZmFjZSBTb2FwUmVzcG9uc2VCb2R5IHtcbiAgUmV0cmlldmVSZXNwb25zZU1zZzoge1xuICAgIFJlc3VsdHM6XG4gICAgICB8IEJ1c2luZXNzVW5pdFJlc3BvbnNlXG4gICAgICB8IEJ1c2luZXNzVW5pdFJlc3BvbnNlW11cbiAgICAgIHwgRGF0YUZvbGRlclxuICAgICAgfCBEYXRhRm9sZGVyW11cbiAgICAgIHwgRGF0YUV4dGVuc2lvblJlc3BvbnNlXG4gICAgICB8IERhdGFFeHRlbnNpb25SZXNwb25zZVtdO1xuICB9O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNGTUNFcnJvclJlc3BvbnNlIHtcbiAgZXJyb3Jjb2RlOiBzdHJpbmc7XG4gIGRvY3VtZW50YXRpb246IHN0cmluZztcbiAgbWVzc2FnZTogc3RyaW5nO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/benchmark.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Benchmark utilities for performance testing
+ *
+ * Provides easy-to-use tools for measuring function performance,
+ * memory usage, and creating performance comparisons.
+ *
+ * @example
+ * ```typescript
+ * import { benchmark, createBenchmarkSuite } from './benchmark';
+ *
+ * // Simple benchmark
+ * const result = await benchmark('myFunction', () => myFunction(data));
+ * console.log(`Duration: ${result.duration}ms`);
+ *
+ * // Benchmark suite
+ * const suite = createBenchmarkSuite('Array Operations');
+ * suite.add('native map', () => data.map(x => x * 2));
+ * suite.add('custom map', () => customMap(data, x => x * 2));
+ * await suite.run();
+ * ```
+ */
+/**
+ * Result of a benchmark measurement
+ */
+export type BenchmarkResult = {
+    /** Name of the benchmark */
+    name: string;
+    /** Total duration in milliseconds */
+    duration: number;
+    /** Operations per second */
+    opsPerSecond: number;
+    /** Memory used in bytes (heap difference) */
+    memoryUsed: number;
+    /** Number of iterations run */
+    iterations: number;
+    /** Average duration per iteration in milliseconds */
+    avgDuration: number;
+    /** Standard deviation of durations */
+    stdDev: number;
+    /** Minimum duration observed */
+    minDuration: number;
+    /** Maximum duration observed */
+    maxDuration: number;
+};
+/**
+ * Configuration options for benchmarks
+ */
+export type BenchmarkOptions = {
+    /** Number of iterations to run (default: 1) */
+    iterations?: number;
+    /** Number of warmup runs before measuring (default: 1) */
+    warmupRuns?: number;
+    /** Whether to force garbage collection between runs (default: false) */
+    forceGC?: boolean;
+    /** Whether to measure memory usage (default: true) */
+    measureMemory?: boolean;
+    /** Timeout in milliseconds for the entire benchmark (default: 30000) */
+    timeout?: number;
+};
+/**
+ * Benchmark function type
+ */
+export type BenchmarkFunction<T = unknown> = () => T | Promise<T>;
+/**
+ * Run a benchmark for a single function
+ *
+ * @param name - Name of the benchmark
+ * @param fn - Function to benchmark
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to benchmark results
+ *
+ * @example
+ * ```typescript
+ * const result = await benchmark('Array.map', () => {
+ *   return largeArray.map(x => x * 2);
+ * }, { iterations: 10, warmupRuns: 3 });
+ *
+ * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);
+ * ```
+ */
+export declare function benchmark(name: string, fn: BenchmarkFunction, options?: BenchmarkOptions): Promise<BenchmarkResult>;
+/**
+ * Compare multiple functions with the same benchmark configuration
+ *
+ * @param benchmarks - Object with benchmark names and functions
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to array of benchmark results
+ *
+ * @example
+ * ```typescript
+ * const results = await compareBenchmarks({
+ *   'native map': () => data.map(x => x * 2),
+ *   'for loop': () => {
+ *     const result = [];
+ *     for (let i = 0; i < data.length; i++) {
+ *       result.push(data[i] * 2);
+ *     }
+ *     return result;
+ *   }
+ * }, { iterations: 5 });
+ *
+ * results.forEach(result => {
+ *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);
+ * });
+ * ```
+ */
+export declare function compareBenchmarks(benchmarks: Record<string, BenchmarkFunction>, options?: BenchmarkOptions): Promise<BenchmarkResult[]>;
+/**
+ * Benchmark suite for organizing and running multiple related benchmarks
+ */
+export declare class BenchmarkSuite {
+    readonly suiteName: string;
+    private benchmarks;
+    private options;
+    constructor(suiteName: string, options?: BenchmarkOptions);
+    /**
+     * Add a benchmark to the suite
+     *
+     * @param name - Name of the benchmark
+     * @param fn - Function to benchmark
+     * @returns This suite instance for chaining
+     */
+    add(name: string, fn: BenchmarkFunction): this;
+    /**
+     * Run all benchmarks in the suite
+     *
+     * @param customOptions - Override suite options for this run
+     * @returns Promise resolving to array of benchmark results
+     */
+    run(customOptions?: BenchmarkOptions): Promise<BenchmarkResult[]>;
+    /**
+     * Get the number of benchmarks in the suite
+     */
+    get size(): number;
+    /**
+     * Clear all benchmarks from the suite
+     */
+    clear(): this;
+}
+/**
+ * Create a new benchmark suite
+ *
+ * @param suiteName - Name of the benchmark suite
+ * @param options - Default options for all benchmarks in the suite
+ * @returns New BenchmarkSuite instance
+ *
+ * @example
+ * ```typescript
+ * const suite = createBenchmarkSuite('String Operations', {
+ *   iterations: 10,
+ *   warmupRuns: 2
+ * });
+ *
+ * suite
+ *   .add('concat', () => str1 + str2)
+ *   .add('template', () => `${str1}${str2}`)
+ *   .add('join', () => [str1, str2].join(''));
+ *
+ * await suite.run();
+ * ```
+ */
+export declare function createBenchmarkSuite(suiteName: string, options?: BenchmarkOptions): BenchmarkSuite;
+/**
+ * Utility to measure memory usage of a function
+ *
+ * @param fn - Function to measure
+ * @param forceGC - Whether to force garbage collection before measuring
+ * @returns Memory usage in bytes
+ *
+ * @example
+ * ```typescript
+ * const memoryUsed = await measureMemory(() => {
+ *   return new Array(100000).fill(0).map(x => ({ value: x }));
+ * });
+ *
+ * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+ * ```
+ */
+export declare function measureMemory(fn: BenchmarkFunction, forceGC?: boolean): Promise<number>;
+//# sourceMappingURL=benchmark.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/utils/benchmark.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sDAAsD;IACtD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAqBlE;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,iBAAiB,EACrB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CA4E1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC7C,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,EAAE,CAAC,CAM5B;AAED;;GAEG;AACH,qBAAa,cAAc;aAKG,SAAS,EAAE,MAAM;IAJ7C,OAAO,CAAC,UAAU,CAAsD;IAExE,OAAO,CAAC,OAAO,CAAmB;gBAEN,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB;IAI7E;;;;;;OAMG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI;IAK9C;;;;;OAKG;IACG,GAAG,CAAC,aAAa,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAkEvE;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAId;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,gBAAgB,GACzB,cAAc,CAEhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,EAAE,EAAE,iBAAiB,EAAE,OAAO,UAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAU1F"}

package/build/utils/benchmark.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Benchmark utilities for performance testing
+ *
+ * Provides easy-to-use tools for measuring function performance,
+ * memory usage, and creating performance comparisons.
+ *
+ * @example
+ * ```typescript
+ * import { benchmark, createBenchmarkSuite } from './benchmark';
+ *
+ * // Simple benchmark
+ * const result = await benchmark('myFunction', () => myFunction(data));
+ * console.log(`Duration: ${result.duration}ms`);
+ *
+ * // Benchmark suite
+ * const suite = createBenchmarkSuite('Array Operations');
+ * suite.add('native map', () => data.map(x => x * 2));
+ * suite.add('custom map', () => customMap(data, x => x * 2));
+ * await suite.run();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkSuite = void 0;
+exports.benchmark = benchmark;
+exports.compareBenchmarks = compareBenchmarks;
+exports.createBenchmarkSuite = createBenchmarkSuite;
+exports.measureMemory = measureMemory;
+/**
+ * Force garbage collection if available
+ */
+function forceGarbageCollection() {
+    if (typeof global !== 'undefined' && global.gc) {
+        global.gc();
+    }
+}
+/**
+ * Calculate standard deviation of an array of numbers
+ */
+function calculateStdDev(values) {
+    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
+    const squaredDiffs = values.map((val) => (val - mean) ** 2);
+    const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;
+    return Math.sqrt(avgSquaredDiff);
+}
+/**
+ * Run a benchmark for a single function
+ *
+ * @param name - Name of the benchmark
+ * @param fn - Function to benchmark
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to benchmark results
+ *
+ * @example
+ * ```typescript
+ * const result = await benchmark('Array.map', () => {
+ *   return largeArray.map(x => x * 2);
+ * }, { iterations: 10, warmupRuns: 3 });
+ *
+ * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);
+ * ```
+ */
+// eslint-disable-next-line require-await
+async function benchmark(name, fn, options = {}) {
+    const { iterations = 1, warmupRuns = 1, forceGC = false, measureMemory: shouldMeasureMemory = true, timeout = 30000, } = options;
+    // Timeout protection
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(`Benchmark "${name}" timed out after ${timeout}ms`)), timeout);
+    });
+    const benchmarkPromise = async () => {
+        // Warmup runs
+        await Promise.all(Array.from({ length: warmupRuns }, async () => {
+            await fn();
+        }));
+        if (forceGC) {
+            forceGarbageCollection();
+        }
+        const durations = [];
+        const startMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;
+        const overallStart = performance.now();
+        // Actual benchmark runs
+        for (let i = 0; i < iterations; i += 1) {
+            if (forceGC && i > 0) {
+                forceGarbageCollection();
+            }
+            const iterationStart = performance.now();
+            // eslint-disable-next-line no-await-in-loop
+            await fn();
+            const iterationEnd = performance.now();
+            durations.push(iterationEnd - iterationStart);
+        }
+        const overallEnd = performance.now();
+        const endMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;
+        const totalDuration = overallEnd - overallStart;
+        const avgDuration = durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;
+        const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
+        const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+        const stdDev = durations.length > 0 ? calculateStdDev(durations) : 0;
+        const opsPerSecond = totalDuration > 0 ? iterations / (totalDuration / 1000) : 0;
+        const memoryUsed = endMemory - startMemory;
+        return {
+            name,
+            duration: totalDuration,
+            opsPerSecond,
+            memoryUsed,
+            iterations,
+            avgDuration,
+            stdDev,
+            minDuration,
+            maxDuration,
+        };
+    };
+    return Promise.race([benchmarkPromise(), timeoutPromise]).finally(() => {
+        clearTimeout(timeoutId);
+    });
+}
+/**
+ * Compare multiple functions with the same benchmark configuration
+ *
+ * @param benchmarks - Object with benchmark names and functions
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to array of benchmark results
+ *
+ * @example
+ * ```typescript
+ * const results = await compareBenchmarks({
+ *   'native map': () => data.map(x => x * 2),
+ *   'for loop': () => {
+ *     const result = [];
+ *     for (let i = 0; i < data.length; i++) {
+ *       result.push(data[i] * 2);
+ *     }
+ *     return result;
+ *   }
+ * }, { iterations: 5 });
+ *
+ * results.forEach(result => {
+ *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);
+ * });
+ * ```
+ */
+async function compareBenchmarks(benchmarks, options = {}) {
+    const results = await Promise.all(Object.entries(benchmarks).map(([name, fn]) => benchmark(name, fn, options)));
+    return results.sort((a, b) => a.avgDuration - b.avgDuration);
+}
+/**
+ * Benchmark suite for organizing and running multiple related benchmarks
+ */
+class BenchmarkSuite {
+    constructor(suiteName, options = {}) {
+        this.suiteName = suiteName;
+        this.benchmarks = [];
+        this.options = options;
+    }
+    /**
+     * Add a benchmark to the suite
+     *
+     * @param name - Name of the benchmark
+     * @param fn - Function to benchmark
+     * @returns This suite instance for chaining
+     */
+    add(name, fn) {
+        this.benchmarks.push({ name, fn });
+        return this;
+    }
+    /**
+     * Run all benchmarks in the suite
+     *
+     * @param customOptions - Override suite options for this run
+     * @returns Promise resolving to array of benchmark results
+     */
+    async run(customOptions) {
+        const options = { ...this.options, ...customOptions };
+        const results = [];
+        // eslint-disable-next-line no-console
+        console.log(`\n🚀 Running benchmark suite: ${this.suiteName}`);
+        // eslint-disable-next-line no-console
+        console.log('='.repeat(60));
+        // eslint-disable-next-line no-restricted-syntax
+        for (const { name, fn } of this.benchmarks) {
+            // eslint-disable-next-line no-console
+            console.log(`\n⏱️  Running: ${name}...`);
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const result = await benchmark(name, fn, options);
+                results.push(result);
+                // eslint-disable-next-line no-console
+                console.log(`   ✅ ${result.avgDuration.toFixed(2)}ms avg (${result.opsPerSecond.toFixed(0)} ops/sec)`);
+                if (options.measureMemory) {
+                    // eslint-disable-next-line no-console
+                    console.log(`   💾 Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+                }
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.log(`   ❌ Failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        // Summary
+        if (results.length > 1) {
+            // eslint-disable-next-line no-console
+            console.log(`\n📊 Summary (sorted by performance):`);
+            const sortedResults = [...results].sort((a, b) => a.avgDuration - b.avgDuration);
+            const fastest = sortedResults[0];
+            sortedResults.forEach((result, index) => {
+                const relative = result.avgDuration / fastest.avgDuration;
+                let icon = '  ';
+                if (index === 0)
+                    icon = '🥇';
+                else if (index === 1)
+                    icon = '🥈';
+                else if (index === 2)
+                    icon = '🥉';
+                // eslint-disable-next-line no-console
+                console.log(`   ${icon} ${result.name.padEnd(25)} | ${result.avgDuration.toFixed(2)}ms | ${relative.toFixed(2)}x`);
+            });
+        }
+        // eslint-disable-next-line no-console
+        console.log(`\n✅ Suite completed: ${results.length}/${this.benchmarks.length} benchmarks successful\n`);
+        return results;
+    }
+    /**
+     * Get the number of benchmarks in the suite
+     */
+    get size() {
+        return this.benchmarks.length;
+    }
+    /**
+     * Clear all benchmarks from the suite
+     */
+    clear() {
+        this.benchmarks = [];
+        return this;
+    }
+}
+exports.BenchmarkSuite = BenchmarkSuite;
+/**
+ * Create a new benchmark suite
+ *
+ * @param suiteName - Name of the benchmark suite
+ * @param options - Default options for all benchmarks in the suite
+ * @returns New BenchmarkSuite instance
+ *
+ * @example
+ * ```typescript
+ * const suite = createBenchmarkSuite('String Operations', {
+ *   iterations: 10,
+ *   warmupRuns: 2
+ * });
+ *
+ * suite
+ *   .add('concat', () => str1 + str2)
+ *   .add('template', () => `${str1}${str2}`)
+ *   .add('join', () => [str1, str2].join(''));
+ *
+ * await suite.run();
+ * ```
+ */
+function createBenchmarkSuite(suiteName, options) {
+    return new BenchmarkSuite(suiteName, options);
+}
+/**
+ * Utility to measure memory usage of a function
+ *
+ * @param fn - Function to measure
+ * @param forceGC - Whether to force garbage collection before measuring
+ * @returns Memory usage in bytes
+ *
+ * @example
+ * ```typescript
+ * const memoryUsed = await measureMemory(() => {
+ *   return new Array(100000).fill(0).map(x => ({ value: x }));
+ * });
+ *
+ * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+ * ```
+ */
+async function measureMemory(fn, forceGC = true) {
+    if (forceGC) {
+        forceGarbageCollection();
+    }
+    const startMemory = process.memoryUsage().heapUsed;
+    await fn();
+    const endMemory = process.memoryUsage().heapUsed;
+    return endMemory - startMemory;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"benchmark.js","sourceRoot":"","sources":["../../src/utils/benchmark.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Benchmark utilities for performance testing\n *\n * Provides easy-to-use tools for measuring function performance,\n * memory usage, and creating performance comparisons.\n *\n * @example\n * ```typescript\n * import { benchmark, createBenchmarkSuite } from './benchmark';\n *\n * // Simple benchmark\n * const result = await benchmark('myFunction', () => myFunction(data));\n * console.log(`Duration: ${result.duration}ms`);\n *\n * // Benchmark suite\n * const suite = createBenchmarkSuite('Array Operations');\n * suite.add('native map', () => data.map(x => x * 2));\n * suite.add('custom map', () => customMap(data, x => x * 2));\n * await suite.run();\n * ```\n */\n\n/**\n * Result of a benchmark measurement\n */\nexport type BenchmarkResult = {\n  /** Name of the benchmark */\n  name: string;\n  /** Total duration in milliseconds */\n  duration: number;\n  /** Operations per second */\n  opsPerSecond: number;\n  /** Memory used in bytes (heap difference) */\n  memoryUsed: number;\n  /** Number of iterations run */\n  iterations: number;\n  /** Average duration per iteration in milliseconds */\n  avgDuration: number;\n  /** Standard deviation of durations */\n  stdDev: number;\n  /** Minimum duration observed */\n  minDuration: number;\n  /** Maximum duration observed */\n  maxDuration: number;\n};\n\n/**\n * Configuration options for benchmarks\n */\nexport type BenchmarkOptions = {\n  /** Number of iterations to run (default: 1) */\n  iterations?: number;\n  /** Number of warmup runs before measuring (default: 1) */\n  warmupRuns?: number;\n  /** Whether to force garbage collection between runs (default: false) */\n  forceGC?: boolean;\n  /** Whether to measure memory usage (default: true) */\n  measureMemory?: boolean;\n  /** Timeout in milliseconds for the entire benchmark (default: 30000) */\n  timeout?: number;\n};\n\n/**\n * Benchmark function type\n */\nexport type BenchmarkFunction<T = unknown> = () => T | Promise<T>;\n\n/**\n * Force garbage collection if available\n */\nfunction forceGarbageCollection(): void {\n  if (typeof global !== 'undefined' && global.gc) {\n    global.gc();\n  }\n}\n\n/**\n * Calculate standard deviation of an array of numbers\n */\nfunction calculateStdDev(values: number[]): number {\n  const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n  const squaredDiffs = values.map((val) => (val - mean) ** 2);\n  const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;\n  return Math.sqrt(avgSquaredDiff);\n}\n\n/**\n * Run a benchmark for a single function\n *\n * @param name - Name of the benchmark\n * @param fn - Function to benchmark\n * @param options - Benchmark configuration options\n * @returns Promise resolving to benchmark results\n *\n * @example\n * ```typescript\n * const result = await benchmark('Array.map', () => {\n *   return largeArray.map(x => x * 2);\n * }, { iterations: 10, warmupRuns: 3 });\n *\n * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);\n * ```\n */\n// eslint-disable-next-line require-await\nexport async function benchmark(\n  name: string,\n  fn: BenchmarkFunction,\n  options: BenchmarkOptions = {},\n): Promise<BenchmarkResult> {\n  const {\n    iterations = 1,\n    warmupRuns = 1,\n    forceGC = false,\n    measureMemory: shouldMeasureMemory = true,\n    timeout = 30000,\n  } = options;\n\n  // Timeout protection\n  let timeoutId: NodeJS.Timeout;\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    timeoutId = setTimeout(\n      () => reject(new Error(`Benchmark \"${name}\" timed out after ${timeout}ms`)),\n      timeout,\n    );\n  });\n\n  const benchmarkPromise = async (): Promise<BenchmarkResult> => {\n    // Warmup runs\n    await Promise.all(\n      Array.from({ length: warmupRuns }, async () => {\n        await fn();\n      }),\n    );\n\n    if (forceGC) {\n      forceGarbageCollection();\n    }\n\n    const durations: number[] = [];\n    const startMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;\n    const overallStart = performance.now();\n\n    // Actual benchmark runs\n    for (let i = 0; i < iterations; i += 1) {\n      if (forceGC && i > 0) {\n        forceGarbageCollection();\n      }\n\n      const iterationStart = performance.now();\n      // eslint-disable-next-line no-await-in-loop\n      await fn();\n      const iterationEnd = performance.now();\n\n      durations.push(iterationEnd - iterationStart);\n    }\n\n    const overallEnd = performance.now();\n    const endMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;\n\n    const totalDuration = overallEnd - overallStart;\n    const avgDuration =\n      durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;\n    const minDuration = durations.length > 0 ? Math.min(...durations) : 0;\n    const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;\n    const stdDev = durations.length > 0 ? calculateStdDev(durations) : 0;\n    const opsPerSecond = totalDuration > 0 ? iterations / (totalDuration / 1000) : 0;\n    const memoryUsed = endMemory - startMemory;\n\n    return {\n      name,\n      duration: totalDuration,\n      opsPerSecond,\n      memoryUsed,\n      iterations,\n      avgDuration,\n      stdDev,\n      minDuration,\n      maxDuration,\n    };\n  };\n\n  return Promise.race([benchmarkPromise(), timeoutPromise]).finally(() => {\n    clearTimeout(timeoutId);\n  });\n}\n\n/**\n * Compare multiple functions with the same benchmark configuration\n *\n * @param benchmarks - Object with benchmark names and functions\n * @param options - Benchmark configuration options\n * @returns Promise resolving to array of benchmark results\n *\n * @example\n * ```typescript\n * const results = await compareBenchmarks({\n *   'native map': () => data.map(x => x * 2),\n *   'for loop': () => {\n *     const result = [];\n *     for (let i = 0; i < data.length; i++) {\n *       result.push(data[i] * 2);\n *     }\n *     return result;\n *   }\n * }, { iterations: 5 });\n *\n * results.forEach(result => {\n *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);\n * });\n * ```\n */\nexport async function compareBenchmarks(\n  benchmarks: Record<string, BenchmarkFunction>,\n  options: BenchmarkOptions = {},\n): Promise<BenchmarkResult[]> {\n  const results = await Promise.all(\n    Object.entries(benchmarks).map(([name, fn]) => benchmark(name, fn, options)),\n  );\n\n  return results.sort((a, b) => a.avgDuration - b.avgDuration);\n}\n\n/**\n * Benchmark suite for organizing and running multiple related benchmarks\n */\nexport class BenchmarkSuite {\n  private benchmarks: Array<{ name: string; fn: BenchmarkFunction }> = [];\n\n  private options: BenchmarkOptions;\n\n  constructor(public readonly suiteName: string, options: BenchmarkOptions = {}) {\n    this.options = options;\n  }\n\n  /**\n   * Add a benchmark to the suite\n   *\n   * @param name - Name of the benchmark\n   * @param fn - Function to benchmark\n   * @returns This suite instance for chaining\n   */\n  add(name: string, fn: BenchmarkFunction): this {\n    this.benchmarks.push({ name, fn });\n    return this;\n  }\n\n  /**\n   * Run all benchmarks in the suite\n   *\n   * @param customOptions - Override suite options for this run\n   * @returns Promise resolving to array of benchmark results\n   */\n  async run(customOptions?: BenchmarkOptions): Promise<BenchmarkResult[]> {\n    const options = { ...this.options, ...customOptions };\n    const results: BenchmarkResult[] = [];\n\n    // eslint-disable-next-line no-console\n    console.log(`\\n🚀 Running benchmark suite: ${this.suiteName}`);\n    // eslint-disable-next-line no-console\n    console.log('='.repeat(60));\n\n    // eslint-disable-next-line no-restricted-syntax\n    for (const { name, fn } of this.benchmarks) {\n      // eslint-disable-next-line no-console\n      console.log(`\\n⏱️  Running: ${name}...`);\n\n      try {\n        // eslint-disable-next-line no-await-in-loop\n        const result = await benchmark(name, fn, options);\n        results.push(result);\n\n        // eslint-disable-next-line no-console\n        console.log(\n          `   ✅ ${result.avgDuration.toFixed(2)}ms avg (${result.opsPerSecond.toFixed(\n            0,\n          )} ops/sec)`,\n        );\n        if (options.measureMemory) {\n          // eslint-disable-next-line no-console\n          console.log(`   💾 Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`);\n        }\n      } catch (error) {\n        // eslint-disable-next-line no-console\n        console.log(`   ❌ Failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n      }\n    }\n\n    // Summary\n    if (results.length > 1) {\n      // eslint-disable-next-line no-console\n      console.log(`\\n📊 Summary (sorted by performance):`);\n      const sortedResults = [...results].sort((a, b) => a.avgDuration - b.avgDuration);\n      const fastest = sortedResults[0];\n\n      sortedResults.forEach((result, index) => {\n        const relative = result.avgDuration / fastest.avgDuration;\n        let icon = '  ';\n        if (index === 0) icon = '🥇';\n        else if (index === 1) icon = '🥈';\n        else if (index === 2) icon = '🥉';\n\n        // eslint-disable-next-line no-console\n        console.log(\n          `   ${icon} ${result.name.padEnd(25)} | ${result.avgDuration.toFixed(\n            2,\n          )}ms | ${relative.toFixed(2)}x`,\n        );\n      });\n    }\n\n    // eslint-disable-next-line no-console\n    console.log(\n      `\\n✅ Suite completed: ${results.length}/${this.benchmarks.length} benchmarks successful\\n`,\n    );\n\n    return results;\n  }\n\n  /**\n   * Get the number of benchmarks in the suite\n   */\n  get size(): number {\n    return this.benchmarks.length;\n  }\n\n  /**\n   * Clear all benchmarks from the suite\n   */\n  clear(): this {\n    this.benchmarks = [];\n    return this;\n  }\n}\n\n/**\n * Create a new benchmark suite\n *\n * @param suiteName - Name of the benchmark suite\n * @param options - Default options for all benchmarks in the suite\n * @returns New BenchmarkSuite instance\n *\n * @example\n * ```typescript\n * const suite = createBenchmarkSuite('String Operations', {\n *   iterations: 10,\n *   warmupRuns: 2\n * });\n *\n * suite\n *   .add('concat', () => str1 + str2)\n *   .add('template', () => `${str1}${str2}`)\n *   .add('join', () => [str1, str2].join(''));\n *\n * await suite.run();\n * ```\n */\nexport function createBenchmarkSuite(\n  suiteName: string,\n  options?: BenchmarkOptions,\n): BenchmarkSuite {\n  return new BenchmarkSuite(suiteName, options);\n}\n\n/**\n * Utility to measure memory usage of a function\n *\n * @param fn - Function to measure\n * @param forceGC - Whether to force garbage collection before measuring\n * @returns Memory usage in bytes\n *\n * @example\n * ```typescript\n * const memoryUsed = await measureMemory(() => {\n *   return new Array(100000).fill(0).map(x => ({ value: x }));\n * });\n *\n * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);\n * ```\n */\nexport async function measureMemory(fn: BenchmarkFunction, forceGC = true): Promise<number> {\n  if (forceGC) {\n    forceGarbageCollection();\n  }\n\n  const startMemory = process.memoryUsage().heapUsed;\n  await fn();\n  const endMemory = process.memoryUsage().heapUsed;\n\n  return endMemory - startMemory;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",