shuttlepro-shared 1.2.4 → 1.2.5

package/common/repositories/label.repository.js

@@ -1,85 +1,258 @@
-const { getRedisData, setRedisData } = require("../../config/redis");
-const Label = require("../../models/Label");
+// 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 CACHE_KEY_ALL = "labels_all";
 
-const updateCachedLabels = async () => {
-  const labels = await Label.find().lean().exec();
-  await setRedisData(CACHE_KEY_ALL, JSON.stringify(labels));
-};
+// 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 createLabel = async (data) => {
-  const newLabel = new Label(data);
-  const savedLabel = await newLabel.save();
-  await updateCachedLabels();
-  return savedLabel;
-};
+// const updateCachedLabels = async () => {
+//   const labels = await Label.find().lean().exec();
+//   await setRedisData(CACHE_KEY_ALL, JSON.stringify(labels));
+// };
 
-const findLabelById = async (id) => {
-  const labels = await getCachedLabels();
-  return labels.find((l) => l._id.toString() === id) || null;
-};
+// 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;
+// };
 
-const findLabel = async (filter) => {
-  const labels = await getCachedLabels();
-  return (
-    labels.find((l) =>
-      Object.entries(filter).every(([key, value]) => l[key] === value)
-    ) || null
+// module.exports = {
+//   createLabel,
+//   findLabelById,
+//   findLabel,
+//   findAllLabels,
+//   updateLabel,
+//   deleteLabel,
+//   updateLabelById,
+// };
+
+const R = require("ramda");
+const Label = require("../../models/Label");
+const {
+  setRedisData,
+  getRedisData,
+  deleteRedisData,
+} = require("../../config/redis");
+
+// Configuration as a pure function
+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, // 1 hour
+  },
+});
+
+// Pure query construction function
+const constructQuery = R.curry((baseQuery, additionalQuery) =>
+  R.mergeDeepRight(baseQuery, additionalQuery)
+);
+
+// Functional label repository
+const createLabelRepository = (dependencies) => {
+  const { Label, redisConfig } = dependencies;
+
+  // Pure function for generating cache key
+  const generateCacheKey = R.pipe(
+    R.toPairs,
+    R.map(([key, value]) => `${key}:${JSON.stringify(value)}`),
+    R.join("|"),
+    R.concat("labels:query:")
   );
-};
 
-const findAllLabels = async (filter = {}) => {
-  const labels = await getCachedLabels();
-  return labels.filter((l) =>
-    Object.entries(filter).every(([key, value]) => l[key] === value)
+  // Caching Higher-Order Function
+  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;
+  });
+
+  // Pure validation function
+  const validateLabel = R.curry((existingLabels, newLabel) => {
+    const isDuplicate = R.any(
+      (label) =>
+        label.title.toLowerCase() === newLabel.title.toLowerCase() &&
+        R.equals(label.workspaceId, newLabel.workspaceId)
+    )(existingLabels);
+
+    if (isDuplicate) {
+      throw new Error("Label with this title already exists");
+    }
+
+    return newLabel;
+  });
+
+  // Functional CRUD Operations
+  const createLabel = async (labelData) => {
+    // Compose validation and creation
+    const create = R.composeP(
+      (label) => label.save(),
+      validateLabel(await Label.find()),
+      Label.hydrate
+    );
+
+    return create(labelData);
+  };
+
+  // Advanced finding with functional composition
+  const findLabels = R.curry(async (options = {}, query = {}) => {
+    const {
+      lean = true,
+      populate = [],
+      sort = { createdAt: -1 },
+      limit = 100,
+    } = options;
+
+    // Compose query construction and execution
+    const executeQuery = R.composeP(
+      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)
+    );
+
+    // Use cache wrapper
+    const cachedFind = withCache(
+      generateCacheKey(query),
+      () => Label.find(query).exec(),
+      false
+    );
+
+    return executeQuery(await cachedFind());
+  });
+
+  // Functional update with immutable updates
+  const updateLabel = R.curry(async (labelId, updateData) => {
+    const update = R.composeP(
+      R.tap(async (updatedLabel) => {
+        // Update cache atomically
+        await setRedisData(
+          redisConfig.cache.keys.LABEL_DETAILS(labelId),
+          updatedLabel.toObject()
+        );
+      }),
+      (label) => label.save(),
+      (label) => {
+        // Immutable update
+        const updatedFields = R.mergeDeepRight(label.toObject(), updateData);
+        return Label.hydrate(updatedFields);
+      },
+      () => Label.findById(labelId)
+    );
+
+    return update();
+  });
+
+  // Functional delete with side effect management
+  const deleteLabel = async (labelId) => {
+    const performDelete = R.composeP(
+      R.tap(async () => {
+        // Clear all related caches
+        await deleteRedisData(redisConfig.cache.keys.LABEL_DETAILS(labelId));
+      }),
+      (label) => label.remove(),
+      () => Label.findById(labelId)
+    );
+
+    return performDelete();
+  };
+
+  // Advanced filtering with functional transformations
+  const filterLabels = R.curry((filterFn, labels) =>
+    R.filter(filterFn, labels)
   );
-};
 
-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;
+  // Public API
+  return {
+    createLabel,
+    findLabels,
+    updateLabel,
+    deleteLabel,
+    filterLabels,
+  };
 };
 
-const deleteLabel = async (id) => {
-  const deletedLabel = await Label.findByIdAndDelete(id).exec();
-  if (deletedLabel) {
-    await updateCachedLabels();
-  }
-  return deletedLabel;
+// Dependency Injection
+const dependencies = {
+  Label,
+  redisConfig: createConfig(process.env),
 };
 
-module.exports = {
-  createLabel,
-  findLabelById,
-  findLabel,
-  findAllLabels,
-  updateLabel,
-  deleteLabel,
-  updateLabelById,
-};
+module.exports = createLabelRepository(dependencies);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -16,13 +16,14 @@
     "@babel/plugin-proposal-decorators": "^7.22.5",
     "@babel/preset-env": "^7.22.5",
     "@babel/register": "^7.22.5",
-    "redis": "^4.6.14",
+    "bull": "^4.10.4",
+    "cors": "^2.8.5",
     "express": "^4.17.1",
+    "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.7.1",
-    "cors": "^2.8.5",
-    "helmet": "^8.0.0",
-    "bull": "^4.10.4",
+    "ramda": "^0.30.1",
+    "redis": "^4.6.14",
     "socket.io": "^4.8.1"
   }
 }