Storage

abstract class AbstractStorage {
  abstract readonly wallets: Repository<Wallet, string>
  abstract readonly sessions: Repository<Session, string>
  abstract readonly bets: Repository<Bet, number>
}

interface Repository<T extends { id: Id }, Id extends string | number> {
  get(id: Id): Promise<T | undefined>
  /** The repository assigns the id. */
  create(data: Omit<T, "id">): Promise<T>
  /** Throws if no record has this id. */
  update(id: Id, patch: Partial<Omit<T, "id">>): Promise<T>
  delete(id: Id): Promise<void>
  find(predicate: (item: T) => boolean): Promise<T[]>
}

import { EngineLgs, InMemoryStorage } from "@slot-engine/lgs"

const lgs = new EngineLgs({ storage: new InMemoryStorage() })

import {
  AbstractStorage,
  type Bet,
  type Repository,
  type Session,
  type Wallet,
} from "@slot-engine/lgs"

class MapRepository<T extends { id: Id }, Id extends string | number>
  implements Repository<T, Id>
{
  private readonly items = new Map<Id, T>()

  constructor(private readonly nextId: () => Id) {}

  async get(id: Id) {
    return this.items.get(id)
  }

  async create(data: Omit<T, "id">) {
    const item = { ...data, id: this.nextId() } as T
    this.items.set(item.id, item)
    return item
  }

  async update(id: Id, patch: Partial<Omit<T, "id">>) {
    const existing = this.items.get(id)
    if (!existing) throw new Error(`No record with id ${id}`)
    const updated = { ...existing, ...patch, id }
    this.items.set(id, updated)
    return updated
  }

  async delete(id: Id) {
    this.items.delete(id)
  }

  async find(predicate: (item: T) => boolean) {
    return [...this.items.values()].filter(predicate)
  }
}

let nextBetId = 0

export class MyStorage extends AbstractStorage {
  readonly wallets = new MapRepository<Wallet, string>(() => crypto.randomUUID())
  readonly sessions = new MapRepository<Session, string>(() => crypto.randomUUID())
  readonly bets = new MapRepository<Bet, number>(() => ++nextBetId)
}