@drawbridge/mongodb 0.0.1

package/dist/index.js

@@ -0,0 +1,362 @@
+// index.js
+var { ObjectId } = require("mongodb");
+var ids = ({
+  _id
+}) => {
+  const id = _id || new ObjectId();
+  return {
+    _id: id,
+    id: id.toString()
+  };
+};
+var formats = {
+  documents: {
+    insert: (data, authenticated) => {
+      const date = /* @__PURE__ */ new Date();
+      return {
+        createdAt: date,
+        updatedAt: date,
+        ...ids(data),
+        ...authenticated && {
+          createdBy: (authenticated == null ? void 0 : authenticated.id) + "." + date.getTime()
+        },
+        ...data
+      };
+    },
+    update: ({
+      $set,
+      $setOnInsert,
+      ...rest
+    }, authenticated) => {
+      const date = /* @__PURE__ */ new Date();
+      return {
+        $set: {
+          updatedAt: date,
+          ...authenticated && {
+            updatedBy: (authenticated == null ? void 0 : authenticated.id) + "." + date.getTime()
+          },
+          ...$set
+        },
+        $setOnInsert: {
+          ...ids(rest),
+          createdAt: date,
+          ...authenticated && {
+            createdBy: (authenticated == null ? void 0 : authenticated.id) + "." + date.getTime()
+          },
+          ...$setOnInsert
+        },
+        ...rest
+      };
+    }
+  },
+  timeseries: {
+    insert: (data) => {
+      const { _id, id } = ids(data);
+      const date = /* @__PURE__ */ new Date();
+      return {
+        _id,
+        meta: {
+          ...data,
+          id
+        },
+        time: date
+      };
+    },
+    update: ({
+      $set
+    }) => {
+      return {
+        $set
+      };
+    }
+  }
+};
+module.exports = ({
+  client,
+  database
+}) => ({
+  aggregate: async ({
+    collection,
+    options = {},
+    pipeline = []
+  }) => {
+    return await database.collection(collection).aggregate(pipeline, options).toArray();
+  },
+  bulk: async ({
+    collection,
+    options = {},
+    pipeline = []
+  }) => {
+    return await database.collection(collection).bulkWrite(pipeline, options);
+  },
+  count: async ({
+    collection,
+    options = {},
+    query
+  }) => {
+    return await database.collection(collection).countDocuments(query, options);
+  },
+  create: async ({
+    authenticated,
+    collection,
+    data,
+    multiple = false,
+    options,
+    pre,
+    timeseries = false
+  }) => {
+    const endpoint = multiple ? "insertMany" : "insertOne";
+    const format = timeseries ? "timeseries" : "documents";
+    let result;
+    try {
+      if (multiple) {
+        result = data.map((item) => formats[format].insert(item, authenticated));
+      } else {
+        result = formats[format].insert(data, authenticated);
+      }
+      if (pre instanceof Function) {
+        result = await pre(result);
+      }
+      await database.collection(collection)[endpoint](
+        result,
+        timeseries ? {} : {
+          returnDocument: "after",
+          returnNewDocument: true,
+          ...options
+        }
+      );
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  },
+  delete: async ({
+    collection,
+    query,
+    multiple,
+    options = {}
+  }) => {
+    let result;
+    try {
+      if (multiple) {
+        result = await database.collection(collection).find(
+          query,
+          {},
+          options
+        ).toArray();
+        await database.collection(collection).deleteMany(
+          query,
+          options
+        );
+      } else {
+        result = await database.collection(collection).findOne(
+          query
+        );
+        await database.collection(collection).deleteOne(
+          query,
+          options
+        );
+      }
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  },
+  formats,
+  get: async ({
+    collection,
+    extend = [],
+    options = {},
+    refine = {},
+    query
+  }) => {
+    try {
+      const pipeline = [
+        {
+          $match: query
+        },
+        ...extend
+      ];
+      if (refine) {
+        pipeline.push({
+          $match: refine
+        });
+      }
+      const result = await database.collection(collection).aggregate(
+        pipeline,
+        options
+      ).toArray();
+      return result == null ? void 0 : result[0];
+    } catch (error) {
+      throw error;
+    }
+  },
+  paged: async ({
+    collection,
+    limit,
+    filters = {},
+    refine,
+    search = null,
+    skip,
+    sort,
+    ...rest
+  }) => {
+    var _a, _b, _c;
+    try {
+      const pipelines = {
+        query: []
+      };
+      if (filters && Object.keys(filters).length > 0) {
+        pipelines.query.push(
+          {
+            $match: filters
+          }
+        );
+      }
+      pipelines.query.push({
+        $sort: Object.keys(sort).reduce(
+          (accumulator, key) => {
+            accumulator[key] = Number(sort[key]);
+            return accumulator;
+          },
+          {}
+        )
+      });
+      if (((rest == null ? void 0 : rest.extend) || []).length > 0) {
+        pipelines.query = [...pipelines.query, ...rest.extend];
+      }
+      if (refine && Object.keys(refine).length > 0) {
+        pipelines.query.push(
+          {
+            $match: refine
+          }
+        );
+      }
+      if ((search == null ? void 0 : search.value) && ((_a = search == null ? void 0 : search.keys) == null ? void 0 : _a.length) > 0) {
+        const value = search.value.trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        search = {
+          $match: {
+            $or: ((search == null ? void 0 : search.keys) || []).reduce(
+              (accumulator, key) => {
+                accumulator.push({
+                  [key]: {
+                    $regex: value,
+                    $options: "i"
+                  }
+                });
+                return accumulator;
+              },
+              []
+            )
+          }
+        };
+        pipelines.query.push(search);
+      }
+      const dataStages = [];
+      if (skip && limit) {
+        dataStages.push({
+          $skip: Number(Number(Number(skip) * Number(limit)))
+        });
+      }
+      if (limit) {
+        dataStages.push({
+          $limit: Number(limit)
+        });
+      }
+      if (rest == null ? void 0 : rest.project) {
+        dataStages.push({
+          $project: rest == null ? void 0 : rest.project
+        });
+      }
+      const facetPipeline = [
+        ...pipelines.query,
+        {
+          $facet: {
+            items: dataStages,
+            total: [
+              {
+                $group: {
+                  _id: null,
+                  total: {
+                    $sum: 1
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ];
+      const [facetResult] = await database.collection(collection).aggregate(facetPipeline).toArray();
+      const items = (facetResult == null ? void 0 : facetResult.items) || [];
+      const total = ((_c = (_b = facetResult == null ? void 0 : facetResult.total) == null ? void 0 : _b[0]) == null ? void 0 : _c.total) || 0;
+      const offset = Number(Number(skip) + 1) * Number(limit);
+      const hasPreviousPage = Boolean(Number(Number(skip)) * Number(limit) > 0);
+      const hasNextPage = Boolean(offset < Number(total));
+      return {
+        items,
+        pageInfo: {
+          hasNextPage,
+          hasPreviousPage,
+          offset: hasNextPage ? offset : total,
+          total
+        }
+      };
+    } catch (error) {
+      throw error;
+    }
+  },
+  transaction: async (callback) => {
+    try {
+      const result = await new Promise(
+        (resolve, reject) => client.withSession(
+          async (session) => session.withTransaction(
+            async (session2) => resolve(await callback(session2)),
+            null
+          ).catch(reject)
+        ).catch(reject)
+      );
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  },
+  update: async ({
+    authenticated,
+    collection,
+    data,
+    query,
+    multiple = false,
+    options,
+    timeseries = false
+  }) => {
+    let result = {};
+    try {
+      if (multiple || timeseries) {
+        const format = timeseries ? "timeseries" : "documents";
+        result.value = await database.collection(collection).find(
+          query,
+          {},
+          options
+        ).toArray();
+        await database.collection(collection).updateMany(
+          query,
+          formats[format].update(data, authenticated),
+          options
+        );
+      } else {
+        result = await database.collection(collection).findOneAndUpdate(
+          query,
+          formats.documents.update(data, authenticated),
+          {
+            returnDocument: "after",
+            returnNewDocument: true,
+            ...options
+          }
+        );
+      }
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+});