mogobase 1.0.0 → 1.0.2

package/lib/client/hooks/useMutation.js

@@ -0,0 +1,18 @@
+const apiUrl = `${process.env.NEXT_MOGOBASE_URL || process.env.MOGOBASE_URL || "http://localhost:4000"}/api/handlers`;
+function useMutation(name) {
+    return async (args) => {
+        const rs = await fetch(apiUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                name,
+                args,
+            }),
+        });
+        const data = await rs.json();
+        return data;
+    };
+}
+export default useMutation;

package/lib/client/hooks/usePaginatedQuery.js

@@ -0,0 +1,104 @@
+import { hc } from "hono/client";
+import { useCallback, useEffect, useRef, useState } from "react";
+const client = hc(process.env.NEXT_MOGOBASE_URL || process.env.MOGOBASE_URL || "http://localhost:4000");
+const mergeArray = (arr1, arr2, key, insert = false) => {
+    const result = [...arr1];
+    for (const item of arr2) {
+        const foundIndex = result.findIndex((i) => i[key] === item[key]);
+        if (foundIndex >= 0) {
+            result[foundIndex] = item;
+            continue;
+        }
+        else if (insert) {
+            result.push(item);
+        }
+    }
+    return result;
+};
+function usePaginatedQuery(name, args, paginationData = {
+    pageSize: 10,
+}) {
+    const [data, setData] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const nextPage = useRef("");
+    const previousPage = useRef("");
+    const ws = useRef(null);
+    const fetchNextPage = useCallback(() => {
+        setLoading(true);
+        ws.current?.send(JSON.stringify({
+            type: "paginated-query",
+            name,
+            args: {
+                ...(args || {}),
+                paginationArgs: {
+                    limit: paginationData.pageSize,
+                    next: nextPage.current || undefined,
+                    sortAscending: paginationData.sortAscending ?? true,
+                    sortCaseInsensitive: paginationData.sortCaseInsensitive ?? false,
+                },
+            },
+        }));
+    }, [name, JSON.stringify(args), paginationData]);
+    const fetchPreviousPage = useCallback(() => {
+        setLoading(true);
+        ws.current?.send(JSON.stringify({
+            type: "paginated-query",
+            name,
+            args: {
+                ...(args || {}),
+                paginationArgs: {
+                    limit: paginationData.pageSize,
+                    previous: previousPage.current || undefined,
+                    sortAscending: paginationData.sortAscending ?? true,
+                    sortCaseInsensitive: paginationData.sortCaseInsensitive ?? false,
+                },
+            },
+        }));
+    }, [name, JSON.stringify(args), paginationData]);
+    useEffect(() => {
+        ws.current = client.ws.$ws(0);
+        ws.current.addEventListener("open", () => {
+            fetchNextPage();
+        });
+        ws.current.addEventListener("message", (event) => {
+            setLoading(false);
+            const rs = JSON.parse(event.data);
+            if (rs.type === "PaginatedQueryResult") {
+                if (rs.success) {
+                    const { results, previous, hasPrevious, next, hasNext } = rs.data;
+                    nextPage.current = hasNext ? next : undefined;
+                    previousPage.current = hasPrevious ? previous : undefined;
+                    setData((d) => mergeArray(d, results, "_id", true));
+                }
+                else {
+                    console.error(rs.error);
+                }
+            }
+            else if (rs.type === "UpdateDoc") {
+                setData((d) => mergeArray(d, [rs.data], "_id"));
+            }
+        });
+        return () => {
+            ws.current?.close();
+        };
+    }, [fetchNextPage]);
+    const loadNext = useCallback(() => {
+        if (nextPage.current) {
+            fetchNextPage();
+        }
+    }, [fetchNextPage]);
+    const loadPrevious = useCallback(() => {
+        if (previousPage.current) {
+            fetchPreviousPage();
+        }
+    }, [fetchPreviousPage]);
+    return {
+        results: data,
+        hasNext: !!nextPage.current,
+        loadNext,
+        hasPrevious: !!previousPage.current,
+        loadPrevious,
+        isLoading: loading,
+    };
+}
+export default usePaginatedQuery;

package/lib/client/hooks/useQuery.js

@@ -0,0 +1,32 @@
+import { hc } from "hono/client";
+import { useEffect, useState } from "react";
+const client = hc(process.env.NEXT_MOGOBASE_URL || process.env.MOGOBASE_URL || "http://localhost:4000");
+function useQuery(name, args) {
+    const [data, setData] = useState(null);
+    useEffect(() => {
+        const ws = client.ws.$ws(0);
+        ws.addEventListener("open", () => {
+            ws.send(JSON.stringify({
+                type: "query",
+                name,
+                args,
+            }));
+        });
+        ws.addEventListener("message", (event) => {
+            const rs = JSON.parse(event.data);
+            if (rs.type === "QueryResult") {
+                if (rs.success) {
+                    setData(rs.data);
+                }
+                else {
+                    console.error(rs.error);
+                }
+            }
+        });
+        return () => {
+            ws.close();
+        };
+    }, [name, JSON.stringify(args)]);
+    return data;
+}
+export default useQuery;

package/lib/db/buildMongoFilters.js

@@ -0,0 +1,189 @@
+import { ObjectId } from "mongodb";
+import merge from "lodash.merge";
+const processValue = (value) => {
+    if (value && typeof value.getMonth === "function") {
+        return new Date(value).valueOf();
+    }
+    return value;
+};
+const processOrAndFilter = (filter) => {
+    // Note:
+    // input = { '$or': [ { email: 'chardy@gmail.com' }, { email: 'abc@gmail.com' } ]}
+    // output = { '$or': [ { email: { '$regex': '.*$chardy@gmail.com.*'} }, { email: { '$regex': '.*$abc@gmail.com.*'} } ]}
+    let filters = [];
+    for (let key in filter) {
+        let obj = filter[key];
+        Object.keys(obj).forEach((item) => {
+            const k = item;
+            if (key && k) {
+                filters.push(processFilter({ [k]: obj[k] }));
+            }
+        });
+    }
+    return filters;
+};
+const processKey = (key, opts) => {
+    if (key === "_id") {
+        return key;
+    }
+    const { allowSnakeCase } = opts || {};
+    if (!allowSnakeCase) {
+        return key.replace(/_/g, ".");
+    }
+    return key;
+};
+const processFilter = (filter, opts) => {
+    let filters = {};
+    let newFilters = {};
+    for (let key in filter) {
+        if (filter[key] === "") {
+            // Do nothing
+        }
+        else if (key == "OR" || key == "or") {
+            // query = filter: { OR: [{email: "chardy@gmail.com"}, {email: "abc@gmail.com"}] }
+            // output = { "$or":[{"email":{"$regex":".*chardy@gmail.com.*"}},{"email":{"$regex":".*abc@gmail.com.*"}}] }
+            filters = { $or: processOrAndFilter(filter[key]) };
+        }
+        else if (key == "AND" || key == "and") {
+            // query = filter: { AND: [{email: "chardy@gmail.com"}, {email: "abc@gmail.com"}] }
+            // output = { "$and":[{"email":{"$regex":".*chardy@gmail.com.*"}},{"email":{"$regex":".*abc@gmail.com.*"}}] }
+            filters = { $and: processOrAndFilter(filter[key]) };
+        }
+        else if (key.indexOf("_id") > 0 && key.includes("Id")) {
+            // query = filter: { _id: "5f8d9f1d-d3a1-4d0d-b5a8-c8e8c2e3d4e5" }
+            // output = { _id: new ObjectId("5f8d9f1d-d3a1-4d0d-b5a8-c8e8c2e3d4e5") }
+            filters = { [key.replace("_id", "")]: new ObjectId(filter[key]) };
+        }
+        else if (key.includes("_eq")) {
+            // equal ==
+            // query = filter: { amount_eq: 20}
+            // output = { amount: { $eq: 20 }}
+            filters = {
+                [processKey(key.replace("_eq", ""), opts)]: {
+                    $eq: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_ne")) {
+            // not equal !=
+            // query = filter: { amount_ne: 20}
+            // output = { amount: { $ne: 20 }}
+            filters = {
+                [processKey(key.replace("_ne", ""), opts)]: {
+                    $ne: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_lte")) {
+            // less than equal <=
+            // query = filter: { amount_lte: 20}
+            // output = { amount: { $lte: 20 }}
+            filters = {
+                [processKey(key.replace("_lte", ""), opts)]: {
+                    $lte: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_gte")) {
+            // greater than equal >=
+            // query = filter: { amount_gte: 20}
+            // output = { amount: { $gte: 20 }}
+            filters = {
+                [processKey(key.replace("_gte", ""), opts)]: {
+                    $gte: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_lt")) {
+            // less than <
+            // query = filter: { amount_lt: 20}
+            // output = { amount: { $lt: 20 }}
+            filters = {
+                [processKey(key.replace("_lt", ""), opts)]: {
+                    $lt: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_gt")) {
+            // greater than >
+            // query = filter: { amount_gt: 20}
+            // output = { amount: { $gt: 20 }}
+            filters = {
+                [processKey(key.replace("_gt", ""), opts)]: {
+                    $gt: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_between")) {
+            // query = filter: { amount_between: [20, 30]}
+            // output = { amount: { $gte: 20, $lte: 30 }}
+            filters = {
+                [processKey(key.replace("_between", ""), opts)]: {
+                    $gte: processValue(filter[key][0]),
+                    $lte: processValue(filter[key][1]),
+                },
+            };
+        }
+        else if (key.includes("_in")) {
+            // same like IN sql
+            // query = filter: { email_in: ["chardy@gmail.com", "abc@gmail.com"]}
+            // output = { email: { $in: ["chardy@gmail.com", "abc@gmail.com"] }}
+            filters = {
+                [processKey(key.replace("_in", ""), opts)]: {
+                    $in: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_all")) {
+            // same like ALL sql
+            // query = filter: { email_all: ["chardy@gmail.com", "abc@gmail.com"]}
+            // output = { email: { $all: ["chardy@gmail.com", "abc@gmail.com"] }}
+            filters = {
+                [processKey(key.replace("_all", ""), opts)]: { $all: filter[key] },
+            };
+        }
+        else if (key.includes("_nin")) {
+            // not in
+            // query = filter: { email_nin: ["chardy@gmail.com", "abc@gmail.com"]}
+            // output = { email: { $nin: ["chardy@gmail.com", "abc@gmail.com"] }}
+            filters = {
+                [processKey(key.replace("_nin", ""), opts)]: {
+                    $nin: processValue(filter[key]),
+                },
+            };
+        }
+        else if (key.includes("_contains")) {
+            // same like LIKE in SQL
+            // query = filter: { email_contains: "chardy@gmail.com" }
+            // output = { email: { "$regex":".*char.*" }}
+            filters = {
+                [processKey(key.replace("_contains", ""), opts)]: {
+                    $regex: `.*${filter[key]}.*`,
+                },
+            };
+        }
+        else if (key.includes("_regex")) {
+            // use REGEX to search
+            // query = filter: { email_regex: "^abc.*" }
+            // output = { email: { "$regex":"^abc.*" }}
+            filters = {
+                [processKey(key.replace("_regex", ""), opts)]: {
+                    $regex: `${filter[key]}`,
+                    $options: "i",
+                },
+            };
+        }
+        else {
+            // no regex search
+            // query = filter: {email:"chardy@gmail.com"}
+            // output = { "email":"chardy@gmail.com" }
+            filters = { [processKey(key, opts)]: processValue(filter[key]) };
+        }
+        newFilters = merge(newFilters, filters);
+    }
+    return newFilters;
+};
+export default (filter, opts) => {
+    const newFilters = processFilter(filter, opts);
+    return { ...newFilters, deletedAt: null };
+};

package/lib/db/index.js

@@ -0,0 +1,86 @@
+import { MongoClient, ObjectId } from "mongodb";
+import DataLoader from "dataloader";
+import buildMongoFilters from "./buildMongoFilters.js";
+const MONGO_URI = process.env.MONGO_URI || "mongodb://localhost:27017";
+const MONGO_DB = process.env.MONGO_DB || "mogobase";
+console.log("MONGO_URI", MONGO_URI);
+console.log("MONGO_DB", MONGO_DB);
+class MogobaseDB {
+    static _instance;
+    _mongoClient;
+    _db;
+    _schemas = new Map();
+    constructor() {
+        if (!MogobaseDB._instance) {
+            MogobaseDB._instance = this;
+        }
+        return MogobaseDB._instance;
+    }
+    async connect() {
+        // Connect to MongoDB
+        if (this._mongoClient && this._db) {
+            return this._db;
+        }
+        const client = await MongoClient.connect(MONGO_URI);
+        this._mongoClient = client;
+        this._db = client.db(MONGO_DB);
+        return this._db;
+    }
+    async disconnect() {
+        if (!this._mongoClient)
+            return;
+        await this._mongoClient.close();
+    }
+    get client() {
+        if (!this._mongoClient) {
+            throw new Error("Call connect() first");
+        }
+        return this._mongoClient;
+    }
+    get db() {
+        if (!this._db) {
+            throw new Error("Call connect() first");
+        }
+        return this._db;
+    }
+    model(name) {
+        if (!this._db) {
+            throw new Error("Call connect() first");
+        }
+        return this._db.collection(name);
+    }
+    async defineModel(name, schema, indexes) {
+        if (!this._db) {
+            this._db = await this.connect();
+        }
+        let collection = this._db.collection(name);
+        if (!collection) {
+            collection = await this._db.createCollection(name);
+        }
+        if (schema) {
+            this._schemas.set(name, schema);
+        }
+        if (indexes) {
+            await collection.createIndexes(indexes.indexSpecs, indexes.options);
+        }
+        return collection;
+    }
+}
+export const Id = ObjectId;
+export const buildFilters = buildMongoFilters;
+export const DataLoaderGenerate = (model, key = "_id") => {
+    const DB = new MogobaseDB();
+    return new DataLoader(async (ids) => {
+        console.log("DataLoader", model, key, ids);
+        const data = await DB.model(model)
+            .find({
+            [key]: {
+                $in: ids.map((id) => new Id(id)),
+            },
+        })
+            .toArray();
+        return ids.map((id) => data.find((item) => `${item[key]}` === id));
+    });
+};
+// Export singleton
+export default new MogobaseDB();

package/lib/dev/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import makeCli from "make-cli";
+const version = "1.0.0";
+makeCli({
+    version,
+    name: "mogobase",
+    usage: "mogobase dev",
+    arguments: "[command] [options]",
+    options: [],
+    action: (command = "dev", options) => {
+        if (command === "dev") {
+            const child = spawn("npx tsx watch", ["./node_modules/mogobase/lib/dev/start.js"], {
+                shell: true,
+                stdio: "inherit",
+            });
+            child.on("exit", (code) => process.exit(code));
+        }
+    },
+});

package/lib/dev/start.js

@@ -0,0 +1,41 @@
+import { serve } from "@hono/node-server";
+import app from "../server/hono.js";
+import path from "path";
+import ws from "../server/ws.js";
+import fs from "fs";
+const cwd = process.cwd();
+const mogobaseFolder = path.resolve(cwd, "./mogobase");
+let server;
+const port = Number(process.env.MOGOBASE_PORT) || 4000;
+const files = fs.readdirSync(mogobaseFolder);
+for (const file of files) {
+    if (!file.endsWith(".ts"))
+        continue;
+    const filePath = path.join(mogobaseFolder, file);
+    const module = (await import(filePath));
+    if (typeof module.default === "function") {
+        module.default(app);
+    }
+}
+server = serve({
+    fetch: app.fetch,
+    port,
+});
+console.log(`Mogobase dev server running on port ${port}`);
+ws.injectWebSocket(server);
+// graceful shutdown
+process.on("SIGINT", () => {
+    server.close();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    if (!server)
+        return;
+    server.close((err) => {
+        if (err) {
+            console.error(err);
+            process.exit(1);
+        }
+        process.exit(0);
+    });
+});

package/lib/index.js

@@ -0,0 +1,4 @@
+import useMutation from "./client/hooks/useMutation.js";
+import useQuery from "./client/hooks/useQuery.js";
+import usePaginatedQuery from "./client/hooks/usePaginatedQuery.js";
+export { useMutation, useQuery, usePaginatedQuery };

package/lib/server/handlers.js

@@ -0,0 +1,93 @@
+import z4 from "zod/v4";
+import DB from "../db/index.js";
+class Handlers {
+    static _instance;
+    queries = new Map();
+    mutations = new Map();
+    _queries = new Map();
+    _mutations = new Map();
+    constructor() {
+        if (!Handlers._instance) {
+            Handlers._instance = this;
+        }
+        return Handlers._instance;
+    }
+    async _runQuery(name, args, ctx = {}) {
+        let handler = this.queries.get(name);
+        if (!handler) {
+            if (name.startsWith("internal")) {
+                handler = this._queries.get(name);
+                if (!handler) {
+                    throw new Error(`Query ${name} not found`);
+                }
+            }
+            else {
+                throw new Error(`Query ${name} not found`);
+            }
+        }
+        const validated = await handler.args.safeParseAsync(args);
+        if (validated.success) {
+            return await handler.handler(validated.data, {
+                db: ctx.db || DB,
+                runQuery: this._runQuery.bind(this),
+                runMutation: this._runMutation.bind(this),
+                watch: ctx.watch || (() => { }),
+            });
+        }
+        else {
+            throw new Error(`Invalid args: ${validated.error.issues[0].message}`);
+        }
+    }
+    async _runMutation(name, args, ctx = {}) {
+        let handler = this.mutations.get(name);
+        if (!handler) {
+            if (name.startsWith("internal")) {
+                handler = this._mutations.get(name);
+                if (!handler) {
+                    throw new Error(`Mutation ${name} not found`);
+                }
+            }
+            else {
+                throw new Error(`Mutation ${name} not found`);
+            }
+        }
+        const validated = await handler.args.safeParseAsync(args);
+        if (validated.success) {
+            return await handler.handler(validated.data, {
+                db: ctx.db || DB,
+                runQuery: this._runQuery.bind(this),
+                runMutation: this._runMutation.bind(this),
+            });
+        }
+        else {
+            throw new Error(`Invalid args: ${validated.error.issues[0].message}`);
+        }
+    }
+}
+// filename: callsite.ts
+export function query(name, c) {
+    if (Handlers._instance.queries.has(name)) {
+        throw new Error(`Handler ${name} already exists`);
+    }
+    Handlers._instance.queries.set(name, c);
+}
+export function mutation(name, c) {
+    if (Handlers._instance.mutations.has(name)) {
+        throw new Error(`Handler ${name} already exists`);
+    }
+    Handlers._instance.mutations.set(name, c);
+}
+export function internalQuery(name, c) {
+    if (Handlers._instance._queries.has(name)) {
+        throw new Error(`Handler ${name} already exists`);
+    }
+    Handlers._instance._queries.set(`internal.${name}`, c);
+}
+export function internalMutation(name, c) {
+    if (Handlers._instance._mutations.has(name)) {
+        throw new Error(`Handler ${name} already exists`);
+    }
+    Handlers._instance._mutations.set(`internal.${name}`, c);
+}
+export const v = z4;
+export default new Handlers();

package/lib/server/hono.js

@@ -0,0 +1,51 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import ws from "../server/ws.js";
+import handlers from "../server/handlers.js";
+import DB from "../db/index.js";
+const app = new Hono();
+ws.createNodeWebSocket(app);
+app.get("/", (c) => {
+    return c.json({
+        apiVersion: "1.0.0",
+    });
+});
+app.get("/ws", ws.upgradeWebSocket());
+app.use("/api/handlers", cors());
+app.get("/api/handlers", async (c) => {
+    const body = c.req.query();
+    const { name, args } = body;
+    if (!name) {
+        return c.text("Name is required", 400);
+    }
+    try {
+        await DB.connect();
+        const rs = await handlers._runQuery(name, JSON.parse(args), {
+            db: DB,
+        });
+        // await DB.disconnect();
+        return c.json(rs);
+    }
+    catch (error) {
+        return c.text(`${error}`, 400);
+    }
+});
+app.post("/api/handlers", async (c) => {
+    const body = await c.req.json();
+    const { name, args } = body;
+    if (!name) {
+        return c.text("Name is required", 400);
+    }
+    try {
+        await DB.connect();
+        const rs = await handlers._runMutation(name, args, {
+            db: DB,
+        });
+        // await DB.disconnect();
+        return c.json(rs);
+    }
+    catch (error) {
+        return c.text(`${error}`, 400);
+    }
+});
+export default app;

package/lib/server/index.js

@@ -0,0 +1,10 @@
+import { query, mutation, internalQuery, internalMutation, v } from "../server/handlers.js";
+const PaginationQueryArgs = v.object({
+    limit: v.number(),
+    paginatedField: v.string().optional(),
+    sortAscending: v.boolean().optional(),
+    sortCaseInsensitive: v.boolean().optional(),
+    previous: v.string().optional(),
+    next: v.string().optional(),
+});
+export { query, mutation, internalQuery, internalMutation, v, PaginationQueryArgs };

package/lib/server/start.js

@@ -0,0 +1,20 @@
+import { serve } from "@hono/node-server";
+import app from "../server/hono.js";
+const server = serve({
+    fetch: app.fetch,
+    port: Number(process.env.MOGOBASE_PORT) || 4000,
+});
+// graceful shutdown
+process.on("SIGINT", () => {
+    server.close();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    server.close((err) => {
+        if (err) {
+            console.error(err);
+            process.exit(1);
+        }
+        process.exit(0);
+    });
+});

package/lib/server/ws.js

@@ -0,0 +1,133 @@
+// import { upgradeWebSocket } from "hono/cloudflare-workers";
+import { createNodeWebSocket } from "@hono/node-ws";
+import handlers from "./handlers.js";
+import DB from "../db/index.js";
+class WebSocket {
+    static _instance;
+    _nodeWebSocket;
+    _changeStream;
+    _state = new Map();
+    constructor() {
+        if (!WebSocket._instance) {
+            WebSocket._instance = this;
+        }
+        return WebSocket._instance;
+    }
+    async _handleEvent(event, socket, id) {
+        const data = JSON.parse(event.data);
+        const { type, name, args } = data;
+        if (!name) {
+            return socket.send({
+                success: false,
+                error: "Name is required",
+            });
+        }
+        let rs;
+        if (type === "query") {
+            const func = async (noWatch) => {
+                await DB.connect();
+                rs = await handlers._runQuery(name, args, {
+                    db: DB,
+                    watch: (modelName, pipeline, options) => {
+                        if (noWatch) {
+                            return;
+                        }
+                        const state = this._state.get(id);
+                        const resumeToken = state.changeStream?.resumeToken;
+                        if (state.changeStream) {
+                            state.changeStream.close();
+                        }
+                        const changeStream = DB.model(modelName).watch(pipeline, {
+                            ...(options || {}),
+                            fullDocument: "updateLookup",
+                            resumeAfter: resumeToken,
+                        });
+                        this._state.set(id, { ...state, changeStream: changeStream });
+                        changeStream.on("change", (change) => {
+                            func(true);
+                        });
+                    },
+                });
+                socket.send(JSON.stringify({ type: "QueryResult", success: true, data: rs }));
+            };
+            func();
+        }
+        else if (type === "paginated-query") {
+            const func = async (noWatch) => {
+                await DB.connect();
+                rs = await handlers._runQuery(name, args, {
+                    db: DB,
+                    watch: (modelName, pipeline, options) => {
+                        if (noWatch) {
+                            return;
+                        }
+                        const state = this._state.get(id);
+                        const resumeToken = state.changeStream?.resumeToken;
+                        if (state.changeStream) {
+                            state.changeStream.close();
+                        }
+                        const changeStream = DB.model(modelName).watch(pipeline, {
+                            ...(options || {}),
+                            fullDocument: "updateLookup",
+                            resumeAfter: resumeToken,
+                        });
+                        this._state.set(id, { ...state, changeStream: changeStream });
+                        changeStream.on("change", (change) => {
+                            if (change.operationType === "update") {
+                                const { fullDocument } = change;
+                                socket.send(JSON.stringify({ type: "UpdateDoc", success: true, data: fullDocument }));
+                            }
+                            func(true);
+                        });
+                    },
+                });
+                if (!rs.results) {
+                    throw new Error("Invalid paginated result. Make sure the return value is from MongoPaging.find");
+                }
+                socket.send(JSON.stringify({ type: "PaginatedQueryResult", success: true, data: rs }));
+            };
+            func();
+        }
+        else if (type === "mutation") {
+            await DB.connect();
+            rs = await handlers._runMutation(name, args, {
+                db: DB,
+            });
+            socket.send(JSON.stringify({ type: "MutationResult", success: true, data: rs }));
+        }
+    }
+    createNodeWebSocket(app) {
+        this._nodeWebSocket = createNodeWebSocket({ app });
+    }
+    upgradeWebSocket() {
+        if (!this._nodeWebSocket) {
+            throw new Error("Call createNodeWebSocket() first");
+        }
+        return this._nodeWebSocket.upgradeWebSocket((c) => {
+            const id = crypto.randomUUID();
+            return {
+                onMessage: (event, ws) => {
+                    const state = this._state.get(id);
+                    if (!state) {
+                        this._state.set(id, { ws });
+                    }
+                    this._handleEvent(event, ws, id);
+                },
+                onClose: async () => {
+                    const state = this._state.get(id);
+                    if (state && state.changeStream) {
+                        await state.changeStream.close();
+                        this._state.delete(id);
+                    }
+                },
+            };
+        });
+    }
+    injectWebSocket(server) {
+        if (!this._nodeWebSocket) {
+            throw new Error("Call createNodeWebSocket() first");
+        }
+        this._nodeWebSocket.injectWebSocket(server);
+    }
+}
+export default new WebSocket();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mogobase",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
@@ -44,7 +44,7 @@
     "hono": "^4.11.3",
     "lodash.merge": "^4.6.2",
     "make-cli": "^6.0.0",
-    "mongodb": "^6.21.0",
+    "mongodb": "6.8.2",
     "react": "^19.2.3",
     "tsx": "^4.21.0",
     "zod": "^4.3.5"

package/types/client/hooks/useMutation.d.ts

@@ -0,0 +1,2 @@
+declare function useMutation(name: string): (args?: any) => Promise<unknown>;
+export default useMutation;

package/types/client/hooks/usePaginatedQuery.d.ts

@@ -0,0 +1,14 @@
+type PaginationData = {
+    pageSize: number;
+    sortAscending?: boolean;
+    sortCaseInsensitive?: boolean;
+};
+declare function usePaginatedQuery(name: string, args?: any, paginationData?: PaginationData): {
+    results: any[];
+    hasNext: boolean;
+    loadNext: () => void;
+    hasPrevious: boolean;
+    loadPrevious: () => void;
+    isLoading: boolean;
+};
+export default usePaginatedQuery;

package/types/client/hooks/useQuery.d.ts

@@ -0,0 +1,2 @@
+declare function useQuery(name: string, args?: any): any;
+export default useQuery;

package/types/db/buildMongoFilters.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (filter: any, opts?: any) => any;
+export default _default;

package/types/db/index.d.ts

@@ -0,0 +1,24 @@
+import { Collection, CreateIndexesOptions, Db, IndexDescription, MongoClient, ObjectId } from "mongodb";
+import DataLoader from "dataloader";
+declare class MogobaseDB {
+    static _instance: MogobaseDB;
+    _mongoClient?: MongoClient;
+    _db?: Db;
+    _schemas: Map<string, any>;
+    constructor();
+    connect(): Promise<Db>;
+    disconnect(): Promise<void>;
+    get client(): MongoClient;
+    get db(): Db;
+    model(name: string): Collection;
+    defineModel(name: string, schema?: any, indexes?: {
+        indexSpecs: IndexDescription[];
+        options?: CreateIndexesOptions;
+    }): Promise<Collection>;
+}
+export type { MogobaseDB };
+export declare const Id: typeof ObjectId;
+export declare const buildFilters: (filter: any, opts?: any) => any;
+export declare const DataLoaderGenerate: (model: string, key?: string) => DataLoader<string, import("mongodb").WithId<import("bson").Document> | undefined, string>;
+declare const _default: MogobaseDB;
+export default _default;

package/types/dev/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/dev/start.d.ts

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import useMutation from "./client/hooks/useMutation";
+import useQuery from "./client/hooks/useQuery";
+import usePaginatedQuery from "./client/hooks/usePaginatedQuery";
+export { useMutation, useQuery, usePaginatedQuery };

package/types/server/handlers.d.ts

@@ -0,0 +1,43 @@
+import z4 from "zod/v4";
+import type { MogobaseDB } from "../db";
+import { ChangeStreamOptions, Document } from "mongodb";
+export type Context = {
+    db?: MogobaseDB;
+    runQuery?: (name: string, args: any, ctx?: Context) => Promise<any>;
+    runMutation?: (name: string, args: any, ctx?: Context) => Promise<any>;
+    watch?: (modelName: string, pipeline?: Document[], options?: ChangeStreamOptions) => void;
+};
+export type QueryHandler = {
+    args: z4.ZodType;
+    handler: (args: any, ctx: {
+        db: MogobaseDB;
+        runQuery: (name: string, args: any, ctx?: Context) => Promise<any>;
+        runMutation: (name: string, args: any, ctx?: Context) => Promise<any>;
+        watch: (modelName: string, pipeline?: Document[], options?: ChangeStreamOptions) => void;
+    }) => Promise<any>;
+};
+export type MutationHandler = {
+    args: z4.ZodType;
+    handler: (args: any, ctx: {
+        db: MogobaseDB;
+        runQuery: (name: string, args: any, ctx?: Context) => Promise<any>;
+        runMutation: (name: string, args: any, ctx?: Context) => Promise<any>;
+    }) => Promise<any>;
+};
+declare class Handlers {
+    static _instance: Handlers;
+    queries: Map<string, QueryHandler>;
+    mutations: Map<string, MutationHandler>;
+    _queries: Map<string, QueryHandler>;
+    _mutations: Map<string, MutationHandler>;
+    constructor();
+    _runQuery(name: string, args: any, ctx?: Context): Promise<any>;
+    _runMutation(name: string, args: any, ctx?: Context): Promise<any>;
+}
+export declare function query(name: string, c: QueryHandler): void;
+export declare function mutation(name: string, c: MutationHandler): void;
+export declare function internalQuery(name: string, c: QueryHandler): void;
+export declare function internalMutation(name: string, c: MutationHandler): void;
+export declare const v: typeof z4;
+declare const _default: Handlers;
+export default _default;

package/types/server/hono.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/types/server/index.d.ts

@@ -0,0 +1,10 @@
+import { query, mutation, internalQuery, internalMutation, v } from "../server/handlers";
+declare const PaginationQueryArgs: import("zod/v4").ZodObject<{
+    limit: import("zod/v4").ZodNumber;
+    paginatedField: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    sortAscending: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+    sortCaseInsensitive: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+    previous: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    next: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+}, import("zod/v4/core").$strip>;
+export { query, mutation, internalQuery, internalMutation, v, PaginationQueryArgs };

package/types/server/start.d.ts

@@ -0,0 +1 @@
+export {};

package/types/server/ws.d.ts

@@ -0,0 +1,19 @@
+import { NodeWebSocket } from "@hono/node-ws";
+import { Hono } from "hono";
+import { ServerType } from "@hono/node-server";
+import { ChangeStream } from "mongodb";
+declare class WebSocket {
+    static _instance: WebSocket;
+    _nodeWebSocket?: NodeWebSocket;
+    _changeStream?: ChangeStream;
+    _state: Map<string, any>;
+    constructor();
+    _handleEvent(event: any, socket: any, id: string): Promise<any>;
+    createNodeWebSocket(app: Hono): void;
+    upgradeWebSocket(): import("hono").MiddlewareHandler<any, string, {
+        outputFormat: "ws";
+    }>;
+    injectWebSocket(server: ServerType): void;
+}
+declare const _default: WebSocket;
+export default _default;