@prosopo/database 2.5.5 → 2.6.2

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# @prosopo/database
+
+## 2.6.2
+
+### Patch Changes
+
+- Updated dependencies [6ff193a]
+  - @prosopo/types@2.6.2
+  - @prosopo/types-database@2.6.2
+  - @prosopo/user-access-policy@2.6.2
+
+## 2.6.1
+
+### Patch Changes
+
+- 52feffc: Adjustable difficulty img captcha
+- Updated dependencies [52feffc]
+  - @prosopo/types-database@2.6.1
+  - @prosopo/types@2.6.1
+  - @prosopo/user-access-policy@2.6.1
+
+## 2.6.0
+
+### Minor Changes
+
+- a0bfc8a: bump all pkg versions since independent versioning applied
+
+### Patch Changes
+
+- Updated dependencies [a0bfc8a]
+  - @prosopo/config@2.6.0
+  - @prosopo/common@2.6.0
+  - @prosopo/types@2.6.0
+  - @prosopo/types-database@2.6.0
+  - @prosopo/user-access-policy@2.6.0

package/dist/cjs/base/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mongo = require("./mongo.cjs");
+const mongoMemory = require("./mongoMemory.cjs");
+exports.MongoDatabase = mongo.MongoDatabase;
+exports.MongoMemoryDatabase = mongoMemory.MongoMemoryDatabase;

package/dist/cjs/base/mongo.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const mongodb = require("mongodb");
+const mongoose = require("mongoose");
+mongoose.set("strictQuery", false);
+const DEFAULT_ENDPOINT = "mongodb://127.0.0.1:27017";
+class MongoDatabase {
+  constructor(url, dbname, authSource, logger) {
+    this.connected = false;
+    const baseEndpoint = url || DEFAULT_ENDPOINT;
+    const parsedUrl = new URL(baseEndpoint);
+    if (dbname) {
+      parsedUrl.pathname = dbname;
+    }
+    if (authSource) {
+      parsedUrl.searchParams.set("authSource", authSource);
+    }
+    this._url = parsedUrl.toString();
+    this.safeURL = this.url.replace(/\w+:\w+/, "<Credentials>");
+    this.dbname = dbname || parsedUrl.pathname.replace("/", "");
+    this.logger = logger || common.getLoggerDefault();
+  }
+  get url() {
+    return this._url;
+  }
+  getConnection() {
+    if (!this.connection) {
+      throw new common.ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
+        context: { failedFuncName: this.getConnection.name },
+        logger: this.logger
+      });
+    }
+    return this.connection;
+  }
+  /**
+   * @description Connect to the database and set the various tables
+   */
+  async connect() {
+    this.logger.info(`Mongo url: ${this.safeURL}`);
+    try {
+      if (this.connected) {
+        this.logger.info(`Database connection to ${this.safeURL} already open`);
+        return;
+      }
+      this.connection = await new Promise((resolve, reject) => {
+        const connection = mongoose.createConnection(this.url, {
+          dbName: this.dbname,
+          serverApi: mongodb.ServerApiVersion.v1
+        });
+        connection.on("open", () => {
+          this.logger.info(`Database connection to ${this.safeURL} opened`);
+          this.connected = true;
+          resolve(connection);
+        });
+        connection.on("error", (err) => {
+          this.connected = false;
+          this.logger.error(`Database error: ${err}`);
+          reject(err);
+        });
+        connection.on("connected", () => {
+          this.logger.info(`Database connected to ${this.safeURL}`);
+          this.connected = true;
+          resolve(connection);
+        });
+        connection.on("disconnected", () => {
+          this.connected = false;
+          this.logger.info(`Database disconnected from ${this.safeURL}`);
+        });
+        connection.on("reconnected", () => {
+          this.logger.info(`Database reconnected to ${this.safeURL}`);
+          this.connected = true;
+          resolve(connection);
+        });
+        connection.on("reconnectFailed", () => {
+          this.connected = false;
+          this.logger.error(`Database reconnect failed to ${this.safeURL}`);
+        });
+        connection.on("close", () => {
+          this.connected = false;
+          this.logger.info(`Database connection to ${this.safeURL} closed`);
+        });
+        connection.on("fullsetup", () => {
+          this.connected = true;
+          this.logger.info(
+            `Database connection to ${this.safeURL} is fully setup`
+          );
+          resolve(connection);
+        });
+      });
+    } catch (e) {
+      this.logger.error(`Database connection error: ${e}`);
+      throw e;
+    }
+  }
+  /** Close connection to the database */
+  async close() {
+    this.logger.debug(`Closing connection to ${this.safeURL}`);
+    await this.connection?.close();
+  }
+}
+exports.MongoDatabase = MongoDatabase;

package/dist/cjs/base/mongoMemory.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mongodbMemoryServer = require("mongodb-memory-server");
+const mongo = require("./mongo.cjs");
+class MongoMemoryDatabase extends mongo.MongoDatabase {
+  constructor(url, dbname, logger, authSource) {
+    const mongod = new mongodbMemoryServer.MongoMemoryServer();
+    const mongoMemoryURL = mongod.getUri();
+    super(mongoMemoryURL, dbname, authSource, logger);
+    this.running = false;
+    this.mongod = mongod;
+    this._url = mongoMemoryURL;
+  }
+  connect() {
+    if (!this.running) {
+      this.mongod?.start();
+      this.running = true;
+    } else {
+    }
+    return super.connect();
+  }
+  async close() {
+    await super.close();
+    await this.mongod?.stop();
+    this.running = false;
+  }
+}
+exports.MongoMemoryDatabase = MongoMemoryDatabase;

package/dist/cjs/databases/captcha.cjs

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const typesDatabase = require("@prosopo/types-database");
+require("../base/index.cjs");
+const mongo = require("../base/mongo.cjs");
+const logger = common.getLoggerDefault();
+var TableNames = /* @__PURE__ */ ((TableNames2) => {
+  TableNames2["frictionlessToken"] = "frictionlessToken";
+  TableNames2["session"] = "session";
+  TableNames2["commitment"] = "commitment";
+  TableNames2["powcaptcha"] = "powcaptcha";
+  return TableNames2;
+})(TableNames || {});
+const CAPTCHA_TABLES = [
+  {
+    collectionName: "session",
+    modelName: "Session",
+    schema: typesDatabase.StoredSessionRecordSchema
+  },
+  {
+    collectionName: "powcaptcha",
+    modelName: "PowCaptcha",
+    schema: typesDatabase.StoredPoWCaptchaRecordSchema
+  },
+  {
+    collectionName: "commitment",
+    modelName: "UserCommitment",
+    schema: typesDatabase.StoredUserCommitmentRecordSchema
+  }
+];
+class CaptchaDatabase extends mongo.MongoDatabase {
+  constructor(url, dbname, authSource, logger2) {
+    super(url, dbname, authSource, logger2);
+    this.tables = {};
+  }
+  async connect() {
+    await super.connect();
+    CAPTCHA_TABLES.map(({ collectionName, modelName, schema }) => {
+      if (this.connection) {
+        this.tables[collectionName] = this.connection.model(modelName, schema);
+      }
+    });
+  }
+  getTables() {
+    if (!this.tables) {
+      throw new common.ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
+        context: { failedFuncName: this.getTables.name },
+        logger: this.logger
+      });
+    }
+    return this.tables;
+  }
+  async saveCaptchas(sessionEvents, imageCaptchaEvents, powCaptchaEvents) {
+    await this.connect();
+    if (sessionEvents.length) {
+      const result = await this.tables.session.bulkWrite(
+        sessionEvents.map((document) => {
+          const { _id, ...safeDoc } = document;
+          return {
+            insertOne: {
+              document: safeDoc
+            }
+          };
+        })
+      );
+      logger.info("Mongo Saved Session Events", result.insertedCount);
+    }
+    if (imageCaptchaEvents.length) {
+      const result = await this.tables.commitment.bulkWrite(
+        imageCaptchaEvents.map((doc) => {
+          const { _id, ...safeDoc } = doc;
+          return {
+            updateOne: {
+              filter: { id: safeDoc.id },
+              update: { $set: safeDoc },
+              upsert: true
+            }
+          };
+        })
+      );
+      logger.info("Mongo Saved Image Events", result.upsertedCount);
+    }
+    if (powCaptchaEvents.length) {
+      const result = await this.tables.powcaptcha.bulkWrite(
+        powCaptchaEvents.map((doc) => {
+          const { _id, ...safeDoc } = doc;
+          return {
+            updateOne: {
+              filter: { challenge: safeDoc.challenge },
+              update: { $set: safeDoc },
+              upsert: true
+            }
+          };
+        })
+      );
+      logger.info("Mongo Saved PoW Events", result.upsertedCount);
+    }
+    await this.close();
+  }
+  async getCaptchas(filter = {}, limit = 100) {
+    await this.connect();
+    try {
+      const commitmentResults = await this.tables.commitment.find(filter).limit(limit).lean();
+      const powCaptchaResults = await this.tables.powcaptcha.find(filter).limit(limit).lean();
+      return {
+        userCommitmentRecords: commitmentResults,
+        powCaptchaRecords: powCaptchaResults
+      };
+    } catch (error) {
+      throw new common.ProsopoDBError("DATABASE.QUERY_ERROR", {
+        context: {
+          error,
+          filter,
+          limit,
+          failedFuncName: this.getCaptchas.name
+        },
+        logger: this.logger
+      });
+    } finally {
+      await this.close();
+    }
+  }
+}
+exports.CaptchaDatabase = CaptchaDatabase;

package/dist/cjs/databases/client.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const typesDatabase = require("@prosopo/types-database");
+require("../base/index.cjs");
+const mongo = require("../base/mongo.cjs");
+const CLIENT_TABLES = [
+  {
+    collectionName: typesDatabase.TableNames.accounts,
+    modelName: "Account",
+    schema: typesDatabase.AccountSchema
+  }
+];
+class ClientDatabase extends mongo.MongoDatabase {
+  constructor(url, dbname, authSource, logger) {
+    super(url, dbname, authSource, logger);
+    this.tables = {};
+  }
+  async connect() {
+    await super.connect();
+    CLIENT_TABLES.map(({ collectionName, modelName, schema }) => {
+      if (this.connection) {
+        this.tables[collectionName] = this.connection.model(modelName, schema);
+      }
+    });
+  }
+  getTables() {
+    if (!this.tables) {
+      throw new common.ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
+        context: { failedFuncName: this.getTables.name },
+        logger: this.logger
+      });
+    }
+    return this.tables;
+  }
+  async getUpdatedClients(updatedAtTimestamp) {
+    await this.connect();
+    const newClientRecords = await this.tables.accounts.find(
+      {
+        $or: [
+          { "sites.updatedAt": { $gt: updatedAtTimestamp } },
+          { "sites.updatedAt": { $exists: false } }
+        ],
+        "users.status": "active"
+      },
+      { "sites.siteKey": 1, "sites.settings": 1, "sites.tier": 1 }
+    ).lean().then(
+      (records) => records.map(
+        (record) => ({
+          account: record.sites.siteKey,
+          // Rename "sites.siteKey" to "account"
+          settings: record.sites.settings,
+          // Rename "sites.settings" to "settings"
+          tier: record.tier
+          // Keep "tier" as is
+        })
+      )
+    );
+    await this.close();
+    return newClientRecords;
+  }
+}
+exports.ClientDatabase = ClientDatabase;

package/dist/cjs/databases/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const mongo = require("../base/mongo.cjs");
+const mongoMemory = require("../base/mongoMemory.cjs");
+const captcha = require("./captcha.cjs");
+const client = require("./client.cjs");
+const provider = require("./provider.cjs");
+const Databases = {
+  [types.DatabaseTypes.Values.mongo]: mongo.MongoDatabase,
+  [types.DatabaseTypes.Values.provider]: provider.ProviderDatabase,
+  [types.DatabaseTypes.Values.client]: client.ClientDatabase,
+  [types.DatabaseTypes.Values.captcha]: captcha.CaptchaDatabase,
+  [types.DatabaseTypes.Values.mongoMemory]: mongoMemory.MongoMemoryDatabase
+};
+exports.CaptchaDatabase = captcha.CaptchaDatabase;
+exports.ClientDatabase = client.ClientDatabase;
+exports.ProviderDatabase = provider.ProviderDatabase;
+exports.Databases = Databases;