@rudderstack/integrations-lib 0.2.33 → 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,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZGtzL3NmbWMvdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBBdXRoT2JqZWN0IHtcbiAgY2xpZW50SWQ6IHN0cmluZztcbiAgY2xpZW50U2VjcmV0OiBzdHJpbmc7XG4gIHN1YkRvbWFpbjogc3RyaW5nO1xuICBleHBpcmF0aW9uPzogbnVtYmVyO1xuICBhY2Nlc3NfdG9rZW4/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRmlsdGVyT2JqIHtcbiAgbGVmdE9wZXJhbmQ6IHN0cmluZztcbiAgcmlnaHRPcGVyYW5kOiBzdHJpbmc7XG59XG5leHBvcnQgaW50ZXJmYWNlIEZpZWxkcyB7XG4gIG5hbWU6IHN0cmluZztcbiAgdHlwZTogc3RyaW5nO1xuICBzY2FsZT86IG51bWJlcjtcbiAgcHJlY2lzaW9uPzogbnVtYmVyO1xuICBsZW5ndGg6IG51bWJlcjtcbiAgaXNOdWxsYWJsZTogYm9vbGVhbjtcbiAgaXNQcmltYXJ5S2V5OiBib29sZWFuO1xuICBpc0hpZGRlbjogYm9vbGVhbjtcbiAgaXNSZWFkT25seTogYm9vbGVhbjtcbiAgaXNPdmVycmlkYWJsZTogYm9vbGVhbjtcbiAgaXNUZW1wbGF0ZUZpZWxkOiBib29sZWFuO1xuICBpc0luaGVyaXRhYmxlOiBib29sZWFuO1xuICBtdXN0T3ZlcnJpZGU6IGJvb2xlYW47XG4gIG9yZGluYWw6IDA7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUV4dGVuc2lvbkJvZHkge1xuICBuYW1lOiBzdHJpbmc7XG4gIGNhdGVnb3J5SUQ6IHN0cmluZztcbiAgaXNTZW5kYWJsZT86IGJvb2xlYW47XG4gIHNlbmRhYmxlQ3VzdG9tT2JqZWN0RmllbGQ/OiBzdHJpbmc7XG4gIHNlbmRhYmxlU3Vic2NyaWJlckZpZWxkPzogc3RyaW5nO1xuICBkYXRhUmV0ZW50aW9uUHJvcGVydGllcz86IHtcbiAgICBpc0RlbGV0ZUF0RW5kT2ZSZXRlbnRpb25QZXJpb2Q/OiBib29sZWFuO1xuICAgIGlzUm93QmFzZWRSZXRlbnRpb24/OiBib29sZWFuO1xuICAgIGlzUmVzZXRSZXRlbnRpb25QZXJpb2RPbkltcG9ydD86IGJvb2xlYW47XG4gIH07XG4gIGZpZWxkczogRmllbGRzW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQnVzaW5lc3NVbml0IHtcbiAgTmFtZTogc3RyaW5nO1xuICBJRDogbnVtYmVyO1xufVxuZXhwb3J0IGludGVyZmFjZSBEYXRhRm9sZGVyIHtcbiAgUGFydG5lcktleTogc3RyaW5nO1xuICBJRDogbnVtYmVyO1xuICBPYmplY3RJRDogc3RyaW5nO1xuICBQYXJlbnRGb2xkZXI6IHtcbiAgICBQYXJ0bmVyS2V5OiBzdHJpbmc7XG4gICAgSUQ6IG51bWJlcjtcbiAgICBPYmplY3RJRDogc3RyaW5nO1xuICB9O1xuICBOYW1lOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUV4dGVuc2lvbiB7XG4gIE5hbWU6IHN0cmluZztcbiAgT2JqZWN0SWQ6IHN0cmluZztcbiAgQ2F0ZWdvcnlJZDogbnVtYmVyO1xuICBFeHRlcm5hbEtleTogc3RyaW5nO1xuICBJc1NlbmRhYmxlOiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvbnRhY3RBdHRyaWJ1dGVzIHtcbiAgaXNSZWFkT25seTogYm9vbGVhbjtcbiAgYXR0cmlidXRlczogW3sgaXNSZWFkT25seTogYm9vbGVhbjsgZnVsbHlRdWFsaWZpZWROYW1lOiBzdHJpbmc7IGRhdGFUeXBlOiBzdHJpbmcgfV07XG59XG5leHBvcnQgaW50ZXJmYWNlIENvbnRhY3RBdHRyaWJ1dGVzUmVzcG9uc2Uge1xuICBpdGVtczogQ29udGFjdEF0dHJpYnV0ZXNbXTtcbiAgY291bnQ6IG51bWJlcjtcbiAgcGFnZTogbnVtYmVyO1xuICBwYWdlU2l6ZTogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIERhdGFFeHRlbnNpb25GaWVsZHMge1xuICBmaWVsZHM6IEZpZWxkc1tdO1xuICBmaWVsZENvdW50OiBudW1iZXI7XG4gIGZpZWxkUGFnZTogbnVtYmVyO1xuICBmaWVsZFBhZ2VTaXplOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3JlYXRlRGF0YUV4dGVuc2lvblJlc3BvbnNlXG4gIGV4dGVuZHMgT21pdDxEYXRhRXh0ZW5zaW9uRmllbGRzLCAnZmllbHNQYWdlJyB8ICdmaWVsZFBhZ2VTaXplJz4ge1xuICBpZDogc3RyaW5nO1xuICBrZXk6IHN0cmluZztcbiAgbmFtZTogc3RyaW5nO1xufVxuXG5pbnRlcmZhY2UgUGFydG5lclByb3BlcnR5SUQge1xuICBOYW1lOiAnaWQnO1xuICBWYWx1ZTogbnVtYmVyO1xufVxuaW50ZXJmYWNlIFBhcnRuZXJQcm9wZXJ0eU5hbWUge1xuICBOYW1lOiAnbmFtZSc7XG4gIFZhbHVlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIFBhcnRuZXJQcm9wZXJ0eSA9IFBhcnRuZXJQcm9wZXJ0eU5hbWUgfCBQYXJ0bmVyUHJvcGVydHlJRDtcbmV4cG9ydCBpbnRlcmZhY2UgQnVzaW5lc3NVbml0UmVzcG9uc2Uge1xuICBQYXJ0bmVyUHJvcGVydGllczogUGFydG5lclByb3BlcnR5W107XG59XG5cbmV4cG9ydCB0eXBlIERhdGFFeHRlbnNpb25QYXJ0bmVyUHJvcGVydHkgPSB7XG4gIE5hbWU6ICdOQU1FJyB8ICdPYmplY3RJZCcgfCAnQ2F0ZWdvcnlJZCc7XG4gIFZhbHVlOiBzdHJpbmcgfCBudW1iZXI7XG59O1xuXG5leHBvcnQgaW50ZXJmYWNlIERhdGFFeHRlbnNpb25SZXNwb25zZSB7XG4gIFBhcnRuZXJQcm9wZXJ0aWVzOiBEYXRhRXh0ZW5zaW9uUGFydG5lclByb3BlcnR5W107XG4gIEN1c3RvbWVyS2V5OiBzdHJpbmc7XG4gIElzU2VuZGFibGU6IGJvb2xlYW47XG59XG5leHBvcnQgaW50ZXJmYWNlIFNvYXBSZXNwb25zZUJvZHkge1xuICBSZXRyaWV2ZVJlc3BvbnNlTXNnOiB7XG4gICAgUmVzdWx0czpcbiAgICAgIHwgQnVzaW5lc3NVbml0UmVzcG9uc2VcbiAgICAgIHwgQnVzaW5lc3NVbml0UmVzcG9uc2VbXVxuICAgICAgfCBEYXRhRm9sZGVyXG4gICAgICB8IERhdGFGb2xkZXJbXVxuICAgICAgfCBEYXRhRXh0ZW5zaW9uUmVzcG9uc2VcbiAgICAgIHwgRGF0YUV4dGVuc2lvblJlc3BvbnNlW107XG4gIH07XG59XG5leHBvcnQgaW50ZXJmYWNlIFNGTUNFcnJvclJlc3BvbnNlIHtcbiAgZXJyb3Jjb2RlOiBzdHJpbmc7XG4gIGRvY3VtZW50YXRpb246IHN0cmluZztcbiAgbWVzc2FnZTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEV2ZW50RGVmaW5pdGlvbnNSZXNwb25zZSB7XG4gIGl0ZW1zOiBFdmVudERlZmluaXRpb25bXTtcbiAgY291bnQ6IG51bWJlcjtcbiAgcGFnZTogbnVtYmVyO1xuICBwYWdlU2l6ZTogbnVtYmVyO1xufVxuZXhwb3J0IGludGVyZmFjZSBFdmVudERlZmluaXRpb24ge1xuICBpZDogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIGV2ZW50RGVmaW5pdGlvbktleTogc3RyaW5nO1xuICBkYXRhRXh0ZW5zaW9uSWQ6IHN0cmluZztcbiAgZGF0YUV4dGVuc2lvbk5hbWU6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEYXRhRXh0ZW5zaW9uQXBpUmVzcG9uc2Uge1xuICBpZDogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIGtleTogc3RyaW5nO1xuICBpc1NlbmRhYmxlOiBib29sZWFuO1xufVxuIl19

package/build/utils/batch-processing.bench.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batch-processing.bench.d.ts.map

package/build/utils/batch-processing.bench.d.ts.map

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

package/build/utils/batch-processing.bench.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const node_perf_hooks_1 = require("node:perf_hooks");
+const lodash_1 = __importDefault(require("lodash"));
+const batch_processing_1 = require("./batch-processing");
+async function bench(fn, label, iterations = 5) {
+    let total = 0;
+    for (let i = 0; i < iterations; i += 1) {
+        const start = node_perf_hooks_1.performance.now();
+        // eslint-disable-next-line no-await-in-loop
+        await fn();
+        total += node_perf_hooks_1.performance.now() - start;
+    }
+    const avg = total / iterations;
+    console.log(`${label}: avg ${avg.toFixed(2)} ms over ${iterations} runs`);
+    return avg;
+}
+async function section(title, fn) {
+    console.log(`\n=== ${title} ===`);
+    await fn();
+}
+async function runBenchmarks() {
+    const arr = Array.from({ length: 10_000 }, (_, i) => i);
+    console.log(`Running benchmarks on array of length ${arr.length}`);
+    await section('map', async () => {
+        await bench(() => (0, batch_processing_1.mapInBatches)(arr, (x) => x + 1, { batchSize: 20, yieldThreshold: 10 }), 'mapInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.mapInBatches)(arr, (x) => x + 1, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'mapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.map(arr, (x) => x + 1)), 'lodash.map');
+        await bench(() => Promise.resolve(arr.map((x) => x + 1)), 'Array.prototype.map');
+    });
+    await section('filter', async () => {
+        await bench(() => (0, batch_processing_1.filterInBatches)(arr, (x) => x % 2 === 0, { batchSize: 20, yieldThreshold: 10 }), 'filterInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.filterInBatches)(arr, (x) => x % 2 === 0, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'filterInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.filter(arr, (x) => x % 2 === 0)), 'lodash.filter');
+        await bench(() => Promise.resolve(arr.filter((x) => x % 2 === 0)), 'Array.prototype.filter');
+    });
+    await section('groupBy', async () => {
+        await bench(() => (0, batch_processing_1.groupByInBatches)(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {
+            batchSize: 20,
+            yieldThreshold: 10,
+        }), 'groupByInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.groupByInBatches)(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'groupByInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.groupBy(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'))), 'lodash.groupBy');
+    });
+    await section('reduce', async () => {
+        await bench(() => (0, batch_processing_1.reduceInBatches)(arr, (acc, x) => acc + x, 0, { batchSize: 20, yieldThreshold: 10 }), 'reduceInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => Promise.resolve(lodash_1.default.reduce(arr, (acc, x) => acc + x, 0)), 'lodash.reduce');
+        await bench(() => Promise.resolve(arr.reduce((acc, x) => acc + x, 0)), 'Array.prototype.reduce');
+    });
+    await section('flatMap', async () => {
+        await bench(() => (0, batch_processing_1.flatMapInBatches)(arr, (x) => [x, x], { batchSize: 20, yieldThreshold: 10 }), 'flatMapInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.flatMapInBatches)(arr, (x) => [x, x], {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'flatMapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.flatMap(arr, (x) => [x, x])), 'lodash.flatMap');
+        await bench(() => Promise.resolve(arr.flatMap
+            ? arr.flatMap((x) => [x, x])
+            : [].concat(...arr.map((x) => [x, x]))), 'Array.prototype.flatMap');
+    });
+    await section('forEach', async () => {
+        await bench(() => (0, batch_processing_1.forEachInBatches)(arr, () => { }, { batchSize: 20, yieldThreshold: 10 }), 'forEachInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.forEachInBatches)(arr, () => { }, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'forEachInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(arr.forEach(() => { })), 'Array.prototype.forEach');
+        await bench(() => Promise.resolve(lodash_1.default.forEach(arr, () => { })), 'lodash.forEach');
+    });
+}
+// to run benchmarks use: npx ts-node src/utils/batch-processing.bench.ts
+if (require.main === module) {
+    runBenchmarks().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch-processing.bench.js","sourceRoot":"","sources":["../../src/utils/batch-processing.bench.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport { performance } from 'node:perf_hooks';\nimport lodash from 'lodash';\nimport {\n  mapInBatches,\n  filterInBatches,\n  groupByInBatches,\n  reduceInBatches,\n  flatMapInBatches,\n  forEachInBatches,\n} from './batch-processing';\n\nasync function bench(\n  fn: () => Promise<unknown> | unknown,\n  label: string,\n  iterations = 5,\n): Promise<number> {\n  let total = 0;\n  for (let i = 0; i < iterations; i += 1) {\n    const start = performance.now();\n    // eslint-disable-next-line no-await-in-loop\n    await fn();\n    total += performance.now() - start;\n  }\n  const avg = total / iterations;\n  console.log(`${label}: avg ${avg.toFixed(2)} ms over ${iterations} runs`);\n  return avg;\n}\n\nasync function section(title: string, fn: () => Promise<void>) {\n  console.log(`\\n=== ${title} ===`);\n  await fn();\n}\n\nasync function runBenchmarks() {\n  const arr = Array.from({ length: 10_000 }, (_, i) => i);\n\n  console.log(`Running benchmarks on array of length ${arr.length}`);\n\n  await section('map', async () => {\n    await bench(\n      () => mapInBatches(arr, (x) => x + 1, { batchSize: 20, yieldThreshold: 10 }),\n      'mapInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        mapInBatches(arr, (x) => x + 1, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'mapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.map(arr, (x) => x + 1)), 'lodash.map');\n    await bench(() => Promise.resolve(arr.map((x) => x + 1)), 'Array.prototype.map');\n  });\n\n  await section('filter', async () => {\n    await bench(\n      () => filterInBatches(arr, (x) => x % 2 === 0, { batchSize: 20, yieldThreshold: 10 }),\n      'filterInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        filterInBatches(arr, (x) => x % 2 === 0, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'filterInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.filter(arr, (x) => x % 2 === 0)), 'lodash.filter');\n    await bench(() => Promise.resolve(arr.filter((x) => x % 2 === 0)), 'Array.prototype.filter');\n  });\n\n  await section('groupBy', async () => {\n    await bench(\n      () =>\n        groupByInBatches(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {\n          batchSize: 20,\n          yieldThreshold: 10,\n        }),\n      'groupByInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        groupByInBatches(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'groupByInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(\n      () => Promise.resolve(lodash.groupBy(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'))),\n      'lodash.groupBy',\n    );\n  });\n\n  await section('reduce', async () => {\n    await bench(\n      () => reduceInBatches(arr, (acc, x) => acc + x, 0, { batchSize: 20, yieldThreshold: 10 }),\n      'reduceInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(() => Promise.resolve(lodash.reduce(arr, (acc, x) => acc + x, 0)), 'lodash.reduce');\n    await bench(\n      () => Promise.resolve(arr.reduce((acc, x) => acc + x, 0)),\n      'Array.prototype.reduce',\n    );\n  });\n\n  await section('flatMap', async () => {\n    await bench(\n      () => flatMapInBatches(arr, (x) => [x, x], { batchSize: 20, yieldThreshold: 10 }),\n      'flatMapInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        flatMapInBatches(arr, (x) => [x, x], {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'flatMapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.flatMap(arr, (x) => [x, x])), 'lodash.flatMap');\n    await bench(\n      () =>\n        Promise.resolve(\n          arr.flatMap\n            ? arr.flatMap((x) => [x, x])\n            : ([] as number[]).concat(...arr.map((x) => [x, x])),\n        ),\n      'Array.prototype.flatMap',\n    );\n  });\n\n  await section('forEach', async () => {\n    await bench(\n      () => forEachInBatches(arr, () => {}, { batchSize: 20, yieldThreshold: 10 }),\n      'forEachInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        forEachInBatches(arr, () => {}, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'forEachInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(arr.forEach(() => {})), 'Array.prototype.forEach');\n    await bench(() => Promise.resolve(lodash.forEach(arr, () => {})), 'lodash.forEach');\n  });\n}\n\n// to run benchmarks use: npx ts-node src/utils/batch-processing.bench.ts\nif (require.main === module) {\n  runBenchmarks().catch((err) => {\n    console.error(err);\n    process.exit(1);\n  });\n}\n"]}