@lowdefy/connection-mongodb 5.4.0 → 5.5.1

package/dist/auth/adapters/MultiAppMongoDBAdapter/MultiAppMongoDBAdapter.js

@@ -0,0 +1,155 @@
+/*
+  Copyright 2020-2026 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 createDatabaseUser from './createDatabaseUser.js';
+import getUserFromDbByEmail from './getUserFromDbByEmail.js';
+import getUserFromDbById from './getUserFromDbById.js';
+import updateDatabaseUser from './updateDatabaseUser.js';
+function from({ _id, ...data }) {
+    return {
+        id: _id,
+        ...data
+    };
+}
+function to({ id, ...data }) {
+    return {
+        _id: id,
+        ...data
+    };
+}
+function MultiAppMongoDBAdapter({ properties }) {
+    const { appName, collections, databaseUri, mongoDBClientOptions } = properties;
+    const mongoClient = new MongoClient(databaseUri, mongoDBClientOptions);
+    const collectionNames = {
+        accounts: collections?.accounts ?? 'user-accounts',
+        contacts: collections?.contacts ?? 'user-contacts',
+        sessions: collections?.sessions ?? 'user-sessions',
+        verificationTokens: collections?.verificationTokens ?? 'user-verification-tokens'
+    };
+    return {
+        async createUser (adapterUserData) {
+            return createDatabaseUser({
+                adapterUserData,
+                appName,
+                collectionNames,
+                inviteRequired: properties.invite?.required,
+                mongoClient
+            });
+        },
+        async getUser (userId) {
+            return getUserFromDbById({
+                appName,
+                collectionNames,
+                mongoClient,
+                userId
+            });
+        },
+        async getUserByEmail (email) {
+            return getUserFromDbByEmail({
+                appName,
+                collectionNames,
+                mongoClient,
+                email
+            });
+        },
+        async getUserByAccount (provider_providerAccountId) {
+            const account = await mongoClient.db().collection(collectionNames.accounts).findOne(provider_providerAccountId);
+            if (!account) return null;
+            return getUserFromDbById({
+                appName,
+                collectionNames,
+                mongoClient,
+                userId: account.userId
+            });
+        },
+        async updateUser (adapterUserData) {
+            await updateDatabaseUser({
+                adapterUserData,
+                collectionNames,
+                mongoClient
+            });
+            return adapterUserData;
+        },
+        // This is not yet implemented by Auth.js
+        // and we want to set a disabled flag, not delete users
+        // async deleteUser(userId) {
+        //   await Promise.all([
+        //     db.accounts.deleteMany({ userId }),
+        //     db.sessions.deleteMany({ userId }),
+        //     deleteDatabaseUser({ userId }),
+        //   ]);
+        // },
+        async linkAccount (account) {
+            await mongoClient.db().collection(collectionNames.accounts).insertOne(to(account));
+            return from(account);
+        },
+        async unlinkAccount (provider_providerAccountId) {
+            const account = await mongoClient.db().collection(collectionNames.accounts).findOneAndDelete(provider_providerAccountId);
+            return from(account);
+        },
+        async getSessionAndUser (sessionToken) {
+            // eslint-disable-next-line no-unused-vars
+            const session = await mongoClient.db().collection(collectionNames.sessions).findOne({
+                sessionToken
+            });
+            if (!session) return null;
+            const user = await getUserFromDbById({
+                appName,
+                collectionNames,
+                mongoClient,
+                userId: session.userId
+            });
+            return {
+                user,
+                session: from(session)
+            };
+        },
+        async createSession (session) {
+            await mongoClient.db().collection(collectionNames.sessions).insertOne(to(session));
+            return session;
+        },
+        async updateSession (data) {
+            // eslint-disable-next-line no-unused-vars
+            const { _id, ...session } = to(data);
+            const result = await mongoClient.db().collection(collectionNames.sessions).findOneAndUpdate({
+                sessionToken: session.sessionToken
+            }, {
+                $set: session
+            }, {
+                returnDocument: 'after'
+            });
+            return from(result);
+        },
+        async deleteSession (sessionToken) {
+            const session = await mongoClient.db().collection(collectionNames.sessions).findOneAndDelete({
+                sessionToken
+            });
+            return from(session);
+        },
+        async createVerificationToken (data) {
+            const tokens = Array.from({
+                length: properties?.verificationTokens?.uses ?? 1
+            }, ()=>to(data));
+            await mongoClient.db().collection(collectionNames.verificationTokens).insertMany(tokens);
+            return data;
+        },
+        async useVerificationToken (identifier_token) {
+            const verificationToken = await mongoClient.db().collection(collectionNames.verificationTokens).findOneAndDelete(identifier_token);
+            if (!verificationToken) return null;
+            return from(verificationToken);
+        }
+    };
+}
+export default MultiAppMongoDBAdapter;

package/dist/auth/adapters/MultiAppMongoDBAdapter/createDatabaseUser.js

@@ -0,0 +1,39 @@
+/*
+  Copyright 2020-2026 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 createDatabaseUserFromContact from './createDatabaseUserFromContact.js';
+import createDatabaseUserWithoutContact from './createDatabaseUserWithoutContact.js';
+async function createDatabaseUser({ adapterUserData, appName, collectionNames, inviteRequired, mongoClient }) {
+    const contact = await mongoClient.db().collection(collectionNames.contacts).findOne({
+        lowercase_email: adapterUserData.email.toLowerCase()
+    });
+    if (contact) {
+        return createDatabaseUserFromContact({
+            adapterUserData,
+            appName,
+            collectionNames,
+            contact,
+            inviteRequired,
+            mongoClient
+        });
+    }
+    return createDatabaseUserWithoutContact({
+        adapterUserData,
+        appName,
+        collectionNames,
+        inviteRequired,
+        mongoClient
+    });
+}
+export default createDatabaseUser;

package/dist/auth/adapters/MultiAppMongoDBAdapter/createDatabaseUserFromContact.js

@@ -0,0 +1,63 @@
+/*
+  Copyright 2020-2026 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 transformContactToAdapterUser from './transformContactToAdapterUser.js';
+async function createDatabaseUserFromContact({ adapterUserData, appName, collectionNames, contact, inviteRequired, mongoClient }) {
+    const invite = contact.apps?.[appName]?.invite;
+    if (inviteRequired && (!invite || !invite.open)) {
+        throw new Error('Access denied.');
+    }
+    if (contact.disabled || contact.removed || contact.apps?.[appName]?.disabled) {
+        throw new Error('Access denied.');
+    }
+    const { emailVerified: email_verified, image } = adapterUserData;
+    const update = {
+        email_verified,
+        image,
+        updated: {
+            timestamp: new Date(),
+            user: {
+                id: contact._id
+            }
+        }
+    };
+    if (contact.apps?.[appName]) {
+        update[`apps.${appName}.disabled`] = false;
+        update[`apps.${appName}.is_user`] = true;
+        update[`apps.${appName}.sign_up`] = new Date();
+        if (invite) {
+            update[`apps.${appName}.invite.open`] = false;
+        }
+    } else {
+        update[`apps.${appName}`] = {
+            app_attributes: {},
+            disabled: false,
+            is_user: true,
+            roles: [],
+            sign_up: new Date()
+        };
+    }
+    const updatedContact = await mongoClient.db().collection(collectionNames.contacts).findOneAndUpdate({
+        _id: contact._id
+    }, {
+        $set: update
+    }, {
+        returnDocument: 'after'
+    });
+    return transformContactToAdapterUser({
+        appName,
+        contact: updatedContact
+    });
+}
+export default createDatabaseUserFromContact;

package/dist/auth/adapters/MultiAppMongoDBAdapter/createDatabaseUserWithoutContact.js

@@ -0,0 +1,59 @@
+/*
+  Copyright 2020-2026 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 { v4 as uuid } from 'uuid';
+import transformContactToAdapterUser from './transformContactToAdapterUser.js';
+async function createDatabaseUserWithoutContact({ adapterUserData, appName, collectionNames, inviteRequired, mongoClient }) {
+    if (inviteRequired) {
+        throw new Error('Access denied.');
+    }
+    const { email, emailVerified: email_verified, image = null } = adapterUserData;
+    const contact = {
+        _id: uuid(),
+        email,
+        email_verified,
+        global_attributes: {},
+        image,
+        lowercase_email: email.toLowerCase(),
+        profile: {},
+        disabled: false,
+        apps: {
+            [appName]: {
+                app_attributes: {},
+                disabled: false,
+                is_user: true,
+                roles: [],
+                sign_up: new Date()
+            }
+        }
+    };
+    contact.created = {
+        timestamp: new Date(),
+        user: {
+            id: contact._id
+        }
+    };
+    contact.updated = {
+        timestamp: new Date(),
+        user: {
+            id: contact._id
+        }
+    };
+    await mongoClient.db().collection(collectionNames.contacts).insertOne(contact);
+    return transformContactToAdapterUser({
+        appName,
+        contact
+    });
+}
+export default createDatabaseUserWithoutContact;

package/dist/auth/adapters/MultiAppMongoDBAdapter/getUserFromDbByEmail.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 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 transformContactToAdapterUser from './transformContactToAdapterUser.js';
+async function getUserFromDbByEmail({ appName, collectionNames, email, mongoClient }) {
+    const contact = await mongoClient.db().collection(collectionNames.contacts).findOne({
+        lowercase_email: email.toLowerCase()
+    });
+    if (!contact || contact.disabled || contact.removed || !contact.apps?.[appName]?.is_user || contact.apps?.[appName]?.disabled) {
+        return null;
+    }
+    return transformContactToAdapterUser({
+        appName,
+        contact
+    });
+}
+export default getUserFromDbByEmail;

package/dist/auth/adapters/MultiAppMongoDBAdapter/getUserFromDbById.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 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 transformContactToAdapterUser from './transformContactToAdapterUser.js';
+async function getUserFromDbById({ appName, collectionNames, mongoClient, userId }) {
+    const contact = await mongoClient.db().collection(collectionNames.contacts).findOne({
+        _id: userId
+    });
+    if (!contact || contact.disabled || contact.removed || !contact.apps?.[appName]?.is_user || contact.apps?.[appName]?.disabled) {
+        return null;
+    }
+    return transformContactToAdapterUser({
+        appName,
+        contact
+    });
+}
+export default getUserFromDbById;

package/dist/auth/adapters/MultiAppMongoDBAdapter/transformContactToAdapterUser.js

@@ -0,0 +1,29 @@
+/*
+  Copyright 2020-2026 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.
+*/ async function transformContactToAdapterUser({ appName, contact }) {
+    const { _id: id, email, email_verified: emailVerified = null, global_attributes = {}, image = null, profile = {} } = contact;
+    const { app_attributes, roles } = contact.apps[appName];
+    return {
+        id,
+        app_attributes,
+        email,
+        emailVerified,
+        image,
+        profile,
+        roles,
+        global_attributes
+    };
+}
+export default transformContactToAdapterUser;

package/dist/auth/adapters/MultiAppMongoDBAdapter/updateDatabaseUser.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 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.
+*/ async function updateDatabaseUser({ adapterUserData, collectionNames, mongoClient }) {
+    const { emailVerified: email_verified, id, image } = adapterUserData;
+    await mongoClient.db().collection(collectionNames.contacts).updateOne({
+        _id: id
+    }, {
+        $set: {
+            email_verified,
+            image
+        }
+    });
+}
+export default updateDatabaseUser;

package/dist/auth/adapters.js

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

package/dist/connections/MongoDBCollection/MongoDBAggregation/MongoDBAggregation.js

@@ -31,18 +31,11 @@ async function MongodbAggregation({ request, connection }) {
         pipeline,
         connection
     });
-    const { collection, client } = await getCollection({
+    const { collection } = await getCollection({
         connection
     });
-    let res;
-    try {
-        const cursor = await collection.aggregate(pipeline, options);
-        res = await cursor.toArray();
-    } catch (error) {
-        await client.close();
-        throw error;
-    }
-    await client.close();
+    const cursor = await collection.aggregate(pipeline, options);
+    const res = await cursor.toArray();
     return serialize(res);
 }
 MongodbAggregation.schema = schema;

package/dist/connections/MongoDBCollection/MongoDBBulkWrite/MongoDBBulkWrite.js

@@ -18,17 +18,10 @@ import schema from './schema.js';
 async function MongodbBulkWrite({ connection, request }) {
     const deserializedRequest = deserialize(request);
     const { operations, options } = deserializedRequest;
-    const { collection, client } = await getCollection({
+    const { collection } = await getCollection({
         connection
     });
-    let response;
-    try {
-        response = await collection.bulkWrite(operations, options);
-    } catch (error) {
-        await client.close();
-        throw error;
-    }
-    await client.close();
+    const response = await collection.bulkWrite(operations, options);
     return serialize(response);
 }
 MongodbBulkWrite.schema = schema;

package/dist/connections/MongoDBCollection/MongoDBCollection.js

@@ -18,10 +18,13 @@ import MongoDBDeleteMany from './MongoDBDeleteMany/MongoDBDeleteMany.js';
 import MongoDBDeleteOne from './MongoDBDeleteOne/MongoDBDeleteOne.js';
 import MongoDBFind from './MongoDBFind/MongoDBFind.js';
 import MongoDBFindOne from './MongoDBFindOne/MongoDBFindOne.js';
+import MongoDBInsertConsecutiveId from './MongoDBInsertConsecutiveId/MongoDBInsertConsecutiveId.js';
 import MongoDBInsertMany from './MongoDBInsertMany/MongoDBInsertMany.js';
+import MongoDBInsertManyConsecutiveIds from './MongoDBInsertManyConsecutiveIds/MongoDBInsertManyConsecutiveIds.js';
 import MongoDBInsertOne from './MongoDBInsertOne/MongoDBInsertOne.js';
 import MongoDBUpdateMany from './MongoDBUpdateMany/MongoDBUpdateMany.js';
 import MongoDBUpdateOne from './MongoDBUpdateOne/MongoDBUpdateOne.js';
+import MongoDBVersionedUpdateOne from './MongoDBVersionedUpdateOne/MongoDBVersionedUpdateOne.js';
 import schema from './schema.js';
 export default {
     schema,
@@ -32,9 +35,12 @@ export default {
         MongoDBDeleteOne,
         MongoDBFind,
         MongoDBFindOne,
+        MongoDBInsertConsecutiveId,
         MongoDBInsertMany,
+        MongoDBInsertManyConsecutiveIds,
         MongoDBInsertOne,
         MongoDBUpdateMany,
-        MongoDBUpdateOne
+        MongoDBUpdateOne,
+        MongoDBVersionedUpdateOne
     }
 };

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

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

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

@@ -15,20 +15,43 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbDeleteOne({ connection, request }) {
+async function MongodbDeleteOne({ blockId, connection, connectionId, pageId, payload, request, requestId }) {
     const deserializedRequest = deserialize(request);
     const { filter, options } = deserializedRequest;
-    const { collection, client } = await getCollection({
+    const { collection, logCollection } = await getCollection({
         connection
     });
     let response;
-    try {
+    if (logCollection) {
+        // findOneAndDelete instead of deleteOne to capture the deleted document
+        // for the change log. The response shape matches the deleteOne response.
+        const result = await collection.findOneAndDelete(filter, {
+            ...options,
+            includeResultMetadata: true
+        });
+        const before = result.value ?? null;
+        response = {
+            acknowledged: true,
+            deletedCount: result.lastErrorObject?.n ?? 0
+        };
+        await logCollection.insertOne({
+            args: {
+                filter,
+                options
+            },
+            blockId,
+            connectionId,
+            pageId,
+            payload,
+            requestId,
+            before,
+            timestamp: new Date(),
+            type: 'MongoDBDeleteOne',
+            meta: connection.changeLog?.meta
+        });
+    } else {
         response = await collection.deleteOne(filter, options);
-    } catch (error) {
-        await client.close();
-        throw error;
     }
-    await client.close();
     return serialize(response);
 }
 MongodbDeleteOne.schema = schema;

package/dist/connections/MongoDBCollection/MongoDBFind/MongoDBFind.js

@@ -18,18 +18,11 @@ import schema from './schema.js';
 async function MongodbFind({ request, connection }) {
     const deserializedRequest = deserialize(request);
     const { query, options } = deserializedRequest;
-    const { collection, client } = await getCollection({
+    const { collection } = await getCollection({
         connection
     });
-    let res;
-    try {
-        const cursor = await collection.find(query, options);
-        res = await cursor.toArray();
-    } catch (error) {
-        await client.close();
-        throw error;
-    }
-    await client.close();
+    const cursor = await collection.find(query, options);
+    const res = await cursor.toArray();
     return serialize(res);
 }
 MongodbFind.schema = schema;

package/dist/connections/MongoDBCollection/MongoDBFindOne/MongoDBFindOne.js

@@ -18,17 +18,10 @@ import schema from './schema.js';
 async function MongodbFindOne({ request, connection }) {
     const deserializedRequest = deserialize(request);
     const { query, options } = deserializedRequest;
-    const { collection, client } = await getCollection({
+    const { collection } = await getCollection({
         connection
     });
-    let res;
-    try {
-        res = await collection.findOne(query, options);
-    } catch (error) {
-        await client.close();
-        throw error;
-    }
-    await client.close();
+    const res = await collection.findOne(query, options);
     return serialize(res);
 }
 MongodbFindOne.schema = schema;