fluxor-cloud-db 1.0.0

package/src/mongo/mongo.ts

@@ -0,0 +1,690 @@
+/**
+ * MongoDB implementation of DatabaseAdapter interface
+ * This is a template implementation showing how to adapt another database backend
+ */
+
+import { MongoClient, Db, Collection, Filter, UpdateFilter, WithId } from "mongodb";
+import {
+    DatabaseAdapter
+} from "./../contracts/database-adapter";
+import { DatabaseAdapterError } from "./../types/error";
+import { WhereClause, QueryOptions, PaginatedResult, BatchResult, UpdateClause, QueryOperator } from "./../types/query";
+
+export interface MongoConfig {
+    uri: string;
+    dbName: string;
+    authSource?: string;
+    retryWrites?: boolean;
+    w?: "majority" | number;
+}
+
+export class MongoService implements DatabaseAdapter {
+    private client: MongoClient | undefined;
+    private db: Db | undefined;
+    private isConnectedFlag = false;
+    private config: MongoConfig | undefined;
+
+    public setConfig(config: MongoConfig): void {
+        this.config = config;
+    }
+
+    connect(): Promise<void> {
+        if (!this.config) {
+            return Promise.reject(new DatabaseAdapterError(
+                "No configuration provided. Call setConfig() first.",
+                "INVALID_CONFIG"
+            ));
+        }
+
+        return Promise.resolve().then(async () => {
+            try {
+                this.validateConfig(this.config!);
+
+                this.client = new MongoClient(this.config!.uri, {
+                    retryWrites: this.config!.retryWrites ?? true,
+                    w: this.config!.w ?? "majority",
+                    authSource: this.config!.authSource
+                });
+
+                await this.client.connect();
+                this.db = this.client.db(this.config!.dbName);
+
+                // Verify connection
+                await this.db.admin().ping();
+                this.isConnectedFlag = true;
+            } catch (error) {
+                this.isConnectedFlag = false;
+                throw this.handleError(error, "connect");
+            }
+        });
+    }
+
+    async disconnect(): Promise<void> {
+        try {
+            if (this.client) {
+                await this.client.close();
+            }
+            this.isConnectedFlag = false;
+            this.db = undefined;
+            this.client = undefined;
+        } catch (error) {
+            console.warn("Error disconnecting from MongoDB:", error);
+            this.isConnectedFlag = false;
+        }
+    }
+
+    isConnected(): boolean {
+        return this.isConnectedFlag && this.client !== undefined;
+    }
+
+    async healthCheck(): Promise<boolean> {
+        try {
+            const db = this.getDb();
+            await db.admin().ping();
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async selectOne<T = Record<string, any>>(
+        tableName: string,
+        where: WhereClause,
+        options?: QueryOptions
+    ): Promise<T | null> {
+        try {
+            const collection = this.getCollection<T>(tableName);
+            const filter = this.buildMongoFilter(where);
+
+            const findOptions: Record<string, unknown> = {};
+            if (Array.isArray(options?.projection)) {
+                const projection: Record<string, 1 | 0> = {};
+                for (const field of options.projection) {
+                    if (typeof field === "string") {
+                        projection[field] = 1;
+                    }
+                }
+                if (Object.keys(projection).length > 0) {
+                    findOptions.projection = projection;
+                }
+            }
+
+            const result = await collection.findOne(filter, findOptions as Parameters<Collection['findOne']>[1]);
+            
+            if (result === null || result === undefined) {
+                return null;
+            }
+
+            return result as unknown as T;
+        } catch (error) {
+            throw this.handleError(error, "selectOne");
+        }
+    }
+
+    async selectMany<T = Record<string, any>>(
+        tableName: string,
+        where?: WhereClause,
+        options?: QueryOptions
+    ): Promise<PaginatedResult<T>> {
+        try {
+            const collection = this.getCollection<T>(tableName);
+            const filter = where ? this.buildMongoFilter(where) : {};
+
+            const findOptions: Record<string, unknown> = {};
+
+            if (typeof options?.limit === "number" && options.limit > 0) {
+                findOptions.limit = options.limit;
+            }
+
+            if (typeof options?.offset === "number" && options.offset >= 0) {
+                findOptions.skip = options.offset;
+            }
+
+            if (Array.isArray(options?.orderBy) && options.orderBy.length > 0) {
+                const sort: Record<string, 1 | -1> = {};
+                for (const order of options.orderBy) {
+                    if (typeof order === "object" && order !== null && "field" in order && "direction" in order) {
+                        const field = order.field;
+                        const direction = order.direction;
+                        if (typeof field === "string" && (direction === "ASC" || direction === "DESC")) {
+                            sort[field] = direction === "DESC" ? -1 : 1;
+                        }
+                    }
+                }
+                if (Object.keys(sort).length > 0) {
+                    findOptions.sort = sort;
+                }
+            }
+
+            if (Array.isArray(options?.projection)) {
+                const projection: Record<string, 1 | 0> = {};
+                for (const field of options.projection) {
+                    if (typeof field === "string") {
+                        projection[field] = 1;
+                    }
+                }
+                if (Object.keys(projection).length > 0) {
+                    findOptions.projection = projection;
+                }
+            }
+
+            const items = await collection.find(filter, findOptions as Parameters<Collection['find']>[1]).toArray();
+            const total = await collection.countDocuments(filter);
+
+            const offset = typeof options?.offset === "number" ? options.offset : 0;
+            const hasMore = offset + items.length < total;
+
+            return {
+                items: items as unknown as T[],
+                total,
+                hasMore
+            };
+        } catch (error) {
+            throw this.handleError(error, "selectMany");
+        }
+    }
+
+    async createOne<T = Record<string, any>>(
+        tableName: string,
+        data: Record<string, any>
+    ): Promise<T> {
+        try {
+            if (typeof data !== "object" || data === null) {
+                throw new DatabaseAdapterError(
+                    "Data must be an object",
+                    "INVALID_INPUT"
+                );
+            }
+
+            const collection = this.getCollection(tableName);
+            const result = await collection.insertOne(data as unknown as WithId<Record<string, unknown>>);
+
+            return { ...data, _id: result.insertedId } as T;
+        } catch (error) {
+            if (error instanceof DatabaseAdapterError) {
+                throw error;
+            }
+            throw this.handleError(error, "createOne");
+        }
+    }
+
+    async createMany<T = Record<string, any>>(
+        tableName: string,
+        data: Record<string, any>[],
+        options?: { stopOnError?: boolean }
+    ): Promise<{ items: T[]; result: BatchResult }> {
+        try {
+            if (!Array.isArray(data)) {
+                throw new DatabaseAdapterError(
+                    "Data must be an array",
+                    "INVALID_INPUT"
+                );
+            }
+
+            if (data.length === 0) {
+                return {
+                    items: [],
+                    result: {
+                        successful: 0,
+                        failed: 0
+                    }
+                };
+            }
+
+            const collection = this.getCollection(tableName);
+            const stopOnError = typeof options?.stopOnError === "boolean" ? options.stopOnError : false;
+
+            try {
+                const result = await collection.insertMany(
+                    data as unknown as WithId<Record<string, unknown>>[],
+                    {
+                        ordered: stopOnError
+                    }
+                );
+
+                const items = data.map((item, index) => {
+                    const insertedId = result.insertedIds[index];
+                    if (insertedId === null || insertedId === undefined) {
+                        return item as T;
+                    }
+                    return {
+                        ...item,
+                        _id: insertedId
+                    } as T;
+                });
+
+                return {
+                    items,
+                    result: {
+                        successful: items.length,
+                        failed: 0
+                    }
+                };
+            } catch (error: unknown) {
+                if (stopOnError) {
+                    throw this.handleError(error, "createMany");
+                }
+
+                // Partial success scenario
+                let insertedCount = 0;
+                
+                if (error instanceof Error) {
+                    const errorMsg = error.message;
+                    // Try to extract nInserted from error
+                    if (errorMsg.includes("insertedCount") || errorMsg.includes("nInserted")) {
+                        const match = errorMsg.match(/\d+/);
+                        if (match) {
+                            insertedCount = parseInt(match[0], 10);
+                        }
+                    }
+                }
+
+                const failed = data.length - insertedCount;
+                const errorMessage = error instanceof Error ? error.message : "Unknown error during batch insert";
+
+                return {
+                    items: insertedCount > 0 ? (data.slice(0, insertedCount) as T[]) : [],
+                    result: {
+                        successful: insertedCount,
+                        failed,
+                        errors: failed > 0 ? [
+                            {
+                                index: insertedCount,
+                                error: errorMessage
+                            }
+                        ] : undefined
+                    }
+                };
+            }
+        } catch (error) {
+            throw this.handleError(error, "createMany");
+        }
+    }
+
+    async updateOne<T = Record<string, any>>(
+        tableName: string,
+        update: UpdateClause,
+        where: WhereClause
+    ): Promise<T> {
+        try {
+            const collection = this.getCollection<T>(tableName);
+            const filter = this.buildMongoFilter(where);
+            const updateDoc = this.buildMongoUpdate(update);
+
+            // Driver v5+ returns the document directly; v4 and below wrap it in { value }.
+            // Support both shapes so this works regardless of the installed driver version.
+            const raw = await collection.findOneAndUpdate(filter, updateDoc, {
+                returnDocument: "after"
+            });
+
+            const doc = raw && typeof raw === "object" && "value" in raw
+                ? (raw as any).value
+                : raw;
+
+            if (doc === null || doc === undefined) {
+                throw new DatabaseAdapterError(
+                    "Document not found for update",
+                    "NOT_FOUND"
+                );
+            }
+
+            return doc as unknown as T;
+        } catch (error) {
+            if (error instanceof DatabaseAdapterError) {
+                throw error;
+            }
+            throw this.handleError(error, "updateOne");
+        }
+    }
+
+    async updateMany<T = Record<string, any>>(
+        tableName: string,
+        update: UpdateClause,
+        where?: WhereClause,
+        options?: { limit?: number }
+    ): Promise<{ items: T[]; result: BatchResult }> {
+        try {
+            const collection = this.getCollection<T>(tableName);
+            const filter = where ? this.buildMongoFilter(where) : {};
+            const updateDoc = this.buildMongoUpdate(update);
+
+            const limit = typeof options?.limit === "number" && options.limit > 0 ? options.limit : undefined;
+
+            if (limit) {
+                const matchingDocs = await collection
+                    .find(filter)
+                    .limit(limit)
+                    .toArray();
+
+                if (matchingDocs.length === 0) {
+                    return {
+                        items: [],
+                        result: { successful: 0, failed: 0 }
+                    };
+                }
+
+                const ids = matchingDocs
+                    .map((doc) => {
+                        const docWithId = doc as WithId<Record<string, unknown>>;
+                        return docWithId._id;
+                    })
+                    .filter((id) => id !== null && id !== undefined);
+
+                if (ids.length === 0) {
+                    return {
+                        items: [],
+                        result: { successful: 0, failed: 0 }
+                    };
+                }
+
+                const idFilter: Filter<WithId<Record<string, unknown>>> = { _id: { $in: ids } };
+                const updateResult = await collection.updateMany(idFilter, updateDoc);
+
+                return {
+                    items: matchingDocs as unknown as T[],
+                    result: {
+                        successful: updateResult.modifiedCount,
+                        failed: 0
+                    }
+                };
+            } else {
+                const updateResult = await collection.updateMany(filter, updateDoc);
+                const updatedDocs = await collection.find(filter).toArray();
+
+                return {
+                    items: updatedDocs as unknown as T[],
+                    result: {
+                        successful: updateResult.modifiedCount,
+                        failed: 0
+                    }
+                };
+            }
+        } catch (error) {
+            throw this.handleError(error, "updateMany");
+        }
+    }
+
+    async deleteOne(
+        tableName: string,
+        where: WhereClause
+    ): Promise<{ success: boolean; deletedCount: number }> {
+        try {
+            const collection = this.getCollection(tableName);
+            const filter = this.buildMongoFilter(where);
+
+            const result = await collection.deleteOne(filter);
+
+            return {
+                success: result.deletedCount > 0,
+                deletedCount: result.deletedCount
+            };
+        } catch (error) {
+            throw this.handleError(error, "deleteOne");
+        }
+    }
+
+    async deleteMany(
+        tableName: string,
+        where?: WhereClause,
+        options?: { limit?: number }
+    ): Promise<{ success: boolean; deletedCount: number; result: BatchResult }> {
+        try {
+            const collection = this.getCollection(tableName);
+            const filter = where ? this.buildMongoFilter(where) : {};
+
+            let deletedCount = 0;
+
+            if (typeof options?.limit === "number" && options.limit > 0) {
+                const docsToDelete = await collection
+                    .find(filter)
+                    .limit(options.limit)
+                    .toArray();
+
+                if (docsToDelete.length === 0) {
+                    return {
+                        success: true,
+                        deletedCount: 0,
+                        result: {
+                            successful: 0,
+                            failed: 0
+                        }
+                    };
+                }
+
+                const ids = docsToDelete
+                    .map((doc) => {
+                        const docWithId = doc as WithId<Record<string, unknown>>;
+                        return docWithId._id;
+                    })
+                    .filter((id) => id !== null && id !== undefined);
+
+                if (ids.length === 0) {
+                    return {
+                        success: true,
+                        deletedCount: 0,
+                        result: {
+                            successful: 0,
+                            failed: 0
+                        }
+                    };
+                }
+
+                const idFilter: Filter<WithId<Record<string, unknown>>> = { _id: { $in: ids } };
+                const result = await collection.deleteMany(idFilter);
+                deletedCount = result.deletedCount;
+            } else {
+                const result = await collection.deleteMany(filter);
+                deletedCount = result.deletedCount;
+            }
+
+            return {
+                success: true,
+                deletedCount,
+                result: {
+                    successful: deletedCount,
+                    failed: 0
+                }
+            };
+        } catch (error) {
+            throw this.handleError(error, "deleteMany");
+        }
+    }
+
+    async executeRaw<T = any>(query: string, params?: Record<string, any>): Promise<T> {
+        // This could execute an aggregation pipeline or raw MongoDB query
+        throw new DatabaseAdapterError(
+            "executeRaw not fully implemented for this example",
+            "NOT_IMPLEMENTED"
+        );
+    }
+
+    // ============ Private Helpers ============
+
+    private validateConfig(config: MongoConfig): void {
+        if (!config || !config.uri || !config.dbName) {
+            throw new DatabaseAdapterError(
+                "MongoDB configuration requires uri and dbName",
+                "INVALID_CONFIG"
+            );
+        }
+    }
+
+    private getDb(): Db {
+        if (!this.isConnectedFlag || !this.db) {
+            throw new DatabaseAdapterError(
+                "MongoDB client is not connected. Call connect() first.",
+                "NOT_CONNECTED"
+            );
+        }
+        return this.db;
+    }
+
+    private getCollection<T = Record<string, any>>(tableName: string): Collection<WithId<Record<string, unknown>>> {
+        if (typeof tableName !== "string" || !tableName) {
+            throw new DatabaseAdapterError(
+                "Table name must be a non-empty string",
+                "INVALID_TABLE_NAME"
+            );
+        }
+        return this.getDb().collection<WithId<Record<string, unknown>>>(tableName);
+    }
+
+    private buildMongoFilter(where: WhereClause): Filter<WithId<Record<string, unknown>>> {
+        const filter: Filter<WithId<Record<string, unknown>>> = {};
+
+        if (typeof where !== "object" || where === null) {
+            return filter;
+        }
+
+        for (const [field, condition] of Object.entries(where)) {
+            if (!field || typeof field !== "string") {
+                continue;
+            }
+
+            if (condition === null || condition === undefined) {
+                continue;
+            }
+
+            if (typeof condition === "object" && "operator" in condition) {
+                const condObj = condition as Record<string, unknown>;
+                const operator = condObj["operator"];
+                const value = condObj["value"];
+
+                if (typeof operator !== "string" || !this.isValidOperator(operator)) {
+                    continue;
+                }
+
+                if (value === null || value === undefined) {
+                    continue;
+                }
+
+                const op = operator as QueryOperator;
+
+                switch (op) {
+                    case "=":
+                        filter[field] = value;
+                        break;
+                    case "!=":
+                        filter[field] = { $ne: value };
+                        break;
+                    case ">":
+                        filter[field] = { $gt: value };
+                        break;
+                    case ">=":
+                        filter[field] = { $gte: value };
+                        break;
+                    case "<":
+                        filter[field] = { $lt: value };
+                        break;
+                    case "<=":
+                        filter[field] = { $lte: value };
+                        break;
+                    case "IN":
+                        if (Array.isArray(value)) {
+                            filter[field] = { $in: value };
+                        } else {
+                            filter[field] = { $in: [value] };
+                        }
+                        break;
+                    case "NOT_IN":
+                        if (Array.isArray(value)) {
+                            filter[field] = { $nin: value };
+                        } else {
+                            filter[field] = { $nin: [value] };
+                        }
+                        break;
+                    case "BETWEEN":
+                        if (Array.isArray(value) && value.length === 2) {
+                            const [min, max] = value;
+                            if (min !== null && min !== undefined && max !== null && max !== undefined) {
+                                filter[field] = { $gte: min, $lte: max };
+                            }
+                        }
+                        break;
+                    case "LIKE":
+                        if (typeof value === "string") {
+                            filter[field] = { $regex: value, $options: "i" };
+                        }
+                        break;
+                    case "BEGINS_WITH":
+                        if (typeof value === "string") {
+                            filter[field] = { $regex: `^${value}`, $options: "i" };
+                        }
+                        break;
+                    case "EXISTS":
+                        if (typeof value === "boolean") {
+                            filter[field] = { $exists: value };
+                        }
+                        break;
+                }
+            } else {
+                filter[field] = condition;
+            }
+        }
+
+        return filter;
+    }
+
+    private isValidOperator(op: string): op is QueryOperator {
+        const validOperators: QueryOperator[] = ["=", "!=", ">", ">=", "<", "<=", "IN", "NOT_IN", "BETWEEN", "LIKE", "BEGINS_WITH", "EXISTS"];
+        return validOperators.includes(op as QueryOperator);
+    }
+
+    private buildMongoUpdate(update: UpdateClause): UpdateFilter<WithId<Record<string, unknown>>> {
+        const mongoUpdate: Record<string, Record<string, unknown>> = {};
+        const setFields: Record<string, unknown> = {};
+        const incrementFields: Record<string, unknown> = {};
+
+        if (typeof update !== "object" || update === null) {
+            return mongoUpdate as UpdateFilter<WithId<Record<string, unknown>>>;
+        }
+
+        for (const [field, value] of Object.entries(update)) {
+            if (!field || typeof field !== "string") {
+                continue;
+            }
+
+            if (value === null || value === undefined) {
+                continue;
+            }
+
+            if (typeof value === "object" && "$increment" in value) {
+                const val = value as Record<string, unknown>;
+                if (typeof val["$increment"] === "number") {
+                    incrementFields[field] = val["$increment"];
+                }
+            } else {
+                setFields[field] = value;
+            }
+        }
+
+        if (Object.keys(setFields).length > 0) {
+            mongoUpdate.$set = setFields;
+        }
+
+        if (Object.keys(incrementFields).length > 0) {
+            mongoUpdate.$inc = incrementFields;
+        }
+
+        return mongoUpdate as UpdateFilter<WithId<Record<string, unknown>>>;
+    }
+
+    private handleError(error: unknown, operation: string): DatabaseAdapterError {
+        if (error instanceof DatabaseAdapterError) {
+            return error;
+        }
+
+        if (error instanceof Error) {
+            return new DatabaseAdapterError(
+                `${operation} failed: ${error.message}`,
+                "OPERATION_FAILED",
+                { originalError: error.message }
+            );
+        }
+
+        return new DatabaseAdapterError(
+            `${operation} failed: Unknown error`,
+            "OPERATION_FAILED"
+        );
+    }
+}

package/src/types/error.ts

@@ -0,0 +1,13 @@
+/**
+ * Base error type for database operations
+ */
+export class DatabaseAdapterError extends Error {
+    constructor(
+        message: string,
+        public readonly code: string,
+        public readonly details?: Record<string, any>
+    ) {
+        super(message);
+        this.name = "DatabaseAdapterError";
+    }
+}