@primate/mongodb 0.5.0 → 0.7.0

package/lib/private/ColumnTypes.d.ts

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

package/lib/private/MongoDB.d.ts

@@ -1,22 +1,26 @@
-import type { As, DataDict, DB, Sort, With } from "@primate/core/db";
+import type { As, DataDict, DB, Schema, Sort, With } from "@primate/core/db";
 import type { Dict } from "@rcompat/type";
-import type { StoreSchema } from "pema";
-declare const schema: import("pema").ObjectType<{
-    database: import("pema").StringType;
-    host: import("pema").DefaultType<import("pema").StringType, "localhost">;
-    password: import("pema").OptionalType<import("pema").StringType>;
-    port: import("pema").DefaultType<import("pema").UintType<"u32">, 27017>;
-    username: import("pema").OptionalType<import("pema").StringType>;
+import { MongoClient } from "mongodb";
+declare const schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+    readonly port: import("pema").DefaultType<import("pema").UintType<"u32">, 27017>;
+    readonly database: import("pema").StringType;
+    readonly username: import("pema").OptionalType<import("pema").StringType>;
+    readonly password: import("pema").OptionalType<import("pema").StringType>;
+}>, {
+    host: string;
+    port: number;
+    database: string;
+    username: string | undefined;
+    password: string | undefined;
 }>;
-export default class MongoDB implements DB {
+export default class MongoDB implements DB<MongoClient> {
     #private;
     static config: typeof schema.input;
     constructor(config?: typeof schema.input);
+    get client(): MongoClient;
     close(): Promise<void>;
-    get schema(): {
-        create: (_as: As, _store: StoreSchema) => Promise<void>;
-        delete: (name: string) => Promise<void>;
-    };
+    get schema(): Schema;
     create<O extends Dict>(as: As, record: Dict): Promise<O>;
     read(as: As, args: {
         count: true;

package/lib/private/MongoDB.js

@@ -1,20 +1,17 @@
 import typemap from "#typemap";
-import common from "@primate/core/db";
-import E from "@primate/core/db/error";
+import base from "@primate/core/db";
+import E from "@primate/core/db/errors";
 import assert from "@rcompat/assert";
 import is from "@rcompat/is";
-import { MongoClient, ObjectId } from "mongodb";
+import { MongoClient } from "mongodb";
 import p from "pema";
 const schema = p({
-    database: p.string,
     host: p.string.default("localhost"),
-    password: p.string.optional(),
     port: p.uint.port().default(27017),
+    database: p.string,
     username: p.string.optional(),
+    password: p.string.optional(),
 });
-function is_object_id(x) {
-    return x instanceof ObjectId;
-}
 function get_limit(limit) {
     return limit ?? 0; // 0 = no limit
 }
@@ -52,6 +49,73 @@ async function bind_value(key, value) {
 function unbind_value(key, value) {
     return typemap[key].unbind(value);
 }
+function to_mongo_pk(field, pk) {
+    return field === pk ? "_id" : field;
+}
+async function bind(as, object) {
+    const pk = as.pk;
+    const out = {};
+    for (const [field, value] of Object.entries(object)) {
+        const mongo_field = to_mongo_pk(field, pk);
+        const datatype = as.types[field];
+        if (value === null) {
+            out[mongo_field] = null;
+            continue;
+        }
+        if (is.dict(value) && datatype !== "json") {
+            const ops = Object.entries(value);
+            if (ops.length === 0)
+                throw E.operator_empty(field);
+            for (const [op, op_value] of ops) {
+                const existing = (out[mongo_field] ?? {});
+                let next;
+                switch (op) {
+                    case "$like":
+                        next = { $regex: like_to_regex(String(op_value)) };
+                        break;
+                    case "$ilike":
+                        next = { $regex: like_to_regex(String(op_value)), $options: "i" };
+                        break;
+                    case "$ne":
+                    case "$gt":
+                    case "$gte":
+                    case "$lt":
+                    case "$lte":
+                        next = { [op]: await bind_value(datatype, op_value) };
+                        break;
+                    case "$after":
+                        next = { $gt: await bind_value(datatype, op_value) };
+                        break;
+                    case "$before":
+                        next = { $lt: await bind_value(datatype, op_value) };
+                        break;
+                    case "$in": {
+                        const array = op_value;
+                        const bound = await Promise.all(array.map(v => bind_value(datatype, v)));
+                        next = { $in: bound };
+                        break;
+                    }
+                    default:
+                        throw E.operator_unknown(field, op);
+                }
+                out[mongo_field] = { ...existing, ...next };
+            }
+            continue;
+        }
+        if (field === pk) {
+            const type = as.types[pk];
+            if (base.is_uuid_type(type)) {
+                out._id = await bind_value(type, value);
+            }
+            else {
+                out._id = value;
+            }
+            continue;
+        }
+        out[mongo_field] = await bind_value(datatype, value);
+    }
+    return out;
+}
 function like_to_regex(pattern) {
     return "^" + pattern
         .replace(/\\%/g, "<<PERCENT>>")
@@ -62,15 +126,37 @@ function like_to_regex(pattern) {
         .replace(/<<PERCENT>>/g, "%")
         .replace(/<<UNDERSCORE>>/g, "_") + "$";
 }
+function columns_to_types(row) {
+    switch (row.type) {
+        case "string": return ["string", "url", "time", "i128", "u128"];
+        case "int": return ["i8", "u8", "i16", "u16", "i32", "u32"];
+        case "long": return ["i64"];
+        case "double": return ["f32", "f64"];
+        case "bool": return ["boolean"];
+        case "date": return ["datetime"];
+        case "binData": return row.name === "_id" ? base.UUID_TYPES : ["blob"];
+        case "decimal": return ["u64"];
+        case "objectId": return ["string"];
+        case "object": return ["json"];
+        case "array": return ["json"];
+        default: return [];
+    }
+}
 export default class MongoDB {
     static config;
     #factory;
     #database;
     #client;
     constructor(config) {
-        const { host, port, database } = schema.parse(config);
-        const params = "directConnection=true&replicaSet=rs0";
-        const client = new MongoClient(`mongodb://${host}:${port}?${params}`);
+        const { host, port, database, username, password, } = schema.parse(config);
+        const uri = new URL(`mongodb://${host}:${port}/${database}`);
+        uri.searchParams.set("directConnection", "true");
+        if (username !== undefined) {
+            uri.username = username;
+            uri.password = password ?? "";
+            uri.searchParams.set("authSource", database);
+        }
+        const client = new MongoClient(uri.toString());
         this.#database = database;
         this.#factory = async () => {
             await client.connect();
@@ -81,17 +167,69 @@ export default class MongoDB {
         this.#client ??= await this.#factory();
         return this.#client.db(this.#database).collection(name);
     }
+    get client() {
+        return this.#client;
+    }
     async close() {
-        await this.#client?.close();
+        const client = this.#client;
+        this.#client = undefined;
+        await client?.close();
     }
     get schema() {
         return {
-            create: async (_as, _store) => {
-                // MongoDB is schemaless, noop
+            create: async (collection) => {
+                const client = this.#client ??= await this.#factory();
+                const db = client.db(this.#database);
+                // ignore if already exists
+                await db.createCollection(collection).catch(() => { });
+            },
+            delete: async (collection) => {
+                const client = this.#client ??= await this.#factory();
+                const db = client.db(this.#database);
+                // ignore if doesn't exist
+                await db.dropCollection(collection).catch(() => { });
             },
-            delete: async (name) => {
+            introspect: async (name, pk) => {
+                const client = (this.#client ??= await this.#factory());
+                const db = client.db(this.#database);
+                const collections = await db.listCollections({ name }).toArray();
+                if (collections.length === 0)
+                    return null;
                 const collection = await this.#collection(name);
-                await collection.drop().catch(() => { }); // ignore if doesn't exist
+                const rows = await collection.aggregate([
+                    { $limit: 1 },
+                    { $project: { fields: { $objectToArray: "$$ROOT" } } },
+                    { $unwind: "$fields" },
+                    { $project: { _id: 0, name: "$fields.k", type: { $type: "$fields.v" } } },
+                ]).toArray();
+                if (rows.length === 0)
+                    return {};
+                const result = {};
+                for (const row of rows) {
+                    if (pk !== undefined && row.name === "_id") {
+                        if (pk !== null)
+                            result[pk] = columns_to_types(row);
+                        continue;
+                    }
+                    result[row.name] = columns_to_types(row);
+                }
+                return result;
+            },
+            alter: async (name, diff) => {
+                const client = this.#client ??= await this.#factory();
+                const db = client.db(this.#database);
+                const collections = await db.listCollections({ name }).toArray();
+                if (collections.length === 0)
+                    throw E.table_not_found(name);
+                const collection = await this.#collection(name);
+                if (diff.rename.length > 0) {
+                    const $rename = Object.fromEntries(diff.rename);
+                    await collection.updateMany({}, { $rename });
+                }
+                if (diff.drop.length > 0) {
+                    const $unset = Object.fromEntries(diff.drop.map(f => [f, ""]));
+                    await collection.updateMany({}, { $unset });
+                }
             },
         };
     }
@@ -101,64 +239,6 @@ export default class MongoDB {
     #from_mongo_pk(field, pk) {
         return field === "_id" && pk !== null ? pk : field;
     }
-    async #bind(as, object) {
-        const pk = as.pk;
-        const out = {};
-        for (const [field, value] of Object.entries(object)) {
-            const mongo_field = this.#to_mongo_pk(field, pk);
-            const datatype = as.types[field];
-            if (value === null) {
-                out[mongo_field] = null;
-                continue;
-            }
-            if (is.dict(value)) {
-                const ops = Object.entries(value);
-                if (ops.length === 0)
-                    throw E.operator_empty(field);
-                for (const [op, op_value] of ops) {
-                    const existing = (out[mongo_field] ?? {});
-                    let next;
-                    switch (op) {
-                        case "$like":
-                            next = { $regex: like_to_regex(String(op_value)) };
-                            break;
-                        case "$ilike":
-                            next = { $regex: like_to_regex(String(op_value)), $options: "i" };
-                            break;
-                        case "$ne":
-                        case "$gt":
-                        case "$gte":
-                        case "$lt":
-                        case "$lte":
-                            next = { [op]: await bind_value(datatype, op_value) };
-                            break;
-                        case "$after":
-                            next = { $gt: await bind_value(datatype, op_value) };
-                            break;
-                        case "$before":
-                            next = { $lt: await bind_value(datatype, op_value) };
-                            break;
-                        default:
-                            throw E.operator_unknown(field, op);
-                    }
-                    out[mongo_field] = { ...existing, ...next };
-                }
-                continue;
-            }
-            if (field === pk) {
-                const type = as.types[pk];
-                if (type === "string" && ObjectId.isValid(value)) {
-                    out._id = new ObjectId(value);
-                }
-                else {
-                    out._id = value;
-                }
-                continue;
-            }
-            out[mongo_field] = await bind_value(datatype, value);
-        }
-        return out;
-    }
     #unbind(as, doc) {
         const pk = as.pk;
         const out = {};
@@ -169,8 +249,10 @@ export default class MongoDB {
                 continue;
             }
             if (field === "_id") {
-                // handle ObjectId to string for PK, other keep as-is
-                out[user_field] = is_object_id(value) ? value.toString() : value;
+                const type = as.types[user_field];
+                out[user_field] = base.is_uuid_type(type)
+                    ? unbind_value(type, value)
+                    : value;
                 continue;
             }
             out[user_field] = unbind_value(datatype, value);
@@ -181,13 +263,13 @@ export default class MongoDB {
         const pk = as.pk;
         const type = as.types[pk];
         const collection = await this.#collection(as.table);
-        if (type === "string")
-            return new ObjectId();
+        if (base.is_uuid_type(type))
+            return base.generate_uuid(type);
         // for numeric types, find max and increment
         const pipeline = [{ $group: { _id: null, max: { $max: "$_id" } } }];
         const results = await collection.aggregate(pipeline).toArray();
         const max = results.length === 0 ? 0 : results[0].max ?? 0;
-        if (common.BIGINT_STRING_TYPES.includes(type))
+        if (base.BIGINT_STRING_TYPES.includes(type))
             return BigInt(max) + 1n;
         return Number(max) + 1;
     }
@@ -201,15 +283,17 @@ export default class MongoDB {
             const type = as.types[pk];
             if (pk in record) {
                 pk_value = record[pk];
-                doc._id = type === "string" && ObjectId.isValid(pk_value)
-                    ? new ObjectId(pk_value)
+                doc._id = base.is_uuid_type(type)
+                    ? await bind_value(type, pk_value)
                     : pk_value;
             }
             else if (as.generate_pk !== false) {
                 const generated = await this.#generate_pk(as);
-                doc._id = generated;
                 // convert to user-facing value
-                pk_value = is_object_id(generated) ? generated.toString() : generated;
+                pk_value = generated;
+                doc._id = base.is_uuid_type(type)
+                    ? await bind_value(type, generated)
+                    : generated;
             }
             else {
                 throw E.pk_required(pk);
@@ -232,37 +316,37 @@ export default class MongoDB {
         if (args.count === true)
             return this.#count(as, args.where);
         // relations always use phased approach
-        if (common.withed(args))
+        if (base.withed(args))
             return this.#read_phased(as, args);
         return this.#read(as, args);
     }
     async #count(as, where) {
-        const filter = await this.#bind(as, where);
+        const filter = await bind(as, where);
         const collection = await this.#collection(as.table);
         const count = await collection.countDocuments(filter);
         return count;
     }
     async #read(as, args) {
-        const filter = await this.#bind(as, args.where);
+        const filter = await bind(as, args.where);
         const collection = await this.#collection(as.table);
         const projection = get_projection(as.pk, args.fields);
         const sort = get_sort(args.sort);
         const limit = get_limit(args.limit);
         const options = { useBigInt64: true };
-        if (projection)
+        if (is.defined(projection))
             options.projection = projection;
-        if (sort)
+        if (is.defined(sort))
             options.sort = sort;
-        const docs = await collection
-            .find(filter, options)
-            .limit(limit)
-            .toArray();
+        const cursor = collection.find(filter, options).limit(limit);
+        if (is.defined(args.offset))
+            cursor.skip(args.offset);
+        const docs = await cursor.toArray();
         return docs.map(doc => this.#unbind(as, doc));
     }
     async #read_phased(as, args) {
-        const fields = common.expand(as, args.fields, args.with);
+        const fields = base.expand(as, args.fields, args.with);
         const rows = await this.#read(as, { ...args, fields });
-        const out = rows.map(row => common.project(row, args.fields));
+        const out = rows.map(row => base.project(row, args.fields));
         for (const [name, relation] of Object.entries(args.with)) {
             await this.#attach_relation(as, { rows, out, name, relation });
         }
@@ -298,22 +382,22 @@ export default class MongoDB {
             }
             const rows = grouped.get(join_value) ?? [];
             args.out[i][args.name] = is_many
-                ? rows.map(r => common.project(r, relation.fields))
-                : rows[0] ? common.project(rows[0], relation.fields) : null;
+                ? rows.map(r => base.project(r, relation.fields))
+                : rows[0] ? base.project(rows[0], relation.fields) : null;
         }
     }
     async #load_related(args) {
         // build filter with $in for join values
-        const filter = await this.#bind(args.as, args.where);
+        const filter = await bind(args.as, args.where);
         const by_field = this.#to_mongo_pk(args.by, args.as.pk);
         // convert join values to ObjectId if needed
-        const pk_type = args.as.types[args.as.pk];
-        const in_values = args.by === args.as.pk && pk_type === "string"
-            ? args.join_values.map(v => ObjectId.isValid(v) ? new ObjectId(v) : v)
+        const fk_type = args.as.types[args.by];
+        const in_values = base.is_uuid_type(fk_type)
+            ? await Promise.all(args.join_values.map(v => bind_value(fk_type, v)))
             : args.join_values;
         filter[by_field] = { $in: in_values };
         const collection = await this.#collection(args.as.table);
-        const fields_with_by = common.fields(args.fields, args.by);
+        const fields_with_by = base.fields(args.fields, args.by);
         const projection = get_projection(args.as.pk, fields_with_by);
         const sort = get_sort(args.sort);
         const options = { useBigInt64: true };
@@ -344,7 +428,7 @@ export default class MongoDB {
     async update(as, args) {
         assert.nonempty(args.set);
         assert.dict(args.where);
-        const filter = await this.#bind(as, args.where);
+        const filter = await bind(as, args.where);
         const collection = await this.#collection(as.table);
         const $set = {};
         const $unset = {};
@@ -367,7 +451,7 @@ export default class MongoDB {
     }
     async delete(as, args) {
         assert.nonempty(args.where);
-        const filter = await this.#bind(as, args.where);
+        const filter = await bind(as, args.where);
         const collection = await this.#collection(as.table);
         const result = await collection.deleteMany(filter);
         return result.deletedCount;

package/lib/private/typemap.js

@@ -1,4 +1,4 @@
-import { Binary, Decimal128 } from "mongodb";
+import { Binary, Decimal128, UUID } from "mongodb";
 function identity(column) {
     return {
         bind: value => value,
@@ -45,6 +45,7 @@ const typemap = {
     i32: identity("INT"),
     i64: identity("LONG"),
     i8: identity("INT"),
+    json: identity("JSON"),
     string: identity("STRING"),
     time: identity("TIME"),
     u128: {
@@ -69,6 +70,21 @@ const typemap = {
             return new URL(value);
         },
     },
+    uuid: {
+        bind: (value) => new UUID(value),
+        column: "UUID",
+        unbind: (value) => value.toString(),
+    },
+    uuid_v4: {
+        bind: (value) => new UUID(value),
+        column: "UUID",
+        unbind: (value) => value.toString(),
+    },
+    uuid_v7: {
+        bind: (value) => new UUID(value),
+        column: "UUID",
+        unbind: (value) => value.toString(),
+    },
 };
 export default typemap;
 //# sourceMappingURL=typemap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/mongodb",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "MongoDB databases for Primate",
   "homepage": "https://primate.run/docs/database/mongodb",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,28 +17,28 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.6.0",
-    "@rcompat/dict": "^0.3.1",
-    "@rcompat/is": "^0.4.3",
-    "mongodb": "^6.17.0",
-    "@primate/core": "^0.5.0",
-    "pema": "0.5.0"
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/dict": "^0.10.0",
+    "@rcompat/is": "^0.11.0",
+    "mongodb": "^7.2.0",
+    "@primate/core": "^0.7.0",
+    "pema": "0.7.0"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.9.0"
+    "@rcompat/type": "^0.17.0"
   },
   "peerDependencies": {
-    "primate": "^0.36.0"
+    "primate": "^0.38.0"
   },
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
-      "apekit": "./src/public/index.ts",
+      "@primate/source": "./src/public/index.ts",
       "default": "./lib/public/index.js"
     }
   },
@@ -46,7 +46,7 @@
     "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"
+    "test": "npm run db && npx proby",
+    "db": "scripts/db.sh"
   }
 }