@prosopo/database 3.0.9 → 3.0.10

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @prosopo/database
 
+## 3.0.10
+### Patch Changes
+
+- 3573f0b: fix npm scripts bundle command
+- 3573f0b: build using vite, typecheck using tsc
+- efd8102: Add tests for unwrap error helper
+- 3573f0b: standardise all vite based npm scripts for bundling
+- Updated dependencies [93d5e50]
+- Updated dependencies [3573f0b]
+- Updated dependencies [3573f0b]
+- Updated dependencies [efd8102]
+- Updated dependencies [93d5e50]
+- Updated dependencies [63519d7]
+- Updated dependencies [f29fc7e]
+- Updated dependencies [3573f0b]
+- Updated dependencies [2d0dd8a]
+  - @prosopo/types@3.0.4
+  - @prosopo/user-access-policy@3.3.1
+  - @prosopo/types-database@3.0.10
+  - @prosopo/common@3.1.0
+  - @prosopo/config@3.1.1
+
 ## 3.0.9
 ### Patch Changes
 

package/dist/base/index.js

@@ -1,3 +1,6 @@
-export * from "./mongo.js";
-export * from "./mongoMemory.js";
-//# sourceMappingURL=index.js.map
+import { MongoDatabase } from "./mongo.js";
+import { MongoMemoryDatabase } from "./mongoMemory.js";
+export {
+  MongoDatabase,
+  MongoMemoryDatabase
+};

package/dist/base/mongo.js

@@ -1,129 +1,134 @@
-import { ProsopoDBError, getLogger } from "@prosopo/common";
+import { getLogger, ProsopoDBError } from "@prosopo/common";
 import { ServerApiVersion } from "mongodb";
 import mongoose from "mongoose";
 mongoose.set("strictQuery", false);
 const DEFAULT_ENDPOINT = "mongodb://127.0.0.1:27017";
-export 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 || getLogger("info", import.meta.url);
+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;
     }
-    get url() {
-        return this._url;
+    if (authSource) {
+      parsedUrl.searchParams.set("authSource", authSource);
     }
-    getConnection() {
-        if (!this.connection) {
-            throw new ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
-                context: { failedFuncName: this.getConnection.name },
-                logger: this.logger,
-            });
-        }
-        return this.connection;
+    this._url = parsedUrl.toString();
+    this.safeURL = this.url.replace(/\w+:\w+/, "<Credentials>");
+    this.dbname = dbname || parsedUrl.pathname.replace("/", "");
+    this.logger = logger || getLogger("info", import.meta.url);
+  }
+  get url() {
+    return this._url;
+  }
+  getConnection() {
+    if (!this.connection) {
+      throw new ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
+        context: { failedFuncName: this.getConnection.name },
+        logger: this.logger
+      });
     }
-    async connect() {
+    return this.connection;
+  }
+  /**
+   * @description Connect to the database and set the various tables
+   */
+  async connect() {
+    this.logger.info(() => ({
+      data: { mongoUrl: this.safeURL },
+      msg: "Connecting to database"
+    }));
+    try {
+      if (this.connected) {
         this.logger.info(() => ({
-            data: { mongoUrl: this.safeURL },
-            msg: "Connecting to database",
+          data: { mongoUrl: this.safeURL },
+          msg: "Database connection already open"
         }));
-        try {
-            if (this.connected) {
-                this.logger.info(() => ({
-                    data: { mongoUrl: this.safeURL },
-                    msg: "Database connection already open",
-                }));
-                return;
-            }
-            if (this.connecting) {
-                this.logger.info(() => ({
-                    data: { mongoUrl: this.safeURL },
-                    msg: "Database connection in progress, waiting for it to finish",
-                }));
-                return this.connecting;
-            }
-            this.connecting = new Promise((resolve, reject) => {
-                const connection = mongoose.createConnection(this.url, {
-                    dbName: this.dbname,
-                    serverApi: ServerApiVersion.v1,
-                });
-                const onConnected = () => {
-                    this.logger.info(() => ({
-                        data: { mongoUrl: this.safeURL },
-                        msg: "Database connection opened",
-                    }));
-                    this.connected = true;
-                    this.connection = connection;
-                    this.connecting = undefined;
-                    resolve();
-                };
-                const onError = (err) => {
-                    this.logger.error(() => ({
-                        err,
-                        data: { mongoUrl: this.safeURL },
-                        msg: "Database error",
-                    }));
-                    this.connected = false;
-                    this.connecting = undefined;
-                    reject(err);
-                };
-                connection.once("open", onConnected);
-                connection.once("error", onError);
-                connection.on("disconnected", () => {
-                    this.connected = false;
-                    this.logger.info(() => ({
-                        data: { mongoUrl: this.safeURL },
-                        msg: "Database disconnected",
-                    }));
-                });
-                connection.on("reconnected", () => {
-                    this.connected = true;
-                    this.logger.info(() => ({
-                        data: { mongoUrl: this.safeURL },
-                        msg: "Database reconnected",
-                    }));
-                });
-                connection.on("close", () => {
-                    this.connected = false;
-                    this.logger.info(() => ({
-                        data: { mongoUrl: this.safeURL },
-                        msg: "Database connection closed",
-                    }));
-                });
-                connection.on("fullsetup", () => {
-                    this.connected = true;
-                    this.logger.info(() => ({
-                        data: { mongoUrl: this.safeURL },
-                        msg: "Database connection is fully setup",
-                    }));
-                });
-            });
-            return this.connecting;
-        }
-        catch (e) {
-            this.logger.error(() => ({
-                err: e,
-                data: { mongoUrl: this.safeURL },
-                msg: "Database connection error",
-            }));
-            throw e;
-        }
-    }
-    async close() {
-        this.logger.debug(() => ({
-            data: { mongoUrl: this.safeURL },
-            msg: "Closing connection",
+        return;
+      }
+      if (this.connecting) {
+        this.logger.info(() => ({
+          data: { mongoUrl: this.safeURL },
+          msg: "Database connection in progress, waiting for it to finish"
         }));
-        await this.connection?.close();
+        return this.connecting;
+      }
+      this.connecting = new Promise((resolve, reject) => {
+        const connection = mongoose.createConnection(this.url, {
+          dbName: this.dbname,
+          serverApi: ServerApiVersion.v1
+        });
+        const onConnected = () => {
+          this.logger.info(() => ({
+            data: { mongoUrl: this.safeURL },
+            msg: "Database connection opened"
+          }));
+          this.connected = true;
+          this.connection = connection;
+          this.connecting = void 0;
+          resolve();
+        };
+        const onError = (err) => {
+          this.logger.error(() => ({
+            err,
+            data: { mongoUrl: this.safeURL },
+            msg: "Database error"
+          }));
+          this.connected = false;
+          this.connecting = void 0;
+          reject(err);
+        };
+        connection.once("open", onConnected);
+        connection.once("error", onError);
+        connection.on("disconnected", () => {
+          this.connected = false;
+          this.logger.info(() => ({
+            data: { mongoUrl: this.safeURL },
+            msg: "Database disconnected"
+          }));
+        });
+        connection.on("reconnected", () => {
+          this.connected = true;
+          this.logger.info(() => ({
+            data: { mongoUrl: this.safeURL },
+            msg: "Database reconnected"
+          }));
+        });
+        connection.on("close", () => {
+          this.connected = false;
+          this.logger.info(() => ({
+            data: { mongoUrl: this.safeURL },
+            msg: "Database connection closed"
+          }));
+        });
+        connection.on("fullsetup", () => {
+          this.connected = true;
+          this.logger.info(() => ({
+            data: { mongoUrl: this.safeURL },
+            msg: "Database connection is fully setup"
+          }));
+        });
+      });
+      return this.connecting;
+    } catch (e) {
+      this.logger.error(() => ({
+        err: e,
+        data: { mongoUrl: this.safeURL },
+        msg: "Database connection error"
+      }));
+      throw e;
     }
+  }
+  /** Close connection to the database */
+  async close() {
+    this.logger.debug(() => ({
+      data: { mongoUrl: this.safeURL },
+      msg: "Closing connection"
+    }));
+    await this.connection?.close();
+  }
 }
-//# sourceMappingURL=mongo.js.map
+export {
+  MongoDatabase
+};

package/dist/base/mongoMemory.js

@@ -1,27 +1,28 @@
 import { MongoMemoryServer } from "mongodb-memory-server";
 import { MongoDatabase } from "./mongo.js";
-export class MongoMemoryDatabase extends MongoDatabase {
-    constructor(url, dbname, logger, authSource) {
-        const mongod = new 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;
+class MongoMemoryDatabase extends MongoDatabase {
+  constructor(url, dbname, logger, authSource) {
+    const mongod = new 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;
+  }
 }
-//# sourceMappingURL=mongoMemory.js.map
+export {
+  MongoMemoryDatabase
+};

package/dist/databases/captcha.js

@@ -1,133 +1,134 @@
-import { ProsopoDBError, getLogger } from "@prosopo/common";
-import { StoredPoWCaptchaRecordSchema, StoredSessionRecordSchema, StoredUserCommitmentRecordSchema, } from "@prosopo/types-database";
-import { MongoDatabase } from "../base/index.js";
+import { getLogger, ProsopoDBError } from "@prosopo/common";
+import { StoredSessionRecordSchema, StoredPoWCaptchaRecordSchema, StoredUserCommitmentRecordSchema } from "@prosopo/types-database";
+import "../base/index.js";
+import { MongoDatabase } from "../base/mongo.js";
 const logger = getLogger("info", import.meta.url);
-var TableNames;
-(function (TableNames) {
-    TableNames["frictionlessToken"] = "frictionlessToken";
-    TableNames["session"] = "session";
-    TableNames["commitment"] = "commitment";
-    TableNames["powcaptcha"] = "powcaptcha";
-})(TableNames || (TableNames = {}));
+var TableNames = /* @__PURE__ */ ((TableNames2) => {
+  TableNames2["frictionlessToken"] = "frictionlessToken";
+  TableNames2["session"] = "session";
+  TableNames2["commitment"] = "commitment";
+  TableNames2["powcaptcha"] = "powcaptcha";
+  return TableNames2;
+})(TableNames || {});
 const CAPTCHA_TABLES = [
-    {
-        collectionName: TableNames.session,
-        modelName: "Session",
-        schema: StoredSessionRecordSchema,
-    },
-    {
-        collectionName: TableNames.powcaptcha,
-        modelName: "PowCaptcha",
-        schema: StoredPoWCaptchaRecordSchema,
-    },
-    {
-        collectionName: TableNames.commitment,
-        modelName: "UserCommitment",
-        schema: StoredUserCommitmentRecordSchema,
-    },
+  {
+    collectionName: "session",
+    modelName: "Session",
+    schema: StoredSessionRecordSchema
+  },
+  {
+    collectionName: "powcaptcha",
+    modelName: "PowCaptcha",
+    schema: StoredPoWCaptchaRecordSchema
+  },
+  {
+    collectionName: "commitment",
+    modelName: "UserCommitment",
+    schema: StoredUserCommitmentRecordSchema
+  }
 ];
-export class CaptchaDatabase extends MongoDatabase {
-    constructor(url, dbname, authSource, logger) {
-        super(url, dbname, authSource, logger);
-        this.tables = {};
+class CaptchaDatabase extends 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 ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
+        context: { failedFuncName: this.getTables.name },
+        logger: this.logger
+      });
     }
-    async connect() {
-        await super.connect();
-        CAPTCHA_TABLES.map(({ collectionName, modelName, schema }) => {
-            if (this.connection) {
-                this.tables[collectionName] = this.connection.model(modelName, schema);
+    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(() => ({
+        data: { insertedCount: result.insertedCount },
+        msg: "Mongo Saved Session Events"
+      }));
     }
-    getTables() {
-        if (!this.tables) {
-            throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
-                context: { failedFuncName: this.getTables.name },
-                logger: this.logger,
-            });
-        }
-        return this.tables;
+    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(() => ({
+        data: { upsertedCount: result.upsertedCount },
+        msg: "Mongo Saved Image Events"
+      }));
     }
-    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(() => ({
-                data: { insertedCount: result.insertedCount },
-                msg: "Mongo Saved Session Events",
-            }));
-        }
-        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(() => ({
-                data: { upsertedCount: result.upsertedCount },
-                msg: "Mongo Saved Image Events",
-            }));
-        }
-        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(() => ({
-                data: { upsertedCount: result.upsertedCount },
-                msg: "Mongo Saved PoW Events",
-            }));
-        }
-        await this.close();
+    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(() => ({
+        data: { upsertedCount: result.upsertedCount },
+        msg: "Mongo Saved PoW Events"
+      }));
     }
-    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 ProsopoDBError("DATABASE.QUERY_ERROR", {
-                context: {
-                    error,
-                    filter,
-                    limit,
-                    failedFuncName: this.getCaptchas.name,
-                },
-                logger: this.logger,
-            });
-        }
-        finally {
-            await this.close();
-        }
+    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 ProsopoDBError("DATABASE.QUERY_ERROR", {
+        context: {
+          error,
+          filter,
+          limit,
+          failedFuncName: this.getCaptchas.name
+        },
+        logger: this.logger
+      });
+    } finally {
+      await this.close();
     }
+  }
 }
-//# sourceMappingURL=captcha.js.map
+export {
+  CaptchaDatabase
+};