@lowdefy/connection-mongodb 5.3.0 → 5.5.0

package/dist/connections/MongoDBCollection/MongoDBInsertConsecutiveId/MongoDBInsertConsecutiveId.js

@@ -0,0 +1,84 @@
+/*
+  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 getCollection from '../getCollection.js';
+import getConsecutiveIdIndex from '../getConsecutiveIdIndex.js';
+import { serialize, deserialize } from '../serialize.js';
+import schema from './schema.js';
+async function MongoDBInsertConsecutiveId({ blockId, connection, connectionId, pageId, payload, request, requestId }) {
+    const deserializedRequest = deserialize(request);
+    const { doc, options, prefix, length } = deserializedRequest;
+    const { client, collection, logCollection } = await getCollection({
+        connection
+    });
+    // The id read and insert run in a transaction so concurrent requests cannot
+    // claim the same id. Transactions require MongoDB to run as a replica set.
+    const session = client.startSession();
+    const transactionOptions = {
+        readPreference: 'primary',
+        readConcern: {
+            level: 'local'
+        },
+        writeConcern: {
+            w: 'majority'
+        }
+    };
+    let response = {};
+    try {
+        await session.withTransaction(async ()=>{
+            const index = await getConsecutiveIdIndex({
+                collection,
+                prefix,
+                session
+            });
+            doc._id = `${prefix}${String(index).padStart(length, '0')}`;
+            response = await collection.insertOne(doc, {
+                ...options,
+                session
+            });
+            if (logCollection) {
+                await logCollection.insertOne({
+                    args: {
+                        doc,
+                        options
+                    },
+                    blockId,
+                    connectionId,
+                    pageId,
+                    payload,
+                    requestId,
+                    response,
+                    timestamp: new Date(),
+                    type: 'MongoDBInsertConsecutiveId',
+                    meta: connection.changeLog?.meta
+                }, {
+                    session
+                });
+            }
+        }, transactionOptions);
+    } finally{
+        await session.endSession();
+    }
+    const { acknowledged, insertedId } = serialize(response);
+    return {
+        acknowledged,
+        insertedId
+    };
+}
+MongoDBInsertConsecutiveId.schema = schema;
+MongoDBInsertConsecutiveId.meta = {
+    checkRead: false,
+    checkWrite: true
+};
+export default MongoDBInsertConsecutiveId;

package/dist/connections/MongoDBCollection/MongoDBInsertConsecutiveId/schema.js

@@ -0,0 +1,60 @@
+/*
+  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.
+*/ export default {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    title: 'Lowdefy Request Schema - MongoDBInsertConsecutiveId',
+    type: 'object',
+    required: [
+        'doc',
+        'prefix'
+    ],
+    properties: {
+        doc: {
+            type: 'object',
+            description: 'The document to be inserted.',
+            errorMessage: {
+                type: 'MongoDBInsertConsecutiveId request property "doc" should be an object.'
+            }
+        },
+        options: {
+            type: 'object',
+            description: 'Optional settings.',
+            errorMessage: {
+                type: 'MongoDBInsertConsecutiveId request property "options" should be an object.'
+            }
+        },
+        prefix: {
+            type: 'string',
+            description: 'Prefix to add to _id.',
+            errorMessage: {
+                type: 'MongoDBInsertConsecutiveId request property "prefix" should be a string.'
+            }
+        },
+        length: {
+            type: 'number',
+            description: 'The numeric ID will be padded to this number of digits.',
+            errorMessage: {
+                type: 'MongoDBInsertConsecutiveId request property "length" should be a number.'
+            }
+        }
+    },
+    errorMessage: {
+        type: 'MongoDBInsertConsecutiveId request properties should be an object.',
+        required: {
+            doc: 'MongoDBInsertConsecutiveId request should have required property "doc".',
+            prefix: 'MongoDBInsertConsecutiveId request should have required property "prefix".'
+        }
+    }
+};

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

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

package/dist/connections/MongoDBCollection/MongoDBInsertManyConsecutiveIds/MongoDBInsertManyConsecutiveIds.js

@@ -0,0 +1,86 @@
+/*
+  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 getCollection from '../getCollection.js';
+import getConsecutiveIdIndex from '../getConsecutiveIdIndex.js';
+import { serialize, deserialize } from '../serialize.js';
+import schema from './schema.js';
+async function MongoDBInsertManyConsecutiveIds({ blockId, connection, connectionId, pageId, payload, request, requestId }) {
+    const deserializedRequest = deserialize(request);
+    const { docs, options, prefix, length } = deserializedRequest;
+    const { client, collection, logCollection } = await getCollection({
+        connection
+    });
+    // The id read and insert run in a transaction so concurrent requests cannot
+    // claim the same ids. Transactions require MongoDB to run as a replica set.
+    const session = client.startSession();
+    const transactionOptions = {
+        readPreference: 'primary',
+        readConcern: {
+            level: 'local'
+        },
+        writeConcern: {
+            w: 'majority'
+        }
+    };
+    let response = {};
+    try {
+        await session.withTransaction(async ()=>{
+            const firstIndex = await getConsecutiveIdIndex({
+                collection,
+                prefix,
+                session
+            });
+            docs.forEach((doc, index)=>{
+                doc._id = `${prefix}${String(firstIndex + index).padStart(length, '0')}`;
+            });
+            response = await collection.insertMany(docs, {
+                ...options,
+                session
+            });
+            if (logCollection) {
+                await logCollection.insertOne({
+                    args: {
+                        docs,
+                        options
+                    },
+                    blockId,
+                    connectionId,
+                    pageId,
+                    payload,
+                    requestId,
+                    response,
+                    timestamp: new Date(),
+                    type: 'MongoDBInsertManyConsecutiveIds',
+                    meta: connection.changeLog?.meta
+                }, {
+                    session
+                });
+            }
+        }, transactionOptions);
+    } finally{
+        await session.endSession();
+    }
+    const { acknowledged, insertedIds } = serialize(response);
+    return {
+        acknowledged,
+        insertedIds
+    };
+}
+MongoDBInsertManyConsecutiveIds.schema = schema;
+MongoDBInsertManyConsecutiveIds.meta = {
+    checkRead: false,
+    checkWrite: true
+};
+export default MongoDBInsertManyConsecutiveIds;

package/dist/connections/MongoDBCollection/MongoDBInsertManyConsecutiveIds/schema.js

@@ -0,0 +1,66 @@
+/*
+  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.
+*/ export default {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    title: 'Lowdefy Request Schema - MongoDBInsertManyConsecutiveIds',
+    type: 'object',
+    required: [
+        'docs',
+        'prefix'
+    ],
+    properties: {
+        docs: {
+            type: 'array',
+            description: 'The documents to be inserted.',
+            items: {
+                type: 'object',
+                errorMessage: {
+                    type: 'MongoDBInsertManyConsecutiveIds request property "docs" should be an array of objects.'
+                }
+            },
+            errorMessage: {
+                type: 'MongoDBInsertManyConsecutiveIds request property "docs" should be an array.'
+            }
+        },
+        options: {
+            type: 'object',
+            description: 'Optional settings.',
+            errorMessage: {
+                type: 'MongoDBInsertManyConsecutiveIds request property "options" should be an object.'
+            }
+        },
+        prefix: {
+            type: 'string',
+            description: 'Prefix to add to _id.',
+            errorMessage: {
+                type: 'MongoDBInsertManyConsecutiveIds request property "prefix" should be a string.'
+            }
+        },
+        length: {
+            type: 'number',
+            description: 'The numeric ID will be padded to this number of digits.',
+            errorMessage: {
+                type: 'MongoDBInsertManyConsecutiveIds request property "length" should be a number.'
+            }
+        }
+    },
+    errorMessage: {
+        type: 'MongoDBInsertManyConsecutiveIds request properties should be an object.',
+        required: {
+            docs: 'MongoDBInsertManyConsecutiveIds request should have required property "docs".',
+            prefix: 'MongoDBInsertManyConsecutiveIds request should have required property "prefix".'
+        }
+    }
+};

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

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

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

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

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

@@ -15,20 +15,60 @@
 */ import getCollection from '../getCollection.js';
 import { serialize, deserialize } from '../serialize.js';
 import schema from './schema.js';
-async function MongodbUpdateOne({ connection, request }) {
+async function MongodbUpdateOne({ blockId, connection, connectionId, pageId, payload, request, requestId }) {
     const deserializedRequest = deserialize(request);
-    const { filter, update, options } = deserializedRequest;
-    const { collection, client } = await getCollection({
+    const { filter, update, options, disableNoMatchError } = deserializedRequest;
+    const { collection, logCollection } = await getCollection({
         connection
     });
     let response;
-    try {
+    if (logCollection) {
+        // findOneAndUpdate instead of updateOne to capture before and after
+        // documents for the change log. The response shape matches the updateOne
+        // response so it is invariant to the connection having a changeLog.
+        const before = await collection.findOne(filter);
+        const result = await collection.findOneAndUpdate(filter, update, {
+            ...options,
+            includeResultMetadata: true,
+            returnDocument: 'after'
+        });
+        const after = result.value ?? null;
+        const upsertedId = result.lastErrorObject?.upserted ?? null;
+        const matched = result.lastErrorObject?.updatedExisting ? 1 : 0;
+        response = {
+            acknowledged: true,
+            matchedCount: matched,
+            modifiedCount: matched,
+            upsertedId,
+            upsertedCount: upsertedId ? 1 : 0
+        };
+        // Throw before writing the log record so a no-match update never logs.
+        if (!disableNoMatchError && !options?.upsert && matched === 0 && !upsertedId) {
+            throw new Error('No matching record to update.');
+        }
+        await logCollection.insertOne({
+            args: {
+                filter,
+                update,
+                options
+            },
+            blockId,
+            connectionId,
+            pageId,
+            payload,
+            requestId,
+            before,
+            after,
+            timestamp: new Date(),
+            type: 'MongoDBUpdateOne',
+            meta: connection.changeLog?.meta
+        });
+    } else {
         response = await collection.updateOne(filter, update, options);
-    } catch (error) {
-        await client.close();
-        throw error;
+        if (!disableNoMatchError && !options?.upsert && response.matchedCount === 0) {
+            throw new Error('No matching record to update.');
+        }
     }
-    await client.close();
     return serialize(response);
 }
 MongodbUpdateOne.schema = schema;

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

@@ -44,6 +44,13 @@
             errorMessage: {
                 type: 'MongoDBUpdateOne request property "options" should be an object.'
             }
+        },
+        disableNoMatchError: {
+            type: 'boolean',
+            description: 'Do not throw an error when no document matches the filter. By default the request throws "No matching record to update." when nothing matched and upsert is not set.',
+            errorMessage: {
+                type: 'MongoDBUpdateOne request property "disableNoMatchError" should be a boolean.'
+            }
         }
     },
     errorMessage: {

package/dist/connections/MongoDBCollection/MongoDBVersionedUpdateOne/MongoDBVersionedUpdateOne.js

@@ -0,0 +1,96 @@
+/*
+  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 getCollection from '../getCollection.js';
+import { serialize, deserialize } from '../serialize.js';
+import schema from './schema.js';
+async function MongoDBVersionedUpdateOne({ blockId, connection, connectionId, pageId, payload, request, requestId }) {
+    const deserializedRequest = deserialize(request);
+    const { filter, update, options, disableNoMatchError } = deserializedRequest;
+    const { collection, logCollection } = await getCollection({
+        connection
+    });
+    const findOptions = options?.find;
+    const insertOptions = options?.insert;
+    const updateOptions = options?.update;
+    // The matched document is re-inserted under a new _id so the previous
+    // version is preserved, then the update is applied to the new copy.
+    const document = await collection.findOne(filter, {
+        ...findOptions
+    });
+    let insertedDocument;
+    if (document) {
+        delete document._id;
+        insertedDocument = await collection.insertOne(document, {
+            ...insertOptions
+        });
+    }
+    let response;
+    if (logCollection) {
+        const result = await collection.findOneAndUpdate(insertedDocument ? {
+            _id: insertedDocument.insertedId
+        } : filter, update, {
+            ...updateOptions,
+            includeResultMetadata: true,
+            returnDocument: 'after'
+        });
+        const after = result.value ?? null;
+        const upsertedId = result.lastErrorObject?.upserted ?? null;
+        const matched = result.lastErrorObject?.updatedExisting ? 1 : 0;
+        response = {
+            acknowledged: true,
+            matchedCount: matched,
+            modifiedCount: matched,
+            upsertedId,
+            upsertedCount: upsertedId ? 1 : 0
+        };
+        // Throw before writing the log record so a no-match update never logs.
+        if (!disableNoMatchError && !updateOptions?.upsert && matched === 0 && !upsertedId) {
+            throw new Error('No matching record to update.');
+        }
+        await logCollection.insertOne({
+            args: {
+                filter,
+                update,
+                options
+            },
+            blockId,
+            connectionId,
+            pageId,
+            payload,
+            requestId,
+            before: document,
+            after,
+            timestamp: new Date(),
+            type: 'MongoDBVersionedUpdateOne',
+            meta: connection.changeLog?.meta
+        });
+    } else {
+        response = await collection.updateOne(insertedDocument ? {
+            _id: insertedDocument.insertedId
+        } : filter, update, {
+            ...updateOptions
+        });
+        if (!disableNoMatchError && !updateOptions?.upsert && response.matchedCount === 0) {
+            throw new Error('No matching record to update.');
+        }
+    }
+    return serialize(response);
+}
+MongoDBVersionedUpdateOne.schema = schema;
+MongoDBVersionedUpdateOne.meta = {
+    checkRead: false,
+    checkWrite: true
+};
+export default MongoDBVersionedUpdateOne;