@lobb-js/core 0.13.0

package/src/database/drivers/MongoDriver.ts

@@ -0,0 +1,750 @@
+// import type {
+//   Db,
+//   Document,
+//   Filter,
+//   IndexDescription,
+//   IndexSpecification,
+// } from "mongodb";
+// import type { FindAllParamsOutput } from "../../types/index.ts";
+// import type { Entry } from "../../types/index.ts";
+// import type {
+//   CollectionConfig,
+//   CollectionField,
+//   CollectionFields,
+//   CollectionIndex,
+//   CollectionIndexes,
+//   CollectionIndexFields,
+//   CollectionsConfig,
+// } from "../../types/index.ts";
+
+// import { MongoClient, MongoServerError, ObjectId } from "mongodb";
+// import { DatabaseDriver } from "../../types/index.ts";
+// import { BSON, Decimal128, Double, Long } from "mongodb";
+// import { omit } from "jsr:@opentf/std@0.12.0";
+// import _ from "lodash";
+// import escapeStringRegexp from "escape-string-regexp";
+// import { LobbError } from "../../../LobbError.ts";
+// import { Lobb } from "../../../Lobb.ts";
+
+// export class MongoDriver extends DatabaseDriver {
+//   protected connection!: MongoClient;
+//   protected db!: Db;
+
+//   public async createConnection() {
+//     const url =
+//       `mongodb://${this.databaseConfig.host}:${this.databaseConfig.port}`;
+//     const client = new MongoClient(url, {
+//       auth: {
+//         username: this.databaseConfig.username,
+//         password: this.databaseConfig.password,
+//       },
+//     });
+//     this.connection = await client.connect();
+//     this.db = this.connection.db(this.databaseConfig.database);
+//   }
+
+//   public async close() {
+//     await this.connection.close();
+//   }
+
+//   public async raw(func: (db: Db) => void) {
+//     return await func(this.db);
+//   }
+
+//   public async dropDatabase() {
+//     await this.db.dropDatabase();
+//   }
+
+//   public async createCollection(
+//     collectionName: string,
+//     collectionConfig: CollectionConfig,
+//   ) {
+//     const properties: any = {};
+
+//     for (
+//       const [fieldName, fieldConfig] of Object.entries(collectionConfig.fields)
+//     ) {
+//       if (fieldName === "id") {
+//         continue;
+//       }
+//       properties[fieldName] = {
+//         bsonType: [this.getMongoDBFieldType(fieldConfig.type), "null"],
+//       };
+//     }
+
+//     await this.db.createCollection(collectionName, {
+//       validator: {
+//         "$jsonSchema": {
+//           "bsonType": "object",
+//           "properties": properties,
+//         },
+//       },
+//       validationLevel: "strict",
+//       validationAction: "error",
+//     });
+
+//     // creating the indexes
+//     for (
+//       const [indexName, value] of Object.entries(
+//         collectionConfig.indexes as any,
+//       )
+//     ) {
+//       await this.createIndex(
+//         collectionName,
+//         indexName,
+//         value as any,
+//       );
+//     }
+//   }
+
+//   public async dropCollection(collectionName: string) {
+//     await this.db.dropCollection(collectionName);
+//   }
+
+//   public async addField(
+//     collectionName: string,
+//     fieldName: string,
+//     field: CollectionField,
+//   ): Promise<void> {
+//     const collectionInfo = await this.getCollectionInfo(collectionName) as any;
+//     const newValidator = collectionInfo.options.validator;
+//     newValidator.$jsonSchema.properties[fieldName] = {
+//       bsonType: [this.getMongoDBFieldType(field.type), "null"],
+//     };
+//     await this.db.command({
+//       collMod: collectionName,
+//       validator: newValidator,
+//       validationLevel: "strict",
+//       validationAction: "error",
+//     });
+//   }
+
+//   public async removeField(
+//     collectionName: string,
+//     fieldName: string,
+//   ): Promise<void> {
+//     const collectionInfo = await this.getCollectionInfo(collectionName) as any;
+//     const newValidator = collectionInfo.options.validator;
+//     delete newValidator.$jsonSchema.properties[fieldName];
+//     await this.db.command({
+//       collMod: collectionName,
+//       validator: newValidator,
+//       validationLevel: "strict",
+//       validationAction: "error",
+//     });
+//   }
+
+//   private async getCollectionInfo(collectionName: string) {
+//     const collections = await this.db.listCollections().toArray();
+//     for (let index = 0; index < collections.length; index++) {
+//       const collection = collections[index];
+//       if (collection.name === collectionName) {
+//         return collection;
+//       }
+//     }
+
+//     throw new LobbError({
+//       code: "INTERNAL_SERVER_ERROR",
+//       message:
+//         `Counldn't find the requested (${collectionName}) collection info`,
+//     });
+//   }
+
+//   public async getDbSchema(): Promise<CollectionsConfig> {
+//     const dbSchema: CollectionsConfig = {};
+//     const dbCollections = await this.db.listCollections().toArray();
+
+//     for (let index = 0; index < dbCollections.length; index++) {
+//       const collection: any = dbCollections[index];
+//       const fields = collection.options.validator?.$jsonSchema.properties;
+//       if (fields) {
+//         const fieldsConfig: CollectionFields = {
+//           id: {
+//             type: "integer",
+//           },
+//         };
+//         for (const [fieldName, value] of Object.entries(fields)) {
+//           const fieldValue = value as any;
+//           fieldsConfig[fieldName] = {
+//             type: this.getCollectionFieldType(fieldValue.bsonType[0]),
+//           };
+//         }
+
+//         dbSchema[collection.name] = {
+//           indexes: await this.getIndexes(collection.name),
+//           fields: fieldsConfig,
+//         };
+//       }
+//     }
+
+//     return dbSchema;
+//   }
+
+//   public async adaptFilter(
+//     filter: any,
+//     collectionName: string,
+//   ): Promise<Filter<Document>> {
+//     const fieldNames = Lobb.instance.configManager.getFieldNames(
+//       collectionName,
+//     );
+//     filter = _.cloneDeepWith(
+//       filter,
+//       (value: any, _key: string) => {
+//         const group: any = {};
+//         group.$and = [];
+//         for (let index = 0; index < fieldNames.length; index++) {
+//           const fieldName = fieldNames[index];
+//           const innerGroup: any = {};
+//           innerGroup.$and = [];
+//           if (value[fieldName]) {
+//             if (value[fieldName].$contains) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $regex: escapeStringRegexp(value[fieldName].$contains),
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$icontains) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $regex: escapeStringRegexp(value[fieldName].$icontains),
+//                   $options: "i",
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$ncontains) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $regex: escapeStringRegexp(value[fieldName].$ncontains),
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$incontains) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $regex: escapeStringRegexp(value[fieldName].$incontains),
+//                     $options: "i",
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$starts_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $regex: `^${
+//                     escapeStringRegexp(value[fieldName].$starts_with)
+//                   }`,
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$istarts_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $regex: `^${
+//                     escapeStringRegexp(value[fieldName].$istarts_with)
+//                   }`,
+//                   $options: "i",
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$nstarts_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $regex: `^${
+//                       escapeStringRegexp(value[fieldName].$nstarts_with)
+//                     }`,
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$instarts_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $regex: `^${
+//                       escapeStringRegexp(value[fieldName].$instarts_with)
+//                     }`,
+//                     $options: "i",
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$ends_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $regex: `${escapeStringRegexp(value[fieldName].$ends_with)}$`,
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$iends_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $regex: `${
+//                     escapeStringRegexp(value[fieldName].$iends_with)
+//                   }$`,
+//                   $options: "i",
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$nends_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $regex: `${
+//                       escapeStringRegexp(value[fieldName].$nends_with)
+//                     }$`,
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$inends_with) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $regex: `${
+//                       escapeStringRegexp(value[fieldName].$inends_with)
+//                     }$`,
+//                     $options: "i",
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$between) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $gte: value[fieldName].$between[0],
+//                   $lte: value[fieldName].$between[1],
+//                 },
+//               });
+//             }
+
+//             if (value[fieldName].$nbetween) {
+//               innerGroup.$and.push({
+//                 [fieldName]: {
+//                   $not: {
+//                     $gte: value[fieldName].$nbetween[0],
+//                     $lte: value[fieldName].$nbetween[1],
+//                   },
+//                 },
+//               });
+//             }
+
+//             if (innerGroup.$and.length) {
+//               group.$and.push(innerGroup);
+//             }
+//           }
+//         }
+
+//         if (group.$and.length) {
+//           return group;
+//         }
+//       },
+//     );
+
+//     filter = this.renameIdKeys(filter);
+
+//     return filter;
+//   }
+
+//   ////////////////////////
+//   // Indexes Operations //
+//   ////////////////////////
+//   public async createIndex(
+//     collectionName: string,
+//     indexName: string,
+//     indexInfo: CollectionIndex,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+
+//     const fields: IndexSpecification = {};
+//     for (const fieldName in indexInfo.fields) {
+//       const field = indexInfo.fields[fieldName];
+//       fields[fieldName] = field.order === "asc" ? 1 : -1;
+//     }
+
+//     try {
+//       await collection.createIndex(fields, {
+//         unique: indexInfo.unique,
+//         name: indexName,
+//       });
+//     } catch (error) {
+//       if (error instanceof MongoServerError) {
+//         if (
+//           error.errmsg.includes("Index already exists with a different name")
+//         ) {
+//           const existingIndexName = error.errmsg.split(": ")[1];
+//           await collection.dropIndex(existingIndexName);
+//           await this.createIndex(collectionName, indexName, indexInfo);
+//         } else {
+//           throw error;
+//         }
+//       } else {
+//         throw error;
+//       }
+//     }
+//   }
+
+//   public async dropIndex(collectionName: string, indexName: string) {
+//     const collection = this.db.collection(collectionName);
+//     await collection.dropIndex(indexName);
+//   }
+
+//   public async getIndexes(collectionName: string): Promise<CollectionIndexes> {
+//     const collection = this.db.collection(collectionName);
+//     const indexes: IndexDescription[] = await collection.indexes();
+//     const collectionIndexes: CollectionIndexes = {};
+
+//     for (let index = 0; index < indexes.length; index++) {
+//       const indexObject = indexes[index];
+//       // dont return the default indexes that are created automatically when a
+//       // collection is created
+//       const defaultIndexesNames = ["_id_"];
+//       if (indexObject.name && !defaultIndexesNames.includes(indexObject.name)) {
+//         const fields: CollectionIndexFields = {};
+//         for (const [fieldName, order] of Object.entries(indexObject.key)) {
+//           fields[fieldName] = {
+//             order: order === 1 ? "asc" : "desc",
+//           };
+//         }
+//         collectionIndexes[indexObject.name] = {
+//           unique: indexObject.unique ?? false,
+//           fields,
+//         };
+//       }
+//     }
+
+//     return collectionIndexes;
+//   }
+
+//   /////////////////////
+//   // CRUD OPERATIONS //
+//   /////////////////////
+//   public async findAll(collectionName: string, params: FindAllParamsOutput) {
+//     const collection = this.db.collection(collectionName);
+//     const pipeline = this.findAllParamsToPipeline(params);
+//     const data = await collection.aggregate(pipeline).toArray();
+//     return this.adaptToReturnFormatManyDocuments(data, params);
+//   }
+
+//   public async findOne(collectionName: string, filter: any) {
+//     const collection = this.db.collection(collectionName);
+//     const data = await collection.findOne(filter);
+//     if (data) {
+//       return this.adaptToReturnFormatOneDocuments(data);
+//     }
+//     return data;
+//   }
+
+//   public async createOne(collectionName: string, data: any) {
+//     const collection = this.db.collection(collectionName);
+//     try {
+//       delete data.id;
+//       const result = await collection.insertOne(data);
+//       delete data._id;
+//       return {
+//         id: result.insertedId,
+//         ...data,
+//       };
+//     } catch (error) {
+//       console.error(`(Driver Error): ${error}`);
+//       if (error instanceof MongoServerError) {
+//         if (error.code === 11000) {
+//           throw new LobbError({
+//             code: "CONFLICT",
+//             message:
+//               `One or more fields violate the uniqueness constraint in the (${collectionName}) collection.`,
+//           });
+//         }
+
+//         throw error;
+//       }
+//       throw error;
+//     }
+//   }
+
+//   public async updateOne(
+//     collectionName: string,
+//     filter: any,
+//     data: any,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+//     const entry = await collection.findOneAndUpdate(filter, {
+//       $set: data,
+//     }, {
+//       returnDocument: "after",
+//     });
+//     if (entry) {
+//       return this.adaptToReturnFormatOneDocuments(entry);
+//     }
+//     return entry;
+//   }
+
+//   public async deleteOne(
+//     collectionName: string,
+//     filter: any,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+//     const entry = await collection.findOneAndDelete(filter);
+//     if (entry) {
+//       return this.adaptToReturnFormatOneDocuments(entry);
+//     }
+//     return entry;
+//   }
+
+//   public async deleteMany(
+//     collectionName: string,
+//     filter?: any,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+//     const entry = await collection.deleteMany();
+//     return {
+//       affectedCount: entry.deletedCount,
+//     };
+//   }
+
+//   public async updateMany(
+//     collectionName: string,
+//     data: any,
+//     filter?: any,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+//     const entry = await collection.updateMany(filter, {
+//       $set: data,
+//     });
+//     return {
+//       affectedCount: entry.modifiedCount,
+//     };
+//   }
+
+//   public async createMany(
+//     collectionName: string,
+//     data: any,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+//     const entry = await collection.insertMany(data);
+//     return {
+//       affectedCount: entry.insertedCount,
+//     };
+//   }
+
+//   /////////////////////
+//   // META OPERATIONS //
+//   /////////////////////
+//   public async getTotalCount(
+//     collectionName: string,
+//     filter: any,
+//   ) {
+//     const collection = this.db.collection(collectionName);
+//     return await collection.countDocuments(filter);
+//   }
+
+//   ////////////////////
+//   // HELPER METHODS //
+//   ////////////////////
+//   private adaptToReturnFormatManyDocuments(
+//     data: Document[],
+//     params: FindAllParamsOutput,
+//   ): Entry[] {
+//     // renaming the _id property to id
+//     data = data.map((obj) => {
+//       delete obj.id;
+//       const { _id, ...rest } = obj;
+//       return { id: _id, ...rest };
+//     });
+
+//     // remove the id if it wasn't selected by the user
+//     const idExist = params.fields === "*" || params.fields.includes("id");
+//     if (!idExist) {
+//       data = data.map((element) => {
+//         return omit(element, ["id"]);
+//       });
+//     }
+
+//     return data as Entry[];
+//   }
+
+//   private adaptToReturnFormatOneDocuments(data: Document): Entry {
+//     delete data.id;
+//     const { _id, ...rest } = data;
+//     return { id: _id, ...rest };
+//   }
+
+//   private findAllParamsToPipeline(params: FindAllParamsOutput): Document[] {
+//     const pipelines: Document[] = [];
+
+//     // sort
+//     if (params.sort) {
+//       const document: Document = {};
+//       document["$sort"] = {};
+//       const sorts = params.sort.split(",").map((fieldNames: any) =>
+//         fieldNames.trim()
+//       );
+//       for (let index = 0; index < sorts.length; index++) {
+//         const sort = sorts[index];
+//         if (sort[0] === "-") {
+//           document["$sort"][sort.substring(1)] = -1;
+//         } else {
+//           document["$sort"][sort] = 1;
+//         }
+//       }
+//       pipelines.push(document);
+//     }
+
+//     // page
+//     let offset = params.offset;
+//     if (params.page) {
+//       offset = (params.page - 1) * params.limit;
+//     }
+
+//     // offset
+//     const sortDocument: Document = {};
+//     sortDocument["$skip"] = offset;
+//     pipelines.push(sortDocument);
+
+//     // limit
+//     const limitDocument: Document = {};
+//     limitDocument["$limit"] = params.limit;
+//     pipelines.push(limitDocument);
+
+//     // adding normal and auth filters
+//     const document: Document = {};
+//     if (params.filter) {
+//       document["$match"] = {};
+//       document["$match"]["$and"] = [];
+//       document["$match"]["$and"].push(params.filter);
+//     }
+//     if (Object.keys(document).length) {
+//       pipelines.push(document);
+//     }
+
+//     // fields
+//     if (params.fields !== "*") {
+//       const document: Document = {};
+//       document["$project"] = {};
+//       const fields = Array.isArray(params.fields)
+//         ? params.fields
+//         : params.fields.split(",");
+//       for (let index = 0; index < fields.length; index++) {
+//         const fieldName = fields[index].trim();
+//         document["$project"][fieldName] = 1;
+//       }
+//       pipelines.push(document);
+//     }
+
+//     return pipelines;
+//   }
+
+//   private renameIdKeys(value: any) {
+//     return _.cloneDeepWith(value, (val: any, key: any) => {
+//       if (val && val.id) {
+//         val._id = val.id;
+//         delete val.id;
+//         return val;
+//       }
+//     });
+//   }
+
+//   private getMongoDBFieldType(type: any) {
+//     const typeMapping: any = {
+//       id: "objectId",
+//       string: "string",
+//       bool: "bool",
+//       date: "date",
+//       integer: "int",
+//       long: "long",
+//       float: "double",
+//       decimal: "decimal",
+//     };
+
+//     if (!typeMapping[type]) {
+//       throw new LobbError({
+//         code: "INTERNAL_SERVER_ERROR",
+//         message: "Couldn't find an equivelant mongodb type",
+//       });
+//     }
+
+//     return typeMapping[type];
+//   }
+
+//   private getCollectionFieldType(mongoDBType: string): any {
+//     const typeMapping: Record<string, any> = {
+//       objectId: "integer",
+//       string: "string",
+//       bool: "bool",
+//       date: "date",
+//       int: "integer",
+//       long: "long",
+//       double: "float",
+//       decimal: "decimal",
+//     };
+
+//     if (!typeMapping[mongoDBType]) {
+//       throw new LobbError({
+//         code: "INTERNAL_SERVER_ERROR",
+//         message: "Couldn't find an equivalent CollectionFieldType",
+//       });
+//     }
+
+//     return typeMapping[mongoDBType];
+//   }
+
+//   ///////////////////////////////////////////////////////////
+//   // parse some types of data to be compatible with the db //
+//   ///////////////////////////////////////////////////////////
+//   public override encodeFieldValue(fieldType: string, value: any) {
+//     if (fieldType === "id") {
+//       if (typeof value === "object" && ObjectId.isValid(value)) {
+//         return value;
+//       }
+
+//       return ObjectId.createFromHexString(value);
+//     } else if (fieldType === "decimal") {
+//       return new Decimal128(value);
+//     } else if (fieldType === "float") {
+//       const double = new Double(value);
+//       if (isNaN(double.value)) {
+//         throw new LobbError({
+//           code: "INTERNAL_SERVER_ERROR",
+//           message: `this Value (${value}) is not a valid float`,
+//         });
+//       }
+//       return double;
+//     } else if (fieldType === "long") {
+//       return new Long(value);
+//     }
+
+//     return value;
+//   }
+
+//   public override decodeFieldValue(fieldType: string, value: any) {
+//     if (fieldType === "id") {
+//       return value.toHexString();
+//     } else if (fieldType === "date") {
+//       return value.toISOString();
+//     } else if (fieldType === "decimal") {
+//       return value.toString();
+//     } else if (fieldType === "float") {
+//       return value.toString();
+//     } else if (fieldType === "long") {
+//       return value.toString();
+//     }
+
+//     return value;
+//   }
+// }