@openfn/language-mongodb 1.0.4

package/dist/index.cjs

@@ -0,0 +1,219 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  alterState: () => import_language_common2.alterState,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  default: () => src_default,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  findDocuments: () => findDocuments,
+  fn: () => import_language_common2.fn,
+  insertDocuments: () => insertDocuments,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  sourceValue: () => import_language_common2.sourceValue,
+  updateDocument: () => updateDocument
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => import_language_common2.alterState,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  findDocuments: () => findDocuments,
+  fn: () => import_language_common2.fn,
+  insertDocuments: () => insertDocuments,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  sourceValue: () => import_language_common2.sourceValue,
+  updateDocument: () => updateDocument
+});
+var import_language_common = require("@openfn/language-common");
+var import_mongodb = __toESM(require("mongodb"), 1);
+var import_language_common2 = require("@openfn/language-common");
+var { MongoClient } = import_mongodb.default;
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return (0, import_language_common.execute)(
+      connect,
+      ...operations,
+      disconnect
+    )({ ...initialState, ...state });
+  };
+}
+function connect(state) {
+  const { clusterUrl, username, password } = state.configuration;
+  const uri = `mongodb+srv://${encodeURIComponent(
+    username
+  )}:${encodeURIComponent(
+    password
+  )}@${clusterUrl}/test?retryWrites=true&w=majority`;
+  const client = new MongoClient(uri, { useNewUrlParser: true });
+  return new Promise((resolve, reject) => {
+    client.connect((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        console.log("Connected successfully to server");
+        resolve({ ...state, client });
+      }
+    });
+  });
+}
+function disconnect(state) {
+  state.client.close();
+  delete state.client;
+  return state;
+}
+function insertDocuments(params) {
+  return (state) => {
+    const { client } = state;
+    try {
+      const { database, collection, documents, callback } = (0, import_language_common.expandReferences)(params)(state);
+      const db = client.db(database);
+      const mCollection = db.collection(collection);
+      return new Promise((resolve, reject) => {
+        mCollection.insertMany(documents, (err, result2) => {
+          if (err) {
+            reject(err);
+            state.client.close();
+          } else {
+            console.log(
+              `Inserted ${documents.length} documents into the collection`
+            );
+            console.log(JSON.stringify(result2, null, 2));
+            const nextState = (0, import_language_common.composeNextState)(state, result2);
+            if (callback)
+              resolve(callback(nextState));
+            resolve(nextState);
+          }
+        });
+      });
+    } catch (error) {
+      state.client.close();
+      throw error;
+    }
+  };
+}
+function findDocuments(params) {
+  return (state) => {
+    const { client } = state;
+    try {
+      const { database, collection, query, callback } = (0, import_language_common.expandReferences)(params)(state);
+      const db = client.db(database);
+      const mCollection = db.collection(collection);
+      return new Promise((resolve, reject) => {
+        mCollection.find(query).toArray((err, docs) => {
+          if (err) {
+            reject(err);
+            state.client.close();
+          } else {
+            console.log(`Found ${docs.length} documents in the collection`);
+            console.log(JSON.stringify(result, null, 2));
+            const nextState = (0, import_language_common.composeNextState)(state, docs);
+            if (callback)
+              resolve(callback(nextState));
+            resolve(nextState);
+          }
+        });
+      });
+    } catch (error) {
+      state.client.close();
+      throw error;
+    }
+  };
+}
+function updateDocument(params) {
+  return (state) => {
+    const { client } = state;
+    try {
+      const { database, collection, filter, changes, options, callback } = (0, import_language_common.expandReferences)(params)(state);
+      const db = client.db(database);
+      const mCollection = db.collection(collection);
+      return new Promise((resolve, reject) => {
+        mCollection.updateMany(
+          filter,
+          { $set: changes },
+          options,
+          (err, result2) => {
+            if (err) {
+              reject(err);
+              state.client.close();
+            } else {
+              console.log(
+                `Updated a document matching ${JSON.stringify(
+                  filter
+                )} in the collection.`
+              );
+              console.log(JSON.stringify(result2, null, 2));
+              const nextState = (0, import_language_common.composeNextState)(state, result2);
+              if (callback)
+                resolve(callback(nextState));
+              resolve(nextState);
+            }
+          }
+        );
+      });
+    } catch (error) {
+      state.client.close();
+      throw error;
+    }
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alterState,
+  dataPath,
+  dataValue,
+  each,
+  execute,
+  field,
+  fields,
+  findDocuments,
+  fn,
+  insertDocuments,
+  lastReferenceValue,
+  merge,
+  sourceValue,
+  updateDocument
+});

package/dist/index.js

@@ -0,0 +1,195 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => alterState,
+  dataPath: () => dataPath,
+  dataValue: () => dataValue,
+  each: () => each,
+  execute: () => execute,
+  field: () => field,
+  fields: () => fields,
+  findDocuments: () => findDocuments,
+  fn: () => fn,
+  insertDocuments: () => insertDocuments,
+  lastReferenceValue: () => lastReferenceValue,
+  merge: () => merge,
+  sourceValue: () => sourceValue,
+  updateDocument: () => updateDocument
+});
+import {
+  execute as commonExecute,
+  expandReferences,
+  composeNextState
+} from "@openfn/language-common";
+import pkg from "mongodb";
+import {
+  field,
+  fields,
+  sourceValue,
+  fn,
+  alterState,
+  each,
+  merge,
+  dataPath,
+  dataValue,
+  lastReferenceValue
+} from "@openfn/language-common";
+var { MongoClient } = pkg;
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return commonExecute(
+      connect,
+      ...operations,
+      disconnect
+    )({ ...initialState, ...state });
+  };
+}
+function connect(state) {
+  const { clusterUrl, username, password } = state.configuration;
+  const uri = `mongodb+srv://${encodeURIComponent(
+    username
+  )}:${encodeURIComponent(
+    password
+  )}@${clusterUrl}/test?retryWrites=true&w=majority`;
+  const client = new MongoClient(uri, { useNewUrlParser: true });
+  return new Promise((resolve, reject) => {
+    client.connect((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        console.log("Connected successfully to server");
+        resolve({ ...state, client });
+      }
+    });
+  });
+}
+function disconnect(state) {
+  state.client.close();
+  delete state.client;
+  return state;
+}
+function insertDocuments(params) {
+  return (state) => {
+    const { client } = state;
+    try {
+      const { database, collection, documents, callback } = expandReferences(params)(state);
+      const db = client.db(database);
+      const mCollection = db.collection(collection);
+      return new Promise((resolve, reject) => {
+        mCollection.insertMany(documents, (err, result2) => {
+          if (err) {
+            reject(err);
+            state.client.close();
+          } else {
+            console.log(
+              `Inserted ${documents.length} documents into the collection`
+            );
+            console.log(JSON.stringify(result2, null, 2));
+            const nextState = composeNextState(state, result2);
+            if (callback)
+              resolve(callback(nextState));
+            resolve(nextState);
+          }
+        });
+      });
+    } catch (error) {
+      state.client.close();
+      throw error;
+    }
+  };
+}
+function findDocuments(params) {
+  return (state) => {
+    const { client } = state;
+    try {
+      const { database, collection, query, callback } = expandReferences(params)(state);
+      const db = client.db(database);
+      const mCollection = db.collection(collection);
+      return new Promise((resolve, reject) => {
+        mCollection.find(query).toArray((err, docs) => {
+          if (err) {
+            reject(err);
+            state.client.close();
+          } else {
+            console.log(`Found ${docs.length} documents in the collection`);
+            console.log(JSON.stringify(result, null, 2));
+            const nextState = composeNextState(state, docs);
+            if (callback)
+              resolve(callback(nextState));
+            resolve(nextState);
+          }
+        });
+      });
+    } catch (error) {
+      state.client.close();
+      throw error;
+    }
+  };
+}
+function updateDocument(params) {
+  return (state) => {
+    const { client } = state;
+    try {
+      const { database, collection, filter, changes, options, callback } = expandReferences(params)(state);
+      const db = client.db(database);
+      const mCollection = db.collection(collection);
+      return new Promise((resolve, reject) => {
+        mCollection.updateMany(
+          filter,
+          { $set: changes },
+          options,
+          (err, result2) => {
+            if (err) {
+              reject(err);
+              state.client.close();
+            } else {
+              console.log(
+                `Updated a document matching ${JSON.stringify(
+                  filter
+                )} in the collection.`
+              );
+              console.log(JSON.stringify(result2, null, 2));
+              const nextState = composeNextState(state, result2);
+              if (callback)
+                resolve(callback(nextState));
+              resolve(nextState);
+            }
+          }
+        );
+      });
+    } catch (error) {
+      state.client.close();
+      throw error;
+    }
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+export {
+  alterState,
+  dataPath,
+  dataValue,
+  src_default as default,
+  each,
+  execute,
+  field,
+  fields,
+  findDocuments,
+  fn,
+  insertDocuments,
+  lastReferenceValue,
+  merge,
+  sourceValue,
+  updateDocument
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@openfn/language-mongodb",
+  "version": "1.0.4",
+  "description": "A language package for working with MongoDb",
+  "main": "dist/index.cjs",
+  "author": "Open Function Group",
+  "license": "LGPLv3",
+  "files": [
+    "dist/",
+    "types/",
+    "ast.json",
+    "configuration-schema.json"
+  ],
+  "dependencies": {
+    "@openfn/language-common": "^1.7.5",
+    "mongodb": "^3.7.3"
+  },
+  "devDependencies": {
+    "@openfn/buildtools": "^1.0.2",
+    "@openfn/simple-ast": "0.4.1",
+    "assertion-error": "^1.1.0",
+    "chai": "^3.5.0",
+    "deep-eql": "^0.1.3",
+    "esno": "^0.16.3",
+    "mocha": "^10.1.0",
+    "nock": "^12.0.3",
+    "rimraf": "^3.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openfn/adaptors.git"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "types/index.d.ts",
+  "scripts": {
+    "build": "pnpm clean && build-adaptor mongodb",
+    "test": "mocha --experimental-specifier-resolution=node --no-warnings",
+    "test:watch": "mocha -w --experimental-specifier-resolution=node --no-warnings",
+    "clean": "rimraf dist types docs",
+    "pack": "pnpm pack --pack-destination ../../dist"
+  }
+}

package/types/Adaptor.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Execute a sequence of operations.
+ * Wraps `@openfn/language-common/execute`, and prepends initial state for http.
+ * @example
+ * execute(
+ *   insertDocuments(params),
+ *   findDocuments(params)
+ * )(state)
+ * @function
+ * @param {Operations} operations - Operations to be performed.
+ * @returns {Operation}
+ */
+export function execute(...operations: Operations): Operation;
+/**
+ * Inserts documents into a mongoDb collection
+ * @example
+ *  insertDocuments({
+ *    database: 'str',
+ *    collection: 'kids',
+ *    documents: [1,2,3]
+ *   });
+ * @function
+ * @param {object} params - Configuration for mongo
+ * @returns {State}
+ */
+export function insertDocuments(params: object): State;
+/**
+ * Find documents in a mongoDb collection
+ * @example
+ *  findDocuments({
+ *    database: 'str',
+ *    collection: 'cases',
+ *    query: {a:3}
+ *   });
+ * @function
+ * @param {object} params - Configuration for mongo
+ * @returns {State}
+ */
+export function findDocuments(params: object): State;
+/**
+ * Updates document (optionally upserting) into a mongoDb collection
+ * @example
+ *  updateDocuments({
+ *    database: 'str',
+ *    collection: 'animals',
+ *    filter: { type: 'fuzzy' },
+ *    changes: { kind: 'soft' },
+ *    options: { upsert: true }
+ *   });
+ * @function
+ * @param {object} params - Configuration for mongo
+ * @returns {State}
+ */
+export function updateDocument(params: object): State;
+export { field, fields, sourceValue, fn, alterState, each, merge, dataPath, dataValue, lastReferenceValue } from "@openfn/language-common";

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export default Adaptor;
+export * from "./Adaptor";
+import * as Adaptor from "./Adaptor";