@opra/mongodb 0.31.4 → 0.31.6

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

@@ -0,0 +1,48 @@
+import mongodb from 'mongodb';
+import { StrictOmit, Type } from 'ts-gems';
+import * as OpraCommon from '@opra/common';
+import { PartialInput, PartialOutput } from '@opra/core';
+import { MongoService } from './mongo-service.js';
+/**
+ *
+ * @class MongoSingletonService
+ */
+export declare class MongoSingletonService<T extends mongodb.Document> extends MongoService<T> {
+    protected _id: any;
+    constructor(dataType: Type | string, options?: MongoSingletonService.Options);
+    protected get resource(): OpraCommon.Singleton;
+    protected create(doc: mongodb.OptionalUnlessRequiredId<T>, options?: MongoSingletonService.CreateOptions): Promise<PartialOutput<T>>;
+    protected delete(options?: MongoSingletonService.DeleteOptions<T>): Promise<number>;
+    protected get(options?: MongoSingletonService.GetOptions<T>): Promise<PartialOutput<T>>;
+    protected find(options?: MongoSingletonService.GetOptions<T>): Promise<PartialOutput<T> | undefined>;
+    protected update(doc: PartialInput<T>, options?: MongoSingletonService.UpdateOptions<T>): Promise<PartialOutput<T> | undefined>;
+}
+/**
+ *
+ * @namespace MongoSingletonService
+ */
+export declare namespace MongoSingletonService {
+    interface Options extends MongoService.Options {
+        _id?: any;
+    }
+    interface CreateOptions extends mongodb.InsertOneOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    }
+    interface DeleteOptions<T> extends mongodb.DeleteOptions {
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+    interface GetOptions<T> extends StrictOmit<mongodb.FindOptions, 'sort' | 'limit' | 'skip'> {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+    interface UpdateOptions<T> extends mongodb.UpdateOptions {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        filter?: mongodb.Filter<T> | OpraCommon.OpraFilter.Ast | string;
+    }
+}

package/cjs/mongo-collection.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoCollection = void 0;
-const mongo_adapter_js_1 = require("./mongo-adapter.js");
-// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
-class MongoCollection {
-    constructor(options) {
-        this.defaultLimit = options?.defaultLimit || 100;
-    }
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async deleteMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._deleteMany(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async updateMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._updateMany(ctx, prepared);
-    }
-    async findMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._findMany(ctx, prepared);
-    }
-    async _prepare(ctx) {
-        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
-        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
-    }
-    async _findMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        if (prepared.options.count) {
-            const [items, count] = await Promise.all([
-                service.find(prepared.filter, prepared.options),
-                service.count(prepared.filter, prepared.options)
-            ]);
-            ctx.response.totalMatches = count;
-            return items;
-        }
-        return service.find(prepared.filter, prepared.options);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.insertOne(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteOne(prepared.filter, prepared.options);
-    }
-    async _deleteMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteMany(prepared.filter, prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.findOne(prepared.filter, prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateOne(prepared.filter, prepared.data, prepared.options);
-    }
-    async _updateMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateMany(prepared.filter, prepared.data, prepared.options);
-    }
-}
-exports.MongoCollection = MongoCollection;

package/cjs/mongo-entity-service.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoEntityService = void 0;
-const mongo_entity_service_base_js_1 = require("./mongo-entity-service-base.js");
-class MongoEntityService extends mongo_entity_service_base_js_1.MongoEntityServiceBase {
-    constructor(arg0, arg1) {
-        super(arg0, arg1);
-    }
-    async count(filter, options) {
-        return super._count(filter, options);
-    }
-    async deleteOne(filter, options) {
-        return super._deleteOne(filter, options);
-    }
-    async deleteMany(filter, options) {
-        return super._deleteMany(filter, options);
-    }
-    async findOne(filter, options) {
-        return super._findOne(filter, options);
-    }
-    async find(filter, options) {
-        return super._find(filter, options);
-    }
-    async insertOne(doc, options) {
-        return super._insertOne(doc, options);
-    }
-    async updateOne(filter, doc, options) {
-        return this._updateOne(filter, doc, options);
-    }
-    async updateMany(filter, doc, options) {
-        return super._updateMany(filter, doc, options);
-    }
-}
-exports.MongoEntityService = MongoEntityService;

package/cjs/mongo-singleton.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoSingleton = void 0;
-const mongo_adapter_js_1 = require("./mongo-adapter.js");
-class MongoSingleton {
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        await service.deleteMany();
-        return service.insertOne(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteOne(prepared.filter, prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.findOne(prepared.filter, prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateOne(prepared.filter, prepared.data, prepared.options);
-    }
-    async _prepare(ctx) {
-        const prepared = mongo_adapter_js_1.MongoAdapter.transformRequest(ctx.request);
-        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
-    }
-}
-exports.MongoSingleton = MongoSingleton;

package/cjs/transform-key-values.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function transformKeyValues(resource, keyValues) {
-    const { primaryKey } = resource;
-    if (primaryKey.length > 1) {
-        const query = {};
-        primaryKey.forEach((k, i) => {
-            query[k] = typeof keyValues === 'object' ? keyValues[k] : keyValues[i];
-        });
-        return query;
-    }
-    return { [primaryKey[0]]: keyValues };
-}
-exports.default = transformKeyValues;

package/esm/mongo-collection.js

@@ -1,75 +0,0 @@
-import { MongoAdapter } from './mongo-adapter.js';
-// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
-export class MongoCollection {
-    constructor(options) {
-        this.defaultLimit = options?.defaultLimit || 100;
-    }
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async deleteMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._deleteMany(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async updateMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._updateMany(ctx, prepared);
-    }
-    async findMany(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._findMany(ctx, prepared);
-    }
-    async _prepare(ctx) {
-        const prepared = MongoAdapter.transformRequest(ctx.request);
-        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
-    }
-    async _findMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        if (prepared.options.count) {
-            const [items, count] = await Promise.all([
-                service.find(prepared.filter, prepared.options),
-                service.count(prepared.filter, prepared.options)
-            ]);
-            ctx.response.totalMatches = count;
-            return items;
-        }
-        return service.find(prepared.filter, prepared.options);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.insertOne(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteOne(prepared.filter, prepared.options);
-    }
-    async _deleteMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteMany(prepared.filter, prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.findOne(prepared.filter, prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateOne(prepared.filter, prepared.data, prepared.options);
-    }
-    async _updateMany(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateMany(prepared.filter, prepared.data, prepared.options);
-    }
-}

package/esm/mongo-entity-service.js

@@ -1,30 +0,0 @@
-import { MongoEntityServiceBase } from './mongo-entity-service-base.js';
-export class MongoEntityService extends MongoEntityServiceBase {
-    constructor(arg0, arg1) {
-        super(arg0, arg1);
-    }
-    async count(filter, options) {
-        return super._count(filter, options);
-    }
-    async deleteOne(filter, options) {
-        return super._deleteOne(filter, options);
-    }
-    async deleteMany(filter, options) {
-        return super._deleteMany(filter, options);
-    }
-    async findOne(filter, options) {
-        return super._findOne(filter, options);
-    }
-    async find(filter, options) {
-        return super._find(filter, options);
-    }
-    async insertOne(doc, options) {
-        return super._insertOne(doc, options);
-    }
-    async updateOne(filter, doc, options) {
-        return this._updateOne(filter, doc, options);
-    }
-    async updateMany(filter, doc, options) {
-        return super._updateMany(filter, doc, options);
-    }
-}

package/esm/mongo-singleton.js

@@ -1,40 +0,0 @@
-import { MongoAdapter } from './mongo-adapter.js';
-export class MongoSingleton {
-    async create(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._create(ctx, prepared);
-    }
-    async delete(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._delete(ctx, prepared);
-    }
-    async get(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._get(ctx, prepared);
-    }
-    async update(ctx) {
-        const prepared = await this._prepare(ctx);
-        return this._update(ctx, prepared);
-    }
-    async _create(ctx, prepared) {
-        const service = await this.getService(ctx);
-        await service.deleteMany();
-        return service.insertOne(prepared.data, prepared.options);
-    }
-    async _delete(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.deleteOne(prepared.filter, prepared.options);
-    }
-    async _get(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.findOne(prepared.filter, prepared.options);
-    }
-    async _update(ctx, prepared) {
-        const service = await this.getService(ctx);
-        return service.updateOne(prepared.filter, prepared.data, prepared.options);
-    }
-    async _prepare(ctx) {
-        const prepared = MongoAdapter.transformRequest(ctx.request);
-        return (this.onPrepare && await this.onPrepare(ctx, prepared)) || prepared;
-    }
-}

package/esm/transform-key-values.js

@@ -1,11 +0,0 @@
-export default function transformKeyValues(resource, keyValues) {
-    const { primaryKey } = resource;
-    if (primaryKey.length > 1) {
-        const query = {};
-        primaryKey.forEach((k, i) => {
-            query[k] = typeof keyValues === 'object' ? keyValues[k] : keyValues[i];
-        });
-        return query;
-    }
-    return { [primaryKey[0]]: keyValues };
-}

package/types/mongo-collection.d.ts

@@ -1,32 +0,0 @@
-import mongodb from 'mongodb';
-import { Maybe } from 'ts-gems';
-import { Collection, ICollection, PartialOutput } from '@opra/common';
-import { RequestContext } from '@opra/core';
-import { MongoAdapter } from './mongo-adapter.js';
-import { MongoEntityService } from './mongo-entity-service.js';
-export declare namespace MongoCollection {
-    interface Options {
-        defaultLimit?: number;
-    }
-}
-export declare abstract class MongoCollection<T extends mongodb.Document> implements ICollection<T> {
-    defaultLimit?: number;
-    constructor(options?: MongoCollection.Options);
-    create?(ctx: Collection.Create.Context): Promise<PartialOutput<T>>;
-    delete?(ctx: RequestContext): Promise<number>;
-    deleteMany?(ctx: RequestContext): Promise<number>;
-    get?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
-    update?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
-    updateMany?(ctx: RequestContext): Promise<number>;
-    findMany?(ctx: RequestContext): Promise<PartialOutput<T>[]>;
-    protected _prepare(ctx: RequestContext): Promise<MongoAdapter.TransformedRequest>;
-    protected _findMany(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<PartialOutput<T>[]>;
-    protected _create(ctx: Collection.Create.Context, prepared: MongoAdapter.TransformedRequest): Promise<PartialOutput<T>>;
-    protected _delete(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<number>;
-    protected _deleteMany(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<number>;
-    protected _get(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<Maybe<PartialOutput<T>>>;
-    protected _update(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<Maybe<PartialOutput<T>>>;
-    protected _updateMany(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<number>;
-    protected onPrepare?(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): MongoAdapter.TransformedRequest | Promise<MongoAdapter.TransformedRequest>;
-    protected abstract getService(ctx: RequestContext): MongoEntityService<T> | Promise<MongoEntityService<T>>;
-}

package/types/mongo-entity-service-base.d.ts

@@ -1,32 +0,0 @@
-import mongodb, { UpdateFilter } from 'mongodb';
-import { StrictOmit } from 'ts-gems';
-import { ApiService, PartialOutput, RequestContext } from '@opra/core';
-export declare namespace MongoEntityServiceBase {
-    interface Options {
-        db?: mongodb.Db;
-        defaultLimit?: number;
-    }
-}
-export declare class MongoEntityServiceBase<T extends mongodb.Document> extends ApiService {
-    protected _collectionName: string;
-    defaultLimit: number;
-    db?: mongodb.Db;
-    session?: mongodb.ClientSession;
-    constructor(options?: MongoEntityServiceBase.Options);
-    constructor(collectionName: string, options?: MongoEntityServiceBase.Options);
-    protected _count(filter?: mongodb.Filter<T>, options?: mongodb.CountOptions): Promise<number>;
-    protected _deleteOne(filter?: mongodb.Filter<T>, options?: mongodb.DeleteOptions): Promise<number>;
-    protected _deleteMany(filter?: mongodb.Filter<T>, options?: mongodb.DeleteOptions): Promise<number>;
-    protected _findOne(filter: mongodb.Filter<T>, options?: mongodb.FindOptions): Promise<PartialOutput<T> | undefined>;
-    protected _find(filter: mongodb.Filter<T>, options?: mongodb.FindOptions): Promise<PartialOutput<T>[]>;
-    protected _insertOne(doc: mongodb.OptionalUnlessRequiredId<T>, options?: mongodb.InsertOneOptions): Promise<PartialOutput<T>>;
-    protected _updateOne(filter: mongodb.Filter<T>, doc: UpdateFilter<T> | Partial<T>, options?: mongodb.UpdateOptions): Promise<PartialOutput<T> | undefined>;
-    protected _updateMany(filter: mongodb.Filter<T>, doc: UpdateFilter<T> | Partial<T>, options?: StrictOmit<mongodb.UpdateOptions, 'upsert'>): Promise<number>;
-    forContext(context: RequestContext, db?: mongodb.Db, session?: mongodb.ClientSession): this;
-    protected _onError(error: unknown): Promise<void>;
-    protected getDatabase(): mongodb.Db | Promise<mongodb.Db>;
-    protected getCollection(db: mongodb.Db): Promise<mongodb.Collection<T>>;
-    protected getCollectionName(): string;
-    protected onError?(error: unknown): void | Promise<void>;
-    protected transformData?(row: PartialOutput<T>): PartialOutput<T>;
-}

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

@@ -1,20 +0,0 @@
-import mongodb, { UpdateFilter } from 'mongodb';
-import { StrictOmit } from 'ts-gems';
-import { PartialOutput } from '@opra/core';
-import { MongoEntityServiceBase } from './mongo-entity-service-base.js';
-export declare namespace MongoEntityService {
-    interface Options extends MongoEntityServiceBase.Options {
-    }
-}
-export declare class MongoEntityService<T extends mongodb.Document> extends MongoEntityServiceBase<T> {
-    constructor(options?: MongoEntityService.Options);
-    constructor(collectionName: string, options?: MongoEntityService.Options);
-    count(filter?: mongodb.Filter<T>, options?: mongodb.CountOptions): Promise<number>;
-    deleteOne(filter?: mongodb.Filter<T>, options?: mongodb.DeleteOptions): Promise<number>;
-    deleteMany(filter?: mongodb.Filter<T>, options?: mongodb.DeleteOptions): Promise<number>;
-    findOne(filter: mongodb.Filter<T>, options?: mongodb.FindOptions): Promise<PartialOutput<T> | undefined>;
-    find(filter: mongodb.Filter<T>, options?: mongodb.FindOptions): Promise<PartialOutput<T>[]>;
-    insertOne(doc: mongodb.OptionalUnlessRequiredId<T>, options?: mongodb.InsertOneOptions): Promise<PartialOutput<T>>;
-    updateOne(filter: mongodb.Filter<T>, doc: UpdateFilter<T> | Partial<T>, options?: mongodb.UpdateOptions): Promise<PartialOutput<T> | undefined>;
-    updateMany(filter: mongodb.Filter<T>, doc: UpdateFilter<T> | Partial<T>, options?: StrictOmit<mongodb.UpdateOptions, 'upsert'>): Promise<number>;
-}

package/types/mongo-singleton.d.ts

@@ -1,19 +0,0 @@
-import mongodb from 'mongodb';
-import { Maybe } from 'ts-gems';
-import { ISingleton, PartialOutput } from '@opra/common';
-import { RequestContext } from '@opra/core';
-import { MongoAdapter } from './mongo-adapter.js';
-import { MongoEntityService } from './mongo-entity-service.js';
-export declare abstract class MongoSingleton<T extends mongodb.Document> implements ISingleton<T> {
-    create?(ctx: RequestContext): Promise<PartialOutput<T>>;
-    delete?(ctx: RequestContext): Promise<number>;
-    get?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
-    update?(ctx: RequestContext): Promise<Maybe<PartialOutput<T>>>;
-    protected _create(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<PartialOutput<T>>;
-    protected _delete(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<number>;
-    protected _get(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<Maybe<PartialOutput<T>>>;
-    protected _update(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): Promise<Maybe<PartialOutput<T>>>;
-    protected _prepare(ctx: RequestContext): Promise<MongoAdapter.TransformedRequest>;
-    protected onPrepare?(ctx: RequestContext, prepared: MongoAdapter.TransformedRequest): MongoAdapter.TransformedRequest | Promise<MongoAdapter.TransformedRequest>;
-    protected abstract getService(ctx: RequestContext): MongoEntityService<T> | Promise<MongoEntityService<T>>;
-}

package/types/transform-filter.d.ts

@@ -1,3 +0,0 @@
-import '@opra/core';
-import { OpraFilter } from '@opra/common';
-export default function transformFilter(ast: OpraFilter.Expression | undefined, negative?: boolean): any;

package/types/transform-key-values.d.ts

@@ -1,3 +0,0 @@
-import mongodb from 'mongodb';
-import { Collection } from '@opra/common';
-export default function transformKeyValues(resource: Collection, keyValues: any): mongodb.Filter<any>;

package/types/transform-patch.d.ts

@@ -1 +0,0 @@
-export default function transformPatch(doc: any): any;

package/types/transform-projection.d.ts

@@ -1,9 +0,0 @@
-import mongodb from 'mongodb';
-import { ComplexType } from '@opra/common';
-export default function transformProjection(dataType: ComplexType, args?: {
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-}): mongodb.Document | undefined;
-export declare function _transformInclusionProjection(dataType: ComplexType, target: mongodb.Document, pick?: any, include?: any, omit?: any, defaultFields?: boolean): void;
-export declare function _transformExclusionProjection(dataType: ComplexType, target: mongodb.Document, omit?: any, omitExclusiveFields?: boolean): void;

package/types/transform-sort.d.ts

@@ -1,2 +0,0 @@
-import mongodb from 'mongodb';
-export default function transformSort(sort?: string[]): mongodb.Sort | undefined;