@primate/mongodb 0.4.0 → 0.5.0

package/lib/private/ColumnTypes.d.ts

@@ -1,4 +1,4 @@
-import type TypedArray from "@rcompat/type/TypedArray";
+import type { TypedArray } from "@rcompat/type";
 import type { Binary, Decimal128, ObjectId } from "mongodb";
 type Param = bigint | Binary | boolean | Date | Decimal128 | number | ObjectId | string | TypedArray;
 type Validate<T extends {

package/lib/private/MongoDB.d.ts

@@ -0,0 +1,42 @@
+import type { As, DataDict, DB, 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>;
+}>;
+export default class MongoDB implements DB {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input);
+    close(): Promise<void>;
+    get schema(): {
+        create: (_as: As, _store: StoreSchema) => Promise<void>;
+        delete: (name: string) => Promise<void>;
+    };
+    create<O extends Dict>(as: As, record: Dict): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        where: DataDict;
+        with?: never;
+    }): Promise<number>;
+    read(as: As, args: {
+        where: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        set: DataDict;
+        where: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        where: DataDict;
+    }): Promise<number>;
+}
+export {};
+//# sourceMappingURL=MongoDB.d.ts.map

package/lib/private/MongoDB.js

@@ -0,0 +1,376 @@
+import typemap from "#typemap";
+import common from "@primate/core/db";
+import E from "@primate/core/db/error";
+import assert from "@rcompat/assert";
+import is from "@rcompat/is";
+import { MongoClient, ObjectId } 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),
+    username: p.string.optional(),
+});
+function is_object_id(x) {
+    return x instanceof ObjectId;
+}
+function get_limit(limit) {
+    return limit ?? 0; // 0 = no limit
+}
+function get_sort(sort) {
+    if (sort === undefined)
+        return undefined;
+    const entries = Object.entries(sort);
+    if (entries.length === 0)
+        return undefined;
+    const out = {};
+    for (const [k, dir] of entries) {
+        out[k] = dir.toLowerCase() === "desc" ? -1 : 1;
+    }
+    return out;
+}
+function get_projection(pk, fields) {
+    if (fields === undefined || fields.length === 0)
+        return undefined;
+    const out = {};
+    const has_pk = pk !== null && fields.includes(pk);
+    // MongoDB always includes _id unless explicitly excluded
+    if (!has_pk)
+        out._id = 0;
+    for (const field of fields) {
+        const key = field === pk ? "_id" : field;
+        out[key] = 1;
+    }
+    return out;
+}
+async function bind_value(key, value) {
+    if (value === null)
+        return null;
+    return await typemap[key].bind(value);
+}
+function unbind_value(key, value) {
+    return typemap[key].unbind(value);
+}
+function like_to_regex(pattern) {
+    return "^" + pattern
+        .replace(/\\%/g, "<<PERCENT>>")
+        .replace(/\\_/g, "<<UNDERSCORE>>")
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/%/g, ".*")
+        .replace(/_/g, ".")
+        .replace(/<<PERCENT>>/g, "%")
+        .replace(/<<UNDERSCORE>>/g, "_") + "$";
+}
+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}`);
+        this.#database = database;
+        this.#factory = async () => {
+            await client.connect();
+            return client;
+        };
+    }
+    async #collection(name) {
+        this.#client ??= await this.#factory();
+        return this.#client.db(this.#database).collection(name);
+    }
+    async close() {
+        await this.#client?.close();
+    }
+    get schema() {
+        return {
+            create: async (_as, _store) => {
+                // MongoDB is schemaless, noop
+            },
+            delete: async (name) => {
+                const collection = await this.#collection(name);
+                await collection.drop().catch(() => { }); // ignore if doesn't exist
+            },
+        };
+    }
+    #to_mongo_pk(field, pk) {
+        return field === pk ? "_id" : field;
+    }
+    #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 = {};
+        for (const [field, value] of Object.entries(doc)) {
+            const user_field = this.#from_mongo_pk(field, pk);
+            const datatype = as.types[user_field];
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (field === "_id") {
+                // handle ObjectId to string for PK, other keep as-is
+                out[user_field] = is_object_id(value) ? value.toString() : value;
+                continue;
+            }
+            out[user_field] = unbind_value(datatype, value);
+        }
+        return out;
+    }
+    async #generate_pk(as) {
+        const pk = as.pk;
+        const type = as.types[pk];
+        const collection = await this.#collection(as.table);
+        if (type === "string")
+            return new ObjectId();
+        // 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))
+            return BigInt(max) + 1n;
+        return Number(max) + 1;
+    }
+    async create(as, record) {
+        assert.dict(record);
+        const pk = as.pk;
+        const collection = await this.#collection(as.table);
+        const doc = {};
+        let pk_value = null;
+        if (pk !== null) {
+            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)
+                    : 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;
+            }
+            else {
+                throw E.pk_required(pk);
+            }
+        }
+        for (const [field, value] of Object.entries(record)) {
+            if (field === pk)
+                continue;
+            doc[field] = await bind_value(as.types[field], value);
+        }
+        await collection.insertOne(doc);
+        const result = { ...record };
+        if (pk !== null && !(pk in record) && pk_value !== null) {
+            result[pk] = pk_value;
+        }
+        return result;
+    }
+    async read(as, args) {
+        assert.dict(args.where);
+        if (args.count === true)
+            return this.#count(as, args.where);
+        // relations always use phased approach
+        if (common.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 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 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)
+            options.projection = projection;
+        if (sort)
+            options.sort = sort;
+        const docs = await collection
+            .find(filter, options)
+            .limit(limit)
+            .toArray();
+        return docs.map(doc => this.#unbind(as, doc));
+    }
+    async #read_phased(as, args) {
+        const fields = common.expand(as, args.fields, args.with);
+        const rows = await this.#read(as, { ...args, fields });
+        const out = rows.map(row => common.project(row, args.fields));
+        for (const [name, relation] of Object.entries(args.with)) {
+            await this.#attach_relation(as, { rows, out, name, relation });
+        }
+        return out;
+    }
+    async #attach_relation(as, args) {
+        const relation = args.relation;
+        const by = relation.reverse ? relation.as.pk : relation.fk;
+        if (by === null)
+            throw E.relation_requires_pk("target");
+        const parent_by = relation.reverse ? relation.fk : as.pk;
+        if (parent_by === null)
+            throw E.relation_requires_pk("parent");
+        const join_values = [...new Set(args.rows.map(r => r[parent_by]).filter(v => v != null))];
+        const is_many = relation.kind === "many";
+        const empty = is_many ? [] : null;
+        if (join_values.length === 0) {
+            for (const row of args.out)
+                row[args.name] = empty;
+            return;
+        }
+        const related = await this.#load_related({ by, join_values, ...relation });
+        const grouped = new Map();
+        for (const row of related) {
+            const key = row[by];
+            grouped.set(key, grouped.get(key)?.concat(row) ?? [row]);
+        }
+        for (let i = 0; i < args.out.length; i++) {
+            const join_value = args.rows[i][parent_by];
+            if (join_value == null) {
+                args.out[i][args.name] = empty;
+                continue;
+            }
+            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;
+        }
+    }
+    async #load_related(args) {
+        // build filter with $in for join values
+        const filter = await this.#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)
+            : 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 projection = get_projection(args.as.pk, fields_with_by);
+        const sort = get_sort(args.sort);
+        const options = { useBigInt64: true };
+        if (projection)
+            options.projection = projection;
+        if (sort)
+            options.sort = sort;
+        // for per-parent limits, fetch all and slice in memory
+        // MongoDB doesn't have native per-group limit like SQL's ROW_NUMBER
+        const docs = await collection.find(filter, options).toArray();
+        const rows = docs.map(doc => this.#unbind(args.as, doc));
+        // apply per-parent limit if needed
+        const per_parent = args.kind === "one" ? 1 : args.limit;
+        if (per_parent !== undefined) {
+            const grouped = new Map();
+            for (const row of rows) {
+                const key = row[args.by];
+                const group = grouped.get(key) ?? [];
+                if (group.length < per_parent) {
+                    group.push(row);
+                    grouped.set(key, group);
+                }
+            }
+            return [...grouped.values()].flat();
+        }
+        return rows;
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        const filter = await this.#bind(as, args.where);
+        const collection = await this.#collection(as.table);
+        const $set = {};
+        const $unset = {};
+        for (const [field, value] of Object.entries(args.set)) {
+            const mongo_field = this.#to_mongo_pk(field, as.pk);
+            if (value === null) {
+                $unset[mongo_field] = "";
+            }
+            else {
+                $set[mongo_field] = await bind_value(as.types[field], value);
+            }
+        }
+        const update = {};
+        if (Object.keys($set).length > 0)
+            update.$set = $set;
+        if (Object.keys($unset).length > 0)
+            update.$unset = $unset;
+        const result = await collection.updateMany(filter, update);
+        return result.modifiedCount;
+    }
+    async delete(as, args) {
+        assert.nonempty(args.where);
+        const filter = await this.#bind(as, args.where);
+        const collection = await this.#collection(as.table);
+        const result = await collection.deleteMany(filter);
+        return result.deletedCount;
+    }
+}
+//# sourceMappingURL=MongoDB.js.map

package/lib/private/typemap.d.ts

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

package/lib/private/typemap.js

@@ -1,4 +1,4 @@
-import { Binary, Decimal128, ObjectId } from "mongodb";
+import { Binary, Decimal128 } from "mongodb";
 function identity(column) {
     return {
         bind: value => value,
@@ -45,18 +45,6 @@ const typemap = {
     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: {

package/lib/public/index.d.ts

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

package/lib/public/index.js

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

package/package.json

@@ -1,28 +1,35 @@
 {
   "name": "@primate/mongodb",
-  "version": "0.4.0",
-  "description": "Primate MongoDB database",
+  "version": "0.5.0",
+  "description": "MongoDB databases for Primate",
   "homepage": "https://primate.run/docs/database/mongodb",
   "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
   "license": "MIT",
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/primate-run/primate",
     "directory": "packages/mongodb"
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
   "dependencies": {
-    "@rcompat/assert": "^0.3.1",
-    "@rcompat/record": "^0.9.1",
+    "@rcompat/assert": "^0.6.0",
+    "@rcompat/dict": "^0.3.1",
+    "@rcompat/is": "^0.4.3",
     "mongodb": "^6.17.0",
-    "pema": "",
-    "@primate/core": "^0.4.0"
+    "@primate/core": "^0.5.0",
+    "pema": "0.5.0"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.9.0"
+  },
+  "peerDependencies": {
+    "primate": "^0.36.0"
   },
-  "type": "module",
   "imports": {
     "#*": {
       "apekit": "./src/private/*.ts",

package/lib/private/Database.d.ts

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

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