Caching

import { createRedisClusterCache } from 'ts-prorm-orm';

export const shopCache = createRedisClusterCache(
  [
    { host: 'redis-1', port: 6379 },
    { host: 'redis-2', port: 6379 },
  ],
  {
    key: { prefix: 'shop:' },
    l1: { enabled: true, maxEntries: 1000, ttl: 60 },
    l2: { enabled: true, defaultTtl: 3600 },   // seconds
  },
);

import { createRedisClusterCache } from 'ts-prorm-orm';

const local = createRedisClusterCache([], { key: { prefix: 'shop:' }, l1: { maxEntries: 2 } });

await local.set('product:1', '{"id":1}', 300); // true
await local.set('product:2', '{"id":2}');
await local.get('product:1');                   // '{"id":1}'
await local.set('product:3', '{"id":3}');       // capacity 2: evicts product:2, the least recently used
await local.get('product:2');                   // null
await local.mget(['product:1', 'nope']);        // ['{"id":1}', <empty slot>]

local.getStats();
// { hits: 2, misses: 1, l1Hits: 2, l2Hits: 0, keys: 2, hitRate: 0.6666666666666666 }

await local.invalidatePattern('product:*');     // 2

// shopCache is the cache exported by src/cache.ts

export async function loadProduct(id: number) {
  const key = `product:${id}`;
  const hit = await shopCache.get(key);
  if (hit) return JSON.parse(hit);

  const row = await Product.findByPk(id);
  if (row) await shopCache.set(key, JSON.stringify(row), 300);
  return row;
}

export async function listProducts(page: number) {
  const key = `product:list:${page}`;
  const hit = await shopCache.get(key);
  if (hit) return JSON.parse(hit);

  const rows = await Product.findAll({ order: [['id', 'ASC']], limit: 20, offset: (page - 1) * 20 });
  await shopCache.set(key, JSON.stringify(rows), 60);
  return rows;
}

import { DataTypes } from 'ts-prorm-orm';
// shopCache is the cache exported by src/cache.ts

function invalidate(options: any) {
  const id = options?.where?.id;
  const one = typeof id === 'number' ? shopCache.del(`product:${id}`) : shopCache.invalidatePattern('product:*');
  return Promise.all([one, shopCache.invalidatePattern('product:list:*')]);
}

export const Product = prorm.define('Product', {
  id:    { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
  sku:   { type: DataTypes.STRING(32) },
  price: { type: DataTypes.DECIMAL(10, 2) },
}, {
  tableName: 'products',
  timestamps: false,
  hooks: {
    afterBulkUpdate: (options: any) => invalidate(options),   // instance.save(), Product.update()
    afterBulkDestroy: (options: any) => invalidate(options),  // instance.destroy(), Product.destroy()
    afterBulkCreate: () => shopCache.invalidatePattern('product:list:*'),
    afterCreate: () => shopCache.invalidatePattern('product:list:*'),
  },
});

shop:product:42               -> one product
shop:product:list:1           -> a page of the product listing
shop:user:7:orders:page:1     -> one user's order history

const s = shopCache.getStats();
// { hits, misses, l1Hits, l2Hits, keys, hitRate }
shopCache.resetStats();

import { AbstractCacheManager } from 'ts-prorm-orm';

class MemcachedCache extends AbstractCacheManager {
  async get(key: string): Promise<string | null> { /* … */ return null; }
  async set(key: string, value: string, ttl?: number): Promise<boolean> { /* … */ return true; }
  async del(key: string): Promise<boolean> { /* … */ return true; }
  async exists(key: string): Promise<boolean> { /* … */ return false; }
  async invalidatePattern(pattern: string): Promise<number> { /* … */ return 0; }
  async clear(): Promise<boolean> { /* … */ return true; }
  async mget(keys: string[]): Promise<(string | null)[]> { /* … */ return keys.map(() => null); }
  async mset(entries: Array<{ key: string; value: string; ttl?: number }>): Promise<boolean> { /* … */ return true; }
  async disconnect(): Promise<void> { /* … */ }
  isConnected(): boolean { return true; }
}