@drawbridge/mongodb 0.0.1

package/dist/index.mjs

@@ -0,0 +1,378 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// index.js
+var require_index = __commonJS({
+  "index.js"(exports, module) {
+    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;
+        }
+      }
+    });
+  }
+});
+export default require_index();

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@drawbridge/mongodb",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup ./index.js && npm publish"
+  },
+  "dependencies": {
+    "mongodb": "5.9.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}