shuttlepro-shared 1.2.8 → 1.2.10

package/common/repositories/label.repository.js

@@ -1,90 +1,3 @@
-// const { getRedisData, setRedisData } = require("../../config/redis");
-// const Label = require("../../models/Label");
-
-// const CACHE_KEY_ALL = "labels_all";
-
-// const getCachedLabels = async () => {
-//   let labels = await getRedisData(CACHE_KEY_ALL);
-//   if (!labels) {
-//     labels = await Label.find().lean().exec();
-//     await setRedisData(CACHE_KEY_ALL, JSON.stringify(labels));
-//   } else {
-//     labels = JSON.parse(labels);
-//   }
-//   return labels;
-// };
-
-// const updateCachedLabels = async () => {
-//   const labels = await Label.find().lean().exec();
-//   await setRedisData(CACHE_KEY_ALL, JSON.stringify(labels));
-// };
-
-// const createLabel = async (data) => {
-//   const newLabel = new Label(data);
-//   const savedLabel = await newLabel.save();
-//   await updateCachedLabels();
-//   return savedLabel;
-// };
-
-// const findLabelById = async (id) => {
-//   const labels = await getCachedLabels();
-//   return labels.find((l) => l._id.toString() === id) || null;
-// };
-
-// const findLabel = async (filter) => {
-//   const labels = await getCachedLabels();
-//   return (
-//     labels.find((l) =>
-//       Object.entries(filter).every(([key, value]) => l[key] === value)
-//     ) || null
-//   );
-// };
-
-// const findAllLabels = async (filter = {}) => {
-//   const labels = await getCachedLabels();
-//   return labels.filter((l) =>
-//     Object.entries(filter).every(([key, value]) => l[key] === value)
-//   );
-// };
-
-// const updateLabelById = async (id, data) => {
-//   const updatedLabel = await Label.findByIdAndUpdate(id, data, {
-//     new: true,
-//   }).exec();
-//   if (updatedLabel) {
-//     await updateCachedLabels();
-//   }
-//   return updatedLabel;
-// };
-// const updateLabel = async (filter, data) => {
-//   const updatedLabel = await Label.findOneAndUpdate(filter, data, {
-//     new: true,
-//   }).exec();
-//   if (updatedLabel) {
-//     await updateCachedLabels();
-//   }
-//   return updatedLabel;
-// };
-
-// const deleteLabel = async (id) => {
-//   const deletedLabel = await Label.findByIdAndDelete(id).exec();
-//   if (deletedLabel) {
-//     await updateCachedLabels();
-//   }
-//   return deletedLabel;
-// };
-
-// module.exports = {
-//   createLabel,
-//   findLabelById,
-//   findLabel,
-//   findAllLabels,
-//   updateLabel,
-//   deleteLabel,
-//   updateLabelById,
-// };
-
-const R = require("ramda");
 const Label = require("../../models/Label");
 const {
   setRedisData,
@@ -92,153 +5,91 @@ const {
   deleteRedisData,
 } = require("../../config/redis");
 
-const createConfig = (env) => ({
-  cache: {
-    keys: {
-      ALL_LABELS: "labels:all",
-      WORKSPACE_LABELS: R.memoizeWith(
-        R.identity,
-        (workspaceId) => `labels:workspace:${workspaceId}`
-      ),
-      LABEL_DETAILS: R.memoizeWith(
-        R.identity,
-        (labelId) => `labels:details:${labelId}`
-      ),
-    },
-    expiry: 60 * 60,
-  },
-});
-
-const createLabelRepository = (dependencies) => {
-  const { Label, redisConfig } = dependencies;
-
-  const generateCacheKey = R.pipe(
-    R.toPairs,
-    R.map(([key, value]) => `${key}:${JSON.stringify(value)}`),
-    R.join("|"),
-    R.concat("labels:query:")
-  );
-
-  const withCache = R.curry(async (cacheKey, fetchFn, forceFresh = false) => {
-    if (!forceFresh) {
-      const cachedData = await getRedisData(cacheKey);
-      if (cachedData) return cachedData;
-    }
-
-    const data = await fetchFn();
-
-    if (data && data.length) {
-      await setRedisData(cacheKey, data, null, redisConfig.cache.expiry);
-    }
-
-    return data;
-  });
+const CACHE_KEYS = {
+  ALL_LABELS: "labels:all",
+  WORKSPACE_LABELS: (workspaceId) => `labels:workspace:${workspaceId}`,
+  LABEL_DETAILS: (labelId) => `labels:details:${labelId}`,
+};
 
-  const validateLabel = R.curry((existingLabels, newLabel) => {
-    const isDuplicate = R.any(
-      (label) =>
-        label.title.toLowerCase() === newLabel.title.toLowerCase() &&
-        R.equals(label.workspaceId, newLabel.workspaceId)
-    )(existingLabels);
+const CACHE_EXPIRY = 60 * 60; // 1 hour
 
-    if (isDuplicate) {
-      throw new Error("Label with this title already exists");
-    }
+// Utility function for caching
+const withCache = async (cacheKey, fetchFn, forceFresh = false) => {
+  if (!forceFresh) {
+    const cachedData = await getRedisData(cacheKey);
+    if (cachedData) return cachedData;
+  }
 
-    return newLabel;
-  });
+  const data = await fetchFn();
+  if (data && data.length) {
+    await setRedisData(cacheKey, data, null, CACHE_EXPIRY);
+  }
 
-  const createLabel = async (labelData) => {
-    const create = R.pipe(
-      (label) => label.save(),
-      validateLabel(await Label.find()),
-      Label.hydrate
-    );
+  return data;
+};
 
-    return create(labelData);
-  };
+// Core functions
+const createLabel = async (labelData) => {
+  const existingLabels = await Label.find();
+  const isDuplicate = existingLabels.some(
+    (label) =>
+      label.title.toLowerCase() === labelData.title.toLowerCase() &&
+      label.workspaceId === labelData.workspaceId
+  );
 
-  const findLabels = R.curry(async (options = {}, query = {}) => {
-    const {
-      lean = true,
-      populate = [],
-      sort = { createdAt: -1 },
-      limit = 100,
-    } = options;
+  if (isDuplicate) throw new Error("Label with this title already exists");
 
-    const executeQuery = R.pipe(
-      R.when(R.always(lean), R.map(R.prop("toObject"))),
-      (labels) => (populate.length ? Label.populate(labels, populate) : labels),
-      (labels) => R.take(limit, labels),
-      (labels) =>
-        R.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt), labels)
-    );
+  const newLabel = new Label(labelData);
+  return await newLabel.save();
+};
 
-    const cachedFind = await withCache(
-      generateCacheKey(query),
-      () => Label.find(query).exec(),
-      false
-    );
+const findLabels = async (query = {}, options = {}) => {
+  return await withCache(JSON.stringify(query), () =>
+    Label.find(query)
+      .sort({ createdAt: -1 })
+      .limit(options.limit || 100)
+      .exec()
+  );
+};
 
-    return executeQuery(cachedFind);
-  });
+const findAllLabels = async (query = {}) => {
+  return await withCache(JSON.stringify(query), () => Label.find(query).exec());
+};
 
-  const findAllLabels = R.curry(async (query = {}) => {
-    return await withCache(
-      generateCacheKey(query),
-      () => Label.find(query).exec(),
-      false
-    );
-  });
+const findLabelById = async (labelId) => {
+  return await withCache(CACHE_KEYS.LABEL_DETAILS(labelId), () =>
+    Label.findById(labelId).exec()
+  );
+};
 
-  const updateLabel = R.curry(async (labelId, updateData) => {
-    const update = R.pipe(
-      R.tap(async (updatedLabel) => {
-        await setRedisData(
-          redisConfig.cache.keys.LABEL_DETAILS(labelId),
-          updatedLabel.toObject()
-        );
-      }),
-      (label) => label.save(),
-      (label) => {
-        const updatedFields = R.mergeDeepRight(label.toObject(), updateData);
-        return Label.hydrate(updatedFields);
-      },
-      () => Label.findById(labelId)
-    );
+const findLabel = async (query = {}) => {
+  return await Label.findOne(query).exec();
+};
 
-    return update();
+const updateLabel = async (labelId, updateData) => {
+  const updatedLabel = await Label.findByIdAndUpdate(labelId, updateData, {
+    new: true,
   });
-
-  const deleteLabel = async (labelId) => {
-    const performDelete = R.pipe(
-      R.tap(async () => {
-        await deleteRedisData(redisConfig.cache.keys.LABEL_DETAILS(labelId));
-      }),
-      (label) => label.remove(),
-      () => Label.findById(labelId)
-    );
-
-    return performDelete();
-  };
-
-  const filterLabels = R.curry((filterFn, labels) =>
-    R.filter(filterFn, labels)
+  await setRedisData(
+    CACHE_KEYS.LABEL_DETAILS(labelId),
+    updatedLabel.toObject(),
+    null,
+    CACHE_EXPIRY
   );
-
-  return {
-    createLabel,
-    findLabels,
-    findAllLabels,
-    updateLabel,
-    deleteLabel,
-    filterLabels,
-  };
+  return updatedLabel;
 };
 
-const dependencies = {
-  Label,
-  redisConfig: createConfig(process.env),
+const deleteLabel = async (labelId) => {
+  await deleteRedisData(CACHE_KEYS.LABEL_DETAILS(labelId));
+  return await Label.findByIdAndDelete(labelId);
 };
 
-module.exports = createLabelRepository(dependencies);
+module.exports = {
+  createLabel,
+  findLabels,
+  findAllLabels,
+  findLabelById,
+  findLabel,
+  updateLabel,
+  deleteLabel,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "",
   "main": "index.js",
   "scripts": {