@owlmeans/redis-resource 0.1.0

package/src/resource.ts

@@ -0,0 +1,294 @@
+import type { ResourceMaker, ResourceRecord } from '@owlmeans/resource'
+import { MisshapedRecord, prepareListOptions, RecordExists, UnknownRecordError, UnsupportedArgumentError } from '@owlmeans/resource'
+import type { RedisClient, RedisDbService, RedisResource } from './types.js'
+import type { ServerConfig, ServerContext } from '@owlmeans/server-context'
+import { DEFAULT_DB_ALIAS, DEFAULT_PAGE_SIZE } from './consts.js'
+import { appendContextual, assertContext } from '@owlmeans/context'
+import type { BasicContext, Contextual } from '@owlmeans/context'
+import { prepareSubOptions } from './utils/options.js'
+
+type Config = ServerConfig
+type Context<C extends Config = Config> = ServerContext<C>
+
+export const makeRedisResource = <
+  R extends ResourceRecord, T extends RedisResource<R> = RedisResource<R>
+>(
+  alias: string, dbAlias = DEFAULT_DB_ALIAS, serviceAlias = DEFAULT_DB_ALIAS,
+  makeCustomResource?: ResourceMaker<R, T>
+): T => {
+  const location = `redis-resource:${alias}`
+
+  const resource: T = appendContextual<T>(alias, {
+    key: key => `${resource.db.prefix}:${key ?? '*'}`,
+
+    get: async (id, field, opts) => {
+      const record = await resource.load(id, field, opts)
+      if (record == null) {
+        throw new UnknownRecordError(id)
+      }
+
+      return record
+    },
+
+    load: async (id, field, opts) => {
+      if (typeof field === 'object') {
+        opts = field
+        field = field.field
+      }
+      if (opts != null) {
+        throw new UnsupportedArgumentError('load:opts')
+      }
+      if (field === 'id' || field == null) {
+        const val = await resource.db.client.get(resource.key(id))
+        if (val == null) {
+          return null
+        }
+
+        return JSON.parse(val)
+      }
+      const list = await resource.list({ [field]: id }, { pager: { size: 1 } })
+
+      return list.items[0] ?? null
+    },
+
+    save: async (record, opts) => {
+      if (record.id == null) {
+        throw new MisshapedRecord('id')
+      }
+      const existing = await resource.load(record.id)
+      if (existing != null) {
+        return resource.update(record, opts)
+      }
+
+      return resource.create(record, typeof opts !== 'string' ? opts : undefined)
+    },
+
+    update: async (record, opts) => {
+      let field = 'id'
+      if (typeof opts === 'string') {
+        field = opts
+      } else if (typeof opts === 'object') {
+        field = opts.field ?? field
+      }
+      if (field !== 'id' && record[field as keyof typeof record] == null) {
+        throw new MisshapedRecord('no-field-value')
+      }
+      const id = field == 'id' ? record.id : record[field as keyof typeof record] as string
+      if (id == null) {
+        throw new MisshapedRecord('id')
+      }
+      const _opts = typeof opts === 'object' ? opts : {}
+      const existing = await resource.get(id, field)
+      const updated = { ...existing, ...record }
+      await resource.db.client.set(resource.key(id), JSON.stringify(updated))
+      if (_opts.ttl != null) {
+        if (_opts.ttl instanceof Date) {
+          await resource.db.client.expireat(resource.key(id), _opts.ttl.getTime())
+        } else {
+          await resource.db.client.expire(resource.key(id), _opts.ttl)
+        }
+      }
+
+      return updated
+    },
+
+    create: async (record, opts) => {
+      if (record.id == null) {
+        throw new UnknownRecordError('id')
+      }
+      if (await resource.load(record.id) != null) {
+        throw new RecordExists(record.id)
+      }
+
+      const id = record.id
+      await resource.db.client.set(resource.key(id), JSON.stringify(record))
+      if (opts?.ttl != null) {
+        if (opts.ttl instanceof Date) {
+          await resource.db.client.expireat(resource.key(id), opts.ttl.getTime())
+        } else {
+          await resource.db.client.expire(resource.key(id), opts.ttl)
+        }
+      }
+
+      return record
+    },
+
+    delete: async (id, opts) => {
+      let record: R | null = null
+      if (typeof id === 'object') {
+        if (id.id == null) {
+          throw new MisshapedRecord('id')
+        }
+        record = await resource.load(id.id)
+      } else if (typeof opts === 'string') {
+        record = await resource.load(id, opts)
+      }
+
+      if (record == null) {
+        return null
+      }
+
+      let field = 'id'
+      if (typeof opts === 'string') {
+        field = opts
+        opts = undefined
+      } else if (typeof opts === 'object') {
+        field = opts.field ?? field
+      }
+
+      id = record.id ?? ''
+
+      if (id === '') {
+        throw new MisshapedRecord('id')
+      }
+
+      if (await resource.db.client.del(resource.key(id)) > 0) {
+        return record
+      }
+
+      return null
+    },
+
+    pick: async (id, opts) => {
+      let record: R | null = null
+      if (typeof id === 'object') {
+        if (id.id == null) {
+          throw new MisshapedRecord('id')
+        }
+        record = await resource.load(id.id)
+      } else {
+        record = await resource.load(id, opts)
+      }
+
+      if (record == null) {
+        return null
+      }
+
+      let field = 'id'
+      if (typeof opts === 'string') {
+        field = opts
+        opts = undefined
+      } else if (typeof opts === 'object') {
+        field = opts.field ?? field
+      }
+
+      id = record.id ?? ''
+
+      if (id === '') {
+        throw new MisshapedRecord('id')
+      }
+
+      if (await resource.db.client.del(resource.key(id)) > 0) {
+        return record
+      }
+
+      throw new UnknownRecordError(id)
+    },
+
+    list: async (criteria, opts) => {
+      const options = prepareListOptions(DEFAULT_PAGE_SIZE, criteria, opts)
+      criteria = options.criteria
+      const pager = options.pager ?? {}
+
+      const keys = await resource.db.client.keys(resource.key())
+      pager.total = keys.length
+      pager.page = pager.page ?? 0
+      pager.size = pager.size ?? DEFAULT_PAGE_SIZE
+
+      if (keys.length === 0) {
+        return { items: [], pager }
+      }
+
+      const start = pager.page * pager.size
+      const slice = keys.toSpliced(start, pager.size)
+
+      return {
+        pager, items: (await Promise.all(slice.map(
+          async key => await resource.db.client.get(key)
+        ))).filter(val => typeof val === 'string').map(
+          val => JSON.parse(val as string)
+        )
+      }
+    },
+
+    subscribe: async (handler, opts) => {
+      opts = prepareSubOptions(opts)
+
+      let _unsubascribeCalled = false
+      const unsusbscibe = async () => {
+        if (_unsubascribeCalled) {
+          return
+        }
+        _unsubascribeCalled = true
+        try {
+          await subscriber.punsubscribe(resource.key(opts.key)).then(() => subscriber.quit())
+        } catch (e) {
+          console.error('Try to unsubscribe redis resource', e)
+        }
+      }
+
+      const listener = (value: R) => {
+        handler(value as any)
+        if (opts.once === true) {
+          void unsusbscibe()
+        }
+      }
+
+      const subscriber = (resource.db.client as RedisClient).duplicate()
+      if (opts.key != null && null != await resource.load(opts.key)) {
+        await subscriber.psubscribe(`__keyspace@0__:${resource.key(opts.key)}`)
+        subscriber.on('pmessage', async (_, channel) => {
+          const [, , ...key] = (channel as string).split(':')
+          const record = await resource.load(key.join(':'))
+          listener(record ?? { id: key, __null: true } as any as R)
+        })
+      } else {
+        await subscriber.psubscribe(resource.key(opts.key))
+        subscriber.on('pmessage', (_, __, message) => listener(JSON.parse(message)))
+      }
+
+
+      if (opts.ttl != null) {
+        const ttl = opts.ttl instanceof Date
+          ? opts.ttl.getTime() - Date.now()
+          : typeof opts.ttl === 'number'
+            ? opts.ttl * 1000
+            : null
+        if (ttl == null) {
+          throw new UnsupportedArgumentError(`subscribe:ttl:${typeof opts.ttl}`)
+        }
+        setTimeout(unsusbscibe, ttl)
+      }
+
+      return unsusbscibe
+    },
+
+    publish: async (record, key) => {
+      await resource.db.client.publish(resource.key(key), JSON.stringify(record))
+    }
+  } as Partial<T>)
+
+  resource.init = async () => {
+    const context = assertContext<Config, Context>(resource.ctx as Context, location)
+    const redis = context.service<RedisDbService>(serviceAlias ?? dbAlias)
+    await redis.ready()
+    const db = await redis.db(dbAlias)
+    const _pref = (val: string) => val.replaceAll(/\W+/g, '_')
+
+    resource.db = {
+      client: db.client,
+      prefix: `${_pref(db.prefix)}-${_pref(resource.name ?? alias)}`
+    }
+  }
+
+  resource.reinitializeContext = <Type extends Contextual>(context: BasicContext<Config>) => {
+    const resource = (makeCustomResource?.(dbAlias, serviceAlias)
+      ?? makeRedisResource<R, T>(alias, dbAlias, serviceAlias)) as unknown as Type
+
+    resource.ctx = context
+
+    return resource as Type
+  }
+
+  return resource
+}

package/src/types.ts

@@ -0,0 +1,32 @@
+import type { LifecycleOptions, Resource, ResourceDbService, ResourceRecord } from '@owlmeans/resource'
+
+import type { RedisCommander, Redis, Cluster } from 'ioredis'
+
+export interface RedisDbService extends ResourceDbService<RedisDb, RedisClient> {
+}
+
+export type RedisClient = Redis | Cluster
+
+export interface RedisDb {
+  client: RedisCommander
+  prefix: string
+}
+
+export interface RedisResource<T extends ResourceRecord> extends Resource<T> {
+  name?: string
+
+  db: RedisDb
+
+  key: (key?: string) => string
+
+  subscribe: <Type extends T>(handler: (value: Type) => Promise<void>, key?: SubOpts) => Promise<() => Promise<void>>
+
+  publish: <Type extends T>(value: Type, key?: string) => Promise<void>
+}
+
+export type SubOpts = number |string | boolean | SubscriptionOptions
+
+export interface SubscriptionOptions extends LifecycleOptions {
+  key?: string
+  once?: boolean
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+
+export * from './options.js'

package/src/utils/options.ts

@@ -0,0 +1,17 @@
+
+import type { SubOpts, SubscriptionOptions } from '../types.js'
+
+export const prepareSubOptions = (opts?: SubOpts): SubscriptionOptions => {
+  let _opts: SubscriptionOptions = {}
+  if (typeof opts === 'string') {
+    _opts.key = opts
+  } else if (typeof opts === 'number') {
+    _opts.ttl = opts
+  } else if (typeof opts === 'boolean') {
+    _opts.once = opts
+  } else if (typeof opts === 'object') {
+    _opts = opts
+  }
+
+  return _opts
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/consts.ts","./src/index.ts","./src/resource.ts","./src/types.ts","./src/utils/index.ts","./src/utils/options.ts"],"version":"5.6.3"}