shuttlepro-shared 1.2.8 → 1.2.9

package/common/repositories/label.repository.js

@@ -92,153 +92,80 @@ 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 CACHE_KEYS = {
+  ALL_LABELS: "labels:all",
+  WORKSPACE_LABELS: (workspaceId) => `labels:workspace:${workspaceId}`,
+  LABEL_DETAILS: (labelId) => `labels:details:${labelId}`,
+};
 
-  const withCache = R.curry(async (cacheKey, fetchFn, forceFresh = false) => {
-    if (!forceFresh) {
-      const cachedData = await getRedisData(cacheKey);
-      if (cachedData) return cachedData;
-    }
+const CACHE_EXPIRY = 60 * 60; // 1 hour
 
-    const data = await fetchFn();
+// Utility function for caching
+const withCache = async (cacheKey, fetchFn, forceFresh = false) => {
+  if (!forceFresh) {
+    const cachedData = await getRedisData(cacheKey);
+    if (cachedData) return cachedData;
+  }
 
-    if (data && data.length) {
-      await setRedisData(cacheKey, data, null, redisConfig.cache.expiry);
-    }
+  const data = await fetchFn();
+  if (data && data.length) {
+    await setRedisData(cacheKey, data, null, CACHE_EXPIRY);
+  }
 
-    return data;
-  });
+  return data;
+};
 
-  const validateLabel = R.curry((existingLabels, newLabel) => {
-    const isDuplicate = R.any(
-      (label) =>
-        label.title.toLowerCase() === newLabel.title.toLowerCase() &&
-        R.equals(label.workspaceId, newLabel.workspaceId)
-    )(existingLabels);
+// 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
+  );
 
-    if (isDuplicate) {
-      throw new Error("Label with this title already exists");
-    }
+  if (isDuplicate) throw new Error("Label with this title already exists");
 
-    return newLabel;
-  });
+  const newLabel = new Label(labelData);
+  return await newLabel.save();
+};
 
-  const createLabel = async (labelData) => {
-    const create = R.pipe(
-      (label) => label.save(),
-      validateLabel(await Label.find()),
-      Label.hydrate
-    );
-
-    return create(labelData);
-  };
-
-  const findLabels = R.curry(async (options = {}, query = {}) => {
-    const {
-      lean = true,
-      populate = [],
-      sort = { createdAt: -1 },
-      limit = 100,
-    } = options;
-
-    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 cachedFind = await withCache(
-      generateCacheKey(query),
-      () => Label.find(query).exec(),
-      false
-    );
-
-    return executeQuery(cachedFind);
-  });
+const findLabels = async (query = {}, options = {}) => {
+  return await withCache(JSON.stringify(query), () =>
+    Label.find(query)
+      .sort({ createdAt: -1 })
+      .limit(options.limit || 100)
+      .exec()
+  );
+};
 
-  const findAllLabels = R.curry(async (query = {}) => {
-    return await withCache(
-      generateCacheKey(query),
-      () => Label.find(query).exec(),
-      false
-    );
-  });
+const findAllLabels = async (query = {}) => {
+  return await withCache(JSON.stringify(query), () => Label.find(query).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)
-    );
-
-    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 updatedLabel;
+};
 
-  return {
-    createLabel,
-    findLabels,
-    findAllLabels,
-    updateLabel,
-    deleteLabel,
-    filterLabels,
-  };
+const deleteLabel = async (labelId) => {
+  await deleteRedisData(CACHE_KEYS.LABEL_DETAILS(labelId));
+  return await Label.findByIdAndDelete(labelId);
 };
 
-const dependencies = {
-  Label,
-  redisConfig: createConfig(process.env),
+module.exports = {
+  createLabel,
+  findLabels,
+  findAllLabels,
+  updateLabel,
+  deleteLabel,
 };
 
-module.exports = createLabelRepository(dependencies);

package/package.json

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