odac 1.4.8 → 1.4.9

package/src/WebSocket.js

@@ -14,10 +14,26 @@ const OPCODE = {
   PONG: 0xa
 }
 
+/**
+ * RFC 6455 connection lifecycle states.
+ * Exposed as static constants on WebSocketClient for consumer-side checks.
+ */
+const READY_STATE = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+}
+
 class WebSocketClient {
+  static CONNECTING = READY_STATE.CONNECTING
+  static OPEN = READY_STATE.OPEN
+  static CLOSING = READY_STATE.CLOSING
+  static CLOSED = READY_STATE.CLOSED
+
   #socket
   #handlers = {}
-  #closed = false
+  #readyState = READY_STATE.CONNECTING
   #server
   #id
   #rooms = new Set()
@@ -26,6 +42,7 @@ class WebSocketClient {
   #rateLimitWindow
   #messageCount = 0
   #rateLimitTimer
+  #fragments = null
   data = {}
 
   constructor(socket, server, id, options = {}) {
@@ -47,10 +64,20 @@ class WebSocketClient {
     this.#setupListeners()
   }
 
+  /**
+   * Transitions the client from CONNECTING to OPEN and resumes the underlying socket.
+   * Must be called after the handler is attached to begin receiving frames.
+   */
   resume() {
+    this.#readyState = READY_STATE.OPEN
     this.#socket.resume()
   }
 
+  /** @returns {number} Current RFC 6455 ready state (0–3). */
+  get readyState() {
+    return this.#readyState
+  }
+
   get id() {
     return this.#id
   }
@@ -154,10 +181,36 @@ class WebSocketClient {
 
     switch (frame.opcode) {
       case OPCODE.TEXT:
-        this.#handleMessage(frame.payload.toString('utf8'))
-        break
       case OPCODE.BINARY:
-        this.#handleMessage(frame.payload)
+        if (frame.fin) {
+          if (this.#fragments) {
+            // Final fragment of a fragmented sequence
+            this.#fragments.buffers.push(frame.payload)
+            const merged = Buffer.concat(this.#fragments.buffers)
+            const opcode = this.#fragments.opcode
+            this.#fragments = null
+            this.#handleMessage(opcode === OPCODE.TEXT ? merged.toString('utf8') : merged)
+          } else {
+            // Single, unfragmented message
+            this.#handleMessage(frame.opcode === OPCODE.TEXT ? frame.payload.toString('utf8') : frame.payload)
+          }
+        } else {
+          // First fragment — start accumulating
+          this.#fragments = {opcode: frame.opcode, buffers: [frame.payload]}
+        }
+        break
+      case OPCODE.CONTINUATION:
+        if (!this.#fragments) {
+          this.close(1002, 'Protocol error: unexpected continuation frame')
+          return
+        }
+        this.#fragments.buffers.push(frame.payload)
+        if (frame.fin) {
+          const merged = Buffer.concat(this.#fragments.buffers)
+          const opcode = this.#fragments.opcode
+          this.#fragments = null
+          this.#handleMessage(opcode === OPCODE.TEXT ? merged.toString('utf8') : merged)
+        }
         break
       case OPCODE.PING:
         this.#sendFrame(OPCODE.PONG, frame.payload)
@@ -181,11 +234,16 @@ class WebSocketClient {
     }
   }
 
-  #handleClose() {
-    if (this.#closed) return
-    this.#closed = true
+  /**
+   * Centralised resource teardown — called by both close() and the socket 'close' event.
+   * Idempotent: subsequent calls are no-ops once state reaches CLOSED.
+   */
+  #cleanup() {
+    if (this.#readyState === READY_STATE.CLOSED) return
+    this.#readyState = READY_STATE.CLOSED
 
     if (this.#rateLimitTimer) clearInterval(this.#rateLimitTimer)
+    this.#fragments = null
 
     this.#socket.removeAllListeners()
 
@@ -197,8 +255,15 @@ class WebSocketClient {
     this.#server.removeClient(this.#id)
   }
 
+  #handleClose() {
+    this.#cleanup()
+  }
+
   #sendFrame(opcode, data) {
-    if (this.#closed && opcode !== OPCODE.CLOSE) return
+    if (this.#readyState === READY_STATE.CLOSED) return
+    if (this.#readyState === READY_STATE.CLOSING && opcode !== OPCODE.CLOSE) return
+    if (!this.#socket.writable) return
+
     const payload = Buffer.isBuffer(data) ? data : Buffer.from(data)
     const length = payload.length
 
@@ -247,28 +312,27 @@ class WebSocketClient {
   }
 
   send(data) {
-    if (this.#closed) return this
+    if (this.#readyState !== READY_STATE.OPEN) return this
     const payload = typeof data === 'object' ? JSON.stringify(data) : String(data)
     this.#sendFrame(OPCODE.TEXT, payload)
     return this
   }
 
   sendBinary(data) {
-    if (this.#closed) return this
+    if (this.#readyState !== READY_STATE.OPEN) return this
     this.#sendFrame(OPCODE.BINARY, data)
     return this
   }
 
   ping() {
+    if (this.#readyState !== READY_STATE.OPEN) return this
     this.#sendFrame(OPCODE.PING, Buffer.alloc(0))
     return this
   }
 
   close(code = 1000, reason = '') {
-    if (this.#closed) return
-    this.#closed = true
-
-    if (this.#rateLimitTimer) clearInterval(this.#rateLimitTimer)
+    if (this.#readyState === READY_STATE.CLOSED || this.#readyState === READY_STATE.CLOSING) return
+    this.#readyState = READY_STATE.CLOSING
 
     const reasonBuffer = Buffer.from(reason)
     const payload = Buffer.alloc(2 + reasonBuffer.length)
@@ -277,14 +341,7 @@ class WebSocketClient {
 
     this.#sendFrame(OPCODE.CLOSE, payload)
     this.#socket.end()
-    this.#socket.removeAllListeners()
-
-    for (const room of this.#rooms) {
-      this.#server.leaveRoom(this.#id, room)
-    }
-
-    this.#emit('close')
-    this.#server.removeClient(this.#id)
+    this.#cleanup()
   }
 
   join(room) {
@@ -448,4 +505,4 @@ class WebSocketServer {
   }
 }
 
-module.exports = {WebSocketServer, WebSocketClient}
+module.exports = {WebSocketServer, WebSocketClient, READY_STATE}

package/test/Database/Migration/migrate_column.test.js

@@ -49,4 +49,172 @@ describe('Migration.migrate() - Column Diff', () => {
 
     expect(dropOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'drop_column', column: 'obsolete', table: 'items'})]))
   })
+
+  it('should alter a column when its default value changes', async () => {
+    writeSchema('settings', {columns: {id: {type: 'increments'}, status: {type: 'string', default: 'active'}}})
+    await Migration.migrate()
+
+    writeSchema('settings', {columns: {id: {type: 'increments'}, status: {type: 'string', default: 'inactive'}}})
+    const result = await Migration.migrate()
+    const alterOps = result.default.schema.filter(op => op.type === 'alter_column')
+
+    expect(alterOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'alter_column', column: 'status', table: 'settings'})]))
+  })
+
+  it('should alter a column when its default value is removed', async () => {
+    writeSchema('settings', {columns: {id: {type: 'increments'}, status: {type: 'string', default: 'active'}}})
+    await Migration.migrate()
+
+    writeSchema('settings', {columns: {id: {type: 'increments'}, status: {type: 'string'}}})
+    const result = await Migration.migrate()
+    const alterOps = result.default.schema.filter(op => op.type === 'alter_column')
+
+    expect(alterOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'alter_column', column: 'status', table: 'settings'})]))
+  })
+
+  it('should not alter a column when its default value is unchanged', async () => {
+    writeSchema('settings', {columns: {id: {type: 'increments'}, status: {type: 'string', default: 'active'}}})
+    await Migration.migrate()
+
+    writeSchema('settings', {columns: {id: {type: 'increments'}, status: {type: 'string', default: 'active'}}})
+    const result = await Migration.migrate()
+    const alterOps = result.default.schema.filter(op => op.type === 'alter_column')
+
+    expect(alterOps).toHaveLength(0)
+  })
+})
+
+describe('Migration.migrate() - Foreign Key Diff', () => {
+  it('should add a foreign key to an existing column', async () => {
+    writeSchema('users', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    writeSchema('posts', {columns: {id: {type: 'increments'}, user_id: {type: 'integer', unsigned: true}}})
+    await Migration.migrate()
+
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', unsigned: true, references: {table: 'users', column: 'id'}, onDelete: 'CASCADE'}
+      }
+    })
+    const result = await Migration.migrate()
+    const fkOps = result.default.schema.filter(op => op.type === 'add_foreign_key')
+
+    expect(fkOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'add_foreign_key', column: 'user_id', table: 'posts'})]))
+  })
+
+  it('should drop a foreign key removed from schema', async () => {
+    writeSchema('users', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', unsigned: true, references: {table: 'users', column: 'id'}, onDelete: 'CASCADE'}
+      }
+    })
+    await Migration.migrate()
+
+    writeSchema('posts', {columns: {id: {type: 'increments'}, user_id: {type: 'integer', unsigned: true}}})
+    const result = await Migration.migrate()
+    const fkOps = result.default.schema.filter(op => op.type === 'drop_foreign_key')
+
+    expect(fkOps).toEqual(expect.arrayContaining([expect.objectContaining({type: 'drop_foreign_key', column: 'user_id', table: 'posts'})]))
+  })
+
+  it('should replace a foreign key when onDelete action changes', async () => {
+    writeSchema('users', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', unsigned: true, references: {table: 'users', column: 'id'}, onDelete: 'SET NULL'}
+      }
+    })
+    await Migration.migrate()
+
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', unsigned: true, references: {table: 'users', column: 'id'}, onDelete: 'CASCADE'}
+      }
+    })
+    const result = await Migration.migrate()
+    const dropOps = result.default.schema.filter(op => op.type === 'drop_foreign_key')
+    const addOps = result.default.schema.filter(op => op.type === 'add_foreign_key')
+
+    expect(dropOps).toHaveLength(1)
+    expect(addOps).toHaveLength(1)
+    expect(addOps[0]).toMatchObject({column: 'user_id', table: 'posts'})
+  })
+
+  it('should not produce FK ops when references are unchanged', async () => {
+    writeSchema('users', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', unsigned: true, references: {table: 'users', column: 'id'}, onDelete: 'CASCADE'}
+      }
+    })
+    await Migration.migrate()
+
+    const result = await Migration.migrate()
+    const fkOps = result.default.schema.filter(op => op.type === 'add_foreign_key' || op.type === 'drop_foreign_key')
+
+    expect(fkOps).toHaveLength(0)
+  })
+
+  it('should clean orphan rows before adding a foreign key constraint', async () => {
+    writeSchema('users', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    writeSchema('posts', {columns: {id: {type: 'increments'}, user_id: {type: 'integer', nullable: true}}})
+    await Migration.migrate()
+
+    // Insert a valid parent and an orphan child
+    await db('users').insert({name: 'Alice'})
+    await db('posts').insert({user_id: 1})
+    await db('posts').insert({user_id: 999}) // orphan — user 999 does not exist
+
+    // Now add FK constraint
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', nullable: true, references: {table: 'users', column: 'id'}, onDelete: 'CASCADE'}
+      }
+    })
+    await Migration.migrate()
+
+    // Orphan row should have user_id set to NULL (nullable column)
+    const orphan = await db('posts').where('id', 2).first()
+    expect(orphan.user_id).toBeNull()
+
+    // Valid row should be untouched
+    const valid = await db('posts').where('id', 1).first()
+    expect(valid.user_id).toBe(1)
+  })
+
+  it('should skip FK and warn when non-nullable column has orphan rows', async () => {
+    writeSchema('users', {columns: {id: {type: 'increments'}, name: {type: 'string'}}})
+    writeSchema('posts', {columns: {id: {type: 'increments'}, user_id: {type: 'integer', nullable: false}}})
+    await Migration.migrate()
+
+    await db('users').insert({name: 'Alice'})
+    await db('posts').insert({user_id: 1})
+    await db('posts').insert({user_id: 999}) // orphan
+
+    const warnSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    writeSchema('posts', {
+      columns: {
+        id: {type: 'increments'},
+        user_id: {type: 'integer', nullable: false, references: {table: 'users', column: 'id'}, onDelete: 'CASCADE'}
+      }
+    })
+    await Migration.migrate()
+
+    // Orphan row must NOT be deleted — all data preserved
+    const rows = await db('posts').select()
+    expect(rows).toHaveLength(2)
+
+    // Warning must have been emitted
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping foreign key'))
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('1 orphan row(s)'))
+
+    warnSpy.mockRestore()
+  })
 })

package/test/Database/ReadCache/crossTable.test.js

@@ -0,0 +1,179 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests cross-table cache invalidation for JOIN queries.
+ * Why: A cached query like posts.join('users').cache().select() must be invalidated
+ * when EITHER posts OR users is written to. Validates that cache keys are registered
+ * in all joined tables' indexes.
+ */
+
+let knexLib, db
+
+beforeEach(async () => {
+  jest.resetModules()
+
+  knexLib = require('knex')
+  db = knexLib({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+
+  await db.schema.createTable('posts', table => {
+    table.integer('id').primary()
+    table.string('title', 255)
+    table.integer('user_id')
+  })
+
+  await db.schema.createTable('users', table => {
+    table.integer('id').primary()
+    table.string('name', 255)
+  })
+
+  await db.schema.createTable('categories', table => {
+    table.integer('id').primary()
+    table.string('label', 255)
+  })
+
+  await db('users').insert([
+    {id: 1, name: 'Alice'},
+    {id: 2, name: 'Bob'}
+  ])
+
+  await db('categories').insert([{id: 1, label: 'Tech'}])
+
+  await db('posts').insert([
+    {id: 1, title: 'Post A', user_id: 1},
+    {id: 2, title: 'Post B', user_id: 2}
+  ])
+
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  const Ipc = require('../../../src/Ipc')
+  global.Odac = {
+    Config: {
+      cache: {ttl: 60, maxKeys: 10000},
+      buffer: {flushInterval: 999999, checkpointInterval: 999999}
+    },
+    Storage: {
+      isReady: () => false,
+      put: jest.fn(),
+      remove: jest.fn(),
+      getRange: () => []
+    },
+    Ipc
+  }
+  await Ipc.init()
+
+  const writeBuffer = require('../../../src/Database/WriteBuffer')
+  await writeBuffer.init({default: db})
+
+  const readCache = require('../../../src/Database/ReadCache')
+  readCache.init()
+
+  const DB = require('../../../src/Database')
+  DB.connections = {default: db}
+})
+
+afterEach(async () => {
+  const writeBuffer = require('../../../src/Database/WriteBuffer')
+  await writeBuffer.close()
+  await Odac.Ipc.close()
+  await db.destroy()
+  delete global.Odac
+})
+
+describe('Cross-table cache invalidation (JOIN queries)', () => {
+  it('should register cache key in joined table index', async () => {
+    const readCache = require('../../../src/Database/ReadCache')
+
+    const qb = db('posts').join('users', 'posts.user_id', '=', 'users.id').select('posts.title', 'users.name')
+    const executeFn = () => qb.then(r => r)
+    await readCache.get('default', 'posts', qb, executeFn, 60)
+
+    // Cache key should be in BOTH posts and users indexes
+    const postKeys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    const userKeys = await Odac.Ipc.smembers('rc:idx:default:users')
+
+    expect(postKeys).toHaveLength(1)
+    expect(userKeys).toHaveLength(1)
+    expect(postKeys[0]).toBe(userKeys[0])
+  })
+
+  it('should invalidate joined query when joined table is written to', async () => {
+    const DB = require('../../../src/Database')
+
+    // Cache a JOIN query via proxy
+    const result1 = await DB.posts.cache(60).join('users', 'posts.user_id', '=', 'users.id').select('posts.title', 'users.name')
+
+    expect(result1).toHaveLength(2)
+
+    // Verify cache exists in both indexes
+    let postKeys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    let userKeys = await Odac.Ipc.smembers('rc:idx:default:users')
+    expect(postKeys).toHaveLength(1)
+    expect(userKeys).toHaveLength(1)
+
+    // Write to the JOINED table (users) — should invalidate the cached join query
+    await DB.users.where({id: 1}).update({name: 'Alice Updated'})
+
+    userKeys = await Odac.Ipc.smembers('rc:idx:default:users')
+    expect(userKeys).toHaveLength(0)
+
+    // The cache entry itself should be deleted — next read should hit DB
+    const result2 = await DB.posts.cache(60).join('users', 'posts.user_id', '=', 'users.id').select('posts.title', 'users.name')
+
+    expect(result2[0].name).toBe('Alice Updated')
+  })
+
+  it('should invalidate joined query when primary table is written to', async () => {
+    const DB = require('../../../src/Database')
+
+    await DB.posts.cache(60).join('users', 'posts.user_id', '=', 'users.id').select('posts.title', 'users.name')
+
+    // Write to the PRIMARY table (posts)
+    await DB.posts.where({id: 1}).update({title: 'Updated Post'})
+
+    const postKeys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    expect(postKeys).toHaveLength(0)
+
+    // Fresh read should reflect the update
+    const result = await DB.posts.cache(60).join('users', 'posts.user_id', '=', 'users.id').select('posts.title', 'users.name')
+
+    expect(result[0].title).toBe('Updated Post')
+  })
+
+  it('should handle multiple joins', async () => {
+    const readCache = require('../../../src/Database/ReadCache')
+
+    const qb = db('posts')
+      .join('users', 'posts.user_id', '=', 'users.id')
+      .leftJoin('categories', 'posts.id', '=', 'categories.id')
+      .select('posts.title', 'users.name', 'categories.label')
+
+    const executeFn = () => qb.then(r => r)
+    await readCache.get('default', 'posts', qb, executeFn, 60)
+
+    // Cache key should be in ALL three table indexes
+    const postKeys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    const userKeys = await Odac.Ipc.smembers('rc:idx:default:users')
+    const catKeys = await Odac.Ipc.smembers('rc:idx:default:categories')
+
+    expect(postKeys).toHaveLength(1)
+    expect(userKeys).toHaveLength(1)
+    expect(catKeys).toHaveLength(1)
+    expect(postKeys[0]).toBe(userKeys[0])
+    expect(postKeys[0]).toBe(catKeys[0])
+  })
+
+  it('should handle aliased table names in joins', async () => {
+    const readCache = require('../../../src/Database/ReadCache')
+
+    const qb = db('posts').join('users as u', 'posts.user_id', '=', 'u.id').select('posts.title', 'u.name')
+
+    const executeFn = () => qb.then(r => r)
+    await readCache.get('default', 'posts', qb, executeFn, 60)
+
+    // Should register under 'users', not 'users as u'
+    const userKeys = await Odac.Ipc.smembers('rc:idx:default:users')
+    expect(userKeys).toHaveLength(1)
+  })
+})

package/test/Database/ReadCache/get.test.js

@@ -0,0 +1,128 @@
+'use strict'
+
+const cluster = require('node:cluster')
+
+/**
+ * Tests ReadCache.get() — the core read-through logic.
+ * Why: Validates cache HIT/MISS behavior, TTL propagation, and maxKeys guard.
+ */
+
+let knexLib, db
+
+beforeEach(async () => {
+  jest.resetModules()
+
+  knexLib = require('knex')
+  db = knexLib({client: 'sqlite3', connection: {filename: ':memory:'}, useNullAsDefault: true})
+
+  await db.schema.createTable('posts', table => {
+    table.integer('id').primary()
+    table.string('title', 255)
+    table.boolean('active').defaultTo(true)
+  })
+
+  await db('posts').insert([
+    {id: 1, title: 'First Post', active: true},
+    {id: 2, title: 'Second Post', active: true},
+    {id: 3, title: 'Draft', active: false}
+  ])
+
+  Object.defineProperty(cluster, 'isPrimary', {value: true, configurable: true})
+
+  const Ipc = require('../../../src/Ipc')
+  global.Odac = {
+    Config: {cache: {ttl: 60, maxKeys: 10000}},
+    Ipc
+  }
+  await Ipc.init()
+})
+
+afterEach(async () => {
+  await Odac.Ipc.close()
+  await db.destroy()
+  delete global.Odac
+})
+
+describe('ReadCache.get()', () => {
+  let readCache
+
+  beforeEach(() => {
+    readCache = require('../../../src/Database/ReadCache')
+    readCache.init()
+  })
+
+  it('should return DB result on cache MISS and cache it', async () => {
+    const qb = db('posts').where({active: true}).select('id', 'title')
+    const executeFn = () => qb.then(r => r)
+    const result = await readCache.get('default', 'posts', qb, executeFn, 60)
+
+    expect(result).toHaveLength(2)
+    expect(result[0].title).toBe('First Post')
+
+    // Verify it was cached — check index
+    const keys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    expect(keys).toHaveLength(1)
+  })
+
+  it('should return cached result on cache HIT without querying DB', async () => {
+    const qb1 = db('posts').where({active: true}).select('id', 'title')
+    const executeFn1 = () => qb1.then(r => r)
+    const result1 = await readCache.get('default', 'posts', qb1, executeFn1, 60)
+
+    // Modify DB directly — cache should NOT reflect this
+    await db('posts').where({id: 1}).update({title: 'Modified'})
+
+    const qb2 = db('posts').where({active: true}).select('id', 'title')
+    const executeFn2 = () => qb2.then(r => r)
+    const result2 = await readCache.get('default', 'posts', qb2, executeFn2, 60)
+
+    // Should still return the old cached value
+    expect(result2[0].title).toBe('First Post')
+    expect(result1).toEqual(result2)
+  })
+
+  it('should use config default TTL when ttl parameter is 0', async () => {
+    const qb = db('posts').where({id: 1}).first()
+    const executeFn = () => qb.then(r => r)
+    const result = await readCache.get('default', 'posts', qb, executeFn, 0)
+
+    expect(result.title).toBe('First Post')
+
+    // Should still be cached
+    const keys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    expect(keys).toHaveLength(1)
+  })
+
+  it('should respect maxKeys limit', async () => {
+    // Re-init with maxKeys = 1
+    global.Odac.Config.cache = {ttl: 60, maxKeys: 1}
+
+    readCache = require('../../../src/Database/ReadCache')
+    readCache.init()
+
+    const qb1 = db('posts').where({id: 1}).first()
+    const executeFn1 = () => qb1.then(r => r)
+    await readCache.get('default', 'posts', qb1, executeFn1, 60)
+
+    const qb2 = db('posts').where({id: 2}).first()
+    const executeFn2 = () => qb2.then(r => r)
+    await readCache.get('default', 'posts', qb2, executeFn2, 60)
+
+    // Only 1 key should be in the index (first one cached, second skipped)
+    const keys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    expect(keys).toHaveLength(1)
+  })
+
+  it('should generate different keys for different queries', async () => {
+    const qb1 = db('posts').where({id: 1}).first()
+    const qb2 = db('posts').where({id: 2}).first()
+    const executeFn1 = () => qb1.then(r => r)
+    const executeFn2 = () => qb2.then(r => r)
+
+    await readCache.get('default', 'posts', qb1, executeFn1, 60)
+    await readCache.get('default', 'posts', qb2, executeFn2, 60)
+
+    const keys = await Odac.Ipc.smembers('rc:idx:default:posts')
+    expect(keys).toHaveLength(2)
+  })
+})