@opra/mongodb 0.16.0

package/esm/transform-projection.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._transformExclusionProjection = exports._transformInclusionProjection = void 0;
+const common_1 = require("@opra/common");
+function transformProjection(dataType, args) {
+    const out = {};
+    // omitExclusiveFields(dataType, out);
+    const pick = args.pick && (0, common_1.pathToObjectTree)(args.include ? [...args.pick, ...args.include] : args.pick);
+    const include = !args.pick && args.include && (0, common_1.pathToObjectTree)(args.include);
+    const omit = args.omit && (0, common_1.pathToObjectTree)(args.omit);
+    if (pick || include) {
+        _transformInclusionProjection(dataType, out, pick, include, omit);
+    }
+    else
+        _transformExclusionProjection(dataType, out, omit, !omit);
+    return Object.keys(out).length ? out : undefined;
+}
+exports.default = transformProjection;
+function _transformInclusionProjection(dataType, target, pick, include, omit, defaultFields) {
+    defaultFields = defaultFields ?? !pick;
+    let n;
+    for (const [k, f] of dataType.fields.entries()) {
+        if (omit?.[k] === true)
+            continue;
+        n = (defaultFields && !f.exclusive) ||
+            pick === true || pick?.[k] || include === true || include?.[k];
+        if (n) {
+            if (f.type instanceof common_1.ComplexType && (typeof n === 'object' || typeof omit?.[k] === 'object')) {
+                target[k] = {};
+                _transformInclusionProjection(f.type, target[k], pick?.[k] || include?.[k], undefined, omit?.[k], defaultFields);
+                continue;
+            }
+            target[k] = 1;
+        }
+    }
+}
+exports._transformInclusionProjection = _transformInclusionProjection;
+function _transformExclusionProjection(dataType, target, omit, omitExclusiveFields) {
+    let n;
+    for (const [k, f] of dataType.fields.entries()) {
+        n = omit?.[k] || (omitExclusiveFields && f.exclusive);
+        if (n) {
+            if (f.type instanceof common_1.ComplexType && typeof n === 'object') {
+                target[k] = {};
+                _transformExclusionProjection(f.type, target[k], omit?.[k], omitExclusiveFields);
+                continue;
+            }
+            target[k] = 0;
+        }
+    }
+}
+exports._transformExclusionProjection = _transformExclusionProjection;

package/esm/transform-sort.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformSort(sort) {
+    if (!(sort && sort.length))
+        return;
+    const out = {};
+    if (sort)
+        sort.forEach(k => {
+            if (k.startsWith('-'))
+                out[k.substring(1)] = -1;
+            else if (k.startsWith('+'))
+                out[k.substring(1)] = 1;
+            else
+                out[k] = 1;
+        });
+    return out;
+}
+exports.default = transformSort;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@opra/mongodb",
+  "version": "0.16.0",
+  "description": "Opra MongoDB adapter package",
+  "author": "Panates",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/mongodb"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "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 .",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
+    "clean:dist": "rimraf ../../build/mongodb",
+    "clean:cover": "rimraf ../../coverage/mongodb"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^7.6.0",
+    "mongodb": "^5.3.0",
+    "ts-gems": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@opra/common": "^0.16.0",
+    "@opra/core": "^0.16.0",
+    "mongodb": ">=4.x.x"
+  },
+  "type": "module",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "mongodb",
+    "adapter"
+  ]
+}

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mongo-adapter.js';
+export * from './mongo-collection-resource.js';
+export * from './mongo-entity-service.js';
+export * from './mongo-singleton-resource.js';

package/types/mongo-adapter.d.ts

@@ -0,0 +1,14 @@
+import { Request } from '@opra/core';
+import _transformFilter from './transform-filter.js';
+import _transformKeyValues from './transform-key-values.js';
+import _transformPatch from './transform-patch.js';
+import _transformProjection from './transform-projection.js';
+import _transformSort from './transform-sort.js';
+export declare namespace MongoAdapter {
+    const transformFilter: typeof _transformFilter;
+    const transformKeyValues: typeof _transformKeyValues;
+    const transformPatch: typeof _transformPatch;
+    const transformProjection: typeof _transformProjection;
+    const transformSort: typeof _transformSort;
+    function transformRequest(request: Request): any;
+}

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

@@ -0,0 +1,15 @@
+import mongodb from 'mongodb';
+import { PartialOutput } from '@opra/common';
+import { RequestContext } from '@opra/core';
+import { MongoEntityService } from './mongo-entity-service.js';
+export declare abstract class MongoCollectionResource<T extends mongodb.Document, TOutput = PartialOutput<T>> {
+    defaultLimit: number;
+    create(ctx: RequestContext): Promise<TOutput>;
+    delete(ctx: RequestContext): Promise<number>;
+    deleteMany(ctx: RequestContext): Promise<number>;
+    get(ctx: RequestContext): Promise<TOutput>;
+    update(ctx: RequestContext): Promise<TOutput>;
+    updateMany(ctx: RequestContext): Promise<number>;
+    search(ctx: RequestContext): Promise<TOutput[]>;
+    abstract getService(ctx: RequestContext): MongoEntityService<T, TOutput> | Promise<MongoEntityService<T, TOutput>>;
+}

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

@@ -0,0 +1,30 @@
+import mongodb, { UpdateFilter } from 'mongodb';
+import { StrictOmit } from 'ts-gems';
+import { PartialOutput, RequestContext } from '@opra/core';
+export declare namespace MongoEntityService {
+    interface Options {
+        db?: mongodb.Db;
+        defaultLimit?: number;
+    }
+}
+export declare class MongoEntityService<T extends mongodb.Document, TOutput = PartialOutput<T>> {
+    readonly collectionName: string;
+    context: RequestContext;
+    defaultLimit: number;
+    db?: mongodb.Db;
+    session?: mongodb.ClientSession;
+    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<TOutput | undefined>;
+    find(filter: mongodb.Filter<T>, options?: mongodb.FindOptions): Promise<TOutput[]>;
+    insertOne(doc: mongodb.OptionalUnlessRequiredId<T>, options?: mongodb.InsertOneOptions): Promise<TOutput>;
+    updateOne(filter: mongodb.Filter<T>, doc: UpdateFilter<T> | Partial<T>, options?: mongodb.UpdateOptions): Promise<TOutput | undefined>;
+    updateMany(filter: mongodb.Filter<T>, doc: UpdateFilter<T> | Partial<T>, options?: StrictOmit<mongodb.UpdateOptions, 'upsert'>): Promise<number>;
+    with(context: RequestContext, db?: mongodb.Db, session?: mongodb.ClientSession): MongoEntityService<T, TOutput>;
+    protected _onError(error: unknown): Promise<void>;
+    protected getDatabase(): mongodb.Db | Promise<mongodb.Db>;
+    protected onError?(error: unknown): void | Promise<void>;
+    protected onTransformRow?(row: mongodb.WithId<T>): mongodb.WithId<T>;
+}

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

@@ -0,0 +1,12 @@
+import mongodb from 'mongodb';
+import { PartialOutput } from '@opra/common';
+import { RequestContext } from '@opra/core';
+import { MongoEntityService } from './mongo-entity-service.js';
+export declare abstract class MongoSingletonResource<T extends mongodb.Document, TOutput = PartialOutput<T>> {
+    defaultLimit: number;
+    create(ctx: RequestContext): Promise<TOutput>;
+    delete(ctx: RequestContext): Promise<number>;
+    get(ctx: RequestContext): Promise<TOutput>;
+    update(ctx: RequestContext): Promise<TOutput>;
+    abstract getService(ctx: RequestContext): MongoEntityService<T, TOutput> | Promise<MongoEntityService<T, TOutput>>;
+}

package/types/transform-filter.d.ts

@@ -0,0 +1,2 @@
+import { Expression } from '@opra/common';
+export default function transformFilter(str: string | Expression | undefined): any;

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

@@ -0,0 +1,3 @@
+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

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

package/types/transform-projection.d.ts

@@ -0,0 +1,9 @@
+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

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