@primate/mongodb 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@primate/mongodb",
+  "version": "0.1.0",
+  "description": "Primate MongoDB database",
+  "homepage": "https://primatejs.com/modules/mongodb",
+  "bugs": "https://github.com/primatejs/primate/issues",
+  "license": "MIT",
+  "files": [
+    "src/**/*.js",
+    "!src/**/*.spec.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primatejs/primate",
+    "directory": "packages/mongodb"
+  },
+  "dependencies": {
+    "@rcompat/invariant": "^0.5.0",
+    "@rcompat/object": "^0.5.0",
+    "@primate/core": "^0.1.0",
+    "@primate/store": "^0.25.0"
+  },
+  "devDependencies": {
+    "mongodb": "^6.8.0"
+  },
+  "peerDependencies": {
+    "mongodb": "6"
+  },
+  "type": "module",
+  "imports": {
+    "#*": {
+      "@primate/lt": "./src/private/*.js",
+      "default": "./src/private/*.js"
+    }
+  },
+  "exports": {
+    ".": "./src/default.js"
+  }
+}

package/src/default.js

@@ -0,0 +1,10 @@
+import defaults from "#defaults";
+import serve from "#serve";
+
+export default ({
+  host = defaults.host,
+  port = defaults.port,
+  database,
+} = {}) => ({
+  serve: serve({ host, port, database }),
+});

package/src/private/Facade.js

@@ -0,0 +1,89 @@
+import maybe from "@rcompat/invariant/maybe";
+import empty from "@rcompat/object/empty";
+import filter from "@rcompat/object/filter";
+import valmap from "@rcompat/object/valmap";
+
+const toid = ({ _id, ...rest }) => ({ id: _id, ...rest });
+const to_id = ({ id, ...rest }) => id === undefined
+  ? rest
+  : { _id: id, ...rest };
+const cid = criteria => criteria.id === undefined ? criteria : to_id(criteria);
+const null_to_set_unset = delta => {
+  const $set = filter(delta, ([, value]) => value !== null);
+  const $unset = filter(delta, ([, value]) => value === null);
+  return { $set, $unset };
+};
+
+const make_sort = ({ sort = {} } = {}) => {
+  maybe(sort).object();
+
+  return valmap(sort, value => value === "asc" ? 1 : -1);
+};
+
+export default class Facade {
+  schema = {
+    create: async _ => {
+      // noop
+    },
+    delete: async name => {
+      await this.#by(name).drop();
+    },
+  };
+
+  constructor(connection, session) {
+    this.connection = connection;
+    this.session = session;
+  }
+
+  #by(name) {
+    return this.connection.collection(name);
+  }
+
+  get #options() {
+    return { session: this.session };
+  }
+
+  async find(name, criteria = {}, projection = [], options = {}) {
+    const sort = make_sort(options);
+    const $options = {
+      ...this.#options,
+      ...projection.length === 0
+        ? {}
+        : {
+          projection: {
+            // erase _id unless explicit in projection
+            _id: 0,
+            ...Object.fromEntries(projection.map(field => [field, 1])),
+          },
+        },
+      ...empty(sort) ? {} : { sort },
+    };
+    return (await this.#by(name).find(cid(criteria), $options).toArray())
+      .map(document => toid(document));
+  }
+
+  async count(name, criteria = {}) {
+    return this.#by(name).countDocuments(criteria, this.#options);
+  }
+
+  async get(name, primary, value) {
+    const result = await this.#by(name).findOne({ _id: value }, this.#options);
+    return result === null ? undefined : toid(result);
+  }
+
+  async insert(name, primary, document) {
+    await this.#by(name).insertOne(document, this.#options);
+    return toid(document);
+  }
+
+  async update(name, criteria = {}, delta = {}) {
+    return (await this.#by(name)
+      .updateMany(cid(criteria), null_to_set_unset(delta), this.#options))
+      .modifiedCount;
+  }
+
+  async delete(name, criteria = {}) {
+    return (await this.#by(name).deleteMany(cid(criteria), this.#options))
+      .deletedCount;
+  }
+}

package/src/private/connect.js

@@ -0,0 +1,8 @@
+import { MongoClient } from "mongodb";
+
+export default async ({ host, port }) => {
+  const url = `mongodb://${host}:${port}?replicaSet=rs0&directConnection=true`;
+  const client = new MongoClient(url);
+  await client.connect();
+  return client;
+};

package/src/private/defaults.js

@@ -0,0 +1,4 @@
+export default {
+  host: "localhost",
+  port: 27017,
+};

package/src/private/serve.js

@@ -0,0 +1,62 @@
+import Facade from "#Facade";
+import connect from "#connect";
+import ident from "@primate/store/core/ident";
+import wrap from "@primate/store/core/wrap";
+import { Decimal128, ObjectId } from "mongodb";
+
+export default ({ host, port, database } = {}) => async _ => {
+  const client = await connect({ host, port });
+
+  const types = {
+    primary: {
+      validate(value) {
+        /* TODO: check that has valid objectid form */
+        if (typeof value === "string") {
+          return value;
+        }
+        throw new Error(`\`${value}\` is not a valid primary key value`);
+      },
+      in(value) {
+        return new ObjectId(value);
+      },
+      out(value) {
+        return value.toString();
+      },
+    },
+    object: ident,
+    number: ident,
+    bigint: {
+      in(value) {
+        return new Decimal128(value.toString());
+      },
+      out(value) {
+        return BigInt(value.toString());
+      },
+    },
+    boolean: ident,
+    date: ident,
+    string: ident,
+  };
+
+  return {
+    name: "@primate/mongodb",
+    types,
+    async transact(stores) {
+      return async (others, next) => {
+        const session = client.startSession();
+        const facade = new Facade(client.db(database), session);
+
+        try {
+          return await session.withTransaction(async () => {
+            const response = await next([...others, ...stores.map(([_, store]) =>
+              [_, wrap(store, facade, types)]),
+            ]);
+            return response;
+          });
+        } finally {
+          session.endSession();
+        }
+      };
+    },
+  };
+};