@rebasepro/server-mongo 0.0.1-canary.4829d6e

package/src/connection.ts

@@ -0,0 +1,60 @@
+/**
+ * MongoDB Connection
+ *
+ * Wraps MongoDB connection to implement the DatabaseConnection interface.
+ */
+
+import { Db, MongoClient } from "mongodb";
+import { DatabaseConnection } from "@rebasepro/types";
+
+/**
+ * MongoDB database connection wrapper that implements DatabaseConnection interface.
+ */
+export class MongoDBConnection implements DatabaseConnection {
+    readonly type = "mongodb";
+
+    constructor(
+        public readonly db: Db,
+        public readonly client: MongoClient
+    ) { }
+
+    get isConnected(): boolean {
+        // MongoClient doesn't have a direct isConnected property in v6+
+        // We check if the client topology is connected
+        try {
+            const clientInternal = this.client as unknown as Record<string, { isConnected?: () => boolean } | undefined>;
+            return clientInternal.topology?.isConnected?.() ?? false;
+        } catch {
+            return false;
+        }
+    }
+
+    async close(): Promise<void> {
+        await this.client.close();
+    }
+}
+
+/**
+ * Create a MongoDB database connection from a connection string.
+ *
+ * @param connectionString - MongoDB connection string (e.g., mongodb://localhost:27017)
+ * @param databaseName - Name of the database to use
+ * @returns Promise resolving to MongoDBConnection
+ *
+ * @example
+ * ```typescript
+ * const connection = await createMongoDBConnection(
+ *     "mongodb://localhost:27017",
+ *     "my_database"
+ * );
+ * ```
+ */
+export async function createMongoDBConnection(
+    connectionString: string,
+    databaseName: string
+): Promise<MongoDBConnection> {
+    const client = new MongoClient(connectionString);
+    await client.connect();
+    const db = client.db(databaseName);
+    return new MongoDBConnection(db, client);
+}

package/src/db/MongoConditionBuilder.ts

@@ -0,0 +1,224 @@
+/**
+ * MongoDB Condition Builder
+ *
+ * Translates Rebase filter conditions to MongoDB query operators.
+ */
+
+import { FilterValues, WhereFilterOp } from "@rebasepro/types";
+import { Filter, Document } from "mongodb";
+import { logger } from "@rebasepro/server";
+
+/**
+ * Mapping from Rebase filter operators to MongoDB query operators
+ */
+const REBASE_TO_MONGO_OP: Partial<Record<WhereFilterOp, string>> = {
+    "<": "$lt",
+    "<=": "$lte",
+    "==": "$eq",
+    "!=": "$ne",
+    ">=": "$gte",
+    ">": "$gt",
+    "array-contains": "$elemMatch",
+    "array-contains-any": "$in",
+    "in": "$in",
+    "not-in": "$nin"
+};
+
+function escapeRegExp(str: string): string {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Translate a SQL LIKE/ILIKE pattern into an anchored regular expression.
+ * `%` matches any sequence of characters, `_` matches a single character;
+ * every other character is matched literally.
+ */
+function likePatternToRegExp(pattern: string, caseInsensitive: boolean): RegExp {
+    let body = "";
+    for (const ch of String(pattern)) {
+        if (ch === "%") body += ".*";
+        else if (ch === "_") body += ".";
+        else body += escapeRegExp(ch);
+    }
+    return new RegExp(`^${body}$`, caseInsensitive ? "i" : "");
+}
+
+/**
+ * MongoDB Condition Builder
+ *
+ * Provides static methods to translate Rebase filter conditions
+ * to MongoDB query filters.
+ */
+export class MongoConditionBuilder {
+    /**
+     * Build MongoDB filter conditions from Rebase FilterValues
+     *
+     * @param filter - Rebase filter values
+     * @returns Array of MongoDB filter objects
+     */
+    static buildFilterConditions<M extends Record<string, any>>(
+        filter: FilterValues<Extract<keyof M, string>>
+    ): Filter<Document>[] {
+        if (!filter) return [];
+
+        const conditions: Filter<Document>[] = [];
+
+        for (const [field, filterParam] of Object.entries(filter)) {
+            if (!filterParam) continue;
+
+            const [op, value] = filterParam as [WhereFilterOp, any];
+
+            // Null-testing operators ignore their value.
+            if (op === "is-null") {
+                conditions.push({ [field]: { $eq: null } });
+                continue;
+            }
+            if (op === "is-not-null") {
+                conditions.push({ [field]: { $ne: null } });
+                continue;
+            }
+
+            // Pattern matching → regular expressions.
+            if (op === "like" || op === "ilike" || op === "not-like" || op === "not-ilike") {
+                const caseInsensitive = op === "ilike" || op === "not-ilike";
+                const regex = likePatternToRegExp(value, caseInsensitive);
+                const negated = op === "not-like" || op === "not-ilike";
+                conditions.push({
+                    [field]: negated ? { $not: regex } : { $regex: regex }
+                });
+                continue;
+            }
+
+            const mongoOp = REBASE_TO_MONGO_OP[op];
+
+            if (!mongoOp) {
+                logger.warn(`Unsupported filter operator: ${op}`);
+                continue;
+            }
+
+            // Handle array-contains specially
+            if (op === "array-contains") {
+                conditions.push({
+                    [field]: { $elemMatch: { $eq: value } }
+                });
+            } else {
+                conditions.push({
+                    [field]: { [mongoOp]: value }
+                });
+            }
+        }
+
+        return conditions;
+    }
+
+    /**
+     * Build search conditions for text search
+     *
+     * @param searchString - Text to search for
+     * @param properties - Properties to search in
+     * @returns Array of MongoDB filter objects for text search
+     */
+    static buildSearchConditions(
+        searchString: string,
+        properties: Record<string, any>
+    ): Filter<Document>[] {
+        if (!searchString) return [];
+
+        // Build regex conditions for each searchable string property
+        const orConditions: Filter<Document>[] = [];
+        const escapedSearch = escapeRegExp(searchString);
+        const searchRegex = new RegExp(escapedSearch, "i");
+
+        for (const [key, prop] of Object.entries(properties)) {
+            // Only search in string-type properties
+            if (prop?.dataType === "string" || typeof prop === "string") {
+                orConditions.push({
+                    [key]: { $regex: searchRegex }
+                });
+            }
+        }
+
+        // If no properties to search, use MongoDB text search
+        if (orConditions.length === 0) {
+            return [{ $text: { $search: searchString } }];
+        }
+
+        return orConditions;
+    }
+
+    /**
+     * Combine multiple conditions with AND operator
+     *
+     * @param conditions - Array of filter conditions
+     * @returns Combined filter or undefined if empty
+     */
+    static combineConditionsWithAnd(conditions: Filter<Document>[]): Filter<Document> | undefined {
+        if (conditions.length === 0) return undefined;
+        if (conditions.length === 1) return conditions[0];
+        return { $and: conditions };
+    }
+
+    /**
+     * Combine multiple conditions with OR operator
+     *
+     * @param conditions - Array of filter conditions
+     * @returns Combined filter or undefined if empty
+     */
+    static combineConditionsWithOr(conditions: Filter<Document>[]): Filter<Document> | undefined {
+        if (conditions.length === 0) return undefined;
+        if (conditions.length === 1) return conditions[0];
+        return { $or: conditions };
+    }
+
+    /**
+     * Build a complete MongoDB query from Rebase options
+     *
+     * @param options - Rebase fetch options
+     * @returns MongoDB filter object
+     */
+    static buildQuery<M extends Record<string, any>>(options: {
+        filter?: FilterValues<Extract<keyof M, string>>;
+        searchString?: string;
+        properties?: Record<string, any>;
+    }): Filter<Document> {
+        const conditions: Filter<Document>[] = [];
+
+        // Add filter conditions
+        if (options.filter) {
+            const filterConditions = this.buildFilterConditions<M>(options.filter);
+            conditions.push(...filterConditions);
+        }
+
+        // Add search conditions
+        if (options.searchString && options.properties) {
+            const searchConditions = this.buildSearchConditions(
+                options.searchString,
+                options.properties
+            );
+            if (searchConditions.length > 0) {
+                // Search conditions are OR'd together
+                const searchFilter = this.combineConditionsWithOr(searchConditions);
+                if (searchFilter) {
+                    conditions.push(searchFilter);
+                }
+            }
+        }
+
+        return this.combineConditionsWithAnd(conditions) ?? {};
+    }
+
+    /**
+     * Build MongoDB sort options from Rebase options
+     *
+     * @param orderBy - Field to order by
+     * @param order - Sort direction
+     * @returns MongoDB sort object
+     */
+    static buildSort(
+        orderBy?: string,
+        order?: "asc" | "desc"
+    ): Record<string, 1 | -1> | undefined {
+        if (!orderBy) return undefined;
+        return { [orderBy]: order === "desc" ? -1 : 1 };
+    }
+}

package/src/db/MongoDataService.ts

@@ -0,0 +1,368 @@
+/**
+ * MongoDB Row Service
+ *
+ * Implements DataRepository interface for MongoDB.
+ * Provides all CRUD operations for rows.
+ */
+
+import { Db, ObjectId, Collection, Document, FindOptions, Filter } from "mongodb";
+import { FilterValues, DataRepository, CollectionConfig, EntityReference } from "@rebasepro/types";
+import { MongoConditionBuilder } from "./MongoConditionBuilder";
+import { logger } from "@rebasepro/server";
+
+/**
+ * MongoDB Row Service
+ *
+ * Implements the DataRepository interface for MongoDB.
+ * Provides all CRUD operations for rows stored in MongoDB collections.
+ */
+export class MongoDataService implements DataRepository {
+    constructor(private db: Db) { }
+
+    /**
+     * Get a MongoDB collection by its path
+     */
+    private getCollection(collectionPath: string): Collection<Document> {
+        // Handle nested paths (e.g., "posts/123/comments" -> "posts_123_comments")
+        const collectionName = collectionPath.replace(/\//g, "_");
+        return this.db.collection(collectionName);
+    }
+
+    /**
+     * Convert a string ID to ObjectId if it's a valid ObjectId string
+     */
+    private toObjectId(id: string | number): ObjectId | string | number {
+        if (typeof id === "string" && ObjectId.isValid(id) && id.length === 24) {
+            return new ObjectId(id);
+        }
+        return id;
+    }
+
+    /**
+     * Convert a MongoDB document to a flat row (`{ id, ...fields }`)
+     */
+    private documentToRow(doc: Document): Record<string, unknown> {
+        const { _id, ...values } = doc;
+        return {
+            ...this.convertFromMongoValues(values),
+            // Spread the canonical id last so it wins over a literal `id` field
+            id: _id.toString()
+        };
+    }
+
+    /**
+     * Convert values from MongoDB format to Rebase format
+     */
+    private convertFromMongoValues(values: Record<string, any>): Record<string, any> {
+        const result: Record<string, any> = {};
+
+        for (const [key, value] of Object.entries(values)) {
+            result[key] = this.convertFromMongoValue(value);
+        }
+
+        return result;
+    }
+
+    /**
+     * Convert a single value from MongoDB format
+     */
+    private convertFromMongoValue(value: any): any {
+        if (value === null || value === undefined) return value;
+
+        // Handle ObjectId
+        if (value instanceof ObjectId) {
+            return value.toString();
+        }
+
+        // Handle Date
+        if (value instanceof Date) {
+            return value;
+        }
+
+        // Handle arrays
+        if (Array.isArray(value)) {
+            return value.map(v => this.convertFromMongoValue(v));
+        }
+
+        // Handle stored EntityReference. New writes are tagged with the
+        // `__type: "reference"` sentinel (see convertToMongoValue), which is
+        // unambiguous. We also accept the legacy shape — an object whose ONLY
+        // keys are `id` and `path` — so references written before the sentinel
+        // existed still decode. We deliberately do NOT treat any object that
+        // merely *contains* `id` and `path` as a reference, because that
+        // silently rewrites ordinary embedded sub-documents.
+        if (typeof value === "object") {
+            const keys = Object.keys(value);
+            const isTagged = value.__type === "reference" && "id" in value && "path" in value;
+            const isLegacy = keys.length === 2 && keys.includes("id") && keys.includes("path");
+            if (isTagged || isLegacy) {
+                return new EntityReference({
+                    id: value.id instanceof ObjectId ? value.id.toString() : String(value.id),
+                    path: value.path,
+                    driver: value.driver,
+                    databaseId: value.databaseId
+                });
+            }
+        }
+
+        // Handle nested objects
+        if (typeof value === "object") {
+            return this.convertFromMongoValues(value);
+        }
+
+        return value;
+    }
+
+    /**
+     * Convert values to MongoDB format for storage
+     */
+    private convertToMongoValues(values: Record<string, any>): Record<string, any> {
+        const result: Record<string, any> = {};
+
+        for (const [key, value] of Object.entries(values)) {
+            result[key] = this.convertToMongoValue(value);
+        }
+
+        return result;
+    }
+
+    /**
+     * Convert a single value to MongoDB format
+     */
+    private convertToMongoValue(value: any): any {
+        if (value === null || value === undefined) return value;
+
+        // Handle EntityReference. Persist with a `__type: "reference"` sentinel
+        // so it round-trips unambiguously, and preserve `driver`/`databaseId`
+        // so cross-datasource pointers don't lose their target on write.
+        if (typeof value === "object" && value.isEntityReference?.()) {
+            const ref: Record<string, unknown> = {
+                __type: "reference",
+                id: ObjectId.isValid(value.id) ? new ObjectId(value.id) : value.id,
+                path: value.path
+            };
+            if (value.driver !== undefined) ref.driver = value.driver;
+            if (value.databaseId !== undefined) ref.databaseId = value.databaseId;
+            return ref;
+        }
+
+        // Handle Date
+        if (value instanceof Date) {
+            return value;
+        }
+
+        // Handle arrays
+        if (Array.isArray(value)) {
+            return value.map(v => this.convertToMongoValue(v));
+        }
+
+        // Handle nested objects
+        if (typeof value === "object") {
+            return this.convertToMongoValues(value);
+        }
+
+        return value;
+    }
+
+    // =============================================================
+    // DataRepository Implementation
+    // =============================================================
+
+    /**
+     * Fetch a single row by ID
+     */
+    async fetchOne<M extends Record<string, any>>(
+        collectionPath: string,
+        id: string | number,
+        _databaseId?: string
+    ): Promise<Record<string, unknown> | undefined> {
+        const collection = this.getCollection(collectionPath);
+        const objectId = this.toObjectId(id);
+
+        const doc = await collection.findOne({ _id: objectId } as Filter<Document>);
+
+        if (!doc) return undefined;
+
+        return this.documentToRow(doc);
+    }
+
+    /**
+     * Fetch a collection of rows with optional filtering, ordering, and pagination
+     */
+    async fetchCollection<M extends Record<string, any>>(
+        collectionPath: string,
+        options: {
+            filter?: FilterValues<Extract<keyof M, string>>;
+            orderBy?: string;
+            order?: "desc" | "asc";
+            limit?: number;
+            startAfter?: any;
+            searchString?: string;
+            databaseId?: string;
+            collection?: CollectionConfig;
+            rawQuery?: Filter<Document>;
+        } = {}
+    ): Promise<Record<string, unknown>[]> {
+        const collection = this.getCollection(collectionPath);
+
+        // Build query
+        const query = options.rawQuery ?? MongoConditionBuilder.buildQuery<M>({
+            filter: options.filter,
+            searchString: options.searchString,
+            properties: options.collection?.properties ?? {}
+        });
+
+        // Build find options
+        const findOptions: FindOptions = {};
+
+        // Apply sorting
+        const sort = MongoConditionBuilder.buildSort(options.orderBy, options.order);
+        if (sort) {
+            findOptions.sort = sort;
+        }
+
+        // Apply limit
+        if (options.limit) {
+            findOptions.limit = options.limit;
+        }
+
+        // Apply pagination (skip-based for now, cursor-based would be better)
+        if (options.startAfter !== undefined) {
+            findOptions.skip = Number(options.startAfter);
+        }
+
+        const docs = await collection.find(query, findOptions).toArray();
+
+        return docs.map((doc: Document) => this.documentToRow(doc));
+    }
+
+    /**
+     * Search rows by text
+     */
+    async searchRows<M extends Record<string, any>>(
+        collectionPath: string,
+        searchString: string,
+        options: {
+            filter?: FilterValues<Extract<keyof M, string>>;
+            orderBy?: string;
+            order?: "desc" | "asc";
+            limit?: number;
+            databaseId?: string;
+            collection?: CollectionConfig;
+            rawQuery?: Filter<Document>;
+        } = {}
+    ): Promise<Record<string, unknown>[]> {
+        return this.fetchCollection<M>(collectionPath, {
+            ...options,
+            searchString
+        });
+    }
+
+    /**
+     * Count rows in a collection
+     */
+    async count<M extends Record<string, any>>(
+        collectionPath: string,
+        options: {
+            filter?: FilterValues<Extract<keyof M, string>>;
+            databaseId?: string;
+            rawQuery?: Filter<Document>;
+        } = {}
+    ): Promise<number> {
+        const collection = this.getCollection(collectionPath);
+
+        const query = options.rawQuery ?? (options.filter
+            ? MongoConditionBuilder.buildQuery<M>({ filter: options.filter })
+            : {});
+
+        return collection.countDocuments(query);
+    }
+
+    /**
+     * Save an row (create or update)
+     */
+    async save<M extends Record<string, any>>(
+        collectionPath: string,
+        values: Partial<M>,
+        id?: string | number,
+        _databaseId?: string
+    ): Promise<Record<string, unknown>> {
+        const collection = this.getCollection(collectionPath);
+        const mongoValues = this.convertToMongoValues(values as Record<string, any>);
+
+        if (id) {
+            // Update existing row
+            const objectId = this.toObjectId(id);
+            await collection.updateOne(
+                { _id: objectId } as Filter<Document>,
+                { $set: mongoValues },
+                { upsert: true }
+            );
+
+            return {
+                ...values,
+                id: id.toString()
+            };
+        } else {
+            // Create new row
+            const newId = new ObjectId();
+            await collection.insertOne({
+                _id: newId,
+                ...mongoValues
+            });
+
+            return {
+                ...values,
+                id: newId.toString()
+            };
+        }
+    }
+
+    /**
+     * Delete an row by ID
+     */
+    async delete(
+        collectionPath: string,
+        id: string | number,
+        _databaseId?: string
+    ): Promise<void> {
+        const collection = this.getCollection(collectionPath);
+        const objectId = this.toObjectId(id);
+
+        const result = await collection.deleteOne({ _id: objectId } as Filter<Document>);
+
+        if (result.deletedCount === 0) {
+            logger.warn(`Row ${id} not found in collection ${collectionPath}`);
+        }
+    }
+
+    /**
+     * Check if a field value is unique in a collection
+     */
+    async checkUniqueField(
+        collectionPath: string,
+        fieldName: string,
+        value: any,
+        excludeEntityId?: string,
+        _databaseId?: string
+    ): Promise<boolean> {
+        const collection = this.getCollection(collectionPath);
+
+        const query: Filter<Document> = { [fieldName]: value };
+
+        if (excludeEntityId) {
+            const objectId = this.toObjectId(excludeEntityId);
+            (query as Record<string, unknown>)._id = { $ne: objectId };
+        }
+
+        const count = await collection.countDocuments(query);
+        return count === 0;
+    }
+
+    /**
+     * Generate a new row ID
+     */
+    generateId(): string {
+        return new ObjectId().toString();
+    }
+}