@qazuor/qzpay-drizzle 1.7.8 → 1.8.0

package/dist/index.cjs

@@ -130,13 +130,13 @@ function firstOrThrow(results, entityType, id) {
 }
 async function updateWithVersionHelper(db, table, id, expectedVersion, updateData, options) {
   const { entityType, entityId, includeSoftDeleted = false, transform } = options;
-  const { and: and19, eq: eq18, isNull: isNull13 } = await import('drizzle-orm');
+  const { and: and20, eq: eq19, isNull: isNull13 } = await import('drizzle-orm');
   const { generateVersion: generateVersion2 } = await Promise.resolve().then(() => (init_optimistic_locking(), optimistic_locking_exports));
-  const conditions = [eq18(table.id, id), eq18(table.version, expectedVersion)];
+  const conditions = [eq19(table.id, id), eq19(table.version, expectedVersion)];
   if (!includeSoftDeleted && "deletedAt" in table) {
     conditions.push(isNull13(table.deletedAt));
   }
-  const whereClause = and19(...conditions);
+  const whereClause = and20(...conditions);
   if (!whereClause) {
     throw new Error("Failed to build WHERE clause for version update");
   }
@@ -150,7 +150,7 @@ async function updateWithVersionHelper(db, table, id, expectedVersion, updateDat
     result = await db.update(table).set(dataWithVersion).where(whereClause).returning();
   } catch (_error) {
     try {
-      const existsQuery = await db.select().from(table).where(includeSoftDeleted ? eq18(table.id, id) : and19(eq18(table.id, id), isNull13(table.deletedAt))).limit(1);
+      const existsQuery = await db.select().from(table).where(includeSoftDeleted ? eq19(table.id, id) : and20(eq19(table.id, id), isNull13(table.deletedAt))).limit(1);
       if (existsQuery.length > 0) {
         throw new exports.QZPayOptimisticLockError(entityType, entityId);
       }
@@ -159,7 +159,7 @@ async function updateWithVersionHelper(db, table, id, expectedVersion, updateDat
     throw new exports.QZPayEntityNotFoundError(entityType, entityId);
   }
   if (result.length === 0) {
-    const existsQuery = await db.select().from(table).where(includeSoftDeleted ? eq18(table.id, id) : and19(eq18(table.id, id), isNull13(table.deletedAt))).limit(1);
+    const existsQuery = await db.select().from(table).where(includeSoftDeleted ? eq19(table.id, id) : and20(eq19(table.id, id), isNull13(table.deletedAt))).limit(1);
     if (existsQuery.length > 0) {
       throw new exports.QZPayOptimisticLockError(entityType, entityId);
     }
@@ -1107,6 +1107,46 @@ function mapCorePromoCodeUpdateToDrizzle(update) {
   return result;
 }
 
+// src/mappers/subscription-polling-job.mapper.ts
+var POLLING_JOB_DEFAULTS = {
+  initialDelayMs: 3e4,
+  maxAttempts: 60
+};
+function mapDrizzlePollingJobToCore(row) {
+  return {
+    id: row.id,
+    subscriptionId: row.subscriptionId,
+    provider: row.provider,
+    providerResourceId: row.providerResourceId,
+    status: row.status,
+    attempts: row.attempts,
+    maxAttempts: row.maxAttempts,
+    nextPollAt: row.nextPollAt,
+    lastPolledAt: row.lastPolledAt ?? null,
+    lastProviderStatus: row.lastProviderStatus ?? null,
+    lastError: row.lastError ?? null,
+    metadata: row.metadata ?? {},
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    completedAt: row.completedAt ?? null,
+    version: row.version
+  };
+}
+function mapPollingScheduleInputToDrizzleInsert(input) {
+  const initialDelayMs = input.initialDelayMs ?? POLLING_JOB_DEFAULTS.initialDelayMs;
+  const nextPollAt = new Date(Date.now() + initialDelayMs);
+  return {
+    subscriptionId: input.subscriptionId,
+    provider: input.provider,
+    providerResourceId: input.providerResourceId,
+    status: "pending",
+    attempts: 0,
+    maxAttempts: input.maxAttempts ?? POLLING_JOB_DEFAULTS.maxAttempts,
+    nextPollAt,
+    metadata: input.metadata ?? {}
+  };
+}
+
 // src/mappers/subscription.mapper.ts
 function mapDrizzleSubscriptionToCore(drizzle3) {
   const providerSubscriptionIds = {};
@@ -1890,6 +1930,80 @@ var billingPrices = pgCore.pgTable(
 );
 var billingPriceInsertSchema = drizzleZod.createInsertSchema(billingPrices);
 var billingPriceSelectSchema = drizzleZod.createSelectSchema(billingPrices);
+var billingSubscriptionPollingJobs = pgCore.pgTable(
+  "billing_subscription_polling_jobs",
+  {
+    id: pgCore.uuid("id").primaryKey().defaultRandom(),
+    subscriptionId: pgCore.uuid("subscription_id").notNull().references(() => billingSubscriptions.id, { onDelete: "cascade" }),
+    /**
+     * Provider identifier, e.g. `mercadopago`. Future-proofed so
+     * Stripe or other adapters can opt in to polling if needed.
+     */
+    provider: pgCore.varchar("provider", { length: 50 }).notNull(),
+    /**
+     * Provider-side resource id (e.g. MP preapproval id) that the
+     * poller uses to query the provider's REST endpoint.
+     */
+    providerResourceId: pgCore.varchar("provider_resource_id", { length: 255 }).notNull(),
+    /**
+     * Job lifecycle status.
+     * - `pending`: cron will pick up when due
+     * - `succeeded`: provider returned a terminal authorized state
+     * - `failed`: provider returned cancelled/rejected
+     * - `timeout`: max_attempts reached without resolution
+     * - `cancelled`: cancelled externally (e.g. user cancelled sub mid-flight)
+     */
+    status: pgCore.varchar("status", { length: 20 }).notNull().default("pending"),
+    attempts: pgCore.integer("attempts").notNull().default(0),
+    maxAttempts: pgCore.integer("max_attempts").notNull().default(60),
+    nextPollAt: pgCore.timestamp("next_poll_at", { withTimezone: true }).notNull().defaultNow(),
+    lastPolledAt: pgCore.timestamp("last_polled_at", { withTimezone: true }),
+    /**
+     * Raw provider status from the last poll (e.g. `pending`,
+     * `authorized`). Useful for diagnostics without joining logs.
+     */
+    lastProviderStatus: pgCore.varchar("last_provider_status", { length: 50 }),
+    /**
+     * Last error message (truncated server-side to avoid bloat).
+     * Set when a poll attempt fails (network, 4xx, 5xx).
+     */
+    lastError: pgCore.text("last_error"),
+    metadata: pgCore.jsonb("metadata").notNull().default({}),
+    createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    completedAt: pgCore.timestamp("completed_at", { withTimezone: true }),
+    /**
+     * Optimistic lock token. Updated on every state change. Workers
+     * must include this in their UPDATE WHERE clause to detect
+     * concurrent modifications.
+     */
+    version: pgCore.uuid("version").notNull().defaultRandom()
+  },
+  (table) => ({
+    /**
+     * Partial index that supports the cron's "find due pending
+     * jobs" query. Only rows still pending are scanned, so the
+     * per-tick cost is O(k) where k = #pending jobs (NOT a full
+     * table scan that would grow with historical job count).
+     */
+    dueIdx: pgCore.index("idx_polling_jobs_due").on(table.nextPollAt).where(drizzleOrm.sql`status = 'pending'`),
+    /**
+     * Lookup by subscription, e.g. when a webhook arrives and we
+     * need to mark the active polling job as `succeeded`.
+     */
+    subscriptionIdx: pgCore.index("idx_polling_jobs_subscription").on(table.subscriptionId),
+    /**
+     * At most one ACTIVE polling job per subscription. Prevents
+     * duplicate enqueuing if `schedulePolling()` is called twice
+     * concurrently. Historical jobs (succeeded/failed/timeout/
+     * cancelled) are NOT constrained — multiple terminal rows per
+     * subscription are allowed for audit trail.
+     */
+    oneActivePerSubscriptionIdx: pgCore.uniqueIndex("idx_polling_jobs_one_active_per_sub").on(table.subscriptionId).where(drizzleOrm.sql`status = 'pending'`)
+  })
+);
+var billingSubscriptionPollingJobInsertSchema = drizzleZod.createInsertSchema(billingSubscriptionPollingJobs);
+var billingSubscriptionPollingJobSelectSchema = drizzleZod.createSelectSchema(billingSubscriptionPollingJobs);
 var billingUsageRecords = pgCore.pgTable(
   "billing_usage_records",
   {
@@ -1991,7 +2105,14 @@ var billingSubscriptionsRelations = drizzleOrm.relations(billingSubscriptions, (
   payments: many(billingPayments),
   invoices: many(billingInvoices),
   usageRecords: many(billingUsageRecords),
-  addons: many(billingSubscriptionAddons)
+  addons: many(billingSubscriptionAddons),
+  pollingJobs: many(billingSubscriptionPollingJobs)
+}));
+var billingSubscriptionPollingJobsRelations = drizzleOrm.relations(billingSubscriptionPollingJobs, ({ one }) => ({
+  subscription: one(billingSubscriptions, {
+    fields: [billingSubscriptionPollingJobs.subscriptionId],
+    references: [billingSubscriptions.id]
+  })
 }));
 var billingPaymentsRelations = drizzleOrm.relations(billingPayments, ({ one, many }) => ({
   customer: one(billingCustomers, {
@@ -2188,6 +2309,7 @@ var qzpaySchema = {
   billingPromoCodes,
   billingPromoCodeUsage,
   billingSubscriptions,
+  billingSubscriptionPollingJobs,
   billingUsageRecords,
   billingVendors,
   billingVendorPayouts,
@@ -2212,6 +2334,7 @@ var qzpaySchema = {
   billingPromoCodesRelations,
   billingPromoCodeUsageRelations,
   billingSubscriptionsRelations,
+  billingSubscriptionPollingJobsRelations,
   billingUsageRecordsRelations,
   billingVendorsRelations,
   billingVendorPayoutsRelations
@@ -4700,6 +4823,119 @@ var QZPayPromoCodesRepository = class {
   }
 };
 init_base_repository();
+var PG_UNIQUE_VIOLATION = "23505";
+function isUniqueViolation(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const direct = error;
+  if (direct.code === PG_UNIQUE_VIOLATION) {
+    return true;
+  }
+  const cause = error.cause;
+  if (cause && typeof cause === "object") {
+    const innerCode = cause.code;
+    if (innerCode === PG_UNIQUE_VIOLATION) {
+      return true;
+    }
+  }
+  return false;
+}
+var QZPaySubscriptionPollingJobsRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Insert a new pending polling job.
+   *
+   * Returns `null` if a partial-unique violation is raised — i.e.,
+   * there is already a `pending` job for the same subscription. The
+   * caller can then choose to read the existing job and treat it as
+   * the source of truth.
+   */
+  async create(input) {
+    try {
+      const result = await this.db.insert(billingSubscriptionPollingJobs).values(input).returning();
+      return firstOrNull(result);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Find a polling job by id.
+   */
+  async findById(id) {
+    const result = await this.db.select().from(billingSubscriptionPollingJobs).where(drizzleOrm.eq(billingSubscriptionPollingJobs.id, id)).limit(1);
+    return firstOrNull(result);
+  }
+  /**
+   * Find the active (`pending`) polling job for a subscription, if any.
+   * Returns the single active job because the partial-unique index
+   * enforces at most one.
+   */
+  async findActiveBySubscriptionId(subscriptionId) {
+    const result = await this.db.select().from(billingSubscriptionPollingJobs).where(
+      drizzleOrm.and(drizzleOrm.eq(billingSubscriptionPollingJobs.subscriptionId, subscriptionId), drizzleOrm.eq(billingSubscriptionPollingJobs.status, "pending"))
+    ).limit(1);
+    return firstOrNull(result);
+  }
+  /**
+   * Fetch up to `limit` pending jobs whose `next_poll_at <= now`,
+   * ordered by `next_poll_at` ascending so most-overdue jobs are
+   * processed first.
+   */
+  async findDuePending(now, limit) {
+    const safeLimit = Math.max(1, Math.min(limit, 200));
+    return this.db.select().from(billingSubscriptionPollingJobs).where(drizzleOrm.and(drizzleOrm.eq(billingSubscriptionPollingJobs.status, "pending"), drizzleOrm.lte(billingSubscriptionPollingJobs.nextPollAt, now))).orderBy(drizzleOrm.asc(billingSubscriptionPollingJobs.nextPollAt)).limit(safeLimit);
+  }
+  /**
+   * Optimistic-locked update.
+   *
+   * The UPDATE only fires when both `id` AND `version` match the row
+   * the caller previously read. On success the row's `version` is
+   * rotated to a fresh uuid (server-side via gen_random_uuid()) and
+   * `updated_at` is bumped. Returns `null` when another worker has
+   * already moved the row (the version no longer matches).
+   */
+  async tryLockedUpdate(params) {
+    const updates = {
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (params.status !== void 0) {
+      updates.status = params.status;
+    }
+    if (params.lastPolledAt !== void 0) {
+      updates.lastPolledAt = params.lastPolledAt;
+    }
+    if (params.lastProviderStatus !== void 0) {
+      updates.lastProviderStatus = params.lastProviderStatus;
+    }
+    if (params.lastError !== void 0) {
+      updates.lastError = params.lastError;
+    }
+    if (params.nextPollAt !== void 0) {
+      updates.nextPollAt = params.nextPollAt;
+    }
+    if (params.completedAt !== void 0) {
+      updates.completedAt = params.completedAt;
+    }
+    const attemptsExpr = params.incrementAttemptsBy && params.incrementAttemptsBy !== 0 ? drizzleOrm.sql`${billingSubscriptionPollingJobs.attempts} + ${params.incrementAttemptsBy}` : void 0;
+    const result = await this.db.update(billingSubscriptionPollingJobs).set({
+      ...updates,
+      // Rotate the version token on every successful update so
+      // a subsequent UPDATE with the previous token fails.
+      version: drizzleOrm.sql`gen_random_uuid()`,
+      ...attemptsExpr ? { attempts: attemptsExpr } : {}
+    }).where(
+      drizzleOrm.and(drizzleOrm.eq(billingSubscriptionPollingJobs.id, params.id), drizzleOrm.eq(billingSubscriptionPollingJobs.version, params.expectedVersion))
+    ).returning();
+    return firstOrNull(result);
+  }
+};
+init_base_repository();
 var QZPaySubscriptionsRepository = class {
   constructor(db) {
     this.db = db;
@@ -5767,6 +6003,7 @@ var QZPayDrizzleStorageAdapter = class {
   checkoutsRepo;
   customersRepo;
   subscriptionsRepo;
+  subscriptionPollingJobsRepo;
   paymentsRepo;
   paymentMethodsRepo;
   invoicesRepo;
@@ -5782,6 +6019,7 @@ var QZPayDrizzleStorageAdapter = class {
   checkouts;
   customers;
   subscriptions;
+  subscriptionPollingJobs;
   payments;
   paymentMethods;
   invoices;
@@ -5799,6 +6037,7 @@ var QZPayDrizzleStorageAdapter = class {
     this.checkoutsRepo = new QZPayCheckoutsRepository(this.db);
     this.customersRepo = new QZPayCustomersRepository(typedDb);
     this.subscriptionsRepo = new QZPaySubscriptionsRepository(typedDb);
+    this.subscriptionPollingJobsRepo = new QZPaySubscriptionPollingJobsRepository(this.db);
     this.paymentsRepo = new QZPayPaymentsRepository(this.db);
     this.paymentMethodsRepo = new QZPayPaymentMethodsRepository(this.db);
     this.invoicesRepo = new QZPayInvoicesRepository(typedDb);
@@ -5813,6 +6052,7 @@ var QZPayDrizzleStorageAdapter = class {
     this.checkouts = this.createCheckoutStorage();
     this.customers = this.createCustomerStorage();
     this.subscriptions = this.createSubscriptionStorage();
+    this.subscriptionPollingJobs = this.createSubscriptionPollingJobStorage();
     this.payments = this.createPaymentStorage();
     this.paymentMethods = this.createPaymentMethodStorage();
     this.invoices = this.createInvoiceStorage();
@@ -5949,6 +6189,48 @@ var QZPayDrizzleStorageAdapter = class {
       }
     };
   }
+  // ==================== Subscription Polling Job Storage ====================
+  createSubscriptionPollingJobStorage() {
+    const repo = this.subscriptionPollingJobsRepo;
+    return {
+      async create(input) {
+        if (!input.provider) {
+          throw new Error(
+            'QZPaySchedulePollingInput.provider is required when calling subscriptionPollingJobs.create. Pass the configured payment adapter provider (e.g., "mercadopago") explicitly.'
+          );
+        }
+        const drizzleInput = mapPollingScheduleInputToDrizzleInsert({ ...input, provider: input.provider });
+        const row = await repo.create(drizzleInput);
+        return row ? mapDrizzlePollingJobToCore(row) : null;
+      },
+      async update(input) {
+        const row = await repo.tryLockedUpdate({
+          id: input.id,
+          expectedVersion: input.expectedVersion,
+          ...input.status !== void 0 ? { status: input.status } : {},
+          ...input.incrementAttemptsBy !== void 0 ? { incrementAttemptsBy: input.incrementAttemptsBy } : {},
+          ...input.lastPolledAt !== void 0 ? { lastPolledAt: input.lastPolledAt } : {},
+          ...input.lastProviderStatus !== void 0 ? { lastProviderStatus: input.lastProviderStatus } : {},
+          ...input.lastError !== void 0 ? { lastError: input.lastError } : {},
+          ...input.nextPollAt !== void 0 ? { nextPollAt: input.nextPollAt } : {},
+          ...input.completedAt !== void 0 ? { completedAt: input.completedAt } : {}
+        });
+        return row ? mapDrizzlePollingJobToCore(row) : null;
+      },
+      async findById(id) {
+        const row = await repo.findById(id);
+        return row ? mapDrizzlePollingJobToCore(row) : null;
+      },
+      async findActiveBySubscriptionId(subscriptionId) {
+        const row = await repo.findActiveBySubscriptionId(subscriptionId);
+        return row ? mapDrizzlePollingJobToCore(row) : null;
+      },
+      async findDuePending(now, limit) {
+        const rows = await repo.findDuePending(now, limit);
+        return rows.map(mapDrizzlePollingJobToCore);
+      }
+    };
+  }
   // ==================== Payment Storage ====================
   createPaymentStorage() {
     const repo = this.paymentsRepo;
@@ -6504,9 +6786,9 @@ async function runMigrations(config) {
   if (verbose) {
     console.log("[QZPay] Starting database migrations...");
   }
-  const sql20 = postgres2__default.default(connectionUrl, { max: 1 });
+  const sql22 = postgres2__default.default(connectionUrl, { max: 1 });
   try {
-    const db = postgresJs.drizzle(sql20);
+    const db = postgresJs.drizzle(sql22);
     await migrator.migrate(db, {
       migrationsFolder
     });
@@ -6517,14 +6799,14 @@ async function runMigrations(config) {
     console.error("[QZPay] Migration failed:", error);
     throw error;
   } finally {
-    await sql20.end();
+    await sql22.end();
   }
 }
 async function hasPendingMigrations(connectionUrl) {
-  const sql20 = postgres2__default.default(connectionUrl, { max: 1 });
+  const sql22 = postgres2__default.default(connectionUrl, { max: 1 });
   try {
-    postgresJs.drizzle(sql20);
-    const result = await sql20`
+    postgresJs.drizzle(sql22);
+    const result = await sql22`
             SELECT EXISTS (
                 SELECT FROM information_schema.tables
                 WHERE table_name = 'drizzle_migrations'
@@ -6535,24 +6817,24 @@ async function hasPendingMigrations(connectionUrl) {
     }
     return false;
   } finally {
-    await sql20.end();
+    await sql22.end();
   }
 }
 async function ensureDatabase(config) {
   const { connectionUrl, databaseName } = config;
-  const sql20 = postgres2__default.default(connectionUrl, { max: 1 });
+  const sql22 = postgres2__default.default(connectionUrl, { max: 1 });
   try {
-    const result = await sql20`
+    const result = await sql22`
             SELECT 1 FROM pg_database WHERE datname = ${databaseName}
         `;
     if (result.length === 0) {
-      await sql20.unsafe(`CREATE DATABASE "${databaseName}"`);
+      await sql22.unsafe(`CREATE DATABASE "${databaseName}"`);
       console.log(`[QZPay] Created database: ${databaseName}`);
       return true;
     }
     return false;
   } finally {
-    await sql20.end();
+    await sql22.end();
   }
 }
 
@@ -6787,6 +7069,7 @@ async function executeTransaction(db, options, fn) {
   return withTransaction(db, executeFn);
 }
 
+exports.POLLING_JOB_DEFAULTS = POLLING_JOB_DEFAULTS;
 exports.QZPAY_DRIZZLE_SCHEMA_VERSION = QZPAY_DRIZZLE_SCHEMA_VERSION;
 exports.QZPAY_PAGINATION_DEFAULTS = QZPAY_PAGINATION_DEFAULTS;
 exports.QZPayAddonsRepository = QZPayAddonsRepository;
@@ -6802,6 +7085,7 @@ exports.QZPayPaymentsRepository = QZPayPaymentsRepository;
 exports.QZPayPlansRepository = QZPayPlansRepository;
 exports.QZPayPricesRepository = QZPayPricesRepository;
 exports.QZPayPromoCodesRepository = QZPayPromoCodesRepository;
+exports.QZPaySubscriptionPollingJobsRepository = QZPaySubscriptionPollingJobsRepository;
 exports.QZPaySubscriptionsRepository = QZPaySubscriptionsRepository;
 exports.QZPayUsageRecordsRepository = QZPayUsageRecordsRepository;
 exports.QZPayVendorsRepository = QZPayVendorsRepository;
@@ -6879,6 +7163,10 @@ exports.billingSubscriptionAddonSelectSchema = billingSubscriptionAddonSelectSch
 exports.billingSubscriptionAddons = billingSubscriptionAddons;
 exports.billingSubscriptionAddonsRelations = billingSubscriptionAddonsRelations;
 exports.billingSubscriptionInsertSchema = billingSubscriptionInsertSchema;
+exports.billingSubscriptionPollingJobInsertSchema = billingSubscriptionPollingJobInsertSchema;
+exports.billingSubscriptionPollingJobSelectSchema = billingSubscriptionPollingJobSelectSchema;
+exports.billingSubscriptionPollingJobs = billingSubscriptionPollingJobs;
+exports.billingSubscriptionPollingJobsRelations = billingSubscriptionPollingJobsRelations;
 exports.billingSubscriptionSelectSchema = billingSubscriptionSelectSchema;
 exports.billingSubscriptions = billingSubscriptions;
 exports.billingSubscriptionsRelations = billingSubscriptionsRelations;
@@ -6963,6 +7251,7 @@ exports.mapDrizzleLimitToCore = mapDrizzleLimitToCore;
 exports.mapDrizzlePaymentMethodToCore = mapDrizzlePaymentMethodToCore;
 exports.mapDrizzlePaymentToCore = mapDrizzlePaymentToCore;
 exports.mapDrizzlePlanToCore = mapDrizzlePlanToCore;
+exports.mapDrizzlePollingJobToCore = mapDrizzlePollingJobToCore;
 exports.mapDrizzlePriceToCore = mapDrizzlePriceToCore;
 exports.mapDrizzlePromoCodeToCore = mapDrizzlePromoCodeToCore;
 exports.mapDrizzleSubscriptionAddonToCore = mapDrizzleSubscriptionAddonToCore;
@@ -6970,6 +7259,7 @@ exports.mapDrizzleSubscriptionToCore = mapDrizzleSubscriptionToCore;
 exports.mapDrizzleUsageRecordToCore = mapDrizzleUsageRecordToCore;
 exports.mapDrizzleVendorPayoutToCore = mapDrizzleVendorPayoutToCore;
 exports.mapDrizzleVendorToCore = mapDrizzleVendorToCore;
+exports.mapPollingScheduleInputToDrizzleInsert = mapPollingScheduleInputToDrizzleInsert;
 exports.normalizePaginationOptions = normalizePaginationOptions;
 exports.offsetToPage = offsetToPage;
 exports.onlyDeleted = onlyDeleted;