@drawbridge/mongodb 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,500 @@
+const { ObjectId } = require( 'mongodb' );
+
+const ids = ({
+	_id
+}) => {
+
+	const id = _id || new ObjectId();
+
+	return {
+		_id : id,
+		id : id.toString()
+	};
+
+};
+
+const formats = {
+	documents : {
+		insert : ( data, authenticated ) => {
+
+			const date = new Date();
+
+			return {
+				createdAt : date,
+				updatedAt : date,
+				...ids( data ),
+				...( authenticated && {
+					createdBy : authenticated?.id + '.' + date.getTime()
+				}),
+				...data
+			}
+
+		},
+		update : (
+			{
+				$set,
+				$setOnInsert,
+				...rest
+			},
+			authenticated
+		) => {
+
+			const date = new Date();
+
+			return {
+				$set : {
+					updatedAt : date,
+					...( authenticated && {
+						updatedBy : authenticated?.id + '.' + date.getTime()
+					}),
+					...$set
+				},
+				$setOnInsert : {
+					...ids( rest ),
+					createdAt : date,
+					...( authenticated && {
+						createdBy : authenticated?.id + '.' + date.getTime()
+					}),
+					...$setOnInsert
+				},
+				...rest
+			};
+
+		}
+	},
+	timeseries : {
+		insert : ( data ) => {
+
+			const { _id, id } = ids( data );
+			const date = new Date();
+
+			return {
+				_id,
+				meta : {
+					...data,
+					id
+				},
+				time : date
+			};
+
+		},
+		update : ({
+			$set
+		}) => {
+
+			return {
+				$set
+			};
+
+		}
+	}
+};
+
+module.exports = ({
+	client,
+	database
+}) => ({
+
+	aggregate : async ({
+		collection,
+		options = {},
+		pipeline = []
+	}) => {
+
+		return await database.collection( collection ).aggregate( pipeline, options ).toArray();
+
+	},
+
+	bulk : async ({
+		collection,
+		options = {},
+		pipeline = []
+	}) => {
+
+		return await database.collection( collection ).bulkWrite( pipeline, options );
+
+	},
+
+	count : async ({
+		collection,
+		options = {},
+		query
+	}) => {
+
+		return await database.collection( collection ).countDocuments( query, options );
+
+	},
+
+	create : async ({
+		authenticated,
+		collection,
+		data,
+		multiple = false,
+		options,
+		pre,
+		timeseries = false
+	}) => {
+
+		const endpoint = multiple ? 'insertMany' : 'insertOne';
+		const format = timeseries ? 'timeseries' : 'documents';
+
+		let result;
+
+		try {
+
+			if( multiple ){
+
+				result = data.map( ( item ) => formats[ format ].insert( item, authenticated ) );
+
+			} else {
+
+				result = formats[ format ].insert( data, authenticated );
+
+			}
+
+			if( pre instanceof Function ){
+
+				result = await pre( result );
+
+			}
+
+			await database.collection( collection )[ endpoint ](
+				result,
+				timeseries ? {} : {
+					returnDocument : 'after',
+					returnNewDocument : true,
+					...options
+				}
+			);
+
+			return result;
+
+		} catch ( error ) {
+
+			throw error;
+
+		}
+
+	},
+
+	delete : async ({
+		collection,
+		query,
+		multiple,
+		options = {}
+	}) => {
+
+		let result;
+
+		try {
+
+			if( multiple ){
+
+				result = await database.collection( collection ).find(
+					query,
+					{},
+					options
+				).toArray();
+
+				await database.collection( collection ).deleteMany(
+					query,
+					options
+				);
+
+			} else {
+
+				result = await database.collection( collection ).findOne(
+					query
+				);
+
+				await database.collection( collection ).deleteOne(
+					query,
+					options
+				);
+
+			}
+
+			return result;
+
+		} catch ( error ) {
+
+			throw error;
+
+		}
+
+	},
+
+	formats,
+
+	get : async ({
+		collection,
+		extend = [],
+		options = {},
+		refine = {},
+		query
+	}) => {
+
+		try {
+
+			const pipeline = [
+				{
+					$match : query
+				},
+				...extend
+			];
+
+			if( refine ){
+
+				pipeline.push({
+					$match : refine
+				});
+
+			}
+
+			const result = await database.collection( collection ).aggregate(
+				pipeline,
+				options
+			).toArray();
+
+			return result?.[ 0 ];
+
+		} catch ( error ) {
+
+			throw error;
+
+		}
+
+	},
+
+	paged : async ({
+		collection,
+		limit,
+		filters = {},
+		refine,
+		search = null,
+		skip,
+		sort,
+		...rest
+	}) => {
+
+		try {
+
+			const pipelines = {
+				query : []
+			};
+
+			if( filters && Object.keys( filters ).length > 0 ){
+
+				pipelines.query.push(
+					{
+						$match : filters
+					}
+				);
+
+			}
+
+			pipelines.query.push({
+				$sort : Object.keys( sort ).reduce(
+					( accumulator, key ) => {
+
+						accumulator[ key ] = Number( sort[ key ] );
+
+						return accumulator;
+
+					},
+					{}
+				)
+			});
+
+			// must be after match
+			if( ( rest?.extend || [] ).length > 0 ){
+
+				pipelines.query = [ ...pipelines.query, ...rest.extend ];
+
+			}
+
+			if( refine && Object.keys( refine ).length > 0 ){
+
+				pipelines.query.push(
+					{
+						$match : refine
+					}
+				);
+
+			}
+
+			if( search?.value && search?.keys?.length > 0 ){
+
+				const value = search.value.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+				search = {
+					$match : {
+						$or : ( search?.keys || [] ).reduce(
+							( accumulator, key ) => {
+
+								accumulator.push({
+									[ key ] : {
+										$regex : value,
+										$options : 'i'
+									}
+								});
+
+								return accumulator;
+
+							},
+							[]
+						)
+					}
+				};
+
+				pipelines.query.push( search );
+
+			}
+
+			const dataStages = [];
+
+			if( skip && limit ){
+
+				dataStages.push({
+					$skip : Number( Number( Number( skip ) * Number( limit ) ) )
+				});
+
+			}
+
+			if( limit ){
+
+				dataStages.push({
+					$limit : Number( limit )
+				});
+
+			}
+
+			if( rest?.project ){
+
+				dataStages.push({
+					$project : rest?.project
+				});
+
+			}
+
+			const facetPipeline = [
+				...pipelines.query,
+				{
+					$facet : {
+						items : dataStages,
+						total : [
+							{
+								$group : {
+									_id : null,
+									total : {
+										$sum : 1
+									}
+								}
+							}
+						]
+					}
+				}
+			];
+
+			const [ facetResult ] = await database.collection( collection ).aggregate( facetPipeline ).toArray();
+			const items = facetResult?.items || [];
+			const total = ( facetResult?.total?.[ 0 ]?.total || 0 );
+			const offset = Number( Number( skip ) + 1 ) * Number( limit );
+			const hasPreviousPage = Boolean( Number( Number( skip ) ) * Number( limit ) > 0 );
+			const hasNextPage = Boolean( offset < Number( total ) );
+
+			return {
+				items,
+				pageInfo : {
+					hasNextPage,
+					hasPreviousPage,
+					offset : hasNextPage ? offset : total,
+					total
+				}
+			};
+
+		} catch ( error ) {
+
+			throw error;
+
+		}
+
+	},
+
+	transaction : async ( callback ) => {
+
+		try {
+
+			const result = await new Promise(
+				( resolve, reject ) => client.withSession(
+					async ( session ) => session.withTransaction(
+						async ( session ) => resolve( await callback( session ) ),
+						null
+					).catch( reject )
+				).catch( reject )
+			);
+
+			return result;
+
+		} catch ( error ) {
+
+			throw error
+
+		}
+
+	},
+
+	update : async ({
+		authenticated,
+		collection,
+		data,
+		query,
+		multiple = false,
+		options,
+		timeseries = false
+	}) => {
+
+		let result = {};
+
+		try {
+
+			if( multiple || timeseries ){
+
+				const format = timeseries ? 'timeseries' : 'documents';
+
+				result.value = await database.collection( collection ).find(
+					query,
+					{},
+					options
+				).toArray();
+
+				await database.collection( collection ).updateMany(
+					query,
+					formats[ format].update( data, authenticated ),
+					options
+				);
+
+			} else {
+
+				result = await database.collection( collection ).findOneAndUpdate(
+					query,
+					formats.documents.update( data, authenticated ),
+					{
+						returnDocument : 'after',
+						returnNewDocument : true,
+						...options
+					}
+				);
+
+			}
+
+			return result;
+
+		} catch ( error ) {
+
+			throw error;
+
+		}
+
+	}
+});