pim-import 2.59.0 → 2.61.0

package/src/algolia/models.ts

@@ -123,6 +123,13 @@ const getModelAutodescription = async (productLineCode: string) => {
   );
 };
 
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.slugs?.[defaultEnvironmentLocaleCode];
+};
+
 const getObject = async (
   topicModel: string | Entry
 ): Promise<AlgoliaModelRecord> => {
@@ -265,21 +272,18 @@ const getObject = async (
   return record;
 };
 
-const isObjectToDelete = (object: any) => {
-  return Object.entries(object).length === 1;
-};
-
 export const reindexModel = async (topicModelId: string) => {
   const timeStart = new Date();
 
   log(`reindexModel - entryId: ${topicModelId} `);
 
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
   const object = await getObject(topicModelId);
 
   // Save record to Algolia
   const index = getIndex(indexKey);
   let record = null;
-  if (!isObjectToDelete(object)) {
+  if (!isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
     log(`Save object`);
     record = await index.saveObject(object);
   } else {
@@ -342,13 +346,14 @@ export const reindexModels = async (
   log(
     `reindexModels - offset: ${offset} limit: ${limit} catalogCode: ${catalogCode}`
   );
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
 
   const records = await getObjects(offset, limit, catalogCode);
   const objectsToSave = records.objects.filter(
-    (object) => !isObjectToDelete(object)
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
   );
   const objectIdsToDelete = records.objects
-    .filter((object) => isObjectToDelete(object))
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
     .map((object) => object.objectID);
 
   // Save records to Algolia

package/src/algolia/news.ts

@@ -0,0 +1,228 @@
+import { log } from "../libs/logs";
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+  getTopicPage,
+} from "../libs/contentful-cda";
+import { getIndex, AvailableIndicesKey, removeIndexObject } from "./config";
+import { getLocalISOTime, secondBetweenTwoDate } from "../utils";
+import type { Entry } from "contentful-management/dist/typings/entities/entry";
+import {
+  CfLocalizedEntryField,
+  AlgoliaPaginateRecords,
+  WrapperImageFields,
+} from "../types";
+import { getWrapperImgixFields } from "../libs/imgix";
+
+const indexKey: AvailableIndicesKey = "news";
+
+export type AlgoliaPostRecord = {
+  objectID: string;
+  name?: CfLocalizedEntryField;
+  slugs?: {};
+  previewExcerpt?: string;
+  thumbnailImageImgix?: WrapperImageFields | {};
+  fullScreenImageImgix?: WrapperImageFields | {};
+  visualizationDate?: string;
+  lastSyncDate?: string;
+};
+
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.slugs?.[defaultEnvironmentLocaleCode];
+};
+
+const getObject = async (topicNews: Entry): Promise<AlgoliaPostRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Sync the ${topicNews.sys.id} topicNews...`);
+  let topicNewsWithFields: Entry = topicNews;
+
+  if (!topicNewsWithFields?.fields) {
+    log(`Get the ${topicNews.sys.id} topicNews details...`);
+    topicNewsWithFields = await getEntryByID(topicNews.sys.id, "topicNews");
+  }
+
+  if (!topicNewsWithFields) {
+    log(`The topicNews ${topicNews.sys.id} not found`, "WARN");
+
+    const recordFail: AlgoliaPostRecord = {
+      objectID: topicNews?.sys?.id,
+    };
+
+    return recordFail; // return objectID to delete the record if it exists
+  }
+
+  log(`Get page details...`);
+  const page = await getTopicPage(topicNews.sys.id, "fields.slug");
+  const slugs = page?.fields.slug || {};
+
+  log(`Get thumbnail imgix details...`);
+  let thumbnailImageImgix = {};
+  const thumbnailImgixWrapperImgixID =
+    topicNewsWithFields?.fields?.thumbnailImageImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (thumbnailImgixWrapperImgixID) {
+    thumbnailImageImgix = await getWrapperImgixFields(
+      thumbnailImgixWrapperImgixID
+    );
+  } else {
+    log(`No thumbnail imgix found`, "WARN");
+  }
+
+  log(`Get fullScreenImageImgix imgix details...`);
+  let fullScreenImageImgix = {};
+  const fullScreenImageImgixWrapperImgixID =
+    topicNewsWithFields?.fields?.fullScreenImageImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (fullScreenImageImgixWrapperImgixID) {
+    fullScreenImageImgix = await getWrapperImgixFields(
+      fullScreenImageImgixWrapperImgixID
+    );
+  } else {
+    log(`No fullScreenImageImgix found`, "WARN");
+  }
+
+  // Single record
+  const record: AlgoliaPostRecord = {
+    objectID: topicNewsWithFields.sys.id,
+    name:
+      topicNewsWithFields?.fields?.title?.[defaultEnvironmentLocaleCode] || "",
+    slugs,
+    thumbnailImageImgix,
+    fullScreenImageImgix,
+    visualizationDate:
+      topicNewsWithFields?.fields?.visualizationDate?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+export const reindexPost = async (topicNewsId: string) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+
+  log(`reindexPost - entryId: ${topicNewsId} `);
+
+  const topicNews = await getEntryByID(topicNewsId, "topicNews");
+
+  if (!topicNews) {
+    log(`No topicNews found with id ${topicNewsId}`, "WARN");
+    return false;
+  }
+
+  const object = await getObject(topicNews);
+
+  // Save record to Algolia
+  const index = getIndex(indexKey);
+  let record = null;
+  if (!isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
+    log(`Save object`);
+    record = await index.saveObject(object);
+  } else {
+    log(`Delete object`);
+    record = await index.deleteObject(object.objectID);
+  }
+  const timeEnd = new Date();
+  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+  log(`Execution time: ${seconds} seconds`);
+
+  return { ...record, ...object };
+};
+
+/**
+ * Get Objects
+ *
+ * @param offset
+ * @param limit
+ * @param filterKey
+ * @param filterValue
+ * @returns
+ */
+const getObjects = async (
+  offset: number,
+  limit: number,
+  filterKey?: string,
+  filterValue?: string
+): Promise<AlgoliaPaginateRecords> => {
+  const client = await getClient();
+
+  const opts: any = {
+    content_type: "topicNews",
+    limit,
+    skip: offset,
+    locale: "*",
+    // select: "",
+  };
+  if (filterKey && filterValue) {
+    opts[filterKey] = filterValue;
+  }
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaPostRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicNews of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicNews);
+    const timeEnd = new Date();
+    const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+    log(`Execution time: ${seconds} seconds`);
+    objects.push(record);
+  }
+
+  return {
+    objects,
+    offset: Number(offset) + Number(limit),
+    limit: Number(limit),
+    completed: count >= total, // if is true the import is completed
+    total,
+  };
+};
+
+export const reindexPosts = async (
+  offset: number = 0,
+  limit: number = 50,
+  filterKey: string = "",
+  filterValue: string = ""
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+  log(
+    `reindexPosts - filterKey: ${filterKey} filterValue: ${filterValue} offset: ${offset} limit: ${limit} `
+  );
+
+  const records = await getObjects(offset, limit, filterKey, filterValue);
+  const objectsToSave = records.objects.filter(
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
+  );
+  const objectIdsToDelete = records.objects
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
+    .map((object) => object.objectID);
+
+  // Save records to Algolia
+  const index = getIndex(indexKey);
+  log(`Save ${objectsToSave.length} objects to ${index.indexName} index`);
+  const savedObjectIDs = await index.saveObjects(objectsToSave);
+  log(
+    `Delete ${objectIdsToDelete.length} objects from ${index.indexName} index`
+  );
+  const deletedObjectIDs = await index.deleteObjects(objectIdsToDelete);
+
+  const timeEnd = new Date();
+  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+  log(`Execution time: ${seconds} seconds`);
+
+  return { ...records, ...savedObjectIDs, ...deletedObjectIDs };
+};
+
+export const removePostObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/algolia/pipedreamReindex.ts

@@ -19,7 +19,6 @@ export const pipedreamReindex = async (
     );
     return;
   }
-  console.log(`reindexType: ${reindexType} catalogCode: ${catalogCode}`);
 
   axios.post(process.env.FPI_PIPEDREAM_ALGOLIA, {
     isReindexByImport: true,

package/src/algolia/pressRelease.ts

@@ -0,0 +1,241 @@
+import { log } from "../libs/logs";
+import {
+  getClient,
+  getEnvironmentDefaultLocaleCode,
+  getEntryByID,
+  getTopicDetails,
+} from "../libs/contentful-cda";
+import { getIndex, AvailableIndicesKey, removeIndexObject } from "./config";
+import { getLocalISOTime, secondBetweenTwoDate } from "../utils";
+import type { Entry } from "contentful-management/dist/typings/entities/entry";
+import {
+  CfLocalizedEntryField,
+  AlgoliaPaginateRecords,
+  WrapperImageFields,
+  TopicDetailsResponse,
+  CfSys,
+} from "../types";
+import { getWrapperImgixFields } from "../libs/imgix";
+import { getAssetsByComponentAssetIds } from "./downloads";
+
+const indexKey: AvailableIndicesKey = "pressRelease";
+
+export type AlgoliaPressReleaseRecord = {
+  objectID: string;
+  name?: CfLocalizedEntryField;
+  description?: string;
+  thumbnailImgix?: WrapperImageFields | {};
+  lastSyncDate?: string;
+  category?: TopicDetailsResponse;
+  assets?: {};
+  visualizationDate?: string;
+};
+
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.name?.[defaultEnvironmentLocaleCode];
+};
+
+const getObject = async (
+  topicPressRelease: Entry
+): Promise<AlgoliaPressReleaseRecord> => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  log(`Sync the ${topicPressRelease.sys.id} topicPressRelease...`);
+  let topicPressReleaseWithFields: Entry = topicPressRelease;
+
+  if (!topicPressReleaseWithFields?.fields) {
+    log(`Get the ${topicPressRelease.sys.id} topicPressRelease details...`);
+    topicPressReleaseWithFields = await getEntryByID(
+      topicPressRelease.sys.id,
+      "topicPressRelease"
+    );
+  }
+
+  if (!topicPressReleaseWithFields) {
+    log(`The topicPressRelease ${topicPressRelease.sys.id} not found`, "WARN");
+
+    const recordFail: AlgoliaPressReleaseRecord = {
+      objectID: topicPressRelease?.sys?.id,
+    };
+
+    return recordFail; // return objectID to delete the record if it exists
+  }
+
+  log(`Get thumbnail imgix details...`);
+  let thumbnailImgix = {};
+  const thumbnailImgixWrapperImgixID =
+    topicPressReleaseWithFields?.fields?.thumbnailImgix?.[
+      defaultEnvironmentLocaleCode
+    ]?.sys.id;
+  if (thumbnailImgixWrapperImgixID) {
+    thumbnailImgix = await getWrapperImgixFields(thumbnailImgixWrapperImgixID);
+  } else {
+    log(`No thumbnail imgix found`, "WARN");
+  }
+
+  log(`Get category details...`);
+  const category = await getTopicDetails(
+    topicPressReleaseWithFields,
+    "category",
+    "topicPressReleaseCategory",
+    true,
+    false,
+    false,
+    true
+  );
+
+  log(`Get assets details...`);
+  let assets: any = [];
+  const componentAssets =
+    topicPressReleaseWithFields?.fields?.assets?.[defaultEnvironmentLocaleCode];
+  if (componentAssets) {
+    const componentAssetIds = componentAssets.map(
+      (item: CfSys) => item?.sys?.id
+    );
+    assets = await getAssetsByComponentAssetIds(componentAssetIds);
+  }
+
+  // Single record
+  const record: AlgoliaPressReleaseRecord = {
+    objectID: topicPressReleaseWithFields.sys.id,
+    name: topicPressReleaseWithFields?.fields?.name,
+    description: topicPressReleaseWithFields?.fields?.description,
+    thumbnailImgix,
+    category: category?.[0],
+    assets,
+    visualizationDate:
+      topicPressReleaseWithFields?.fields?.visualizationDate?.[
+        defaultEnvironmentLocaleCode
+      ] || "",
+    lastSyncDate: getLocalISOTime(),
+  };
+
+  return record;
+};
+
+export const reindexPressRelease = async (topicPressReleaseId: string) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+
+  log(`reindexPressRelease - entryId: ${topicPressReleaseId} `);
+
+  const topicPressRelease = await getEntryByID(
+    topicPressReleaseId,
+    "topicPressRelease"
+  );
+
+  if (!topicPressRelease) {
+    log(`No topicPressReleaseId found with id ${topicPressReleaseId}`, "WARN");
+    return false;
+  }
+
+  const object = await getObject(topicPressRelease);
+
+  // Save record to Algolia
+  const index = getIndex(indexKey);
+  let record = null;
+  if (!isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
+    log(`Save object`);
+    record = await index.saveObject(object);
+  } else {
+    log(`Delete object`);
+    record = await index.deleteObject(object.objectID);
+  }
+  const timeEnd = new Date();
+  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+  log(`Execution time: ${seconds} seconds`);
+
+  return { ...record, ...object };
+};
+
+/**
+ * Get Objects
+ *
+ * @param offset
+ * @param limit
+ * @param filterKey
+ * @param filterValue
+ * @returns
+ */
+const getObjects = async (
+  offset: number,
+  limit: number,
+  filterKey?: string,
+  filterValue?: string
+): Promise<AlgoliaPaginateRecords> => {
+  const client = await getClient();
+
+  const opts: any = {
+    content_type: "topicPressRelease",
+    limit,
+    skip: offset,
+    locale: "*",
+    // select: "",
+  };
+  if (filterKey && filterValue) {
+    opts[filterKey] = filterValue;
+  }
+  const { items, total } = await client.getEntries(opts);
+
+  const objects: AlgoliaPressReleaseRecord[] = [];
+  let count: number = Number(offset);
+  for (const topicPressRelease of items) {
+    log(`${++count} of ${total}`, "INFO");
+    const timeStart = new Date();
+    const record = await getObject(topicPressRelease);
+    const timeEnd = new Date();
+    const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+    log(`Execution time: ${seconds} seconds`);
+    objects.push(record);
+  }
+
+  return {
+    objects,
+    offset: Number(offset) + Number(limit),
+    limit: Number(limit),
+    completed: count >= total, // if is true the import is completed
+    total,
+  };
+};
+
+export const reindexPressReleases = async (
+  offset: number = 0,
+  limit: number = 50,
+  filterKey: string = "",
+  filterValue: string = ""
+) => {
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const timeStart = new Date();
+  log(
+    `reindexPressReleases - filterKey: ${filterKey} filterValue: ${filterValue} offset: ${offset} limit: ${limit} `
+  );
+
+  const records = await getObjects(offset, limit, filterKey, filterValue);
+  const objectsToSave = records.objects.filter(
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
+  );
+  const objectIdsToDelete = records.objects
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
+    .map((object) => object.objectID);
+
+  // Save records to Algolia
+  const index = getIndex(indexKey);
+  log(`Save ${objectsToSave.length} objects to ${index.indexName} index`);
+  const savedObjectIDs = await index.saveObjects(objectsToSave);
+  log(
+    `Delete ${objectIdsToDelete.length} objects from ${index.indexName} index`
+  );
+  const deletedObjectIDs = await index.deleteObjects(objectIdsToDelete);
+
+  const timeEnd = new Date();
+  const seconds = secondBetweenTwoDate(timeStart, timeEnd);
+  log(`Execution time: ${seconds} seconds`);
+
+  return { ...records, ...savedObjectIDs, ...deletedObjectIDs };
+};
+
+export const removePressReleaseObject = async (objectId: string) => {
+  return removeIndexObject(objectId, indexKey);
+};

package/src/algolia/pressReview.ts

@@ -28,6 +28,13 @@ export type AlgoliaPressReviewRecord = {
   lastSyncDate?: string;
 };
 
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.name?.[defaultEnvironmentLocaleCode];
+};
+
 const getObject = async (
   topicPressReview: Entry
 ): Promise<AlgoliaPressReviewRecord> => {
@@ -122,8 +129,7 @@ export const reindexPressReview = async (topicPressReviewId: string) => {
   // Save record to Algolia
   const index = getIndex(indexKey);
   let record = null;
-  const names: any = object?.name;
-  if (names?.[defaultEnvironmentLocaleCode]) {
+  if (!isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
     log(`Save object`);
     record = await index.saveObject(object);
   } else {
@@ -201,10 +207,10 @@ export const reindexPressReviews = async (
 
   const records = await getObjects(offset, limit, filterKey, filterValue);
   const objectsToSave = records.objects.filter(
-    (object) => object?.slugs?.[defaultEnvironmentLocaleCode]
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
   );
   const objectIdsToDelete = records.objects
-    .filter((object) => !object?.slugs?.[defaultEnvironmentLocaleCode])
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
     .map((object) => object.objectID);
 
   // Save records to Algolia

package/src/algolia/products.ts

@@ -74,6 +74,13 @@ const pipedreamPDFGenerator = async (topicProductId: string) => {
   }
 };
 
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.code || !object?.slugs?.[defaultEnvironmentLocaleCode];
+};
+
 const getObject = async (
   topicProduct: Entry
 ): Promise<AlgoliaProductRecord> => {
@@ -341,6 +348,7 @@ export const reindexProduct = async (
 
   log(`reindexProduct - entryId: ${topicProductId} `);
 
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
   const topicProduct = await getEntryByID(
     topicProductId,
     "topicProduct",
@@ -356,7 +364,7 @@ export const reindexProduct = async (
   // Save record to Algolia
   const index = getIndex(indexKey);
   let record = null;
-  if (object?.code) {
+  if (!isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
     log(`Save object`);
     record = await index.saveObject(object);
     if (generatePdf && record?.objectID) {
@@ -447,9 +455,12 @@ export const reindexProducts = async (
     limit,
     lastPimSyncDateGte
   );
-  const objectsToSave = records.objects.filter((object) => object?.code);
+  const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
+  const objectsToSave = records.objects.filter(
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
+  );
   const objectIdsToDelete = records.objects
-    .filter((object) => !object?.code)
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
     .map((object) => object.objectID);
 
   // Save records to Algolia

package/src/algolia/projects.ts

@@ -33,6 +33,13 @@ export type AlgoliaProjectRecord = {
   lastSyncDate?: string;
 };
 
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.slugs?.[defaultEnvironmentLocaleCode];
+};
+
 const getObject = async (
   topicProject: Entry
 ): Promise<AlgoliaProjectRecord> => {
@@ -166,8 +173,7 @@ export const reindexProject = async (topicProjectId: string) => {
   // Save record to Algolia
   const index = getIndex(indexKey);
   let record = null;
-  const slugs: any = object?.slugs;
-  if (slugs?.[defaultEnvironmentLocaleCode]) {
+  if (!isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
     log(`Save object`);
     record = await index.saveObject(object);
   } else {
@@ -245,10 +251,10 @@ export const reindexProjects = async (
 
   const records = await getObjects(offset, limit, filterKey, filterValue);
   const objectsToSave = records.objects.filter(
-    (object) => object?.slugs?.[defaultEnvironmentLocaleCode]
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
   );
   const objectIdsToDelete = records.objects
-    .filter((object) => !object?.slugs?.[defaultEnvironmentLocaleCode])
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
     .map((object) => object.objectID);
 
   // Save records to Algolia

package/src/algolia/stories.ts

@@ -34,6 +34,13 @@ export type AlgoliaStoryRecord = {
   lastSyncDate?: string;
 };
 
+const isObjectToDelete = (
+  object: any,
+  defaultEnvironmentLocaleCode: string
+) => {
+  return !object?.slugs?.[defaultEnvironmentLocaleCode];
+};
+
 const getObject = async (topicStory: Entry): Promise<AlgoliaStoryRecord> => {
   const defaultEnvironmentLocaleCode = await getEnvironmentDefaultLocaleCode();
   log(`Sync the ${topicStory.sys.id} topicStory...`);
@@ -194,8 +201,7 @@ export const reindexStory = async (topicStoryId: string) => {
   // Save record to Algolia
   const index = getIndex(indexKey);
   let record = null;
-  const slugs: any = object?.slugs;
-  if (slugs?.[defaultEnvironmentLocaleCode]) {
+  if (isObjectToDelete(object, defaultEnvironmentLocaleCode)) {
     log(`Save object to ${index.indexName} index`);
     record = await index.saveObject(object);
   } else {
@@ -273,10 +279,10 @@ export const reindexStories = async (
 
   const records = await getObjects(offset, limit, filterKey, filterValue);
   const objectsToSave = records.objects.filter(
-    (object) => object?.slugs?.[defaultEnvironmentLocaleCode]
+    (object) => !isObjectToDelete(object, defaultEnvironmentLocaleCode)
   );
   const objectIdsToDelete = records.objects
-    .filter((object) => !object?.slugs?.[defaultEnvironmentLocaleCode])
+    .filter((object) => isObjectToDelete(object, defaultEnvironmentLocaleCode))
     .map((object) => object.objectID);
 
   // Save records to Algolia