@lowdefy/connection-mongodb 4.0.0-alpha.9 → 4.0.0-rc.0

package/dist/auth/adapters/MongoDBAdapter/MongoDBAdapter.js

@@ -0,0 +1,31 @@
+/*
+  Copyright 2020-2022 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { MongoClient } from 'mongodb';
+import { MongoDBAdapter as NextAuthMongoDBAdapter } from '@next-auth/mongodb-adapter';
+/*
+Default collections are:
+{
+  Users: "users",
+  Accounts: "accounts",
+  Sessions: "sessions",
+  VerificationTokens: "verification_tokens",
+}
+*/ // TODO: Docs: MongoDB database name should be in databaseUri
+function MongoDBAdapter({ properties  }) {
+    const { databaseUri , mongoDBClientOptions , collections  } = properties;
+    const clientPromise = new MongoClient(databaseUri, mongoDBClientOptions).connect();
+    return NextAuthMongoDBAdapter(clientPromise, collections);
+}
+export default MongoDBAdapter;

package/dist/auth/adapters.js

@@ -0,0 +1,2 @@
+import MongoDBAdapter from './adapters/MongoDBAdapter/MongoDBAdapter.js';
+export { MongoDBAdapter };

package/dist/connections/MongoDBCollection/MongoDBDeleteMany/MongoDBDeleteMany.js

@@ -15,21 +15,37 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbDeleteMany({ request , connection  }) {
+async function MongodbDeleteMany({ blockId , connection , pageId , request , requestId , payload  }) {
     const deserializedRequest = deserialize(request);
     const { filter , options  } = deserializedRequest;
-    const { collection , client  } = await getCollection({
+    const { collection , client , logCollection  } = await getCollection({
         connection
     });
-    let res;
+    let response;
     try {
-        res = await collection.deleteMany(filter, options);
+        response = await collection.deleteMany(filter, options);
+        if (logCollection) {
+            await logCollection.insertOne({
+                args: {
+                    filter,
+                    options
+                },
+                blockId,
+                pageId,
+                payload,
+                requestId,
+                response,
+                timestamp: new Date(),
+                type: 'MongoDBInsertMany',
+                user: connection.changeLog?.user
+            });
+        }
     } catch (error) {
         await client.close();
         throw error;
     }
     await client.close();
-    const { acknowledged , deletedCount  } = serialize(res);
+    const { acknowledged , deletedCount  } = serialize(response);
     return {
         acknowledged,
         deletedCount

package/dist/connections/MongoDBCollection/MongoDBDeleteOne/MongoDBDeleteOne.js

@@ -15,21 +15,39 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbDeleteOne({ request , connection  }) {
+async function MongodbDeleteOne({ blockId , connection , pageId , request , requestId , payload  }) {
     const deserializedRequest = deserialize(request);
     const { filter , options  } = deserializedRequest;
-    const { collection , client  } = await getCollection({
+    const { collection , client , logCollection  } = await getCollection({
         connection
     });
-    let res;
+    let response;
     try {
-        res = await collection.deleteOne(filter, options);
+        if (logCollection) {
+            response = await collection.findOneAndDelete(filter, options);
+            await logCollection.insertOne({
+                args: {
+                    filter,
+                    options
+                },
+                blockId,
+                pageId,
+                payload,
+                requestId,
+                before: response,
+                timestamp: new Date(),
+                type: 'MongoDBDeleteOne',
+                user: connection.changeLog?.user
+            });
+        } else {
+            response = await collection.deleteOne(filter, options);
+        }
     } catch (error) {
         await client.close();
         throw error;
     }
     await client.close();
-    const { acknowledged , deletedCount  } = serialize(res);
+    const { acknowledged , deletedCount  } = serialize(response);
     return {
         acknowledged,
         deletedCount

package/dist/connections/MongoDBCollection/MongoDBInsertMany/MongoDBInsertMany.js

@@ -15,21 +15,37 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbInsertMany({ request , connection  }) {
+async function MongodbInsertMany({ blockId , connection , pageId , request , requestId , payload  }) {
     const deserializedRequest = deserialize(request);
     const { docs , options  } = deserializedRequest;
-    const { collection , client  } = await getCollection({
+    const { collection , client , logCollection  } = await getCollection({
         connection
     });
-    let res;
+    let response;
     try {
-        res = await collection.insertMany(docs, options);
+        response = await collection.insertMany(docs, options);
+        if (logCollection) {
+            await logCollection.insertOne({
+                args: {
+                    docs,
+                    options
+                },
+                blockId,
+                pageId,
+                payload,
+                requestId,
+                response,
+                timestamp: new Date(),
+                type: 'MongoDBInsertMany',
+                user: connection.changeLog?.user
+            });
+        }
     } catch (error) {
         await client.close();
         throw error;
     }
     await client.close();
-    const { acknowledged , insertedCount  } = serialize(res);
+    const { acknowledged , insertedCount  } = serialize(response);
     return {
         acknowledged,
         insertedCount

package/dist/connections/MongoDBCollection/MongoDBInsertOne/MongoDBInsertOne.js

@@ -15,21 +15,37 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbInsertOne({ request , connection  }) {
+async function MongodbInsertOne({ blockId , connection , pageId , request , requestId , payload  }) {
     const deserializedRequest = deserialize(request);
     const { doc , options  } = deserializedRequest;
-    const { collection , client  } = await getCollection({
+    const { collection , client , logCollection  } = await getCollection({
         connection
     });
-    let res;
+    let response;
     try {
-        res = await collection.insertOne(doc, options);
+        response = await collection.insertOne(doc, options);
+        if (logCollection) {
+            await logCollection.insertOne({
+                args: {
+                    doc,
+                    options
+                },
+                blockId,
+                pageId,
+                payload,
+                requestId,
+                response,
+                timestamp: new Date(),
+                type: 'MongoDBInsertOne',
+                user: connection.changeLog?.user
+            });
+        }
     } catch (error) {
         await client.close();
         throw error;
     }
     await client.close();
-    const { acknowledged , insertedId  } = serialize(res);
+    const { acknowledged , insertedId  } = serialize(response);
     return {
         acknowledged,
         insertedId

package/dist/connections/MongoDBCollection/MongoDBUpdateMany/MongoDBUpdateMany.js

@@ -15,21 +15,38 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbUpdateMany({ request , connection  }) {
+async function MongodbUpdateMany({ blockId , connection , pageId , request , requestId , payload  }) {
     const deserializedRequest = deserialize(request);
     const { filter , update , options  } = deserializedRequest;
-    const { collection , client  } = await getCollection({
+    const { collection , client , logCollection  } = await getCollection({
         connection
     });
-    let res;
+    let response;
     try {
-        res = await collection.updateMany(filter, update, options);
+        response = await collection.updateMany(filter, update, options);
+        if (logCollection) {
+            await logCollection.insertOne({
+                args: {
+                    filter,
+                    update,
+                    options
+                },
+                blockId,
+                pageId,
+                payload,
+                requestId,
+                response,
+                timestamp: new Date(),
+                type: 'MongoDBUpdateMany',
+                user: connection.changeLog?.user
+            });
+        }
     } catch (error) {
         await client.close();
         throw error;
     }
     await client.close();
-    const { modifiedCount , upsertedId , upsertedCount , matchedCount  } = serialize(res);
+    const { modifiedCount , upsertedId , upsertedCount , matchedCount  } = serialize(response);
     return {
         modifiedCount,
         upsertedId,

package/dist/connections/MongoDBCollection/MongoDBUpdateOne/MongoDBUpdateOne.js

@@ -15,21 +15,44 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbUpdateOne({ request , connection  }) {
+async function MongodbUpdateOne({ blockId , connection , pageId , request , requestId , payload  }) {
     const deserializedRequest = deserialize(request);
     const { filter , update , options  } = deserializedRequest;
-    const { collection , client  } = await getCollection({
+    const { collection , client , logCollection  } = await getCollection({
         connection
     });
-    let res;
+    let response;
     try {
-        res = await collection.updateOne(filter, update, options);
+        if (logCollection) {
+            response = await collection.findOneAndUpdate(filter, update, options);
+            const after = await collection.findOne({
+                _id: response._id
+            });
+            await logCollection.insertOne({
+                args: {
+                    filter,
+                    update,
+                    options
+                },
+                blockId,
+                pageId,
+                payload,
+                requestId,
+                before: response,
+                after,
+                timestamp: new Date(),
+                type: 'MongoDBUpdateOne',
+                user: connection.changeLog?.user
+            });
+        } else {
+            response = await collection.updateOne(filter, update, options);
+        }
     } catch (error) {
         await client.close();
         throw error;
     }
     await client.close();
-    const { modifiedCount , upsertedId , upsertedCount , matchedCount  } = serialize(res);
+    const { modifiedCount , upsertedId , upsertedCount , matchedCount  } = serialize(response);
     return {
         modifiedCount,
         upsertedId,

package/dist/connections/MongoDBCollection/getCollection.js

@@ -15,18 +15,15 @@
 */ import { MongoClient } from 'mongodb';
 async function getCollection({ connection  }) {
     let client;
-    const { collection , databaseUri , databaseName , options  } = connection;
-    client = new MongoClient(databaseUri, {
-        ...options,
-        useNewUrlParser: true,
-        useUnifiedTopology: true
-    });
+    const { collection , databaseName , databaseUri , changeLog , options  } = connection;
+    client = new MongoClient(databaseUri, options);
     await client.connect();
     try {
         const db = client.db(databaseName);
         return {
             client,
-            collection: db.collection(collection)
+            collection: db.collection(collection),
+            logCollection: changeLog?.collection && db.collection(changeLog.collection)
         };
     } catch (error) {
         await client.close();

package/dist/types.js

@@ -12,9 +12,12 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import * as connections from './connections.js';
+*/ import * as adapters from './auth/adapters.js';
+import * as connections from './connections.js';
 export default {
+    auth: {
+        adapters: Object.keys(adapters)
+    },
     connections: Object.keys(connections),
-    requests: Object.keys(connections).map((connection)=>Object.keys(connections[connection].requests)
-    ).flat()
+    requests: Object.keys(connections).map((connection)=>Object.keys(connections[connection].requests)).flat()
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lowdefy/connection-mongodb",
-  "version": "4.0.0-alpha.9",
-  "licence": "Apache-2.0",
+  "version": "4.0.0-rc.0",
+  "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
   "keywords": [
@@ -28,6 +28,7 @@
   },
   "type": "module",
   "exports": {
+    "./auth/adapters": "./dist/auth/adapters.js",
     "./connections": "./dist/connections.js",
     "./types": "./dist/types.js"
   },
@@ -35,27 +36,31 @@
     "dist/*"
   ],
   "scripts": {
-    "build": "yarn swc",
+    "build": "swc src --out-dir dist --config-file ../../../../.swcrc --delete-dir-on-start --copy-files",
     "clean": "rm -rf dist",
-    "prepare": "yarn build",
-    "swc": "swc src --out-dir dist --config-file ../../../../.swcrc --delete-dir-on-start --copy-files",
-    "test": "jest --coverage"
+    "prepublishOnly": "pnpm build",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "dependencies": {
-    "@lowdefy/helpers": "4.0.0-alpha.9",
-    "mongodb": "4.4.0",
+    "@lowdefy/helpers": "4.0.0-rc.0",
+    "@next-auth/mongodb-adapter": "1.0.3",
+    "mongodb": "4.6.0",
     "saslprep": "1.0.3"
   },
   "devDependencies": {
-    "@lowdefy/ajv": "4.0.0-alpha.9",
-    "@shelf/jest-mongodb": "2.2.0",
-    "@swc/cli": "0.1.55",
-    "@swc/core": "1.2.135",
-    "@swc/jest": "0.2.17",
-    "jest": "27.5.1"
+    "@lowdefy/ajv": "4.0.0-rc.0",
+    "@shelf/jest-mongodb": "4.1.0",
+    "@swc/cli": "0.1.57",
+    "@swc/core": "1.2.194",
+    "@swc/jest": "0.2.21",
+    "jest": "28.1.0",
+    "jest-environment-node": "28.1.0",
+    "next-auth": "4.10.3",
+    "react": "18.2.0",
+    "react-dom": "18.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "98b544eca231bdcfca6c3a8601a891835d5ce571"
+  "gitHead": "f6872d7ff6da421710096536fce7b2016ef8f35c"
 }