@owlmeans/mongo-resource 0.1.18-rc.8 → 0.1.18

package/src/utils/refs.ts

@@ -1,167 +1,21 @@
 import { MisshapedRecord } from '@owlmeans/resource'
-import type { ListCriteria } from '@owlmeans/resource'
-import { ObjectId } from 'mongodb'
-import type { Collection, Document } from 'mongodb'
+import { ObjectId, type Collection, type Document } from 'mongodb'
+import { logger } from '@owlmeans/log'
 
 import type { MongoReference, MongoTx } from '../types.js'
+import { HEX24, LOGICAL_OPERATORS, OPAQUE_OPERATORS } from './consts.local.js'
+import type { MongoRefHelper } from './refs/types.js'
 
-/**
- * The only shape a stored reference is converted from. Deliberately stricter than
- * `ObjectId.isValid`, which also accepts any 12 character string and would silently
- * swallow short business keys.
- */
-const HEX24 = /^[0-9a-fA-F]{24}$/
-
-export const isObjectIdHex = (value: unknown): value is string =>
-  typeof value === 'string' && HEX24.test(value)
+const log = logger('mongo-resource')
 
 /**
- * Write side of a declared reference: the string id a record carries becomes the
- * `ObjectId` the collection stores. Arrays convert elementwise.
- *
- * Strict on purpose — a declared reference holding something that is not a mongo id is
- * either a mis-declared field (should never have been a reference) or a bug at the call
- * site, and storing it as a string would silently reintroduce the mixed type state this
- * mechanism exists to remove.
+ * Ledger registered body of the system reference migration.
  *
- * @throws {MisshapedRecord}
+ * Stays a module level factory, textually unchanged: the ledger fingerprints a migration by the
+ * source text of the function it registers (`apply.toString()`), so moving the returned closure —
+ * or renaming what it calls — changes the checksum and raises `MigrationConflict` against every
+ * ledger that already applied it.
  */
-export const marshalReference = (field: string, value: unknown): unknown => {
-  if (value == null) {
-    return value
-  }
-  if (value instanceof ObjectId) {
-    return value
-  }
-  if (Array.isArray(value)) {
-    return value.map(item => marshalReference(field, item))
-  }
-  if (isObjectIdHex(value)) {
-    return new ObjectId(value)
-  }
-
-  throw new MisshapedRecord(`ref:${field}`)
-}
-
-/** Read side: `ObjectId` back to the string records carry. Tolerates not yet migrated strings. */
-export const demarshalReference = (value: unknown): unknown => {
-  if (value instanceof ObjectId) {
-    return value.toString()
-  }
-  if (Array.isArray(value)) {
-    return value.map(demarshalReference)
-  }
-
-  return value
-}
-
-/** Convert every declared reference of a fetched document back to string ids, in place. */
-export const demarshalRefs = <T extends {}>(record: T, refs: Map<string, MongoReference>): T => {
-  if (refs.size < 1) {
-    return record
-  }
-  for (const field of refs.keys()) {
-    const value = (record as Document)[field]
-    if (value != null) {
-      (record as Document)[field] = demarshalReference(value)
-    }
-  }
-
-  return record
-}
-
-/**
- * Operators whose operand is never an id — a 24 hex string under `$regex` is a pattern,
- * not a reference.
- */
-const OPAQUE_OPERATORS = ['$regex', '$options', '$type', '$size', '$mod', '$exists', '$where']
-
-const LOGICAL_OPERATORS = ['$and', '$or', '$nor']
-
-const marshalCriteriaValue = (value: unknown): unknown => {
-  if (typeof value === 'string') {
-    return isObjectIdHex(value) ? new ObjectId(value) : value
-  }
-  if (Array.isArray(value)) {
-    return value.map(marshalCriteriaValue)
-  }
-  if (value != null && typeof value === 'object' && !(value instanceof ObjectId) && !(value instanceof Date)) {
-    return Object.fromEntries(Object.entries(value).map(([operator, operand]) =>
-      OPAQUE_OPERATORS.includes(operator)
-        ? [operator, operand]
-        : [operator, marshalCriteriaValue(operand)]
-    ))
-  }
-
-  return value
-}
-
-/**
- * Convert list criteria the way records are converted: values addressed at `_id` or at a
- * declared reference become `ObjectId`s, and the `id` alias records actually carry is
- * mapped onto `_id` — documents never store `id`, so before this mapping such criteria
- * silently matched nothing.
- *
- * Tolerant by design: a value that is not 24 hex passes through unconverted. Criteria are
- * matched against the collection, and against an `ObjectId` typed field a stray string
- * matches nothing — which is exactly what it matched before the field was converted.
- */
-export const marshalCriteria = (
-  criteria: ListCriteria | undefined, refs: Map<string, MongoReference>
-): ListCriteria | undefined => {
-  if (criteria == null) {
-    return criteria
-  }
-
-  return Object.fromEntries(Object.entries(criteria).map(([key, value]) => {
-    if (LOGICAL_OPERATORS.includes(key) && Array.isArray(value)) {
-      return [key, value.map(sub => marshalCriteria(sub as ListCriteria, refs))]
-    }
-    if (key === 'id' || key === '_id') {
-      return ['_id', marshalCriteriaValue(value)]
-    }
-    if (refs.has(key)) {
-      return [key, marshalCriteriaValue(value)]
-    }
-
-    return [key, value]
-  })) as ListCriteria
-}
-
-/**
- * Criteria for addressing a single record by a field — `get`/`load`/`update`/`delete`.
- *
- * `_id` keeps its historical strictness (an invalid id throws through the driver). The
- * `id` alias and declared references convert tolerantly, so a caller probing a reference
- * with a value that is not a mongo id gets "not found" rather than a throw.
- */
-export const identityCriteria = (
-  field: string, id: string, refs: Map<string, MongoReference>
-): Document => {
-  if (field === '_id') {
-    return { _id: new ObjectId(id) }
-  }
-  if (field === 'id') {
-    return { _id: isObjectIdHex(id) ? new ObjectId(id) : id }
-  }
-  if (refs.has(field)) {
-    return { [field]: isObjectIdHex(id) ? new ObjectId(id) : id }
-  }
-
-  return { [field]: id }
-}
-
-/**
- * Name of the system migration that converts a reference field's stored strings.
- *
- * The `@1` is the body's version: the shared body below fingerprints identically for
- * every field, so an edit to it would raise `MigrationConflict` against every ledger on
- * the next boot. Any semantic change to {@link convertReferenceField} must bump this
- * suffix instead — the old name stays applied, the new one runs (idempotently) once.
- */
-export const refMigrationName = (field: string): string => `$ref:${field}@1`
-
-/** Ledger registered body of the system reference migration. */
 export const makeRefMigration = (field: string) => async (tx: MongoTx): Promise<void> => {
   await convertReferenceField(tx.collection, field)
 }
@@ -180,21 +34,10 @@ const convertScalar = (path: string): Document => ({
 })
 
 /**
- * Convert one reference field's stored string ids to `ObjectId`s — the body of the
- * system migration and of the boot time reconciliation probe alike.
- *
- * Idempotent and interrupt safe: it matches only documents where the field (or one of
- * its elements) is still a string, converts only values that are actually 24 hex, and
- * leaves everything else exactly as it was. Safe to run concurrently from several
- * replicas — a document converts once, the loser's filter no longer matches it.
- *
- * Validation is bypassed deliberately: at `Pre` stage the collection still carries the
- * validator that declares the field a *string*, and after the switch a legacy document
- * may violate the schema in unrelated ways — either would wedge the boot on a write
- * that only makes the data more correct. (Bypassing requires the connection's user to
- * hold the `bypassDocumentValidation` privilege — `dbOwner`/`root` do.)
+ * The body {@link makeRefMigration} runs, kept at module level for the same reason it is; the
+ * helper exposes the very same function as `convertReferenceField`.
  */
-export const convertReferenceField = async (collection: Collection, field: string): Promise<number> => {
+const convertReferenceField = async (collection: Collection, field: string): Promise<number> => {
   const result = await collection.updateMany(
     /** An array valued field matches `$type: 'string'` when any element is a string. */
     { [field]: { $type: 'string' } },
@@ -215,26 +58,141 @@ export const convertReferenceField = async (collection: Collection, field: strin
   return result.modifiedCount
 }
 
-/**
- * The second half of the double check the reference migration promises: the ledger says
- * whether the migration ran; this probes whether the collection actually holds no
- * convertible strings — and repairs it when the two disagree (a restored backup, a
- * write from a legacy process, a ledger created by hand).
- */
-export const reconcileReferences = async (
-  collection: Collection, refs: MongoReference[], alias: string
-): Promise<void> => {
-  for (const ref of refs) {
-    const remnant = await collection.findOne(
-      { [ref.field]: { $type: 'string', $regex: HEX24 } },
-      { projection: { _id: 1 } }
-    )
-    if (remnant != null) {
-      const converted = await convertReferenceField(collection, ref.field)
-      console.warn(
-        `@owlmeans/mongo-resource: ${alias}.${ref.field} held string ids outside the migration`
-        + ` ledger — converted ${converted} document(s)`
+export const createMongoRefHelper = (): MongoRefHelper => {
+  const isObjectIdHex = (value: unknown): value is string =>
+    typeof value === 'string' && HEX24.test(value)
+
+  const marshalReference = (field: string, value: unknown): unknown => {
+    if (value == null) {
+      return value
+    }
+    if (value instanceof ObjectId) {
+      return value
+    }
+    if (Array.isArray(value)) {
+      return value.map(item => marshalReference(field, item))
+    }
+    if (isObjectIdHex(value)) {
+      return new ObjectId(value)
+    }
+
+    throw new MisshapedRecord(`ref:${field}`)
+  }
+
+  const demarshalReference = (value: unknown): unknown => {
+    if (value instanceof ObjectId) {
+      return value.toString()
+    }
+    if (Array.isArray(value)) {
+      return value.map(demarshalReference)
+    }
+
+    return value
+  }
+
+  const demarshalRefs = <T extends {}>(record: T, refs: Map<string, MongoReference>): T => {
+    if (refs.size < 1) {
+      return record
+    }
+    for (const field of refs.keys()) {
+      const value = (record as Document)[field]
+      if (value != null) {
+        (record as Document)[field] = demarshalReference(value)
+      }
+    }
+
+    return record
+  }
+
+  const marshalCriteriaValue = (value: unknown): unknown => {
+    if (typeof value === 'string') {
+      return isObjectIdHex(value) ? new ObjectId(value) : value
+    }
+    if (Array.isArray(value)) {
+      return value.map(marshalCriteriaValue)
+    }
+    if (value != null && typeof value === 'object' && !(value instanceof ObjectId) && !(value instanceof Date)) {
+      return Object.fromEntries(Object.entries(value).map(([operator, operand]) =>
+        OPAQUE_OPERATORS.includes(operator)
+          ? [operator, operand]
+          : [operator, marshalCriteriaValue(operand)]
+      ))
+    }
+
+    return value
+  }
+
+  const marshalCriteria = (
+    criteria: Document | undefined, refs: Map<string, MongoReference>
+  ): Document | undefined => {
+    if (criteria == null) {
+      return criteria
+    }
+
+    return Object.fromEntries(Object.entries(criteria).map(([key, value]) => {
+      if (LOGICAL_OPERATORS.includes(key) && Array.isArray(value)) {
+        return [key, value.map(sub => marshalCriteria(sub as Document, refs))]
+      }
+      if (key === 'id' || key === '_id') {
+        return ['_id', marshalCriteriaValue(value)]
+      }
+      if (refs.has(key)) {
+        return [key, marshalCriteriaValue(value)]
+      }
+
+      return [key, value]
+    })) as Document
+  }
+
+  const identityCriteria = (
+    field: string, id: string, refs: Map<string, MongoReference>
+  ): Document => {
+    if (field === '_id') {
+      return { _id: new ObjectId(id) }
+    }
+    if (field === 'id') {
+      return { _id: isObjectIdHex(id) ? new ObjectId(id) : id }
+    }
+    if (refs.has(field)) {
+      return { [field]: isObjectIdHex(id) ? new ObjectId(id) : id }
+    }
+
+    return { [field]: id }
+  }
+
+  const refMigrationName = (field: string): string => `$ref:${field}@1`
+
+  const reconcileReferences = async (
+    collection: Collection, refs: MongoReference[], alias: string
+  ): Promise<void> => {
+    for (const ref of refs) {
+      const remnant = await collection.findOne(
+        { [ref.field]: { $type: 'string', $regex: HEX24 } },
+        { projection: { _id: 1 } }
       )
+      if (remnant != null) {
+        const converted = await convertReferenceField(collection, ref.field)
+        log.warn('Reference field held string ids outside the migration ledger; converted', {
+          resource: alias, field: ref.field, converted,
+        })
+      }
     }
   }
+
+  return {
+    isObjectIdHex, marshalReference, demarshalReference, demarshalRefs, marshalCriteria, identityCriteria,
+    refMigrationName, convertReferenceField, reconcileReferences
+  }
 }
+
+export const mongoRefHelper = createMongoRefHelper()
+
+/** @deprecated compat:factory-refactor — use `mongoRefHelper.isObjectIdHex(…)` */
+export const isObjectIdHex = (value: unknown): value is string => mongoRefHelper.isObjectIdHex(value)
+
+/** @deprecated compat:factory-refactor — use `mongoRefHelper.marshalReference(…)` */
+export const marshalReference = (field: string, value: unknown): unknown => mongoRefHelper.marshalReference(field, value)
+
+/** @deprecated compat:factory-refactor — use `mongoRefHelper.demarshalRefs(…)` */
+export const demarshalRefs = <T extends {}>(record: T, refs: Map<string, MongoReference>): T =>
+  mongoRefHelper.demarshalRefs(record, refs)

package/src/utils/schema/types.ts

@@ -0,0 +1,17 @@
+import type { AnySchema } from 'ajv'
+import type { Document } from 'mongodb'
+
+import type { MongoReference } from '../../types.js'
+
+/** An AJV schema as the `$jsonSchema` validator of a collection. */
+export interface MongoSchemaUtils {
+  /**
+   * Declared references are stored as `ObjectId`s while the AJV schema — which describes
+   * the records the app exchanges — keeps calling them strings. The collection validator
+   * describes what's stored, so the reference fields are overridden here after the plain
+   * conversion. Nullability and array shape carry over from the declared property.
+   */
+  applyReferenceTypes: (mongoSchema: Document, schema: AnySchema, refs: MongoReference[]) => Document
+  /** The plain conversion of an object schema into a `$jsonSchema` document. */
+  schemaToMongoSchema: (schema: AnySchema) => Document
+}

package/src/utils/schema.ts

@@ -2,120 +2,121 @@ import type { AnySchema, JSONSchemaType } from 'ajv'
 import type { Document } from 'mongodb'
 
 import type { MongoReference } from '../types.js'
-
-/**
- * Declared references are stored as `ObjectId`s while the AJV schema — which describes
- * the records the app exchanges — keeps calling them strings. The collection validator
- * describes what's stored, so the reference fields are overridden here after the plain
- * conversion. Nullability and array shape carry over from the declared property.
- */
-export const applyReferenceTypes = (
-  mongoSchema: Document, schema: AnySchema, refs: MongoReference[]
-): Document => {
-  if (mongoSchema.properties == null || refs.length < 1) {
-    return mongoSchema
-  }
-  const properties: Record<string, JSONSchemaType<unknown>> =
-    (schema as JSONSchemaType<unknown>).properties ?? {}
-  for (const ref of refs) {
-    const declared = properties[ref.field]
-    if (declared == null || mongoSchema.properties[ref.field] == null) {
-      continue
+import type { MongoSchemaUtils } from './schema/types.js'
+
+export const createMongoSchemaUtils = (): MongoSchemaUtils => {
+  const applyReferenceTypes = (
+    mongoSchema: Document, schema: AnySchema, refs: MongoReference[]
+  ): Document => {
+    if (mongoSchema.properties == null || refs.length < 1) {
+      return mongoSchema
     }
-    mongoSchema.properties[ref.field] = declared.type === 'array'
-      ? {
-        bsonType: declared.nullable ? ['array', 'null'] : 'array',
-        items: { bsonType: 'objectId' }
+    const properties: Record<string, JSONSchemaType<unknown>> =
+      (schema as JSONSchemaType<unknown>).properties ?? {}
+    for (const ref of refs) {
+      const declared = properties[ref.field]
+      if (declared == null || mongoSchema.properties[ref.field] == null) {
+        continue
       }
-      : { bsonType: declared.nullable ? ['objectId', 'null'] : 'objectId' }
+      mongoSchema.properties[ref.field] = declared.type === 'array'
+        ? {
+          bsonType: declared.nullable ? ['array', 'null'] : 'array',
+          items: { bsonType: 'objectId' }
+        }
+        : { bsonType: declared.nullable ? ['objectId', 'null'] : 'objectId' }
+    }
+
+    return mongoSchema
   }
 
-  return mongoSchema
-}
+  const schemaToMongoSchema = (schema: AnySchema): Document => {
+    const _schema = schema as JSONSchemaType<unknown>
 
-export const schemaToMongoSchema = (schema: AnySchema): Document => {
-  const _schema = schema as JSONSchemaType<unknown>
+    if (_schema.type !== 'object') {
+      throw new SyntaxError('Only object schemas can be converted to mongo schema')
+    }
 
-  if (_schema.type !== 'object') {
-    throw new SyntaxError('Only object schemas can be converted to mongo schema')
-  }
+    const mongoSchems: Document = {
+      bsonType: 'object',
+      properties: _schema.properties != null
+        ? 'allOf' in _schema.properties
+          ? covertAllOfProperties(_schema.properties.allOf) :
+          convertProperties(_schema.properties ?? {})
+        : undefined,
+      additionalProperties:
+        _schema.additionalProperties != null
+          ? convertAdditionalProperties(_schema.additionalProperties)
+          : false,
+      ...(_schema.required != null ? { required: _schema.required } : {}),
+    }
 
-  const mongoSchems: Document = {
-    bsonType: 'object',
-    properties: _schema.properties != null
-      ? 'allOf' in _schema.properties
-        ? covertAllOfProperties(_schema.properties.allOf) :
-        convertProperties(_schema.properties ?? {})
-      : undefined,
-    additionalProperties:
-      _schema.additionalProperties != null
-        ? convertAdditionalProperties(_schema.additionalProperties)
-        : false,
-    ...(_schema.required != null ? { required: _schema.required } : {}),
-  }
+    if (_schema.nullable) {
+      mongoSchems.bsonType = [mongoSchems.bsonType, 'null']
+    }
 
-  if (_schema.nullable) {
-    mongoSchems.bsonType = [mongoSchems.bsonType, 'null']
-  }
+    if ("properties" in mongoSchems && mongoSchems.properties == null) {
+      delete mongoSchems.properties
+    }
 
-  if ("properties" in mongoSchems && mongoSchems.properties == null) {
-    delete mongoSchems.properties
-  }
+    if ("required" in mongoSchems && mongoSchems.required == null
+      || Array.isArray(mongoSchems.required) && mongoSchems.required.length === 0) {
+      delete mongoSchems.required
+    }
 
-  if ("required" in mongoSchems && mongoSchems.required == null
-    || Array.isArray(mongoSchems.required) && mongoSchems.required.length === 0) {
-    delete mongoSchems.required
+    return mongoSchems
   }
 
-  return mongoSchems
-}
+  const convertAdditionalProperties = (additionalProperties: boolean | AnySchema): Document | boolean => {
+    if (typeof additionalProperties === 'boolean') {
+      return additionalProperties
+    }
 
-const convertAdditionalProperties = (additionalProperties: boolean | AnySchema): Document | boolean => {
-  if (typeof additionalProperties === 'boolean') {
-    return additionalProperties
+    return convertToBsonType(additionalProperties as JSONSchemaType<unknown>)
   }
 
-  return convertToBsonType(additionalProperties as JSONSchemaType<unknown>)
-}
+  const convertProperties = (properties: Record<string, AnySchema>): Document =>
+    Object.fromEntries(Object.entries(properties).map(([key, value]) => {
+      if (key === 'oneOf') {
+        throw new SyntaxError('We dont support schemas with oneof properties definition')
+      }
 
-const convertProperties = (properties: Record<string, AnySchema>): Document =>
-  Object.fromEntries(Object.entries(properties).map(([key, value]) => {
-    if (key === 'oneOf') {
-      throw new SyntaxError('We dont support schemas with oneof properties definition')
-    }
+      return [key, convertToBsonType(value as JSONSchemaType<unknown>)]
+    }))
 
-    return [key, convertToBsonType(value as JSONSchemaType<unknown>)]
-  }))
+  const covertAllOfProperties = (allOf: Record<string, JSONSchemaType<unknown>>[]): Document =>
+    allOf.map(schema => convertProperties(schema.properties ?? {}))
+      .reduce((properties, schema) => ({ ...properties, ...schema }), {})
 
-const covertAllOfProperties = (allOf: Record<string, JSONSchemaType<unknown>>[]): Document =>
-  allOf.map(schema => convertProperties(schema.properties ?? {}))
-    .reduce((properties, schema) => ({ ...properties, ...schema }), {})
+  const prepareScalarType = (value: JSONSchemaType<unknown>): string | string[] => {
+    const type = (Array.isArray(value.type) ? value.type : [value.type])
+      .map(type => type === 'boolean' ? 'bool' : type)
+    if (value.nullable) {
+      type.push('null')
+    }
 
-const prepareScalarType = (value: JSONSchemaType<unknown>): string | string[] => {
-  const type = (Array.isArray(value.type) ? value.type : [value.type])
-    .map(type => type === 'boolean' ? 'bool' : type)
-  if (value.nullable) {
-    type.push('null')
+    return type.length === 1 ? type[0] : type
   }
 
-  return type.length === 1 ? type[0] : type
-}
-
-const convertToBsonType = (value: JSONSchemaType<unknown>): Document => {
-  if (Array.isArray(value.type)) {
-    if ('properties' in value || 'additionalProperties' in value) {
-      return {
-        ...schemaToMongoSchema({ ...value, type: 'object' }),
-        bsonType: prepareScalarType(value)
+  const convertToBsonType = (value: JSONSchemaType<unknown>): Document => {
+    if (Array.isArray(value.type)) {
+      if ('properties' in value || 'additionalProperties' in value) {
+        return {
+          ...schemaToMongoSchema({ ...value, type: 'object' }),
+          bsonType: prepareScalarType(value)
+        }
       }
+      return { bsonType: prepareScalarType(value) }
     }
-    return { bsonType: prepareScalarType(value) }
+
+    return value.type === 'object'
+      // `DateSchema` is `{ type: 'object', format: 'date-time' }`, so a date is detected by
+      // format rather than type — but it still has to honor `nullable`, otherwise an optional
+      // date left unset (the driver writes `undefined` as `null`) fails collection validation.
+      ? value.format === 'date-time' ? { bsonType: value.nullable ? ['date', 'null'] : 'date' } : schemaToMongoSchema(value)
+      : { bsonType: prepareScalarType(value) }
   }
 
-  return value.type === 'object'
-    // `DateSchema` is `{ type: 'object', format: 'date-time' }`, so a date is detected by
-    // format rather than type — but it still has to honor `nullable`, otherwise an optional
-    // date left unset (the driver writes `undefined` as `null`) fails collection validation.
-    ? value.format === 'date-time' ? { bsonType: value.nullable ? ['date', 'null'] : 'date' } : schemaToMongoSchema(value)
-    : { bsonType: prepareScalarType(value) }
+  return { applyReferenceTypes, schemaToMongoSchema }
 }
+
+export const mongoSchemaUtils = createMongoSchemaUtils()

package/src/utils/types.local.ts

@@ -0,0 +1,13 @@
+import type { MigrationStage } from '@owlmeans/resource'
+
+export interface LedgerRecord {
+  alias: string
+  name: string
+  stage: MigrationStage
+  checksum: string | null
+  baseline: boolean
+  startedAt: Date
+  /** `null` while a replica is running it — the claim, not the completion. */
+  completedAt: Date | null
+  durationMs: number | null
+}

package/tests/context.ts

@@ -1,4 +1,4 @@
-import { mongoGate, randomNamespace, registerCleanup } from '@owlmeans/test-integration'
+import { randomNamespace, cleanupHelper, gateHelper } from '@owlmeans/test-integration'
 import type { IntegrationGate, MongoEnv } from '@owlmeans/test-integration'
 
 export interface MongoTestEnv {
@@ -22,12 +22,12 @@ let cached: MongoTestEnv | null = null
  */
 export const getTestEnv = (): MongoTestEnv => {
   if (cached != null) return cached
-  const gate = mongoGate()
+  const gate = gateHelper.mongoGate()
   const prefix = process.env.MONGO_TEST_DB_PREFIX ?? 'omt'
   const dbName = randomNamespace(prefix)
   cached = { gate, dbName }
   if (!gate.skip) {
-    registerCleanup(async () => {
+    cleanupHelper.registerCleanup(async () => {
       const { MongoClient } = await import('mongodb')
       const client = new MongoClient(gate.env.MONGO_URL as string)
       try {