@prosopo/types-database 3.0.13 → 3.3.13

package/dist/cjs/types/provider.cjs

@@ -16,6 +16,40 @@ const ClientRecordSchema = new mongoose.Schema({
   tier: { type: String, enum: types.Tier, required: true }
 });
 ClientRecordSchema.index({ account: 1 });
+var IpAddressType = /* @__PURE__ */ ((IpAddressType2) => {
+  IpAddressType2["v4"] = "v4";
+  IpAddressType2["v6"] = "v6";
+  return IpAddressType2;
+})(IpAddressType || {});
+const CompositeIpAddressSchema = zod.object({
+  lower: zod.bigint(),
+  upper: zod.bigint().optional(),
+  type: zod.nativeEnum(IpAddressType)
+});
+const CompositeIpAddressRecordSchemaObj = {
+  lower: {
+    // INT64 isn't enough capable - it reserves extra bits for the sign bit, etc, so Decimal128 guarantees no overflow
+    type: mongoose.Schema.Types.Decimal128,
+    required: true,
+    // without casting to string Mongoose not able to set bigint to Decimal128
+    set: (value) => "bigint" === typeof value ? value.toString() : value
+  },
+  upper: {
+    // INT64 isn't enough capable - it reserves extra bits for the sign bit, etc, so Decimal128 guarantees no overflow
+    type: mongoose.Schema.Types.Decimal128,
+    required: false,
+    // without casting to string Mongoose not able to set bigint to Decimal128
+    set: (value) => "bigint" === typeof value ? value.toString() : value
+  },
+  type: { type: String, enum: IpAddressType, required: true }
+};
+const parseMongooseCompositeIpAddress = (ip) => {
+  return {
+    lower: BigInt(ip.lower.$numberDecimal ?? ip.lower),
+    upper: ip.upper ? BigInt(ip.upper?.$numberDecimal ?? ip.upper) : void 0,
+    type: ip.type
+  };
+};
 const CaptchaResultSchema = zod.object({
   status: zod.nativeEnum(types.CaptchaStatus),
   reason: locale.TranslationKeysSchema.optional(),
@@ -29,18 +63,17 @@ const UserCommitmentSchema = zod.object({
   id: zod.string(),
   result: CaptchaResultSchema,
   userSignature: zod.string(),
-  ipAddress: zod.bigint(),
+  ipAddress: CompositeIpAddressSchema,
+  providedIp: CompositeIpAddressSchema.optional(),
   headers: zod.object({}).catchall(zod.string()),
   ja4: zod.string(),
   userSubmitted: zod.boolean(),
   serverChecked: zod.boolean(),
-  storedAtTimestamp: types.TimestampSchema.optional(),
-  requestedAtTimestamp: types.TimestampSchema,
-  lastUpdatedTimestamp: types.TimestampSchema.optional(),
-  frictionlessTokenId: zod.union([
-    zod.string(),
-    zod.instanceof(mongoose.Types.ObjectId)
-  ]).optional()
+  storedAtTimestamp: zod.date().optional(),
+  requestedAtTimestamp: zod.date(),
+  lastUpdatedTimestamp: zod.date().optional(),
+  sessionId: zod.string().optional(),
+  coords: zod.array(zod.array(zod.array(zod.number()))).optional()
 });
 const CaptchaRecordSchema = new mongoose.Schema({
   captchaId: { type: String, required: true },
@@ -72,8 +105,8 @@ const PoWCaptchaRecordSchema = new mongoose.Schema({
   challenge: { type: String, required: true },
   dappAccount: { type: String, required: true },
   userAccount: { type: String, required: true },
-  requestedAtTimestamp: { type: Number, required: true },
-  lastUpdatedTimestamp: { type: Number, required: false },
+  requestedAtTimestamp: { type: Date, required: true },
+  lastUpdatedTimestamp: { type: Date, required: false },
   result: {
     status: { type: String, enum: types.CaptchaStatus, required: true },
     reason: {
@@ -84,7 +117,11 @@ const PoWCaptchaRecordSchema = new mongoose.Schema({
     error: { type: String, required: false }
   },
   difficulty: { type: Number, required: true },
-  ipAddress: { type: BigInt, required: true },
+  ipAddress: CompositeIpAddressRecordSchemaObj,
+  providedIp: {
+    type: new mongoose.Schema(CompositeIpAddressRecordSchemaObj, { _id: false }),
+    required: false
+  },
   headers: { type: Object, required: true },
   ja4: { type: String, required: true },
   userSignature: { type: String, required: false },
@@ -94,15 +131,17 @@ const PoWCaptchaRecordSchema = new mongoose.Schema({
   geolocation: { type: String, required: false },
   vpn: { type: Boolean, required: false },
   parsedUserAgentInfo: { type: Object, required: false },
-  frictionlessTokenId: {
-    type: mongoose.Schema.Types.ObjectId,
+  sessionId: {
+    type: String,
     required: false
-  }
+  },
+  coords: { type: [[[Number]]], required: false }
 });
 PoWCaptchaRecordSchema.index({ challenge: 1 });
-PoWCaptchaRecordSchema.index({ storedAtTimestamp: 1 });
 PoWCaptchaRecordSchema.index({ storedAtTimestamp: 1, lastUpdatedTimestamp: 1 });
 PoWCaptchaRecordSchema.index({ dappAccount: 1, requestedAtTimestamp: 1 });
+PoWCaptchaRecordSchema.index({ "ipAddress.lower": 1 });
+PoWCaptchaRecordSchema.index({ "ipAddress.upper": 1 });
 const UserCommitmentRecordSchema = new mongoose.Schema({
   userAccount: { type: String, required: true },
   dappAccount: { type: String, required: true },
@@ -118,30 +157,36 @@ const UserCommitmentRecordSchema = new mongoose.Schema({
     },
     error: { type: String, required: false }
   },
-  ipAddress: { type: BigInt, required: true },
+  ipAddress: CompositeIpAddressRecordSchemaObj,
+  providedIp: {
+    type: new mongoose.Schema(CompositeIpAddressRecordSchemaObj, { _id: false }),
+    required: false
+  },
   headers: { type: Object, required: true },
   ja4: { type: String, required: true },
   userSignature: { type: String, required: true },
   userSubmitted: { type: Boolean, required: true },
   serverChecked: { type: Boolean, required: true },
-  storedAtTimestamp: { type: Number, required: false },
-  requestedAtTimestamp: { type: Number, required: true },
-  lastUpdatedTimestamp: { type: Number, required: false },
+  storedAtTimestamp: { type: Date, required: false, expires: ONE_MONTH },
+  requestedAtTimestamp: { type: Date, required: true },
+  lastUpdatedTimestamp: { type: Date, required: false },
   geolocation: { type: String, required: false },
   vpn: { type: Boolean, required: false },
   parsedUserAgentInfo: { type: Object, required: false },
-  frictionlessTokenId: {
-    type: mongoose.Schema.Types.ObjectId,
+  sessionId: {
+    type: String,
     required: false
-  }
+  },
+  coords: { type: [[[Number]]], required: false }
 });
 UserCommitmentRecordSchema.index({ id: -1 });
-UserCommitmentRecordSchema.index({ storedAtTimestamp: 1 });
 UserCommitmentRecordSchema.index({
   storedAtTimestamp: 1,
   lastUpdatedTimestamp: 1
 });
 UserCommitmentRecordSchema.index({ userAccount: 1, dappAccount: 1 });
+UserCommitmentRecordSchema.index({ "ipAddress.lower": 1 });
+UserCommitmentRecordSchema.index({ "ipAddress.upper": 1 });
 const DatasetRecordSchema = new mongoose.Schema({
   contentTree: { type: [[String]], required: true },
   datasetContentId: { type: String, required: true },
@@ -162,7 +207,8 @@ SolutionRecordSchema.index({ captchaId: 1 });
 const UserSolutionSchema = types.CaptchaSolutionSchema.extend({
   processed: zod.boolean(),
   checked: zod.boolean(),
-  commitmentId: zod.string()
+  commitmentId: zod.string(),
+  createdAt: zod.date()
 });
 const UserSolutionRecordSchema = new mongoose.Schema(
   {
@@ -172,7 +218,8 @@ const UserSolutionRecordSchema = new mongoose.Schema(
     solution: [{ type: String, required: true }],
     processed: { type: Boolean, required: true },
     checked: { type: Boolean, required: true },
-    commitmentId: { type: String, required: true }
+    commitmentId: { type: String, required: true },
+    createdAt: { type: Date, default: Date.now, expires: ONE_MONTH }
   },
   { _id: false }
 );
@@ -189,9 +236,9 @@ const PendingRecordSchema = new mongoose.Schema({
   deadlineTimestamp: { type: Number, required: true },
   // unix timestamp
   requestedAtTimestamp: { type: Date, required: true, expires: ONE_WEEK },
-  ipAddress: { type: BigInt, required: true },
-  frictionlessTokenId: {
-    type: mongoose.Schema.Types.ObjectId,
+  ipAddress: CompositeIpAddressRecordSchemaObj,
+  sessionId: {
+    type: String,
     required: false
   },
   threshold: { type: Number, required: true, default: 0.8 }
@@ -199,8 +246,8 @@ const PendingRecordSchema = new mongoose.Schema({
 PendingRecordSchema.index({ requestHash: -1 });
 const ScheduledTaskSchema = zod.object({
   processName: zod.nativeEnum(types.ScheduledTaskNames),
-  datetime: types.TimestampSchema,
-  updated: types.TimestampSchema.optional(),
+  datetime: zod.date(),
+  updated: zod.date().optional(),
   status: zod.nativeEnum(types.ScheduledTaskStatus),
   result: zod.object({
     data: zod.any().optional(),
@@ -210,7 +257,7 @@ const ScheduledTaskSchema = zod.object({
 const ScheduledTaskRecordSchema = new mongoose.Schema({
   processName: { type: String, enum: types.ScheduledTaskNames, required: true },
   datetime: { type: Date, required: true, expires: ONE_WEEK },
-  updated: { type: Number, required: false },
+  updated: { type: Date, required: false },
   status: { type: String, enum: types.ScheduledTaskStatus, required: true },
   result: {
     type: new mongoose.Schema(
@@ -226,7 +273,9 @@ const ScheduledTaskRecordSchema = new mongoose.Schema({
 ScheduledTaskRecordSchema.index({ processName: 1 });
 ScheduledTaskRecordSchema.index({ processName: 1, status: 1 });
 ScheduledTaskRecordSchema.index({ _id: 1, status: 1 });
-const FrictionlessTokenRecordSchema = new mongoose.Schema({
+const SessionRecordSchema = new mongoose.Schema({
+  sessionId: { type: String, required: true },
+  createdAt: { type: Date, required: true },
   token: { type: String, required: true, unique: true },
   score: { type: Number, required: true },
   threshold: { type: Number, required: true },
@@ -234,40 +283,41 @@ const FrictionlessTokenRecordSchema = new mongoose.Schema({
     baseScore: { type: Number, required: true },
     lScore: { type: Number, required: false },
     timeout: { type: Number, required: false },
-    accessPolicy: { type: Number, required: false }
-  },
-  createdAt: { type: Date, default: Date.now, expires: ONE_DAY },
-  storedAtTimestamp: { type: Date, required: false },
-  lastUpdatedTimestamp: { type: Date, required: false }
-});
-FrictionlessTokenRecordSchema.index({ token: 1 }, { unique: true });
-FrictionlessTokenRecordSchema.index({ storedAtTimestamp: 1 });
-const SessionRecordSchema = new mongoose.Schema({
-  sessionId: { type: String, required: true, unique: true },
-  createdAt: { type: Date, required: true, expires: ONE_DAY },
-  tokenId: {
-    type: mongoose.Schema.Types.ObjectId
+    accessPolicy: { type: Number, required: false },
+    unverifiedHost: { type: Number, required: false },
+    webView: { type: Number, required: false }
   },
+  providerSelectEntropy: { type: Number, required: true },
+  ipAddress: CompositeIpAddressRecordSchemaObj,
   captchaType: { type: String, enum: types.CaptchaType, required: true },
-  storedAtTimestamp: { type: Date, required: false },
+  solvedImagesCount: { type: Number, required: false },
+  powDifficulty: { type: Number, required: false },
+  storedAtTimestamp: { type: Date, required: false, expires: ONE_DAY },
   lastUpdatedTimestamp: { type: Date, required: false },
-  deleted: { type: Boolean, required: false }
+  deleted: { type: Boolean, required: false },
+  webView: { type: Boolean, required: true, default: false },
+  iFrame: { type: Boolean, required: true, default: false },
+  decryptedHeadHash: { type: String, required: false, default: "" }
 });
-SessionRecordSchema.index({ sessionId: 1 }, { unique: true });
-SessionRecordSchema.index({ storedAtTimestamp: 1 });
+SessionRecordSchema.index({ createdAt: 1 });
 SessionRecordSchema.index({ deleted: 1 });
+SessionRecordSchema.index({ sessionId: 1 }, { unique: true });
+SessionRecordSchema.index({ providerSelectEntropy: 1 });
+SessionRecordSchema.index({ token: 1 });
 const DetectorRecordSchema = new mongoose.Schema({
   createdAt: { type: Date, required: true },
   detectorKey: { type: String, required: true },
-  expiresAt: { type: Date, required: false, expires: 0 }
+  expiresAt: { type: Date, required: false }
 });
 DetectorRecordSchema.index({ createdAt: 1 }, { unique: true });
 DetectorRecordSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
 exports.CaptchaRecordSchema = CaptchaRecordSchema;
 exports.ClientRecordSchema = ClientRecordSchema;
+exports.CompositeIpAddressRecordSchemaObj = CompositeIpAddressRecordSchemaObj;
+exports.CompositeIpAddressSchema = CompositeIpAddressSchema;
 exports.DatasetRecordSchema = DatasetRecordSchema;
 exports.DetectorRecordSchema = DetectorRecordSchema;
-exports.FrictionlessTokenRecordSchema = FrictionlessTokenRecordSchema;
+exports.IpAddressType = IpAddressType;
 exports.PendingRecordSchema = PendingRecordSchema;
 exports.PoWCaptchaRecordSchema = PoWCaptchaRecordSchema;
 exports.ScheduledTaskRecordSchema = ScheduledTaskRecordSchema;
@@ -279,3 +329,4 @@ exports.UserCommitmentSchema = UserCommitmentSchema;
 exports.UserCommitmentWithSolutionsSchema = UserCommitmentWithSolutionsSchema;
 exports.UserSolutionRecordSchema = UserSolutionRecordSchema;
 exports.UserSolutionSchema = UserSolutionSchema;
+exports.parseMongooseCompositeIpAddress = parseMongooseCompositeIpAddress;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types/index.js";
+export type { PendingCaptchaRequest } from "./provider/pendingCaptchaRequest.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAC;AACjC,YAAY,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC"}

package/dist/index.js

@@ -1,14 +1,17 @@
 import "./types/index.js";
-import { CaptchaRecordSchema, ClientRecordSchema, DatasetRecordSchema, DetectorRecordSchema, FrictionlessTokenRecordSchema, PendingRecordSchema, PoWCaptchaRecordSchema, ScheduledTaskRecordSchema, ScheduledTaskSchema, SessionRecordSchema, SolutionRecordSchema, UserCommitmentRecordSchema, UserCommitmentSchema, UserCommitmentWithSolutionsSchema, UserSolutionRecordSchema, UserSolutionSchema } from "./types/provider.js";
-import { AccountSchema, TableNames, UserDataSchema, UserSettingsSchema } from "./types/client.js";
+import { CaptchaRecordSchema, ClientRecordSchema, CompositeIpAddressRecordSchemaObj, CompositeIpAddressSchema, DatasetRecordSchema, DetectorRecordSchema, IpAddressType, PendingRecordSchema, PoWCaptchaRecordSchema, ScheduledTaskRecordSchema, ScheduledTaskSchema, SessionRecordSchema, SolutionRecordSchema, UserCommitmentRecordSchema, UserCommitmentSchema, UserCommitmentWithSolutionsSchema, UserSolutionRecordSchema, UserSolutionSchema, parseMongooseCompositeIpAddress } from "./types/provider.js";
+import { AccountSchema, IPValidationRulesSchema, TableNames, UserDataSchema, UserSettingsSchema } from "./types/client.js";
 import { StoredPoWCaptchaRecordSchema, StoredSessionRecordSchema, StoredUserCommitmentRecordSchema } from "./types/captcha.js";
 export {
   AccountSchema,
   CaptchaRecordSchema,
   ClientRecordSchema,
+  CompositeIpAddressRecordSchemaObj,
+  CompositeIpAddressSchema,
   DatasetRecordSchema,
   DetectorRecordSchema,
-  FrictionlessTokenRecordSchema,
+  IPValidationRulesSchema,
+  IpAddressType,
   PendingRecordSchema,
   PoWCaptchaRecordSchema,
   ScheduledTaskRecordSchema,
@@ -25,5 +28,6 @@ export {
   UserDataSchema,
   UserSettingsSchema,
   UserSolutionRecordSchema,
-  UserSolutionSchema
+  UserSolutionSchema,
+  parseMongooseCompositeIpAddress
 };

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAC"}

package/dist/provider/pendingCaptchaRequest.d.ts

@@ -0,0 +1,14 @@
+import { ApiParams } from "@prosopo/types";
+import type { CompositeIpAddress } from "../types/index.js";
+export interface PendingCaptchaRequest {
+    accountId: string;
+    pending: boolean;
+    salt: string;
+    [ApiParams.requestHash]: string;
+    deadlineTimestamp: number;
+    requestedAtTimestamp: Date;
+    ipAddress: CompositeIpAddress;
+    sessionId?: string;
+    threshold: number;
+}
+//# sourceMappingURL=pendingCaptchaRequest.d.ts.map

package/dist/provider/pendingCaptchaRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingCaptchaRequest.d.ts","sourceRoot":"","sources":["../../src/provider/pendingCaptchaRequest.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,IAAI,CAAC;IAC3B,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CAClB"}

package/dist/provider/pendingCaptchaRequest.js

@@ -0,0 +1,2 @@
+import { ApiParams } from "@prosopo/types";
+//# sourceMappingURL=pendingCaptchaRequest.js.map

package/dist/provider/pendingCaptchaRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingCaptchaRequest.js","sourceRoot":"","sources":["../../src/provider/pendingCaptchaRequest.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/types/captcha.d.ts

@@ -0,0 +1,18 @@
+import type { PoWCaptcha } from "@prosopo/types";
+import { type RootFilterQuery, Schema } from "mongoose";
+import type { IDatabase } from "./mongo.js";
+import { type PoWCaptchaRecord, type SessionRecord, type UserCommitment, type UserCommitmentRecord } from "./provider.js";
+export type StoredSession = SessionRecord;
+export declare const StoredSessionRecordSchema: Schema;
+export declare const StoredUserCommitmentRecordSchema: Schema;
+export declare const StoredPoWCaptchaRecordSchema: Schema;
+export interface ICaptchaDatabase extends IDatabase {
+    saveCaptchas(sessionEvents: StoredSession[], imageCaptchaEvents: UserCommitmentRecord[], powCaptchaEvents: PoWCaptchaRecord[]): Promise<void>;
+    getCaptchas(filter: RootFilterQuery<CaptchaProperties>, limit: number): Promise<{
+        userCommitmentRecords: UserCommitmentRecord[];
+        powCaptchaRecords: PoWCaptchaRecord[];
+    }>;
+}
+export interface CaptchaProperties extends Partial<UserCommitment & PoWCaptcha> {
+}
+//# sourceMappingURL=captcha.d.ts.map

package/dist/types/captcha.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha.d.ts","sourceRoot":"","sources":["../../src/types/captcha.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,aAAa,EAElB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAEzB,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC;AAE1C,eAAO,MAAM,yBAAyB,EAAE,MAA4B,CAAC;AAErE,eAAO,MAAM,gCAAgC,EAAE,MAE7C,CAAC;AAGH,eAAO,MAAM,4BAA4B,EAAE,MAEzC,CAAC;AAGH,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IAClD,YAAY,CACX,aAAa,EAAE,aAAa,EAAE,EAC9B,kBAAkB,EAAE,oBAAoB,EAAE,EAC1C,gBAAgB,EAAE,gBAAgB,EAAE,GAClC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,WAAW,CACV,MAAM,EAAE,eAAe,CAAC,iBAAiB,CAAC,EAC1C,KAAK,EAAE,MAAM,GACX,OAAO,CAAC;QACV,qBAAqB,EAAE,oBAAoB,EAAE,CAAC;QAC9C,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;KACtC,CAAC,CAAC;CACH;AAED,MAAM,WAAW,iBAChB,SAAQ,OAAO,CAAC,cAAc,GAAG,UAAU,CAAC;CAAG"}

package/dist/types/captcha.js

@@ -1,25 +1,14 @@
 import { Schema } from "mongoose";
-import { FrictionlessTokenRecordSchema, SessionRecordSchema, UserCommitmentRecordSchema, PoWCaptchaRecordSchema } from "./provider.js";
-const StoredSessionRecordSchema = new Schema({
-  sessionId: SessionRecordSchema.obj.sessionId,
-  createdAt: SessionRecordSchema.obj.createdAt,
-  captchaType: SessionRecordSchema.obj.captchaType,
-  tokenId: SessionRecordSchema.obj.tokenId,
-  deleted: SessionRecordSchema.obj.deleted,
-  score: FrictionlessTokenRecordSchema.obj.score,
-  scoreComponents: FrictionlessTokenRecordSchema.obj.scoreComponents,
-  threshold: FrictionlessTokenRecordSchema.obj.threshold
-});
+import { SessionRecordSchema, UserCommitmentRecordSchema, PoWCaptchaRecordSchema } from "./provider.js";
+const StoredSessionRecordSchema = SessionRecordSchema;
 const StoredUserCommitmentRecordSchema = new Schema({
   ...UserCommitmentRecordSchema.obj
 });
-StoredUserCommitmentRecordSchema.index({ frictionlessTokenId: 1 });
+StoredUserCommitmentRecordSchema.index({ sessionId: 1 });
 const StoredPoWCaptchaRecordSchema = new Schema({
   ...PoWCaptchaRecordSchema.obj
 });
-StoredPoWCaptchaRecordSchema.index({ frictionlessTokenId: 1 });
-StoredSessionRecordSchema.index({ sessionId: 1 });
-StoredSessionRecordSchema.index({ tokenId: 1 });
+StoredPoWCaptchaRecordSchema.index({ sessionId: 1 });
 export {
   StoredPoWCaptchaRecordSchema,
   StoredSessionRecordSchema,

package/dist/types/captcha.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha.js","sourceRoot":"","sources":["../../src/types/captcha.ts"],"names":[],"mappings":"AAeA,OAAO,EAAwB,MAAM,EAAE,MAAM,UAAU,CAAC;AAExD,OAAO,EAEN,sBAAsB,EAEtB,mBAAmB,EAGnB,0BAA0B,GAC1B,MAAM,eAAe,CAAC;AAKvB,MAAM,CAAC,MAAM,yBAAyB,GAAW,mBAAmB,CAAC;AAErE,MAAM,CAAC,MAAM,gCAAgC,GAAW,IAAI,MAAM,CAAC;IAClE,GAAG,0BAA0B,CAAC,GAAG;CACjC,CAAC,CAAC;AACH,gCAAgC,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;AAEzD,MAAM,CAAC,MAAM,4BAA4B,GAAW,IAAI,MAAM,CAAC;IAC9D,GAAG,sBAAsB,CAAC,GAAG;CAC7B,CAAC,CAAC;AACH,4BAA4B,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC"}

package/dist/types/client.d.ts

@@ -0,0 +1,259 @@
+import { type IUserData, type IUserSettings, type Timestamp } from "@prosopo/types";
+import type mongoose from "mongoose";
+import type { IDatabase } from "./mongo.js";
+import type { ClientRecord, Tables } from "./provider.js";
+export type UserDataRecord = mongoose.Document & IUserData;
+export declare const IPValidationRulesSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    distanceThresholdKm: number;
+    abuseScoreThreshold: number;
+    requireAllConditions: boolean;
+    forceConsistentIp: boolean;
+    actions?: {
+        countryChangeAction: any;
+        cityChangeAction: any;
+        ispChangeAction: any;
+        distanceExceedAction: any;
+        abuseScoreExceedAction: any;
+    } | null | undefined;
+    countryOverrides?: Map<string, {
+        [x: string]: unknown;
+    } | {
+        actions?: {
+            countryChangeAction?: any;
+            cityChangeAction?: any;
+            ispChangeAction?: any;
+            distanceExceedAction?: any;
+            abuseScoreExceedAction?: any;
+        } | null | undefined;
+        distanceThresholdKm?: number | null | undefined;
+        abuseScoreThreshold?: number | null | undefined;
+        requireAllConditions?: boolean | null | undefined;
+    }> | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    distanceThresholdKm: number;
+    abuseScoreThreshold: number;
+    requireAllConditions: boolean;
+    forceConsistentIp: boolean;
+    actions?: {
+        countryChangeAction: any;
+        cityChangeAction: any;
+        ispChangeAction: any;
+        distanceExceedAction: any;
+        abuseScoreExceedAction: any;
+    } | null | undefined;
+    countryOverrides?: Map<string, {
+        [x: string]: unknown;
+    } | {
+        actions?: {
+            countryChangeAction?: any;
+            cityChangeAction?: any;
+            ispChangeAction?: any;
+            distanceExceedAction?: any;
+            abuseScoreExceedAction?: any;
+        } | null | undefined;
+        distanceThresholdKm?: number | null | undefined;
+        abuseScoreThreshold?: number | null | undefined;
+        requireAllConditions?: boolean | null | undefined;
+    }> | null | undefined;
+}>> & mongoose.FlatRecord<{
+    distanceThresholdKm: number;
+    abuseScoreThreshold: number;
+    requireAllConditions: boolean;
+    forceConsistentIp: boolean;
+    actions?: {
+        countryChangeAction: any;
+        cityChangeAction: any;
+        ispChangeAction: any;
+        distanceExceedAction: any;
+        abuseScoreExceedAction: any;
+    } | null | undefined;
+    countryOverrides?: Map<string, {
+        [x: string]: unknown;
+    } | {
+        actions?: {
+            countryChangeAction?: any;
+            cityChangeAction?: any;
+            ispChangeAction?: any;
+            distanceExceedAction?: any;
+            abuseScoreExceedAction?: any;
+        } | null | undefined;
+        distanceThresholdKm?: number | null | undefined;
+        abuseScoreThreshold?: number | null | undefined;
+        requireAllConditions?: boolean | null | undefined;
+    }> | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const UserSettingsSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    domains: string[];
+    disallowWebView: boolean;
+    captchaType?: string | null | undefined;
+    frictionlessThreshold?: number | null | undefined;
+    powDifficulty?: number | null | undefined;
+    imageThreshold?: number | null | undefined;
+    ipValidationRules?: {
+        distanceThresholdKm: number;
+        abuseScoreThreshold: number;
+        requireAllConditions: boolean;
+        forceConsistentIp: boolean;
+        actions?: {
+            countryChangeAction: any;
+            cityChangeAction: any;
+            ispChangeAction: any;
+            distanceExceedAction: any;
+            abuseScoreExceedAction: any;
+        } | null | undefined;
+        countryOverrides?: Map<string, {
+            [x: string]: unknown;
+        } | {
+            actions?: {
+                countryChangeAction?: any;
+                cityChangeAction?: any;
+                ispChangeAction?: any;
+                distanceExceedAction?: any;
+                abuseScoreExceedAction?: any;
+            } | null | undefined;
+            distanceThresholdKm?: number | null | undefined;
+            abuseScoreThreshold?: number | null | undefined;
+            requireAllConditions?: boolean | null | undefined;
+        }> | null | undefined;
+    } | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    domains: string[];
+    disallowWebView: boolean;
+    captchaType?: string | null | undefined;
+    frictionlessThreshold?: number | null | undefined;
+    powDifficulty?: number | null | undefined;
+    imageThreshold?: number | null | undefined;
+    ipValidationRules?: {
+        distanceThresholdKm: number;
+        abuseScoreThreshold: number;
+        requireAllConditions: boolean;
+        forceConsistentIp: boolean;
+        actions?: {
+            countryChangeAction: any;
+            cityChangeAction: any;
+            ispChangeAction: any;
+            distanceExceedAction: any;
+            abuseScoreExceedAction: any;
+        } | null | undefined;
+        countryOverrides?: Map<string, {
+            [x: string]: unknown;
+        } | {
+            actions?: {
+                countryChangeAction?: any;
+                cityChangeAction?: any;
+                ispChangeAction?: any;
+                distanceExceedAction?: any;
+                abuseScoreExceedAction?: any;
+            } | null | undefined;
+            distanceThresholdKm?: number | null | undefined;
+            abuseScoreThreshold?: number | null | undefined;
+            requireAllConditions?: boolean | null | undefined;
+        }> | null | undefined;
+    } | null | undefined;
+}>> & mongoose.FlatRecord<{
+    domains: string[];
+    disallowWebView: boolean;
+    captchaType?: string | null | undefined;
+    frictionlessThreshold?: number | null | undefined;
+    powDifficulty?: number | null | undefined;
+    imageThreshold?: number | null | undefined;
+    ipValidationRules?: {
+        distanceThresholdKm: number;
+        abuseScoreThreshold: number;
+        requireAllConditions: boolean;
+        forceConsistentIp: boolean;
+        actions?: {
+            countryChangeAction: any;
+            cityChangeAction: any;
+            ispChangeAction: any;
+            distanceExceedAction: any;
+            abuseScoreExceedAction: any;
+        } | null | undefined;
+        countryOverrides?: Map<string, {
+            [x: string]: unknown;
+        } | {
+            actions?: {
+                countryChangeAction?: any;
+                cityChangeAction?: any;
+                ispChangeAction?: any;
+                distanceExceedAction?: any;
+                abuseScoreExceedAction?: any;
+            } | null | undefined;
+            distanceThresholdKm?: number | null | undefined;
+            abuseScoreThreshold?: number | null | undefined;
+            requireAllConditions?: boolean | null | undefined;
+        }> | null | undefined;
+    } | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const UserDataSchema: mongoose.Schema<UserDataRecord>;
+type User = {
+    email: string;
+    name: string;
+    role: string;
+    createdAt: number;
+    updatedAt: number;
+    status: string;
+};
+type AccountRecord = mongoose.Document & {
+    createdAt: number;
+    updatedAt: number;
+    signupEmail: string;
+    tier: string;
+    tierRequestQuota: number;
+    marketingPreferences: boolean;
+    users: User[];
+    sites: {
+        name: string;
+        siteKey: string;
+        secretKey: string;
+        settings: IUserSettings;
+        createdAt: number;
+        updatedAt: number;
+        active: boolean;
+    }[];
+    deletedUsers: User[];
+};
+export declare const AccountSchema: mongoose.Schema<AccountRecord, mongoose.Model<AccountRecord, any, any, any, mongoose.Document<unknown, any, AccountRecord> & mongoose.Document<unknown, any, any> & {
+    createdAt: number;
+    updatedAt: number;
+    signupEmail: string;
+    tier: string;
+    tierRequestQuota: number;
+    marketingPreferences: boolean;
+    users: User[];
+    sites: {
+        name: string;
+        siteKey: string;
+        secretKey: string;
+        settings: IUserSettings;
+        createdAt: number;
+        updatedAt: number;
+        active: boolean;
+    }[];
+    deletedUsers: User[];
+} & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, AccountRecord, mongoose.Document<unknown, {}, mongoose.FlatRecord<AccountRecord>> & mongoose.FlatRecord<AccountRecord> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>;
+export declare enum TableNames {
+    accounts = "accounts"
+}
+export interface IClientDatabase extends IDatabase {
+    getTables(): Tables<TableNames>;
+    getUpdatedClients(updatedAtTimestamp: Timestamp): Promise<ClientRecord[]>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map