@owlmeans/redis 0.1.17 → 0.1.18-rc.0

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/redis",
-  "version": "0.1.17",
-  "generatedAt": "2026-08-15T13:01:19.942Z",
+  "version": "0.1.18-rc.0",
+  "generatedAt": "2026-08-16T22:20:50.516Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/redis/SKILL.md

@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/redis
 
 **Layer:** Infra
-**Install:** `"@owlmeans/redis": "^0.1.17"` in `dependencies`
+**Install:** `"@owlmeans/redis": "^0.1.18-rc.0"` in `dependencies`
 
 ## Key Exports
 

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@owlmeans/redis",
-  "version": "0.1.17",
+  "version": "0.1.18-rc.0",
   "license": "MIT",
   "type": "module",
   "scripts": {
     "build": "tsc -b",
     "dev": "sleep 240 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
-    "watch": "tsc -b -w --preserveWatchOutput --pretty"
+    "watch": "tsc -b -w --preserveWatchOutput --pretty",
+    "test": "bun test ./tests"
   },
   "main": "build/index.js",
   "module": "build/index.js",
@@ -22,16 +23,18 @@
   },
   "devDependencies": {
     "@owlmeans/dep-config": "workspace:*",
+    "@owlmeans/test-integration": "^0.1.18-rc.0",
+    "@types/bun": "^1.3.14",
     "@types/node": "^26.1.0",
     "nodemon": "^3.1.14",
     "typescript": "^7.0.2"
   },
   "dependencies": {
     "@noble/hashes": "^1.5.0",
-    "@owlmeans/context": "^0.1.17",
-    "@owlmeans/redis-resource": "^0.1.17",
-    "@owlmeans/resource": "^0.1.17",
-    "@owlmeans/server-context": "^0.1.17",
+    "@owlmeans/context": "^0.1.18-rc.0",
+    "@owlmeans/redis-resource": "^0.1.18-rc.0",
+    "@owlmeans/resource": "^0.1.18-rc.0",
+    "@owlmeans/server-context": "^0.1.18-rc.0",
     "@scure/base": "^2.3.0",
     "ioredis": "^5.4.1"
   },

package/tests/context.ts

@@ -0,0 +1,84 @@
+import { redisGate, randomNamespace } from '@owlmeans/test-integration'
+import type { IntegrationGate, RedisEnv } from '@owlmeans/test-integration'
+import { config, makeServerContext } from '@owlmeans/server-context'
+import type { ServerConfig, ServerContext } from '@owlmeans/server-context'
+import type { ResourceRecord } from '@owlmeans/resource'
+import { makeRedisResource } from '@owlmeans/redis-resource'
+import type { RedisResource } from '@owlmeans/redis-resource'
+import { appendRedis, DEFAULT_ALIAS } from '@owlmeans/redis'
+
+export const gate: IntegrationGate<RedisEnv> = redisGate()
+
+export interface TestRecord extends ResourceRecord {
+  id: string
+  value?: string
+}
+
+export interface RedisSuite {
+  /** Key prefix this suite owns end to end. Flushed by {@link teardown}. */
+  prefix: string
+  boot: (alias?: string) => Promise<{
+    context: ServerContext<ServerConfig>
+    resource: RedisResource<TestRecord>
+  }>
+  teardown: () => Promise<void>
+}
+
+/**
+ * One key prefix per suite, dropped by that suite's own `afterAll` — Bun runs every spec
+ * file of a package in one process, so a process-global cleanup queue would let the first
+ * file to finish flush the keys of the files still to come.
+ */
+export const makeSuite = (label: string): RedisSuite => {
+  const base = process.env.REDIS_TEST_KEY_PREFIX ?? 'omt'
+  const prefix = randomNamespace(`${base}_${label}`)
+  const contexts: Array<ServerContext<ServerConfig>> = []
+
+  const boot = async (alias = 'test-records'): Promise<{
+    context: ServerContext<ServerConfig>
+    resource: RedisResource<TestRecord>
+  }> => {
+    const url = new URL(gate.env.REDIS_URL as string)
+    const cfg: ServerConfig = config('redis-test', {
+      dbs: [{
+        service: DEFAULT_ALIAS,
+        alias: DEFAULT_ALIAS,
+        host: url.hostname,
+        port: url.port !== '' ? Number(url.port) : 6379,
+        user: url.username !== '' ? url.username : undefined,
+        secret: decodeURIComponent(url.password),
+        schema: prefix,
+      }]
+    } as Partial<ServerConfig>)
+
+    const context = makeServerContext(cfg) as ServerContext<ServerConfig>
+    appendRedis(context)
+    const resource = makeRedisResource<TestRecord>(alias)
+    context.registerResource(resource as never)
+
+    context.configure()
+    await context.init()
+    contexts.push(context)
+
+    return { context, resource: context.resource<RedisResource<TestRecord>>(alias) }
+  }
+
+  const teardown = async (): Promise<void> => {
+    if (gate.skip) {
+      return
+    }
+    for (const context of contexts) {
+      const resource = context.resource<RedisResource<TestRecord>>('test-records')
+      const client = resource.db?.client
+      if (client == null) continue
+      const keys = await client.keys(`${prefix}:*`).catch(() => [] as string[])
+      if (keys.length > 0) {
+        await client.del(...keys).catch(() => undefined)
+      }
+      await client.quit().catch(() => undefined)
+    }
+    contexts.length = 0
+  }
+
+  return { prefix, boot, teardown }
+}

package/tests/resource.spec.ts

@@ -0,0 +1,56 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { gate, makeSuite } from './context.js'
+
+/**
+ * `delete` regression coverage.
+ *
+ * The by-id form silently did nothing: `delete(id, opts)` only loaded the record when `id`
+ * was an object or `opts` was a field name, so the plain `delete(id)` every caller uses fell
+ * through to `record == null` and returned before touching redis. It surfaced as
+ * `RecordExists` on the second email-OTP request for one address inside the code's TTL —
+ * `issueChallenge` upserts by deleting first — and left consumed codes alive in the store.
+ */
+describe('@owlmeans/redis — resource delete', () => {
+  if (gate.skip) {
+    test.skip(gate.reason ?? 'redis gate closed', () => { })
+    return
+  }
+
+  const suite = makeSuite('delete')
+
+  afterAll(async () => {
+    await suite.teardown()
+  })
+
+  test('removes the record when called by id alone', async () => {
+    const { resource } = await suite.boot()
+    await resource.create({ id: 'by-id', value: 'first' })
+
+    expect(await resource.delete('by-id')).toMatchObject({ id: 'by-id' })
+    expect(await resource.load('by-id')).toBeNull()
+  })
+
+  test('returns null for an id that is not there', async () => {
+    const { resource } = await suite.boot()
+
+    expect(await resource.delete('never-created')).toBeNull()
+  })
+
+  test('lets delete-then-create re-issue under the same id — the OTP upsert', async () => {
+    const { resource } = await suite.boot()
+    await resource.create({ id: 'otp', value: 'first-code' }, { ttl: 600 })
+
+    await resource.delete('otp')
+    await resource.create({ id: 'otp', value: 'second-code' }, { ttl: 600 })
+
+    expect((await resource.load('otp'))?.value).toBe('second-code')
+  })
+
+  test('removes the record when handed the record itself', async () => {
+    const { resource } = await suite.boot()
+    const record = await resource.create({ id: 'by-record', value: 'x' })
+
+    expect(await resource.delete(record)).toMatchObject({ id: 'by-record' })
+    expect(await resource.load('by-record')).toBeNull()
+  })
+})

package/tests/ttl.spec.ts

@@ -0,0 +1,72 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { gate, makeSuite } from './context.js'
+
+/**
+ * TTL regression coverage.
+ *
+ * The absolute (`Date`) form was sent to EXPIREAT as `Date.getTime()` — milliseconds against a
+ * command that reads seconds — so the expiry landed ~50 millennia out and the record never
+ * expired. Asserting the redis-side TTL rather than the call is the whole point here: the buggy
+ * version still "set an expiry", just not one that would ever arrive.
+ */
+describe('@owlmeans/redis — resource ttl', () => {
+  if (gate.skip) {
+    test.skip(gate.reason ?? 'redis gate closed', () => { })
+    return
+  }
+
+  const suite = makeSuite('ttl')
+  /** Generous: the assertion is about the order of magnitude, not clock precision. */
+  const tolerance = 5_000
+
+  afterAll(async () => {
+    await suite.teardown()
+  })
+
+  test('a number TTL is seconds from now', async () => {
+    const { resource } = await suite.boot()
+    await resource.create({ id: 'seconds', value: 'x' }, { ttl: 600 })
+
+    const remaining = await resource.db.client.pttl(resource.key('seconds'))
+
+    expect(remaining).toBeGreaterThan(600_000 - tolerance)
+    expect(remaining).toBeLessThanOrEqual(600_000)
+  })
+
+  test('a Date TTL is the absolute instant to expire at', async () => {
+    const { resource } = await suite.boot()
+    const expiresAt = new Date(Date.now() + 600_000)
+    await resource.create({ id: 'absolute', value: 'x' }, { ttl: expiresAt })
+
+    const remaining = await resource.db.client.pttl(resource.key('absolute'))
+
+    expect(remaining).toBeGreaterThan(600_000 - tolerance)
+    expect(remaining).toBeLessThanOrEqual(600_000)
+  })
+
+  test('update renews the expiry the same way', async () => {
+    const { resource } = await suite.boot()
+    await resource.create({ id: 'renewed', value: 'first' }, { ttl: 5 })
+    await resource.update({ id: 'renewed', value: 'second' }, { ttl: new Date(Date.now() + 600_000) })
+
+    const remaining = await resource.db.client.pttl(resource.key('renewed'))
+
+    expect(remaining).toBeGreaterThan(600_000 - tolerance)
+    expect(remaining).toBeLessThanOrEqual(600_000)
+  })
+
+  test('a Date in the past drops the record immediately', async () => {
+    const { resource } = await suite.boot()
+    await resource.create({ id: 'stale', value: 'x' }, { ttl: new Date(Date.now() - 1_000) })
+
+    expect(await resource.load('stale')).toBeNull()
+  })
+
+  test('no TTL leaves the record persistent', async () => {
+    const { resource } = await suite.boot()
+    await resource.create({ id: 'forever', value: 'x' })
+
+    // redis reports -1 for a key that exists with no expiry.
+    expect(await resource.db.client.pttl(resource.key('forever'))).toBe(-1)
+  })
+})

package/tsconfig.json

@@ -10,6 +10,7 @@
   "exclude": [
     "./dist/**/*",
     "./build/**/*",
+    "./tests/**/*",
     "./*.ts"
   ]
 }