@furystack/mongodb-store 11.0.4 → 11.0.5

package/src/mongodb-store.ts

@@ -1,207 +1,207 @@
-import type {
-  Constructable,
-  CreateResult,
-  FilterType,
-  FindOptions,
-  PartialResult,
-  PhysicalStore,
-  WithOptionalId,
-} from '@furystack/core'
-import { NotFoundError } from '@furystack/core'
-import { EventHub } from '@furystack/utils'
-import type { Collection, Filter, MongoClient, OptionalUnlessRequiredId, Sort } from 'mongodb'
-import { ObjectId } from 'mongodb'
-import type { MongoClientFactory } from './mongo-client-factory.js'
-
-// Improved type safety for hasObjectId
-const hasObjectId = <T extends { _id?: unknown }>(value: T): value is T & { _id: ObjectId } => {
-  return value && typeof value === 'object' && value._id instanceof ObjectId
-}
-
-/**
- * {@link PhysicalStore} backed by a MongoDB collection.
- *
- * The collection handle is resolved lazily on the first call via
- * {@link getCollection}; if the primary key is not `_id` a unique index is
- * created on it during init. Init failure clears the cached promise so the
- * next call retries.
- *
- * When `primaryKey` is `_id`, string keys are transparently coerced to
- * `ObjectId` for filters and back to hex strings on results so callers can
- * stay in plain string-key territory.
- *
- * The store has no `[Symbol.asyncDispose]` — client lifetime belongs to
- * {@link MongoClientFactory}, which closes pooled clients on injector teardown.
- */
-export class MongodbStore<
-  T extends object,
-  TPrimaryKey extends keyof T,
-  TWriteableData = WithOptionalId<T, TPrimaryKey>,
->
-  extends EventHub<{
-    onEntityAdded: { entity: T }
-    onEntityUpdated: { id: T[TPrimaryKey]; change: Partial<T> }
-    onEntityRemoved: { key: T[TPrimaryKey] }
-  }>
-  implements PhysicalStore<T, TPrimaryKey, TWriteableData>
-{
-  public readonly primaryKey: TPrimaryKey
-  public readonly model: Constructable<T>
-  private initPromise: Promise<Collection<T>> | null = null
-  private collection?: Collection<T>
-
-  private createIdFilter(...values: Array<T[TPrimaryKey]>): Filter<T> {
-    // If primaryKey is _id, convert string values to ObjectId
-    return {
-      [this.primaryKey]: {
-        $in: this.primaryKey === '_id' ? values.map((value) => new ObjectId(value as string)) : values,
-      },
-    } as Filter<T>
-  }
-
-  private stringifyResultId(item: T): T {
-    // If _id is ObjectId, convert to string
-    if (this.primaryKey === '_id' && hasObjectId(item)) {
-      return {
-        ...item,
-        _id: item._id.toHexString(),
-      }
-    }
-    return item
-  }
-
-  private parseFilter(filter?: FilterType<T>): Filter<T> {
-    if (!filter) {
-      return {}
-    }
-    // Only handle _id conversion if present
-    if (Object.prototype.hasOwnProperty.call(filter, '_id')) {
-      const f = { ...filter } as Record<string, unknown>
-      if (typeof f._id === 'string') {
-        f._id = new ObjectId(f._id)
-      } else if (typeof f._id === 'object' && f._id !== null) {
-        const idObj = f._id as Record<string, unknown>
-        if (idObj.$eq && typeof idObj.$eq === 'string') {
-          idObj.$eq = new ObjectId(idObj.$eq)
-        }
-        if (Array.isArray(idObj.$in)) {
-          idObj.$in = idObj.$in.map((id: string) => new ObjectId(id))
-        }
-        if (Array.isArray(idObj.$nin)) {
-          idObj.$nin = idObj.$nin.map((id: string) => new ObjectId(id))
-        }
-      }
-      return f as Filter<T>
-    }
-    return filter as Filter<T>
-  }
-
-  public async getCollection(): Promise<Collection<T>> {
-    if (this.collection) {
-      return this.collection
-    }
-    if (!this.initPromise) {
-      this.initPromise = this.initializeCollection()
-    }
-    return this.initPromise
-  }
-
-  private async initializeCollection(): Promise<Collection<T>> {
-    try {
-      const client = this.options.mongoClient()
-      const collection = client.db(this.options.db).collection<T>(this.options.collection)
-      if (this.primaryKey !== '_id') {
-        await collection.createIndex({ [this.primaryKey]: 1 }, { unique: true })
-      }
-      this.collection = collection
-      return collection
-    } catch (error) {
-      this.initPromise = null
-      throw error
-    }
-  }
-
-  constructor(
-    private readonly options: {
-      model: Constructable<T>
-      primaryKey: TPrimaryKey
-      db: string
-      collection: string
-      mongoClient: () => MongoClient
-    },
-  ) {
-    super()
-    this.primaryKey = options.primaryKey
-    this.model = options.model
-  }
-
-  public async add(...entries: TWriteableData[]): Promise<CreateResult<T>> {
-    const collection = await this.getCollection()
-    const result = await collection.insertMany(entries.map((e) => ({ ...e }) as OptionalUnlessRequiredId<T>))
-    const created =
-      this.primaryKey === '_id'
-        ? Object.values(result.insertedIds).map((insertedId, index) =>
-            // Use 'unknown' as intermediate cast to satisfy TypeScript
-            this.stringifyResultId({ _id: insertedId, ...entries[index] } as unknown as T),
-          )
-        : Object.values(result.insertedIds).map((insertedId, index) => {
-            // Use 'unknown' as intermediate cast to satisfy TypeScript
-            const entity = { _id: insertedId, ...entries[index] } as unknown as T & { _id: unknown }
-            const { _id, ...r } = entity
-            return r as T
-          })
-    created.forEach((entity) => this.emit('onEntityAdded', { entity }))
-    return { created }
-  }
-
-  public async update(id: T[TPrimaryKey], data: Partial<T>): Promise<void> {
-    const collection = await this.getCollection()
-    const updateResult = await collection.updateOne(this.createIdFilter(id), { $set: data })
-    if (updateResult.matchedCount < 1) {
-      throw new NotFoundError(`Entity not found with id '${String(id)}', cannot update`)
-    }
-    this.emit('onEntityUpdated', { id, change: data })
-  }
-
-  public async count(filter?: FilterType<T>): Promise<number> {
-    const collection = await this.getCollection()
-    return await collection.countDocuments(this.parseFilter(filter), {})
-  }
-
-  public async find<TFields extends Array<keyof T>>(
-    filter: FindOptions<T, TFields>,
-  ): Promise<Array<PartialResult<T, TFields>>> {
-    const collection = await this.getCollection()
-    const sort: Sort = filter.order
-      ? Object.fromEntries(Object.entries(filter.order).map(([key, value]) => [key, value === 'ASC' ? 1 : -1]))
-      : {}
-    const result = await collection
-      .find(this.parseFilter(filter.filter))
-      .project(this.getProjection(filter.select))
-      .skip(filter.skip || 0)
-      .limit(filter.top || Number.MAX_SAFE_INTEGER)
-      .sort(sort)
-      .toArray()
-    return result.map((entity) => this.stringifyResultId(entity as T))
-  }
-
-  private getProjection(fields?: Array<keyof T>) {
-    return {
-      ...(this.primaryKey !== '_id' ? { _id: 0 } : {}),
-      ...(fields ? Object.fromEntries(fields.map((field) => [field, 1])) : {}),
-    }
-  }
-
-  public async get(key: T[TPrimaryKey], select?: Array<keyof T>): Promise<T | undefined> {
-    const collection = await this.getCollection()
-    const projection = this.getProjection(select)
-    const result = await collection.findOne(this.createIdFilter(key), { projection })
-    return result ? this.stringifyResultId(result as T) : undefined
-  }
-
-  public async remove(...keys: Array<T[TPrimaryKey]>): Promise<void> {
-    const collection = await this.getCollection()
-    await collection.deleteMany(this.createIdFilter(...keys))
-    keys.forEach((key) => this.emit('onEntityRemoved', { key }))
-  }
-}
+import type {
+  Constructable,
+  CreateResult,
+  FilterType,
+  FindOptions,
+  PartialResult,
+  PhysicalStore,
+  WithOptionalId,
+} from '@furystack/core'
+import { NotFoundError } from '@furystack/core'
+import { EventHub } from '@furystack/utils'
+import type { Collection, Filter, MongoClient, OptionalUnlessRequiredId, Sort } from 'mongodb'
+import { ObjectId } from 'mongodb'
+import type { MongoClientFactory } from './mongo-client-factory.js'
+
+// Improved type safety for hasObjectId
+const hasObjectId = <T extends { _id?: unknown }>(value: T): value is T & { _id: ObjectId } => {
+  return value && typeof value === 'object' && value._id instanceof ObjectId
+}
+
+/**
+ * {@link PhysicalStore} backed by a MongoDB collection.
+ *
+ * The collection handle is resolved lazily on the first call via
+ * {@link getCollection}; if the primary key is not `_id` a unique index is
+ * created on it during init. Init failure clears the cached promise so the
+ * next call retries.
+ *
+ * When `primaryKey` is `_id`, string keys are transparently coerced to
+ * `ObjectId` for filters and back to hex strings on results so callers can
+ * stay in plain string-key territory.
+ *
+ * The store has no `[Symbol.asyncDispose]` — client lifetime belongs to
+ * {@link MongoClientFactory}, which closes pooled clients on injector teardown.
+ */
+export class MongodbStore<
+  T extends object,
+  TPrimaryKey extends keyof T,
+  TWriteableData = WithOptionalId<T, TPrimaryKey>,
+>
+  extends EventHub<{
+    onEntityAdded: { entity: T }
+    onEntityUpdated: { id: T[TPrimaryKey]; change: Partial<T> }
+    onEntityRemoved: { key: T[TPrimaryKey] }
+  }>
+  implements PhysicalStore<T, TPrimaryKey, TWriteableData>
+{
+  public readonly primaryKey: TPrimaryKey
+  public readonly model: Constructable<T>
+  private initPromise: Promise<Collection<T>> | null = null
+  private collection?: Collection<T>
+
+  private createIdFilter(...values: Array<T[TPrimaryKey]>): Filter<T> {
+    // If primaryKey is _id, convert string values to ObjectId
+    return {
+      [this.primaryKey]: {
+        $in: this.primaryKey === '_id' ? values.map((value) => new ObjectId(value as string)) : values,
+      },
+    } as Filter<T>
+  }
+
+  private stringifyResultId(item: T): T {
+    // If _id is ObjectId, convert to string
+    if (this.primaryKey === '_id' && hasObjectId(item)) {
+      return {
+        ...item,
+        _id: item._id.toHexString(),
+      }
+    }
+    return item
+  }
+
+  private parseFilter(filter?: FilterType<T>): Filter<T> {
+    if (!filter) {
+      return {}
+    }
+    // Only handle _id conversion if present
+    if (Object.prototype.hasOwnProperty.call(filter, '_id')) {
+      const f = { ...filter } as Record<string, unknown>
+      if (typeof f._id === 'string') {
+        f._id = new ObjectId(f._id)
+      } else if (typeof f._id === 'object' && f._id !== null) {
+        const idObj = f._id as Record<string, unknown>
+        if (idObj.$eq && typeof idObj.$eq === 'string') {
+          idObj.$eq = new ObjectId(idObj.$eq)
+        }
+        if (Array.isArray(idObj.$in)) {
+          idObj.$in = idObj.$in.map((id: string) => new ObjectId(id))
+        }
+        if (Array.isArray(idObj.$nin)) {
+          idObj.$nin = idObj.$nin.map((id: string) => new ObjectId(id))
+        }
+      }
+      return f as Filter<T>
+    }
+    return filter as Filter<T>
+  }
+
+  public async getCollection(): Promise<Collection<T>> {
+    if (this.collection) {
+      return this.collection
+    }
+    if (!this.initPromise) {
+      this.initPromise = this.initializeCollection()
+    }
+    return this.initPromise
+  }
+
+  private async initializeCollection(): Promise<Collection<T>> {
+    try {
+      const client = this.options.mongoClient()
+      const collection = client.db(this.options.db).collection<T>(this.options.collection)
+      if (this.primaryKey !== '_id') {
+        await collection.createIndex({ [this.primaryKey]: 1 }, { unique: true })
+      }
+      this.collection = collection
+      return collection
+    } catch (error) {
+      this.initPromise = null
+      throw error
+    }
+  }
+
+  constructor(
+    private readonly options: {
+      model: Constructable<T>
+      primaryKey: TPrimaryKey
+      db: string
+      collection: string
+      mongoClient: () => MongoClient
+    },
+  ) {
+    super()
+    this.primaryKey = options.primaryKey
+    this.model = options.model
+  }
+
+  public async add(...entries: TWriteableData[]): Promise<CreateResult<T>> {
+    const collection = await this.getCollection()
+    const result = await collection.insertMany(entries.map((e) => ({ ...e }) as OptionalUnlessRequiredId<T>))
+    const created =
+      this.primaryKey === '_id'
+        ? Object.values(result.insertedIds).map((insertedId, index) =>
+            // Use 'unknown' as intermediate cast to satisfy TypeScript
+            this.stringifyResultId({ _id: insertedId, ...entries[index] } as unknown as T),
+          )
+        : Object.values(result.insertedIds).map((insertedId, index) => {
+            // Use 'unknown' as intermediate cast to satisfy TypeScript
+            const entity = { _id: insertedId, ...entries[index] } as unknown as T & { _id: unknown }
+            const { _id, ...r } = entity
+            return r as T
+          })
+    created.forEach((entity) => this.emit('onEntityAdded', { entity }))
+    return { created }
+  }
+
+  public async update(id: T[TPrimaryKey], data: Partial<T>): Promise<void> {
+    const collection = await this.getCollection()
+    const updateResult = await collection.updateOne(this.createIdFilter(id), { $set: data })
+    if (updateResult.matchedCount < 1) {
+      throw new NotFoundError(`Entity not found with id '${String(id)}', cannot update`)
+    }
+    this.emit('onEntityUpdated', { id, change: data })
+  }
+
+  public async count(filter?: FilterType<T>): Promise<number> {
+    const collection = await this.getCollection()
+    return await collection.countDocuments(this.parseFilter(filter), {})
+  }
+
+  public async find<TFields extends Array<keyof T>>(
+    filter: FindOptions<T, TFields>,
+  ): Promise<Array<PartialResult<T, TFields>>> {
+    const collection = await this.getCollection()
+    const sort: Sort = filter.order
+      ? Object.fromEntries(Object.entries(filter.order).map(([key, value]) => [key, value === 'ASC' ? 1 : -1]))
+      : {}
+    const result = await collection
+      .find(this.parseFilter(filter.filter))
+      .project(this.getProjection(filter.select))
+      .skip(filter.skip || 0)
+      .limit(filter.top || Number.MAX_SAFE_INTEGER)
+      .sort(sort)
+      .toArray()
+    return result.map((entity) => this.stringifyResultId(entity as T))
+  }
+
+  private getProjection(fields?: Array<keyof T>) {
+    return {
+      ...(this.primaryKey !== '_id' ? { _id: 0 } : {}),
+      ...(fields ? Object.fromEntries(fields.map((field) => [field, 1])) : {}),
+    }
+  }
+
+  public async get(key: T[TPrimaryKey], select?: Array<keyof T>): Promise<T | undefined> {
+    const collection = await this.getCollection()
+    const projection = this.getProjection(select)
+    const result = await collection.findOne(this.createIdFilter(key), { projection })
+    return result ? this.stringifyResultId(result as T) : undefined
+  }
+
+  public async remove(...keys: Array<T[TPrimaryKey]>): Promise<void> {
+    const collection = await this.getCollection()
+    await collection.deleteMany(this.createIdFilter(...keys))
+    keys.forEach((key) => this.emit('onEntityRemoved', { key }))
+  }
+}