@prosopo/database 3.15.18 → 3.15.20

package/dist/databases/captcha.js

@@ -1,258 +1,215 @@
+import { MongoDatabase } from "../base/mongo.js";
 import { ProsopoDBError } from "@prosopo/common";
 import { getLogger } from "@prosopo/logger";
-import { StoredSessionRecordSchema, StoredPoWCaptchaRecordSchema, StoredUserCommitmentRecordSchema, StoredPuzzleCaptchaRecordSchema } from "@prosopo/types-database";
+import { StoredPoWCaptchaRecordSchema, StoredPuzzleCaptchaRecordSchema, StoredSessionRecordSchema, StoredUserCommitmentRecordSchema } from "@prosopo/types-database";
 import { Decimal128, Long } from "bson";
-import "../base/index.js";
-import { MongoDatabase } from "../base/mongo.js";
-const isBsonLong = (value) => typeof value === "object" && value !== null && "_bsontype" in value && value._bsontype === "Long";
-const logger = getLogger("info", "database:captcha");
-var TableNames = /* @__PURE__ */ ((TableNames2) => {
-  TableNames2["frictionlessToken"] = "frictionlessToken";
-  TableNames2["session"] = "session";
-  TableNames2["commitment"] = "commitment";
-  TableNames2["powcaptcha"] = "powcaptcha";
-  TableNames2["puzzlecaptcha"] = "puzzlecaptcha";
-  return TableNames2;
-})(TableNames || {});
-const CAPTCHA_TABLES = [
-  {
-    collectionName: "session",
-    modelName: "Session",
-    schema: StoredSessionRecordSchema
-  },
-  {
-    collectionName: "powcaptcha",
-    modelName: "PowCaptcha",
-    schema: StoredPoWCaptchaRecordSchema
-  },
-  {
-    collectionName: "commitment",
-    modelName: "UserCommitment",
-    schema: StoredUserCommitmentRecordSchema
-  },
-  {
-    collectionName: "puzzlecaptcha",
-    modelName: "PuzzleCaptcha",
-    schema: StoredPuzzleCaptchaRecordSchema
-  }
+//#region src/databases/captcha.ts
+var isBsonLong = (value) => typeof value === "object" && value !== null && "_bsontype" in value && value._bsontype === "Long";
+var logger = getLogger("info", "database:captcha");
+var CAPTCHA_TABLES = [
+	{
+		collectionName: "session",
+		modelName: "Session",
+		schema: StoredSessionRecordSchema
+	},
+	{
+		collectionName: "powcaptcha",
+		modelName: "PowCaptcha",
+		schema: StoredPoWCaptchaRecordSchema
+	},
+	{
+		collectionName: "commitment",
+		modelName: "UserCommitment",
+		schema: StoredUserCommitmentRecordSchema
+	},
+	{
+		collectionName: "puzzlecaptcha",
+		modelName: "PuzzleCaptcha",
+		schema: StoredPuzzleCaptchaRecordSchema
+	}
 ];
-class CaptchaDatabase extends MongoDatabase {
-  constructor(url, dbname, authSource, logger2) {
-    super(url, dbname, authSource, logger2);
-    this.indexesEnsured = false;
-    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
-      });
-    }
-    return this.tables;
-  }
-  async ensureIndexes() {
-    const indexPromises = [];
-    if (!this.indexesEnsured) {
-      CAPTCHA_TABLES.map(({ collectionName }) => {
-        indexPromises.push(
-          new Promise((resolve) => {
-            if (this.connected) {
-              this.tables[collectionName].collection.dropIndexes().then(() => {
-                this.tables[collectionName].ensureIndexes().then(() => {
-                  resolve();
-                }).catch((err) => {
-                  this.logger.warn(() => ({
-                    err,
-                    msg: `Error creating indexes for collection ${collectionName}`
-                  }));
-                  resolve();
-                });
-              });
-            } else {
-              this.logger.info(() => ({
-                msg: `Skipping index creation for collection ${collectionName} as not connected`
-              }));
-              resolve();
-            }
-          })
-        );
-      });
-    }
-    await Promise.all(indexPromises);
-    this.indexesEnsured = true;
-  }
-  /**
-   * Convert a BSON `Long` (which Mongoose's Decimal128 caster rejects)
-   * into a Decimal128 with the *unsigned* numeric value — so a Long
-   * representing an IPv6 lower half with bit 63 set (signed Long shows
-   * as a negative integer) converts to a positive Decimal128 that
-   * matches what `bigint→string→Decimal128` would have produced if the
-   * schema setter had run on the original write.
-   *
-   * Production background: pipeline-form updates (`updateOne(filter,
-   * [{ $set: ... }])`) bypass Mongoose schema casting, so a `bigint`
-   * passed for an IP half is serialised by the driver as BSON Int64
-   * (Long) instead of going through the `Decimal128` setter. The
-   * central-streaming sweep below reads those docs via `.lean()` and
-   * tries to replay them with `bulkWrite`, but `bulkWrite` also skips
-   * setters — so the cast fires raw and throws. Normalising the lean
-   * doc here is the only place that's guaranteed to run before the
-   * bulkWrite sees it.
-   */
-  static normaliseCompositeIp(ip) {
-    if (!ip) return ip;
-    const normaliseHalf = (v) => {
-      if (isBsonLong(v)) {
-        const lng = v;
-        return Decimal128.fromString(
-          Long.fromBits(lng.low, lng.high, true).toString()
-        );
-      }
-      return v;
-    };
-    return {
-      ...ip,
-      lower: normaliseHalf(ip.lower),
-      upper: normaliseHalf(ip.upper)
-    };
-  }
-  static normaliseDocCompositeIps(doc) {
-    return {
-      ...doc,
-      ipAddress: CaptchaDatabase.normaliseCompositeIp(doc.ipAddress),
-      providedIp: CaptchaDatabase.normaliseCompositeIp(doc.providedIp)
-    };
-  }
-  async saveCaptchas(sessionEvents, imageCaptchaEvents, powCaptchaEvents, puzzleCaptchaEvents = []) {
-    await this.connect();
-    if (sessionEvents.length) {
-      const result = await this.tables.session.bulkWrite(
-        sessionEvents.map((document) => {
-          const { _id, ...safeDoc } = document;
-          return {
-            insertOne: {
-              document: CaptchaDatabase.normaliseDocCompositeIps(safeDoc)
-            }
-          };
-        })
-      );
-      logger.info(() => ({
-        data: {
-          insertedCount: result.insertedCount,
-          totalProcessed: sessionEvents.length
-        },
-        msg: "Mongo Saved Session Events"
-      }));
-    }
-    if (imageCaptchaEvents.length) {
-      const result = await this.tables.commitment.bulkWrite(
-        imageCaptchaEvents.map((doc) => {
-          const { _id, ...safeDoc } = doc;
-          const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
-          return {
-            updateOne: {
-              filter: { id: normalised.id },
-              update: { $set: normalised },
-              upsert: true
-            }
-          };
-        })
-      );
-      logger.info(() => ({
-        data: {
-          upsertedCount: result.upsertedCount,
-          matchedCount: result.matchedCount,
-          modifiedCount: result.modifiedCount,
-          totalProcessed: imageCaptchaEvents.length
-        },
-        msg: "Mongo Saved Image Events"
-      }));
-    }
-    if (powCaptchaEvents.length) {
-      const result = await this.tables.powcaptcha.bulkWrite(
-        powCaptchaEvents.map((doc) => {
-          const { _id, ...safeDoc } = doc;
-          const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
-          return {
-            updateOne: {
-              filter: { challenge: normalised.challenge },
-              update: { $set: normalised },
-              upsert: true
-            }
-          };
-        })
-      );
-      logger.info(() => ({
-        data: {
-          upsertedCount: result.upsertedCount,
-          matchedCount: result.matchedCount,
-          modifiedCount: result.modifiedCount,
-          totalProcessed: powCaptchaEvents.length
-        },
-        msg: "Mongo Saved PoW Events"
-      }));
-    }
-    if (puzzleCaptchaEvents.length) {
-      const result = await this.tables.puzzlecaptcha.bulkWrite(
-        puzzleCaptchaEvents.map((doc) => {
-          const { _id, ...safeDoc } = doc;
-          const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
-          return {
-            updateOne: {
-              filter: { challenge: normalised.challenge },
-              update: { $set: normalised },
-              upsert: true
-            }
-          };
-        })
-      );
-      logger.info(() => ({
-        data: {
-          upsertedCount: result.upsertedCount,
-          matchedCount: result.matchedCount,
-          modifiedCount: result.modifiedCount,
-          totalProcessed: puzzleCaptchaEvents.length
-        },
-        msg: "Mongo Saved Puzzle Events"
-      }));
-    }
-    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();
-      const puzzleCaptchaResults = await this.tables.puzzlecaptcha.find(filter).limit(limit).lean();
-      return {
-        userCommitmentRecords: commitmentResults,
-        powCaptchaRecords: powCaptchaResults,
-        puzzleCaptchaRecords: puzzleCaptchaResults
-      };
-    } catch (error) {
-      throw new ProsopoDBError("DATABASE.QUERY_ERROR", {
-        context: {
-          error,
-          filter,
-          limit,
-          failedFuncName: this.getCaptchas.name
-        },
-        logger: this.logger
-      });
-    } finally {
-      await this.close();
-    }
-  }
-}
-export {
-  CaptchaDatabase
+var CaptchaDatabase = class CaptchaDatabase extends MongoDatabase {
+	constructor(url, dbname, authSource, logger) {
+		super(url, dbname, authSource, logger);
+		this.indexesEnsured = false;
+		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
+		});
+		return this.tables;
+	}
+	async ensureIndexes() {
+		const indexPromises = [];
+		if (!this.indexesEnsured) CAPTCHA_TABLES.map(({ collectionName }) => {
+			indexPromises.push(new Promise((resolve) => {
+				if (this.connected) this.tables[collectionName].collection.dropIndexes().then(() => {
+					this.tables[collectionName].ensureIndexes().then(() => {
+						resolve();
+					}).catch((err) => {
+						this.logger.warn(() => ({
+							err,
+							msg: `Error creating indexes for collection ${collectionName}`
+						}));
+						resolve();
+					});
+				});
+				else {
+					this.logger.info(() => ({ msg: `Skipping index creation for collection ${collectionName} as not connected` }));
+					resolve();
+				}
+			}));
+		});
+		await Promise.all(indexPromises);
+		this.indexesEnsured = true;
+	}
+	/**
+	* Convert a BSON `Long` (which Mongoose's Decimal128 caster rejects)
+	* into a Decimal128 with the *unsigned* numeric value — so a Long
+	* representing an IPv6 lower half with bit 63 set (signed Long shows
+	* as a negative integer) converts to a positive Decimal128 that
+	* matches what `bigint→string→Decimal128` would have produced if the
+	* schema setter had run on the original write.
+	*
+	* Production background: pipeline-form updates (`updateOne(filter,
+	* [{ $set: ... }])`) bypass Mongoose schema casting, so a `bigint`
+	* passed for an IP half is serialised by the driver as BSON Int64
+	* (Long) instead of going through the `Decimal128` setter. The
+	* central-streaming sweep below reads those docs via `.lean()` and
+	* tries to replay them with `bulkWrite`, but `bulkWrite` also skips
+	* setters — so the cast fires raw and throws. Normalising the lean
+	* doc here is the only place that's guaranteed to run before the
+	* bulkWrite sees it.
+	*/
+	static normaliseCompositeIp(ip) {
+		if (!ip) return ip;
+		const normaliseHalf = (v) => {
+			if (isBsonLong(v)) {
+				const lng = v;
+				return Decimal128.fromString(Long.fromBits(lng.low, lng.high, true).toString());
+			}
+			return v;
+		};
+		return {
+			...ip,
+			lower: normaliseHalf(ip.lower),
+			upper: normaliseHalf(ip.upper)
+		};
+	}
+	static normaliseDocCompositeIps(doc) {
+		return {
+			...doc,
+			ipAddress: CaptchaDatabase.normaliseCompositeIp(doc.ipAddress),
+			providedIp: CaptchaDatabase.normaliseCompositeIp(doc.providedIp)
+		};
+	}
+	async saveCaptchas(sessionEvents, imageCaptchaEvents, powCaptchaEvents, puzzleCaptchaEvents = []) {
+		await this.connect();
+		if (sessionEvents.length) {
+			const result = await this.tables.session.bulkWrite(sessionEvents.map((document) => {
+				const { _id, ...safeDoc } = document;
+				return { insertOne: { document: CaptchaDatabase.normaliseDocCompositeIps(safeDoc) } };
+			}));
+			logger.info(() => ({
+				data: {
+					insertedCount: result.insertedCount,
+					totalProcessed: sessionEvents.length
+				},
+				msg: "Mongo Saved Session Events"
+			}));
+		}
+		if (imageCaptchaEvents.length) {
+			const result = await this.tables.commitment.bulkWrite(imageCaptchaEvents.map((doc) => {
+				const { _id, ...safeDoc } = doc;
+				const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
+				return { updateOne: {
+					filter: { id: normalised.id },
+					update: { $set: normalised },
+					upsert: true
+				} };
+			}));
+			logger.info(() => ({
+				data: {
+					upsertedCount: result.upsertedCount,
+					matchedCount: result.matchedCount,
+					modifiedCount: result.modifiedCount,
+					totalProcessed: imageCaptchaEvents.length
+				},
+				msg: "Mongo Saved Image Events"
+			}));
+		}
+		if (powCaptchaEvents.length) {
+			const result = await this.tables.powcaptcha.bulkWrite(powCaptchaEvents.map((doc) => {
+				const { _id, ...safeDoc } = doc;
+				const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
+				return { updateOne: {
+					filter: { challenge: normalised.challenge },
+					update: { $set: normalised },
+					upsert: true
+				} };
+			}));
+			logger.info(() => ({
+				data: {
+					upsertedCount: result.upsertedCount,
+					matchedCount: result.matchedCount,
+					modifiedCount: result.modifiedCount,
+					totalProcessed: powCaptchaEvents.length
+				},
+				msg: "Mongo Saved PoW Events"
+			}));
+		}
+		if (puzzleCaptchaEvents.length) {
+			const result = await this.tables.puzzlecaptcha.bulkWrite(puzzleCaptchaEvents.map((doc) => {
+				const { _id, ...safeDoc } = doc;
+				const normalised = CaptchaDatabase.normaliseDocCompositeIps(safeDoc);
+				return { updateOne: {
+					filter: { challenge: normalised.challenge },
+					update: { $set: normalised },
+					upsert: true
+				} };
+			}));
+			logger.info(() => ({
+				data: {
+					upsertedCount: result.upsertedCount,
+					matchedCount: result.matchedCount,
+					modifiedCount: result.modifiedCount,
+					totalProcessed: puzzleCaptchaEvents.length
+				},
+				msg: "Mongo Saved Puzzle Events"
+			}));
+		}
+		await this.close();
+	}
+	async getCaptchas(filter = {}, limit = 100) {
+		await this.connect();
+		try {
+			return {
+				userCommitmentRecords: await this.tables.commitment.find(filter).limit(limit).lean(),
+				powCaptchaRecords: await this.tables.powcaptcha.find(filter).limit(limit).lean(),
+				puzzleCaptchaRecords: await this.tables.puzzlecaptcha.find(filter).limit(limit).lean()
+			};
+		} catch (error) {
+			throw new ProsopoDBError("DATABASE.QUERY_ERROR", {
+				context: {
+					error,
+					filter,
+					limit,
+					failedFuncName: this.getCaptchas.name
+				},
+				logger: this.logger
+			});
+		} finally {
+			await this.close();
+		}
+	}
 };
+//#endregion
+export { CaptchaDatabase };