@primate/mongodb 0.1.3 → 0.3.0

package/lib/private/ColumnTypes.d.ts

@@ -0,0 +1,21 @@
+import type TypedArray from "@rcompat/type/TypedArray";
+import type { Binary, Decimal128, ObjectId } from "mongodb";
+type Param = bigint | Binary | boolean | Date | Decimal128 | number | ObjectId | string | TypedArray;
+type Validate<T extends {
+    [K in keyof T]: Param;
+}> = T;
+type ColumnTypes = Validate<{
+    BINARY: Binary;
+    BOOLEAN: boolean;
+    DATE: Date;
+    DECIMAL: Decimal128;
+    DOUBLE: number;
+    INT: number;
+    LONG: bigint;
+    PRIMARY: ObjectId;
+    STRING: string;
+    TIME: string;
+    UUID: string;
+}>;
+export type { ColumnTypes as default };
+//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/ColumnTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ColumnTypes.js.map

package/lib/private/Database.d.ts

@@ -0,0 +1,45 @@
+import Database from "@primate/core/Database";
+import type As from "@primate/core/database/As";
+import type DataDict from "@primate/core/database/DataDict";
+import type TypeMap from "@primate/core/database/TypeMap";
+import type Dict from "@rcompat/type/Dict";
+declare const schema: import("pema").ObjectType<{
+    database: import("pema/string").StringType;
+    host: import("pema").DefaultType<import("pema/string").StringType, "localhost">;
+    password: import("pema").OptionalType<import("pema/string").StringType>;
+    port: import("pema").DefaultType<import("pema/uint").UintType<"u32">, 27017>;
+    username: import("pema").OptionalType<import("pema/string").StringType>;
+}>;
+export default class MongoDBDatabase extends Database {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input);
+    get typemap(): TypeMap<Dict>;
+    close(): Promise<void>;
+    get schema(): {
+        create: () => undefined;
+        delete: (name: string) => Promise<void>;
+    };
+    create<O extends Dict>(as: As, args: {
+        record: DataDict;
+    }): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        criteria: DataDict;
+    }): Promise<number>;
+    read(as: As, args: {
+        criteria: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Dict<"asc" | "desc">;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        changes: DataDict;
+        criteria: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        criteria: DataDict;
+    }): Promise<number>;
+}
+export {};
+//# sourceMappingURL=Database.d.ts.map

package/lib/private/Database.js

@@ -0,0 +1,147 @@
+import typemap from "#typemap";
+import Database from "@primate/core/Database";
+import assert from "@rcompat/assert";
+import maybe from "@rcompat/assert/maybe";
+import empty from "@rcompat/record/empty";
+import entries from "@rcompat/record/entries";
+import toQueryString from "@rcompat/record/toQueryString";
+import { MongoClient } from "mongodb";
+import pema from "pema";
+import string from "pema/string";
+import uint from "pema/uint";
+const schema = pema({
+    database: string,
+    host: string.default("localhost"),
+    password: string.optional(),
+    port: uint.port().default(27017),
+    username: string.optional(),
+});
+function make_limit(limit) {
+    maybe(limit).usize();
+    if (limit === undefined) {
+        return 0;
+    }
+    return limit;
+}
+;
+const null_to_set_unset = (changes) => {
+    const entry_changes = entries(changes);
+    const $set = entry_changes.filter(([, value]) => value !== null).get();
+    const $unset = entry_changes.filter(([, value]) => value === null).get();
+    return { $set, $unset };
+};
+const url_params = { directConnection: "true", replicaSet: "rs0" };
+export default class MongoDBDatabase extends Database {
+    static config;
+    #factory;
+    #name;
+    #client;
+    constructor(config) {
+        super();
+        const { database, host, port } = schema.parse(config);
+        const url = `mongodb://${host}:${port}?${toQueryString(url_params)}`;
+        const client = new MongoClient(url);
+        this.#name = database;
+        this.#factory = async () => {
+            await client.connect();
+            return client;
+        };
+    }
+    async #get(collection) {
+        if (this.#client === undefined) {
+            this.#client = await this.#factory();
+        }
+        return this.#client.db(this.#name).collection(collection);
+    }
+    get typemap() {
+        return typemap;
+    }
+    async close() {
+        await this.#client.close();
+    }
+    async #drop(name) {
+        await (await this.#get(name)).drop();
+    }
+    get schema() {
+        return {
+            // noop
+            create: () => undefined,
+            delete: this.#drop.bind(this),
+        };
+    }
+    async #bind(object, types) {
+        const prepared = Object.fromEntries(Object.entries(object)
+            .map(([key, value]) => {
+            if (value === null)
+                return [key, null];
+            if (typeof value === "object" && "$like" in value) {
+                const pattern = String(value.$like);
+                const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const $regex = `^${escaped.replace(/%/g, ".*").replace(/_/g, ".")}$`;
+                return [key, { $regex }];
+            }
+            return [key, value];
+        }));
+        const { id, ...rest } = await this.bind(types, prepared);
+        return id === undefined
+            ? rest
+            : { _id: id, ...rest };
+    }
+    #unbind(object, types) {
+        const { _id: id, ...rest } = object;
+        return this.unbind(types, id === undefined ? rest : { id, ...rest });
+    }
+    async create(as, args) {
+        const binds = await this.#bind(args.record, as.types);
+        const { insertedId } = await (await this.#get(as.name)).insertOne(binds);
+        return this.#unbind({ ...args.record, _id: insertedId }, as.types);
+    }
+    async read(as, args) {
+        this.toSelect(as.types, args.fields);
+        this.toSort(as.types, args.sort);
+        const binds = await this.#bind(args.criteria, as.types);
+        if (args.count === true) {
+            return (await this.#get(as.name)).countDocuments(binds);
+        }
+        const fields = args.fields ?? [];
+        const mapped = fields.map(f => f === "id" ? "_id" : f);
+        const sort = args.sort === undefined || empty(args.sort)
+            ? {}
+            : { sort: args.sort };
+        const select = mapped.length === 0
+            ? {}
+            : {
+                projection: (() => {
+                    const out = {};
+                    if (!mapped.includes("_id")) {
+                        out._id = 0;
+                    }
+                    for (const field of mapped) {
+                        out[field] = 1;
+                    }
+                    return out;
+                })(),
+            };
+        const options = { ...select, ...sort, useBigInt64: true };
+        const records = await (await this.#get(as.name))
+            .find(binds, options)
+            .limit(make_limit(args.limit))
+            .toArray();
+        return records.map(record => this.#unbind(record, as.types));
+    }
+    async update(as, args) {
+        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
+        const criteria_binds = await this.#bind(args.criteria, as.types);
+        const changes_binds = await this.#bind(args.changes, as.types);
+        const collection = await this.#get(as.name);
+        return (await collection
+            .updateMany(criteria_binds, null_to_set_unset(changes_binds)))
+            .modifiedCount;
+    }
+    async delete(as, args) {
+        assert(Object.keys(args.criteria).length > 0, "delete: no criteria");
+        const binds = await this.#bind(args.criteria, as.types);
+        return (await ((await this.#get(as.name)).deleteMany(binds))).deletedCount;
+    }
+}
+//# sourceMappingURL=Database.js.map

package/lib/private/typemap.d.ts

@@ -0,0 +1,5 @@
+import type ColumnTypes from "#ColumnTypes";
+import type TypeMap from "@primate/core/database/TypeMap";
+declare const typemap: TypeMap<ColumnTypes>;
+export default typemap;
+//# sourceMappingURL=typemap.d.ts.map

package/lib/private/typemap.js

@@ -0,0 +1,86 @@
+import { Binary, Decimal128, ObjectId } from "mongodb";
+function identity(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => value,
+    };
+}
+function decimal() {
+    return {
+        bind(value) {
+            return new Decimal128(value.toString());
+        },
+        column: "DECIMAL",
+        unbind(value) {
+            return BigInt(value.toString());
+        },
+    };
+}
+const typemap = {
+    blob: {
+        async bind(value) {
+            const arrayBuffer = await value.arrayBuffer();
+            return new Binary(new Uint8Array(arrayBuffer));
+        },
+        column: "BINARY",
+        unbind(value) {
+            return new Blob([value.toBits()], { type: "application/octet-stream" });
+        },
+    },
+    boolean: identity("BOOLEAN"),
+    datetime: identity("DATE"),
+    f32: identity("DOUBLE"),
+    f64: identity("DOUBLE"),
+    i128: {
+        bind(value) {
+            return String(value);
+        },
+        column: "STRING",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    i16: identity("INT"),
+    i32: identity("INT"),
+    i64: identity("LONG"),
+    i8: identity("INT"),
+    primary: {
+        bind(value) {
+            if (typeof value === "string") {
+                return new ObjectId(value);
+            }
+            throw new Error(`\`${value}\` is not a valid primary key value`);
+        },
+        column: "PRIMARY",
+        unbind(value) {
+            return String(value);
+        },
+    },
+    string: identity("STRING"),
+    time: identity("TIME"),
+    u128: {
+        bind(value) {
+            return String(value);
+        },
+        column: "STRING",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    u16: identity("INT"),
+    u32: identity("INT"),
+    u64: decimal(),
+    u8: identity("INT"),
+    url: {
+        bind(value) {
+            return value.toString();
+        },
+        column: "STRING",
+        unbind(value) {
+            return new URL(value);
+        },
+    },
+};
+export default typemap;
+//# sourceMappingURL=typemap.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,4 @@
+import Database from "#Database";
+declare const _default: (config: typeof Database.config) => Database;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,3 @@
+import Database from "#Database";
+export default (config) => new Database(config);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,34 +1,45 @@
 {
   "name": "@primate/mongodb",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Primate MongoDB database",
-  "homepage": "https://primatejs.com/modules/mongodb",
-  "bugs": "https://github.com/primatejs/primate/issues",
+  "homepage": "https://primate.run/docs/database/mongodb",
+  "bugs": "https://github.com/primate-run/primate/issues",
   "license": "MIT",
   "files": [
-    "src/**/*.js",
-    "!src/**/*.spec.js"
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/primatejs/primate",
+    "url": "https://github.com/primate-run/primate",
     "directory": "packages/mongodb"
   },
   "dependencies": {
-    "@rcompat/invariant": "^0.5.0",
-    "@rcompat/object": "^0.5.0",
-    "mongodb": "^6.8.0",
-    "@primate/core": "^0.1.9",
-    "@primate/store": "^0.25.4"
+    "@rcompat/assert": "^0.3.1",
+    "@rcompat/record": "^0.9.1",
+    "mongodb": "^6.17.0",
+    "pema": "",
+    "@primate/core": "^0.3.0"
   },
   "type": "module",
   "imports": {
     "#*": {
-      "livetypes": "./src/private/*.js",
-      "default": "./src/private/*.js"
+      "apekit": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
     }
   },
   "exports": {
-    ".": "./src/default.js"
+    ".": {
+      "apekit": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint .",
+    "test": "npm run build && npx proby",
+    "start:db": "sudo mongod --dbpath /var/lib/mongodb"
   }
 }

package/src/default.js

@@ -1,10 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/src/private/serve.js

@@ -1,62 +0,0 @@
-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();
-        }
-      };
-    },
-  };
-};