@opra/mongodb 0.31.12 → 0.32.0

package/esm/mongo-singleton-service.js

@@ -1,6 +1,5 @@
 import { ObjectId } from 'mongodb';
 import { ResourceNotFoundError } from '@opra/common';
-import * as OpraCommon from '@opra/common';
 import { MongoAdapter } from './mongo-adapter.js';
 import { MongoService } from './mongo-service.js';
 /**
@@ -10,74 +9,89 @@ import { MongoService } from './mongo-service.js';
 export class MongoSingletonService extends MongoService {
     constructor(dataType, options) {
         super(dataType, options);
+        this.collectionKey = options?.collectionKey || '_id';
         this._id = options?._id || new ObjectId('655608925cad472b75fc6485');
     }
-    get resource() {
-        const resource = this.context.request.resource;
-        if (resource instanceof OpraCommon.Singleton)
-            return resource;
-        throw new TypeError(`"${resource}" resource is not a Singleton`);
+    /**
+     * Fetches the Document. Throws error undefined if not found.
+     *
+     * @param options
+     */
+    async assert(options) {
+        const out = await this.get(options);
+        if (!out)
+            throw new ResourceNotFoundError(this.resourceName || this.getCollectionName());
+        return out;
     }
+    /**
+     * Inserts the document into MongoDB
+     *
+     * @param doc
+     * @param options
+     */
     async create(doc, options) {
-        const r = await this._rawInsertOne({ ...doc, _id: this._id }, options);
-        if (r.insertedId) {
-            const out = await this.get(options);
-            if (out)
-                return out;
-        }
+        const r = await this.__insertOne({ ...doc, _id: this._id }, options);
+        if (r.insertedId)
+            return doc;
         /* istanbul ignore next */
         throw new Error('Unknown error while creating document');
     }
+    /**
+     * Delete the document from a collection
+     *
+     * @param options
+     */
     async delete(options) {
-        const filter = { _id: this._id };
-        const optionsFilter = MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        const r = await this._rawDeleteOne(filter, options);
+        const filter = MongoAdapter.prepareFilter([{ _id: this._id }, options?.filter]);
+        const r = await this.__deleteOne(filter, options);
         return r.deletedCount;
     }
-    async get(options) {
-        const out = await this.find(options);
-        if (!out)
-            throw new ResourceNotFoundError(this.resource.name);
-        return out;
+    /**
+     * Checks if the document exists.
+     * Returns true if document exists, false otherwise
+     *
+     */
+    async exists() {
+        return !!(await this.get({ pick: ['_id'] }));
     }
-    async find(options) {
-        const filter = { _id: this._id };
-        const optionsFilter = MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
+    /**
+     * Fetches the document
+     *
+     * @param options
+     */
+    async get(options) {
+        const filter = MongoAdapter.prepareFilter([{ _id: this._id }, options?.filter]);
         const mongoOptions = {
             ...options,
-            projection: MongoAdapter.prepareProjection(this.resource.type, options),
+            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
             sort: undefined,
             skip: undefined,
             limit: undefined
         };
-        const out = await this._rawFindOne(filter, mongoOptions);
-        if (out) {
-            if (this.transformData)
-                return this.transformData(out);
-            return out;
-        }
+        return await this.__findOne(filter, mongoOptions);
     }
+    /**
+     * Updates a single document.
+     * Returns updated document
+     *
+     * @param doc
+     * @param options
+     */
     async update(doc, options) {
-        // Prevent upsert with different _id field
-        if (options?.upsert)
-            doc._id = this._id;
-        else
-            delete doc._id;
+        // Prevent updating _id field
+        delete doc._id;
+        const filter = MongoAdapter.prepareFilter([
+            { _id: this._id },
+            options?.filter
+        ]);
         const patch = MongoAdapter.preparePatch(doc);
         const mongoOptions = {
             ...options,
-            upsert: undefined
+            includeResultMetadata: false,
+            upsert: undefined,
+            projection: MongoAdapter.prepareProjection(this.getDataType(), options),
         };
-        const filter = { _id: this._id };
-        const optionsFilter = MongoAdapter.prepareFilter(options?.filter);
-        if (optionsFilter)
-            filter.$and = [...(Array.isArray(optionsFilter) ? optionsFilter : [optionsFilter])];
-        const r = await this._rawUpdateOne(filter, patch, mongoOptions);
-        if (r.matchedCount)
-            return await this.get(options);
+        const out = await this.__findOneAndUpdate(filter, patch, mongoOptions);
+        return out || undefined;
     }
 }

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/mongodb",
-  "version": "0.31.12",
+  "version": "0.32.0",
   "description": "Opra MongoDB adapter package",
   "author": "Panates",
   "license": "MIT",
@@ -29,11 +29,11 @@
     "@types/lodash.isnil": "^4.0.9",
     "@types/lodash.omitby": "^4.6.9",
     "mongodb": "^6.3.0",
-    "ts-gems": "^2.5.0"
+    "ts-gems": "^2.7.1"
   },
   "peerDependencies": {
-    "@opra/common": "^0.31.12",
-    "@opra/core": "^0.31.12",
+    "@opra/common": "^0.32.0",
+    "@opra/core": "^0.32.0",
     "mongodb": ">=6.x.x"
   },
   "type": "module",

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

@@ -1,4 +1,12 @@
-import '@opra/core';
 import mongodb from 'mongodb';
 import { OpraFilter } from '@opra/common';
-export default function prepareFilter(filter: OpraFilter.Expression | mongodb.Filter<any> | string | undefined): mongodb.Filter<any> | undefined;
+type FilterInput = (OpraFilter.Expression | mongodb.Filter<any> | string | undefined);
+/**
+ * Convert filter expressions to MongoDB filter objects.
+ * This method also merges multiple expressions into one single filter object
+ * @param filters
+ */
+export default function prepareFilter(filters: FilterInput | FilterInput[], options?: {
+    fieldPrefix?: string;
+}): mongodb.Filter<any>;
+export {};

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

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

package/types/index.d.ts

@@ -1,4 +1,6 @@
 export * from './mongo-adapter.js';
+export * from './mongo-array-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-array-service.d.ts

@@ -0,0 +1,193 @@
+import mongodb from 'mongodb';
+import { StrictOmit, Type } from 'ts-gems';
+import vg from 'valgen';
+import * as OpraCommon from '@opra/common';
+import { ComplexType, PartialInput } from '@opra/common';
+import { PartialOutput } from '@opra/core';
+import { MongoCollectionService } from './mongo-collection-service.js';
+import { MongoService } from './mongo-service.js';
+import { AnyId } from './types.js';
+/**
+ *
+ * @class MongoArrayService
+ */
+export declare class MongoArrayService<T extends mongodb.Document> extends MongoService<T> {
+    protected _encoders: Record<string, vg.Validator>;
+    collectionKey: string;
+    arrayKey: string;
+    defaultLimit: number;
+    fieldName: string;
+    constructor(dataType: Type | string, fieldName: string, options?: MongoArrayService.Options);
+    getArrayDataType(): ComplexType;
+    /**
+     * Checks if array item exists. Throws error if not.
+     *
+     * @param parentId
+     * @param id
+     */
+    assert(parentId: AnyId, id: AnyId): Promise<void>;
+    /**
+     * Adds a single item into array field.
+     *
+     * @param parentId
+     * @param input
+     * @param options
+     */
+    create(parentId: AnyId, input: T, options?: MongoArrayService.CreateOptions): Promise<PartialOutput<T>>;
+    /**
+     * Gets the number of array items matching the filter.
+     * @param parentId
+     * @param options
+     */
+    count(parentId: AnyId, options?: MongoArrayService.CountOptions<T>): Promise<number>;
+    /**
+     * Removes one item from an array field
+     *
+     * @param parentId
+     * @param id
+     * @param options
+     */
+    delete(parentId: AnyId, id: AnyId, options?: MongoArrayService.DeleteOptions<T>): Promise<number>;
+    /**
+     * Removes multiple items from an array field
+     *
+     * @param parentId
+     * @param options
+     */
+    deleteMany(parentId: AnyId, options?: MongoArrayService.DeleteManyOptions<T>): Promise<number>;
+    /**
+     * Returns true if item exists, false otherwise
+     *
+     * @param parentId
+     * @param id
+     */
+    exists(parentId: AnyId, id: AnyId): Promise<boolean>;
+    /**
+     * Fetches the first item in an array field that matches by id.
+     *
+     * @param parentId
+     * @param id
+     * @param options
+     */
+    findById(parentId: AnyId, id: AnyId, options?: MongoArrayService.FindOneOptions): Promise<PartialOutput<T> | undefined>;
+    /**
+     * Fetches the first item in an array field that matches the filter. Returns undefined if not found.
+     *
+     * @param parentId
+     * @param options
+     */
+    findOne(parentId: AnyId, options?: MongoArrayService.FindOneOptions): Promise<PartialOutput<T> | undefined>;
+    /**
+     * Fetches all items in an array field that matches the filter
+     *
+     * @param parentId
+     * @param options
+     */
+    findMany(parentId: AnyId, options?: MongoArrayService.FindManyOptions<T>): Promise<PartialOutput<T>[] | undefined>;
+    /**
+     * Fetches the first item in an array field that matches the item id. Throws error undefined if not found.
+     *
+     * @param parentId
+     * @param id
+     * @param options
+     */
+    get(parentId: AnyId, id: AnyId, options?: MongoArrayService.FindOneOptions<T>): Promise<PartialOutput<T>>;
+    /**
+     * Update a single item in array field
+     *
+     * @param parentId
+     * @param id
+     * @param input
+     * @param options
+     */
+    update(parentId: AnyId, id: AnyId, input: PartialInput<T>, options?: MongoArrayService.UpdateOptions<T>): Promise<PartialOutput<T> | undefined>;
+    /**
+     * Update a single item in array field
+     * Returns how many master documents updated (not array items)
+     *
+     * @param parentId
+     * @param id
+     * @param doc
+     * @param options
+     */
+    updateOnly(parentId: AnyId, id: AnyId, doc: PartialInput<T>, options?: MongoArrayService.UpdateOptions<T>): Promise<number>;
+    /**
+     * Update multiple items in array field, returns how many master documents updated (not array items)
+     *
+     * @param parentId
+     * @param input
+     * @param options
+     */
+    updateMany(parentId: AnyId, input: PartialInput<T>, options?: MongoArrayService.UpdateManyOptions<T>): Promise<number>;
+    /**
+     * Update multiple items in array field and returns number of updated array items
+     *
+     * @param parentId
+     * @param doc
+     * @param options
+     */
+    updateManyReturnCount(parentId: AnyId, doc: PartialInput<T>, options?: MongoArrayService.UpdateManyOptions<T>): Promise<number>;
+    /**
+     * Generates Id value
+     *
+     * @protected
+     */
+    protected _generateId(): AnyId;
+    /**
+     * Generates a new Validator  for encoding or returns from cache if already generated before
+     * @param operation
+     * @protected
+     */
+    protected _getEncoder(operation: 'create' | 'update'): vg.Validator;
+    /**
+     * Generates a new Valgen Validator for encode operation
+     *
+     * @param operation
+     * @protected
+     */
+    protected _generateEncoder(operation: 'create' | 'update'): vg.Validator;
+}
+/**
+ *
+ * @namespace MongoArrayService
+ */
+export declare namespace MongoArrayService {
+    interface Options extends MongoCollectionService.Options {
+        arrayKey?: string;
+    }
+    interface CreateOptions extends mongodb.UpdateOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }
+    interface CountOptions<T> extends mongodb.AggregateOptions {
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+    interface DeleteOptions<T> extends mongodb.UpdateOptions {
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+    interface DeleteManyOptions<T> extends mongodb.UpdateOptions {
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+    interface FindOneOptions<T = any> extends StrictOmit<FindManyOptions<T>, 'count' | 'limit'> {
+    }
+    interface FindManyOptions<T> extends mongodb.AggregateOptions {
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        sort?: string[];
+        count?: boolean;
+        limit?: number;
+        skip?: number;
+    }
+    interface UpdateOptions<T> extends mongodb.UpdateOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+    interface UpdateManyOptions<T> extends mongodb.UpdateOptions {
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+}

package/types/mongo-collection-service.d.ts

@@ -1,25 +1,129 @@
 import mongodb from 'mongodb';
 import { StrictOmit, Type } from 'ts-gems';
+import vg from 'valgen';
 import * as OpraCommon from '@opra/common';
 import { PartialInput, PartialOutput } from '@opra/core';
 import { MongoService } from './mongo-service.js';
+import { AnyId } from './types.js';
 /**
  *
  * @class MongoCollectionService
  */
 export declare class MongoCollectionService<T extends mongodb.Document> extends MongoService<T> {
-    keyFields?: string[];
+    protected _encoders: Record<string, vg.Validator>;
+    collectionKey: string;
     defaultLimit: number;
     constructor(dataType: Type | string, options?: MongoCollectionService.Options);
-    protected create(doc: mongodb.OptionalUnlessRequiredId<T>, options?: MongoCollectionService.CreateOptions): Promise<PartialOutput<T>>;
-    protected count(options?: MongoCollectionService.CountOptions<T>): Promise<number>;
-    protected delete(id: any, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
-    protected deleteMany(options?: MongoCollectionService.DeleteManyOptions<T>): Promise<number>;
-    protected get(id: any, options?: MongoCollectionService.GetOptions): Promise<PartialOutput<T>>;
-    protected findOne(id: any, options?: MongoCollectionService.GetOptions): Promise<PartialOutput<T> | undefined>;
-    protected findMany(options?: MongoCollectionService.FindManyOptions<T>): Promise<PartialOutput<T>[]>;
-    protected update(id: any, doc: PartialInput<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialOutput<T> | undefined>;
-    protected updateMany(doc: OpraCommon.PartialInput<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
+    /**
+     * Checks if document exists. Throws error if not.
+     *
+     * @param id
+     */
+    assert(id: AnyId): Promise<void>;
+    /**
+     * Inserts a single document into MongoDB
+     *
+     * @param input
+     * @param options
+     */
+    create(input: PartialInput<T>, options?: MongoCollectionService.CreateOptions): Promise<PartialOutput<T>>;
+    /**
+     * Gets the number of documents matching the filter.
+     *
+     * @param options
+     */
+    count(options?: MongoCollectionService.CountOptions<T>): Promise<number>;
+    /**
+     * Delete a document from a collection
+     *
+     * @param id
+     * @param options
+     */
+    delete(id: AnyId, options?: MongoCollectionService.DeleteOptions<T>): Promise<number>;
+    /**
+     * Delete multiple documents from a collection
+     *
+     * @param options
+     */
+    deleteMany(options?: MongoCollectionService.DeleteManyOptions<T>): Promise<number>;
+    /**
+     * Checks if document exists.
+     * Returns true if document exists, false otherwise
+     *
+     * @param id
+     */
+    exists(id: AnyId): Promise<boolean>;
+    /**
+     * Fetches the first document matches by id.
+     *
+     * @param id
+     * @param options
+     */
+    findById(id: AnyId, options?: MongoCollectionService.FindOneOptions): Promise<PartialOutput<T | undefined>>;
+    /**
+     * Fetches the first document that matches the filter.
+     * Returns undefined if not found.
+     *
+     * @param options
+     */
+    findOne(options?: MongoCollectionService.FindOneOptions): Promise<PartialOutput<T> | undefined>;
+    /**
+     * Fetches all document that matches the filter
+     *
+     * @param options
+     */
+    findMany(options?: MongoCollectionService.FindManyOptions<T>): Promise<PartialOutput<T>[]>;
+    /**
+     * Fetches the first Document that matches the id. Throws error undefined if not found.
+     *
+     * @param id
+     * @param options
+     */
+    get(id: AnyId, options?: MongoCollectionService.FindOneOptions): Promise<PartialOutput<any>>;
+    /**
+     * Updates a single document.
+     * Returns updated document
+     *
+     * @param id
+     * @param input
+     * @param options
+     */
+    update(id: any, input: PartialInput<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<PartialOutput<T> | undefined>;
+    /**
+     * Updates a single document
+     * Returns number of updated documents
+     *
+     * @param id
+     * @param input
+     * @param options
+     */
+    updateOnly(id: any, input: PartialInput<T>, options?: MongoCollectionService.UpdateOptions<T>): Promise<number>;
+    /**
+     *  Update multiple documents in a collection
+     *
+     * @param input
+     * @param options
+     */
+    updateMany(input: OpraCommon.PartialInput<T>, options?: MongoCollectionService.UpdateManyOptions<T>): Promise<number>;
+    /**
+     * Generates Id value
+     *
+     * @protected
+     */
+    protected _generateId(): AnyId;
+    /**
+     * Generates a new Validator  for encoding or returns from cache if already generated before
+     * @param operation
+     * @protected
+     */
+    protected _getEncoder(operation: 'create' | 'update'): vg.Validator;
+    /**
+     * Generates a new Valgen Validator for encode operation
+     *
+     * @param operation
+     * @protected
+     */
+    protected _generateEncoder(operation: 'create' | 'update'): vg.Validator;
 }
 /**
  *
@@ -27,7 +131,7 @@ export declare class MongoCollectionService<T extends mongodb.Document> extends
  */
 export declare namespace MongoCollectionService {
     interface Options extends MongoService.Options {
-        keyField?: string | string[];
+        collectionKey?: string;
         defaultLimit?: number;
     }
     interface CreateOptions extends mongodb.InsertOneOptions {
@@ -44,21 +148,19 @@ export declare namespace MongoCollectionService {
     interface DeleteManyOptions<T> extends mongodb.DeleteOptions {
         filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
     }
-    interface GetOptions<T = any> extends StrictOmit<mongodb.FindOptions, 'sort' | 'limit' | 'skip' | 'projection'> {
-        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
+    interface FindOneOptions<T = any> extends StrictOmit<FindManyOptions<T>, 'count' | 'limit'> {
     }
-    interface FindManyOptions<T> extends StrictOmit<mongodb.FindOptions, 'sort' | 'projection'> {
+    interface FindManyOptions<T> extends mongodb.AggregateOptions {
         filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
         pick?: string[];
         omit?: string[];
         include?: string[];
         sort?: string[];
+        limit?: number;
+        skip?: number;
         count?: boolean;
     }
-    interface UpdateOptions<T> extends mongodb.UpdateOptions {
+    interface UpdateOptions<T> extends StrictOmit<mongodb.FindOneAndUpdateOptions, 'projection' | 'returnDocument' | 'includeResultMetadata'> {
         pick?: string[];
         omit?: string[];
         include?: string[];