muya 2.1.1 → 2.1.2

package/src/sqlite/__tests__/table.test.ts

@@ -0,0 +1,142 @@
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-shadow */
+/* eslint-disable sonarjs/pseudo-random */
+// /* eslint-disable sonarjs/no-unused-vars */
+// /* eslint-disable unicorn/prevent-abbreviations */
+
+import { bunMemoryBackend } from '../table/bun-backend'
+import { createTable } from '../table/table'
+
+interface Person {
+  name: string
+  age: number
+  city: string
+}
+describe('table', () => {
+  let backend = bunMemoryBackend()
+  let table: ReturnType<typeof createTable<Person>> extends Promise<infer T> ? T : never
+
+  beforeEach(async () => {
+    backend = bunMemoryBackend()
+    table = await createTable<Person>({
+      backend,
+      tableName: 'TestTable',
+      key: 'name',
+    })
+  })
+
+  it('should set and get items', async () => {
+    const mutation = await table.set({ name: 'Alice', age: 30, city: 'Paris' })
+    expect(mutation.key).toBe('Alice')
+    expect(mutation.op).toBe('insert')
+    const result = await table.get('Alice')
+    expect(result).toEqual({ name: 'Alice', age: 30, city: 'Paris' })
+
+    const updateMutation = await table.set({ name: 'Alice', age: 31, city: 'Paris' })
+    expect(updateMutation.key).toBe('Alice')
+    expect(updateMutation.op).toBe('update')
+    const updatedResult = await table.get('Alice')
+    expect(updatedResult).toEqual({ name: 'Alice', age: 31, city: 'Paris' })
+  })
+
+  it('should count items and count with where', async () => {
+    await table.set({ name: 'Alice', age: 30, city: 'Paris' })
+    await table.set({ name: 'Bob', age: 25, city: 'London' })
+    expect(await table.count()).toBe(2)
+    expect(await table.count({ where: { city: 'Paris' } })).toBe(1)
+  })
+
+  it('should search with ordering, limit and offset', async () => {
+    const people: Person[] = [
+      { name: 'Alice', age: 30, city: 'Paris' },
+      { name: 'Bob', age: 25, city: 'London' },
+      { name: 'Carol', age: 35, city: 'Berlin' },
+    ]
+    for (const p of people) {
+      await table.set(p)
+    }
+    // sort by age ascending
+    const asc = [] as Person[]
+    for await (const p of table.search({ sorBy: 'age', order: 'asc' })) asc.push(p)
+    expect(asc.map((p) => p.name)).toEqual(['Bob', 'Alice', 'Carol'])
+    // limit and offset
+    const limited = [] as Person[]
+    for await (const p of table.search({ sorBy: 'age', order: 'asc', limit: 2 })) limited.push(p)
+    expect(limited.map((p) => p.name)).toEqual(['Bob', 'Alice'])
+    const offsetted = [] as Person[]
+    for await (const p of table.search({ sorBy: 'age', order: 'asc', offset: 1, limit: 2 })) offsetted.push(p)
+    expect(offsetted.map((p) => p.name)).toEqual(['Alice', 'Carol'])
+  })
+
+  it('should deleteBy where clause', async () => {
+    await table.set({ name: 'Dave', age: 40, city: 'NY' })
+    await table.set({ name: 'Eve', age: 45, city: 'NY' })
+    await table.set({ name: 'Frank', age: 50, city: 'LA' })
+    expect(await table.count()).toBe(3)
+    await table.deleteBy({ city: 'NY' })
+    expect(await table.count()).toBe(1)
+    expect(await table.get('Frank')).toEqual({ name: 'Frank', age: 50, city: 'LA' })
+    expect(await table.get('Dave')).toBeUndefined()
+  })
+
+  it('should use selector in get and search', async () => {
+    await table.set({ name: 'Gary', age: 60, city: 'SF' })
+    // selector in get
+    const ageOnly = await table.get('Gary', ({ age }) => age)
+    expect(ageOnly).toBe(60)
+    // selector in search
+    const cities: string[] = []
+    for await (const city of table.search({ select: ({ city }) => city })) cities.push(city)
+    expect(cities).toEqual(['SF'])
+  })
+
+  it('should delete items by key', async () => {
+    await table.set({ name: 'Helen', age: 28, city: 'Rome' })
+    expect(await table.get('Helen')).toBeDefined()
+    await table.delete('Helen')
+    expect(await table.get('Helen')).toBeUndefined()
+  })
+  it('should test search with 1000 items', async () => {
+    const people: Person[] = []
+    for (let index = 0; index < 1000; index++) {
+      people.push({
+        name: `Person${index}`,
+        age: Math.floor(Math.random() * 100),
+        city: 'City' + (index % 10),
+      })
+    }
+    for (const p of people) {
+      await table.set(p)
+    }
+    const results: Person[] = []
+    for await (const person of table.search({ sorBy: 'age', order: 'asc', limit: 100 })) {
+      results.push(person)
+    }
+    expect(results.length).toBe(100)
+  })
+
+  it('should handle operations on an empty table', async () => {
+    expect(await table.count()).toBe(0)
+    expect(await table.get('NonExistent')).toBeUndefined()
+    const results: Person[] = []
+    for await (const person of table.search({ sorBy: 'age', order: 'asc' })) {
+      results.push(person)
+    }
+    expect(results.length).toBe(0)
+  })
+
+  it('should handle duplicate keys gracefully', async () => {
+    await table.set({ name: 'Alice', age: 30, city: 'Paris' })
+    await table.set({ name: 'Alice', age: 35, city: 'Berlin' })
+    const result = await table.get('Alice')
+    expect(result).toEqual({ name: 'Alice', age: 35, city: 'Berlin' })
+  })
+
+  it('should handle edge cases in selectors', async () => {
+    await table.set({ name: 'Charlie', age: 40, city: 'NY' })
+    const nullSelector = await table.get('Charlie', () => null)
+    expect(nullSelector).toBeNull()
+    const undefinedSelector = await table.get('Charlie', () => void 0)
+    expect(undefinedSelector).toBeUndefined()
+  })
+})

package/src/sqlite/__tests__/use-sqlite-state.test.ts

@@ -0,0 +1,213 @@
+import { act, renderHook } from '@testing-library/react-hooks'
+import { createSqliteState } from '../create-sqlite-state'
+import { useSqliteValue } from '../use-sqlite-value'
+import { waitFor } from '@testing-library/react'
+import { bunMemoryBackend } from '../table/bun-backend'
+import { useState } from 'react'
+import { DEFAULT_STEP_SIZE } from '../table/table'
+
+const backend = bunMemoryBackend()
+interface Person {
+  id: string
+  name: string
+  age: number
+}
+
+describe('use-sqlite-state', () => {
+  it('should get basic value states', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State1', key: 'id' })
+    let reRenders = 0
+    const { result } = renderHook(() => {
+      reRenders++
+      return useSqliteValue(sql, {}, [])
+    })
+    // expect(result.current).toEqual([])
+
+    expect(reRenders).toBe(1)
+
+    act(() => {
+      sql.set({ id: '1', name: 'Alice', age: 30 })
+    })
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice', age: 30 }])
+      expect(reRenders).toBe(3)
+    })
+
+    act(() => {
+      sql.set({ id: '1', name: 'Alice2', age: 30 })
+    })
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([{ id: '1', name: 'Alice2', age: 30 }])
+      expect(reRenders).toBe(4)
+    })
+
+    // delete item
+    act(() => {
+      sql.delete('1')
+    })
+    await waitFor(() => {
+      expect(result.current[0]).toEqual([])
+      expect(reRenders).toBe(5)
+    })
+
+    // add two items
+    act(() => {
+      sql.set({ id: '1', name: 'Alice', age: 30 })
+      sql.set({ id: '2', name: 'Bob', age: 25 })
+    })
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(2)
+      expect(reRenders).toBe(6)
+    })
+  })
+
+  it('should use where clause changed via state', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State2', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+    let reRenders = 0
+    const { result } = renderHook(() => {
+      reRenders++
+      const [minAge, setMinAge] = useState(20)
+      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sorBy: 'age' }, [minAge]), setMinAge] as const
+    })
+
+    await waitFor(() => {
+      expect(result.current[0][0].map((p) => p.name)).toEqual(['Bob', 'Alice', 'Carol'])
+      expect(reRenders).toBe(2)
+    })
+
+    // // change minAge to 29
+    act(() => {
+      result.current[1](29)
+    })
+    await waitFor(() => {
+      expect(result.current[0][0].map((p) => p.name)).toEqual(['Alice', 'Carol'])
+      expect(reRenders).toBe(4)
+    })
+  })
+
+  it('should support like in where clause and update results', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State3', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Alicia', age: 25 },
+      { id: '3', name: 'Bob', age: 40 },
+    ])
+    let reRenders = 0
+    const { result, rerender } = renderHook(
+      ({ like }) => {
+        reRenders++
+        return useSqliteValue(sql, { where: { name: { like } } }, [like])
+      },
+      { initialProps: { like: '%Ali%' } },
+    )
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Alicia'])
+    })
+    act(() => {
+      rerender({ like: '%Bob%' })
+    })
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Bob'])
+    })
+    expect(reRenders).toBeGreaterThanOrEqual(2)
+  })
+
+  it('should update results when changing order and limit options', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State4', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+      { id: '3', name: 'Carol', age: 40 },
+    ])
+    const { result, rerender } = renderHook(
+      ({ order, limit }) => useSqliteValue(sql, { sorBy: 'age', order, limit }, [order, limit]),
+      { initialProps: { order: 'asc' as 'asc' | 'desc', limit: 2 } },
+    )
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Bob', 'Alice'])
+    })
+    act(() => {
+      rerender({ order: 'desc', limit: 2 })
+    })
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Carol', 'Alice'])
+    })
+    act(() => {
+      rerender({ order: 'desc', limit: 1 })
+    })
+    await waitFor(() => {
+      expect(result.current[0].map((p) => p.name)).toEqual(['Carol'])
+    })
+  })
+
+  it('should support actions.next and actions.refresh', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State5', key: 'id' })
+    await sql.batchSet([
+      { id: '1', name: 'Alice', age: 30 },
+      { id: '2', name: 'Bob', age: 25 },
+    ])
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+    // actions.next and actions.refresh should be functions
+    await waitFor(() => {
+      expect(typeof result.current[1].next).toBe('function')
+      expect(typeof result.current[1].reset).toBe('function')
+      expect(result.current[1].reset()).resolves.toBeUndefined()
+      expect(result.current[1].next()).resolves.toBeFalsy()
+    })
+  })
+  it('should handle thousands of records', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State6', key: 'id' })
+    const people: Person[] = []
+    const ITEMS_COUNT = 1000
+    for (let index = 1; index <= ITEMS_COUNT; index++) {
+      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
+    }
+    await sql.batchSet(people)
+    const { result } = renderHook(() => useSqliteValue(sql, {}, []))
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(DEFAULT_STEP_SIZE)
+    })
+
+    // loop until we have all ITEMS_COUNT items
+    for (let index = 0; index < ITEMS_COUNT / DEFAULT_STEP_SIZE; index++) {
+      act(() => {
+        result.current[1].next()
+      })
+      await waitFor(() => {
+        expect(result.current[0].length).toBe(Math.min(DEFAULT_STEP_SIZE * (index + 2), ITEMS_COUNT))
+      })
+    }
+
+    act(() => {
+      result.current[1].reset()
+    })
+    await waitFor(() => {
+      expect(result.current[0].length).toBe(DEFAULT_STEP_SIZE)
+    })
+  })
+  it('should change ordering', async () => {
+    const sql = await createSqliteState<Person>({ backend, tableName: 'State7', key: 'id' })
+    const people: Person[] = []
+    for (let index = 1; index <= 100; index++) {
+      people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
+    }
+    await sql.batchSet(people)
+    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sorBy: 'age', order }, [order]), {
+      initialProps: { order: 'asc' as 'asc' | 'desc' },
+    })
+    await waitFor(() => {
+      expect(result.current[0][0].age).toBe(20)
+    })
+    act(() => {
+      rerender({ order: 'desc' })
+    })
+    await waitFor(() => {
+      expect(result.current[0][0].age).toBe(69)
+    })
+  })
+})

package/src/sqlite/create-sqlite-state.ts

@@ -0,0 +1,256 @@
+/* eslint-disable sonarjs/redundant-type-aliases */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-shadow */
+import { createScheduler } from '../scheduler'
+import { shallow } from '../utils/shallow'
+import { createTable, DEFAULT_STEP_SIZE } from './table/table'
+import type { DbOptions, DocType, Key, MutationResult, SearchOptions, Table } from './table/table.types'
+import type { Where } from './table/where'
+
+type SearchId = string
+const STATE_SCHEDULER = createScheduler()
+
+let stateId = 0
+function getStateId() {
+  return stateId++
+}
+export interface SyncTable<Document extends DocType> {
+  // readonly registerSearch: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => () => void
+  readonly updateSearchOptions: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => void
+  readonly subscribe: (searchId: SearchId, listener: () => void) => () => void
+  readonly getSnapshot: (searchId: SearchId) => Document[]
+  readonly refresh: (searchId: SearchId) => Promise<void>
+
+  readonly set: (document: Document) => Promise<MutationResult>
+  readonly batchSet: (documents: Document[]) => Promise<MutationResult[]>
+  readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>
+
+  readonly delete: (key: Key) => Promise<MutationResult | undefined>
+  readonly search: <Selected = Document>(options?: SearchOptions<Document, Selected>) => AsyncIterableIterator<Selected>
+  readonly count: (options?: { where?: Where<Document> }) => Promise<number>
+  readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>
+  readonly destroy: () => void
+  readonly next: (searchId: SearchId) => Promise<boolean>
+}
+
+interface DataItems<Document extends DocType> {
+  items: Document[]
+  keys: Set<Key>
+  options?: SearchOptions<Document, unknown>
+}
+
+export async function createSqliteState<Document extends DocType>(options: DbOptions<Document>): Promise<SyncTable<Document>> {
+  // const table = await createTable<Document>(options)
+
+  const id = getStateId()
+  function getScheduleId(searchId: SearchId) {
+    return `state-${id}-search-${searchId}`
+  }
+
+  let cachedTable: Table<Document> | undefined
+  async function getTable() {
+    if (!cachedTable) {
+      cachedTable = await createTable<Document>(options)
+    }
+    return cachedTable
+  }
+
+  interface NextResult {
+    document: Document
+    rowId: number
+  }
+  // const emitter = createEmitter<Table<Document>>()
+  const cachedData = new Map<SearchId, DataItems<Document>>()
+  const listeners = new Map<SearchId, () => void>()
+  const iterators = new Map<SearchId, AsyncIterableIterator<NextResult>>()
+
+  async function next(searchId: SearchId, data: DataItems<Document>): Promise<boolean> {
+    const iterator = iterators.get(searchId)
+    const { items, options = {} } = data
+    const { stepSize = DEFAULT_STEP_SIZE } = options
+    if (!iterator) return false
+    const newItems: Document[] = []
+
+    for (let index = 0; index < stepSize; index++) {
+      const result = await iterator.next()
+      if (result.done) {
+        iterators.delete(searchId)
+        break
+      }
+      newItems.push(result.value.document)
+      data.keys.add(String(result.value.rowId))
+    }
+
+    if (shallow(data.items, newItems)) return false
+    data.items = [...items, ...newItems]
+    return newItems.length > 0
+  }
+
+  function notifyListeners(searchId: SearchId) {
+    const searchListeners = listeners.get(searchId)
+    if (searchListeners) {
+      searchListeners()
+    }
+  }
+
+  async function refreshCache(searchId: SearchId) {
+    const table = await getTable()
+    const data = cachedData.get(searchId)
+    if (!data) return
+    const { options } = data
+    const iterator = table.search({ ...options, select: (document, { rowId }) => ({ document, rowId }) })
+    iterators.set(searchId, iterator)
+    data.keys = new Set()
+    data.items = []
+    await next(searchId, data)
+  }
+  async function refresh(searchId: SearchId) {
+    await refreshCache(searchId)
+    notifyListeners(searchId)
+  }
+
+  function handleChange(mutationResult: MutationResult) {
+    const { key, op } = mutationResult
+    // find all cached data with key
+    const searchIds = new Set<SearchId>()
+    for (const [searchId, { keys }] of cachedData) {
+      switch (op) {
+        case 'delete':
+        case 'update': {
+          if (keys.has(String(key))) {
+            searchIds.add(searchId)
+          }
+          break
+        }
+        case 'insert': {
+          // we do not know about the key
+          searchIds.add(searchId)
+          break
+        }
+      }
+    }
+    return searchIds
+  }
+
+  async function handleChanges(mutationResults: MutationResult[]) {
+    const updateSearchIds = new Set<SearchId>()
+    for (const mutationResult of mutationResults) {
+      const searchIds = handleChange(mutationResult)
+      for (const searchId of searchIds) {
+        updateSearchIds.add(searchId)
+      }
+    }
+
+    // const promises = []
+    for (const searchId of updateSearchIds) {
+      const scheduleId = getScheduleId(searchId)
+      STATE_SCHEDULER.schedule(scheduleId, { searchId })
+    }
+  }
+
+  const clearSchedulers = new Set<() => void>()
+
+  function registerData(searchId: SearchId, options?: SearchOptions<Document, unknown>) {
+    if (!cachedData.has(searchId)) {
+      cachedData.set(searchId, { items: [], options, keys: new Set() })
+      if (options) {
+        refresh(searchId)
+      }
+    }
+    const data = cachedData.get(searchId)!
+    if (options) {
+      data.options = options
+    }
+    return data
+  }
+
+  return {
+    async set(document) {
+      const table = await getTable()
+      const changes = await table.set(document)
+      await handleChanges([changes])
+      return changes
+    },
+    async batchSet(documents) {
+      const table = await getTable()
+      const changes = await table.batchSet(documents)
+      await handleChanges(changes)
+      return changes
+    },
+    async delete(key) {
+      const table = await getTable()
+      const changes = await table.delete(key)
+      if (changes) {
+        await handleChanges([changes])
+      }
+      return changes
+    },
+    async deleteBy(where) {
+      const table = await getTable()
+      const changes = await table.deleteBy(where)
+      await handleChanges(changes)
+      return changes
+    },
+    async get(key, selector) {
+      const table = await getTable()
+      return table.get(key, selector)
+    },
+    async *search(options = {}) {
+      const table = await getTable()
+      for await (const item of table.search(options)) {
+        yield item
+      }
+    },
+    async count(options) {
+      const table = await getTable()
+      return await table.count(options)
+    },
+
+    updateSearchOptions(searchId, options) {
+      const data = registerData(searchId, options)
+      data.options = options
+      const scheduleId = getScheduleId(searchId)
+      STATE_SCHEDULER.schedule(scheduleId, { searchId })
+    },
+
+    subscribe(searchId, listener) {
+      const scheduleId = getScheduleId(searchId)
+      const clear = STATE_SCHEDULER.add(scheduleId, {
+        onScheduleDone() {
+          refresh(searchId)
+        },
+      })
+      clearSchedulers.add(clear)
+
+      if (!listeners.has(searchId)) {
+        listeners.set(searchId, listener)
+      }
+      return () => {
+        listeners.delete(searchId)
+        clear()
+        cachedData.delete(searchId)
+      }
+    },
+    getSnapshot(searchId) {
+      const data = registerData(searchId)
+      return data.items
+    },
+    refresh,
+    destroy() {
+      for (const clear of clearSchedulers) clear()
+      cachedData.clear()
+      listeners.clear()
+    },
+    async next(searchId) {
+      const data = cachedData.get(searchId)
+      if (data) {
+        const hasNext = await next(searchId, data)
+        if (hasNext) {
+          notifyListeners(searchId)
+        }
+        return hasNext
+      }
+      return false
+    },
+  }
+}

package/src/sqlite/table/backend.ts

@@ -0,0 +1,21 @@
+export const IN_MEMORY_DB = ':memory:'
+
+export interface QueryResult {
+  /** The number of rows affected by the query. */
+  rowsAffected: number
+  /**
+   * The last inserted `id`.
+   *
+   * This value is not set for Postgres databases. If the
+   * last inserted id is required on Postgres, the `select` function
+   * must be used, with a `RETURNING` clause
+   * (`INSERT INTO todos (title) VALUES ($1) RETURNING id`).
+   */
+  lastInsertId?: number
+}
+export interface Backend {
+  execute: (query: string, bindValues?: unknown[]) => Promise<QueryResult>
+  select: <T>(query: string, bindValues?: unknown[]) => Promise<T>
+  transaction: (callback: (tx: Backend) => Promise<void>) => Promise<void>
+  path: string
+}

package/src/sqlite/table/bun-backend.ts

@@ -0,0 +1,38 @@
+import { Database, type Statement } from 'bun:sqlite'
+import type { Backend } from './backend'
+import { MapDeque } from './map-deque'
+
+export function bunMemoryBackend(): Backend {
+  const db = Database.open(':memory:')
+  const prepares = new MapDeque<string, Statement>(100)
+  function getStatement(query: string): Statement {
+    if (prepares.has(query)) {
+      return prepares.get(query)!
+    }
+    const stmt = db.prepare(query)
+    prepares.set(query, stmt)
+    return stmt
+  }
+
+  const backend: Backend = {
+    execute: async (query, params = []) => {
+      const q = getStatement(query)
+      const result = q.run(...(params as never[]))
+      return {
+        rowsAffected: result.changes,
+        changes: result.changes,
+      }
+    },
+    transaction: async (callback) => {
+      return db.transaction(() => callback(backend))()
+    },
+    path: db.filename,
+    select: async (query, params = []) => {
+      const q = getStatement(query)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const result = q.all(...(params as never[])) as Array<Record<string, any>>
+      return result as never
+    },
+  }
+  return backend
+}

package/src/sqlite/table/map-deque.ts

@@ -0,0 +1,29 @@
+export class MapDeque<K, V> extends Map<K, V> {
+  constructor(
+    private maxSize: number,
+    entries?: ReadonlyArray<readonly [K, V]> | null,
+  ) {
+    super(entries)
+    if (this.maxSize <= 0) {
+      throw new RangeError('maxSize must be greater than 0')
+    }
+  }
+
+  override set(key: K, value: V): this {
+    if (this.has(key)) {
+      super.set(key, value)
+      return this
+    }
+
+    if (this.size >= this.maxSize) {
+      const firstKey = this.keys().next().value
+      if (firstKey !== undefined) {
+        this.delete(firstKey)
+      }
+    }
+
+    super.set(key, value)
+
+    return this
+  }
+}