@opra/mongodb 0.33.13 → 1.0.0-alpha.2

package/esm/mongo-singleton-service.js

@@ -1,14 +1,14 @@
 import { ObjectId } from 'mongodb';
-import { InternalServerError, ResourceNotAvailableError } from '@opra/common';
+import { ResourceNotAvailableError } from '@opra/common';
 import { MongoAdapter } from './mongo-adapter.js';
-import { MongoService } from './mongo-service.js';
+import { MongoEntityService } from './mongo-entity-service.js';
 /**
  * A class that provides access to a MongoDB collection, with support for singleton document operations.
  * @class MongoSingletonService
  * @extends MongoService
  * @template T - The type of document stored in the collection
  */
-export class MongoSingletonService extends MongoService {
+export class MongoSingletonService extends MongoEntityService {
     /**
      * Constructs a new instance
      *
@@ -18,14 +18,12 @@ export class MongoSingletonService extends MongoService {
      */
     constructor(dataType, options) {
         super(dataType, options);
-        this.collectionKey = this.collectionKey || options?.collectionKey || '_id';
         this._id = this._id || options?._id || new ObjectId('655608925cad472b75fc6485');
-        this.$documentFilter = this.$documentFilter || options?.documentFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
     }
     /**
      * Asserts the existence of a resource based on the given options.
      *
+     * @param {MongoSingletonService.ExistsOptions<T>} [options]
      * @returns {Promise<void>} A Promise that resolves when the resource exists.
      * @throws {ResourceNotAvailableError} If the resource does not exist.
      */
@@ -36,37 +34,23 @@ export class MongoSingletonService extends MongoService {
     /**
      * Creates the document in the database.
      *
-     * @param {DTO<T>} input - The partial input to create the document with.
+     * @param {PartialDTO<T>} input - The partial input to create the document with.
      * @param {MongoSingletonService.CreateOptions} [options] - The options for creating the document.
      * @return {Promise<PartialDTO<T>>} A promise that resolves to the partial output of the created document.
      * @throws {Error} Throws an error if an unknown error occurs while creating the document.
      */
     async create(input, options) {
+        input._id = this._id;
         const info = {
             crud: 'create',
             method: 'create',
+            byId: false,
+            documentId: this._id,
             input,
             options,
         };
         return this._intercept(() => this._create(input, options), info);
     }
-    async _create(input, options) {
-        const encode = this.getEncoder('create');
-        const doc = encode(input);
-        doc._id = this._id;
-        const r = await this.__insertOne(doc, options);
-        if (r.insertedId) {
-            if (!options)
-                return doc;
-            const out = await this._findOne(options);
-            if (out)
-                return out;
-            if (!out)
-                throw new ResourceNotAvailableError(this.getResourceName());
-        }
-        /* istanbul ignore next */
-        throw new InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
-    }
     /**
      * Deletes a record from the database
      *
@@ -77,77 +61,51 @@ export class MongoSingletonService extends MongoService {
         const info = {
             crud: 'delete',
             method: 'delete',
+            byId: true,
+            documentId: this._id,
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._delete({ ...options, filter });
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._delete(this._id, { ...options, filter });
         }, info);
     }
-    async _delete(options) {
-        const filter = MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const r = await this.__deleteOne(filter, options);
-        return r.deletedCount;
-    }
     /**
      * Checks if the document exists in the database.
      *
      * @return {Promise<boolean>} - A promise that resolves to a boolean value indicating if the document exists.
      */
     async exists(options) {
-        return !!(await this.findOne({ ...options, pick: ['_id'], omit: undefined, include: undefined }));
+        return !!(await this.find({ ...options, projection: ['_id'], skip: undefined }));
     }
     /**
      * Fetches the document if it exists. Returns undefined if not found.
      *
-     * @param {MongoSingletonService.FindOptions<T>} [options] - The options for finding the document.
+     * @param {MongoSingletonService.FindOneOptions<T>} [options] - The options for finding the document.
      * @returns {Promise<PartialDTO<T> | undefined>} - A promise that resolves to the found document or undefined if not found.
      */
-    async findOne(options) {
+    async find(options) {
         const info = {
             crud: 'read',
             method: 'findOne',
+            byId: true,
+            documentId: this._id,
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._findOne({ ...options, filter });
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._findById(this._id, { ...options, filter });
         }, info);
     }
-    async _findOne(options) {
-        const filter = MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const mongoOptions = {
-            ...options,
-            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
-            sort: undefined,
-            skip: undefined,
-            limit: undefined
-        };
-        const decoder = this.getDecoder();
-        const out = await this.__findOne(filter, mongoOptions);
-        return out ? decoder(out) : undefined;
-    }
     /**
      * Fetches the document from the Mongo collection service. Throws error if not found.
      *
-     * @param {MongoCollectionService.FindOneOptions} options - The options to customize the query.
+     * @param {MongoSingletonService.FindOneOptions<T>} options - The options to customize the query.
      * @return {Promise<PartialDTO<T>>} - A promise that resolves to the fetched document.
      * @throws {ResourceNotAvailableError} - If the document is not found in the collection.
      */
     async get(options) {
-        const out = await this.findOne(options);
+        const out = await this.find(options);
         if (!out)
             throw new ResourceNotAvailableError(this.getResourceName());
         return out;
@@ -164,34 +122,16 @@ export class MongoSingletonService extends MongoService {
         const info = {
             crud: 'update',
             method: 'update',
+            byId: true,
+            documentId: this._id,
             input,
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._updateOnly(input, { ...options, filter });
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._updateOnly(this._id, input, { ...options, filter });
         }, info);
     }
-    async _updateOnly(input, options) {
-        const encode = this.getEncoder('update');
-        const doc = encode(input);
-        const patch = MongoAdapter.preparePatch(doc);
-        const mongoOptions = {
-            ...options,
-            includeResultMetadata: false,
-            upsert: undefined,
-            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
-        };
-        const filter = MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const r = await this.__updateOne(filter, patch, mongoOptions);
-        return r.modifiedCount;
-    }
     /**
      * Updates a document in the MongoDB collection.
      *
@@ -204,50 +144,14 @@ export class MongoSingletonService extends MongoService {
         const info = {
             crud: 'update',
             method: 'update',
+            byId: true,
+            documentId: this._id,
             input,
             options,
         };
         return this._intercept(async () => {
-            const filter = MongoAdapter.prepareFilter([
-                await this._getDocumentFilter(info),
-                options?.filter
-            ]);
-            return this._update(input, { ...options, filter });
+            const filter = MongoAdapter.prepareFilter([await this._getDocumentFilter(info), options?.filter]);
+            return this._update(this._id, input, { ...options, filter });
         }, info);
     }
-    async _update(input, options) {
-        const encode = this.getEncoder('update');
-        const doc = encode(input);
-        const patch = MongoAdapter.preparePatch(doc);
-        const mongoOptions = {
-            ...options,
-            includeResultMetadata: false,
-            upsert: undefined,
-            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
-        };
-        const filter = MongoAdapter.prepareFilter([
-            { _id: this._id },
-            options?.filter
-        ]);
-        const decoder = this.getDecoder();
-        const out = await this.__findOneAndUpdate(filter, patch, mongoOptions);
-        return out ? decoder(out) : undefined;
-    }
-    /**
-     * Retrieves the common filter used for querying the document.
-     * This method is mostly used for security issues like securing multi-tenant applications.
-     *
-     * @protected
-     * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
-     * that resolves to the common filter, or undefined if not available.
-     */
-    _getDocumentFilter(args) {
-        return typeof this.$documentFilter === 'function' ?
-            this.$documentFilter(args, this) : this.$documentFilter;
-    }
-    async _intercept(callback, args) {
-        if (this.$interceptor)
-            return this.$interceptor(callback, args, this);
-        return callback();
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/mongodb",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.2",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -17,6 +17,7 @@
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/mongodb && cp ../../package.cjs.json ../../build/mongodb/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
+    "format": "prettier . --write --log-level=warn",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
@@ -25,14 +26,14 @@
     "clean:cover": "rimraf ../../coverage/mongodb"
   },
   "devDependencies": {
-    "@faker-js/faker": "^8.4.0",
-    "mongodb": "^6.3.0",
-    "ts-gems": "^3.1.1"
+    "@faker-js/faker": "^8.4.1",
+    "mongodb": "^6.7.0",
+    "ts-gems": "^3.4.0"
   },
   "peerDependencies": {
-    "@opra/common": "^0.33.13",
-    "@opra/core": "^0.33.13",
-    "mongodb": ">=6.x.x"
+    "@opra/common": "^1.0.0-alpha.2",
+    "@opra/core": "^1.0.0-alpha.2",
+    "mongodb": ">= 6.0.0"
   },
   "type": "module",
   "module": "./esm/index.js",
@@ -55,4 +56,4 @@
     "mongodb",
     "adapter"
   ]
-}
+}

package/types/adapter-utils/prepare-filter.d.ts

@@ -1,6 +1,5 @@
 import mongodb from 'mongodb';
-import { OpraFilter } from '@opra/common';
-export type FilterInput = (OpraFilter.Expression | mongodb.Filter<any> | string | undefined);
+import type { MongoAdapter } from '../mongo-adapter.js';
 /**
  * Prepare the MongoDB filter based on the provided filters and options.
  *
@@ -10,6 +9,6 @@ export type FilterInput = (OpraFilter.Expression | mongodb.Filter<any> | string
  *
  * @returns {mongodb.Filter<any>} - The prepared MongoDB filter.
  */
-export default function prepareFilter(filters: FilterInput | FilterInput[], options?: {
+export default function prepareFilter(filters: MongoAdapter.FilterInput | MongoAdapter.FilterInput[], options?: {
     fieldPrefix?: string;
 }): mongodb.Filter<any>;

package/types/adapter-utils/prepare-projection.d.ts

@@ -1,13 +1,4 @@
-import mongodb from 'mongodb';
-import { ComplexType } from '@opra/common';
-export default function prepareProjection(dataType: ComplexType, options?: {
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-}): mongodb.Document | undefined;
-export declare function _prepareProjection(dataType: ComplexType, target: mongodb.Document, options: {
-    pickActivated: boolean;
-    include?: any;
-    pick?: any;
-    omit?: any;
-}): void;
+import mongodb, { Document } from 'mongodb';
+import { ComplexType, FieldsProjection } from '@opra/common';
+export default function prepareProjection(dataType: ComplexType, projection?: string | string[] | Document): mongodb.Document | undefined;
+export declare function prepare(dataType: ComplexType, target: mongodb.Document, projection?: FieldsProjection): void;

package/types/index.d.ts

@@ -1,6 +1,5 @@
 export * from './mongo-adapter.js';
-export * from './mongo-array-service.js';
+export * from './mongo-nested-service.js';
 export * from './mongo-collection-service.js';
 export * from './mongo-service.js';
 export * from './mongo-singleton-service.js';
-export * from './types.js';

package/types/mongo-adapter.d.ts

@@ -1,12 +1,25 @@
+import mongodb, { ClientSession, ObjectId } from 'mongodb';
+import { OpraFilter } from '@opra/common';
+import { HttpContext } from '@opra/core';
 import _prepareFilter from './adapter-utils/prepare-filter.js';
 import _prepareKeyValues from './adapter-utils/prepare-key-values.js';
 import _preparePatch from './adapter-utils/prepare-patch.js';
 import _prepareProjection from './adapter-utils/prepare-projection.js';
 import _prepareSort from './adapter-utils/prepare-sort.js';
 export declare namespace MongoAdapter {
-    const prepareKeyValues: typeof _prepareKeyValues;
+    type AnyId = string | number | ObjectId;
+    type FilterInput = OpraFilter.Expression | mongodb.Filter<any> | string | undefined;
+    type WithTransactionCallback = (session: ClientSession) => any;
     const prepareFilter: typeof _prepareFilter;
+    const prepareKeyValues: typeof _prepareKeyValues;
     const preparePatch: typeof _preparePatch;
     const prepareProjection: typeof _prepareProjection;
     const prepareSort: typeof _prepareSort;
+    interface TransformedRequest {
+        method: 'create' | 'delete' | 'deleteMany' | 'get' | 'findMany' | 'update' | 'updateMany';
+        key?: any;
+        data?: any;
+        options: any;
+    }
+    function parseRequest(context: HttpContext): Promise<TransformedRequest>;
 }