@effect-app/infra 0.7.0

package/_src/services/Store/Redis.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as RedisClient from "@effect-app/infra-adapters/redis-client"
+import { NotFoundError } from "../../errors.js"
+import { memFilter } from "./Memory.js"
+
+import type { Filter, FilterJoinSelect, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"
+import { StoreMaker } from "./service.js"
+import { codeFilterJoinSelect, makeETag, makeUpdateETag } from "./utils.js"
+
+export function makeRedisStore({ prefix }: StorageConfig) {
+  return Effect.gen(function*($) {
+    const redis = yield* $(RedisClient.RedisClient.access)
+    return {
+      make: <Id extends string, PM extends PersistenceModelType<Id>, Id2 extends Id>(
+        name: string,
+        existing?: Effect<never, never, ROMap<Id2, PM>>,
+        _config?: StoreConfig<PM>
+      ) =>
+        Effect.gen(function*($) {
+          const updateETag = makeUpdateETag(name)
+          // Very naive implementation of course.
+          const key = `${prefix}${name}`
+          const current = yield* $(RedisClient.get(key).orDie.provideService(RedisClient.RedisClient, redis))
+          if (!current.isSome()) {
+            const m = yield* $(existing ?? Effect(ROMap.empty))
+            yield* $(
+              RedisClient.set(key, JSON.stringify({ data: [...m.values()].map(e => makeETag(e)) }))
+                .orDie
+                .provideService(RedisClient.RedisClient, redis)
+            )
+          }
+          const get = RedisClient.get(key)
+            .flatMap(x => x.encaseInEffect(() => new NotFoundError("data", "")))
+            .orDie
+            .map(x => JSON.parse(x) as { data: readonly PM[] })
+            .map(_ => _.data)
+            .provideService(RedisClient.RedisClient, redis)
+
+          const set = (i: ROMap<Id, PM>) => RedisClient.set(key, JSON.stringify({ data: [...i.values()] })).orDie
+
+          const sem = Semaphore.unsafeMake(1)
+          const withPermit = sem.withPermits(1)
+
+          const asMap = get.map(x => ROMap.make(x.map(x => [x.id, x] as const)))
+          const all = get.map(Chunk.fromIterable)
+          const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
+            items
+              .forEachEffect(e => s.find(e.id).flatMap(current => updateETag(e, current)))
+              .tap(items =>
+                asMap
+                  .map(m => {
+                    const mut = ROMap.toMutable(m)
+                    items.forEach(e => mut.set(e.id, e))
+                    return ROMap.fromMutable(mut)
+                  })
+                  .flatMap(set)
+              )
+              .map(_ => _.toReadonlyArray() as NonEmptyReadonlyArray<PM>)
+              .apply(withPermit)
+              .provideService(RedisClient.RedisClient, redis)
+          const s: Store<PM, Id> = {
+            all,
+            filter: (filter: Filter<PM>, cursor?: { skip?: number; limit?: number }) =>
+              all.map(memFilter(filter, cursor)),
+            filterJoinSelect: <T extends object>(filter: FilterJoinSelect) =>
+              all.map(c => c.flatMap(codeFilterJoinSelect<PM, T>(filter))),
+            find: id => asMap.map(ROMap.lookup(id)),
+            set: e =>
+              s
+                .find(e.id)
+                .flatMap(current => updateETag(e, current))
+                .tap(e => asMap.map(ROMap.insert(e.id, e)).flatMap(set))
+                .apply(withPermit)
+                .provideService(RedisClient.RedisClient, redis),
+            batchSet,
+            bulkSet: batchSet,
+            remove: (e: PM) =>
+              asMap.map(ROMap.remove(e.id)).flatMap(set)
+                .apply(withPermit)
+                .provideService(
+                  RedisClient.RedisClient,
+                  redis
+                )
+          }
+          return s
+        })
+    }
+  })
+}
+export function RedisStoreLive(config: Config<StorageConfig>) {
+  return config.config.flatMap(makeRedisStore).toLayer(StoreMaker)
+}

package/_src/services/Store/codeFilter.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "vitest"
+import type { StoreWhereFilter, Where } from "@effect-app/infra/services/Store"
+import { makeFilters } from "../../lib/filter.js"
+import { codeFilter } from "./utils.js"
+
+
+const somethings = [
+  {a: 1, b: "b", c: ["c"], d: [{a: "a2", b: 1}, {a: "a", b: 1}], id: "1"},
+  {a: 2, b: "b2", c: ["c2"], d: [{a: "a4", b: 2}, {a: "a5", b: 2}], id: "2"},
+] satisfies readonly Something[]
+
+const f_ = makeFilters<Something>()
+export type SomethingWhereFilter = typeof f_
+
+export function makeSomethingFilter_(filter: (f: SomethingWhereFilter) => StoreWhereFilter) {
+  return filter(f_)
+}
+
+export function somethingsWhere(
+  makeWhere: (
+    f: SomethingWhereFilter
+  ) => Where | [Where, ...Where[]],
+  mode?: "or" | "and"
+) {
+  return makeSomethingFilter_(f => {
+    const m = makeWhere ? makeWhere(f) : []
+    return ({
+      mode,
+      where: (Array.isArray(m) ? m as unknown as [Where, ...Where[]] : [m]) as readonly [Where, ...Where[]]
+    })
+  })
+}
+
+
+type SomethingElse = {
+  a: string,
+  b: number
+}
+
+type Something = {
+  a: number,
+  id: string,
+  b: string,
+  c: readonly string[]
+  d: readonly SomethingElse[]
+}
+
+test("works", () => {
+  expect(somethings.filterMap(codeFilter(
+    somethingsWhere(_ => _("b", _ => "b2"))
+  )).toArray)
+  .toEqual([somethings[1]])
+
+  expect(somethings.filterMap(codeFilter(
+    somethingsWhere(_ => _("b", _ => "b"))
+  )).toArray)
+  .toEqual([somethings[0]])
+
+
+  expect(somethings.filterMap(codeFilter(
+    somethingsWhere(_ => _("d.-1.a", _ => "a5"))
+  )).toArray)
+  .toEqual([somethings[1]])
+
+  expect(somethings.filterMap(codeFilter(
+    somethingsWhere(_ => _("d.-1.a", _ => "a"))
+  )).toArray)
+  .toEqual([somethings[0]])
+
+  expect(somethings.filterMap(codeFilter(
+    somethingsWhere(_ => _("d.-1.a", _ => _.$isnt("a")))
+  )).toArray)
+  .toEqual([somethings[1]])
+})

package/_src/services/Store/index.test.ts.bak

@@ -0,0 +1,112 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Test from "@effect-ts/jest/Test"
+import { describe, expect } from "@jest/globals"
+
+import { OptimisticConcurrencyException } from "../../errors.js"
+
+import { makeMemoryStore } from "./Memory.js"
+
+const { it } = Test.runtime()
+
+describe("Optimistic Concurrency", () => {
+  describe("set", () => {
+    it("works", () =>
+      Effect.gen(function*($) {
+        const existing = new Map<
+          string,
+          { _etag: string | undefined; id: string; a: string }
+        >()
+        const { make } = makeMemoryStore()
+        const store = yield* $(make("test", Effect(existing)))
+
+        const result1 = yield* $(store.set({ id: "1", a: "string", _etag: undefined }))
+        const result2_1 = yield* $(
+          store.set({ id: "2", a: "string", _etag: undefined })
+        )
+        const result2 = yield* $(store.set({ ...result1, a: "another-string" }))
+        const result3 = yield* $(store.set({ ...result2, a: "another-string2" }))
+        const failResult = yield* $(
+          store.set({ ...result1, a: "another-string3" }).result
+        )
+        expect(result1._etag).toBeTruthy()
+        expect(result2_1._etag).toBeTruthy()
+        expect(result2._etag).toBeTruthy()
+        expect(result3._etag).toBeTruthy()
+
+        expect(result2._etag).not.toEqual(result1._etag)
+        expect(result3._etag).not.toEqual(result2._etag)
+
+        expect(Exit.untraced(failResult)).toEqual(
+          Exit.fail(new OptimisticConcurrencyException("test", "1"))
+        )
+        console.log({ result1, result2 })
+      }))
+  })
+
+  describe("bulkSet", () => {
+    it("works", () =>
+      Effect.gen(function*($) {
+        const existing = new Map<
+          string,
+          { _etag: string | undefined; id: string; a: string }
+        >()
+        const { make } = makeMemoryStore()
+        const store = yield* $(make("test", Effect(existing)))
+
+        const [result1] = yield* $(
+          store.bulkSet([{ id: "1", a: "string", _etag: undefined }])
+        )
+        const [result2_1] = yield* $(
+          store.bulkSet([{ id: "2", a: "string", _etag: undefined }])
+        )
+        const [result2] = yield* $(store.bulkSet([{ ...result1, a: "another-string" }]))
+        const [result3] = yield* $(
+          store.bulkSet([{ ...result2, a: "another-string2" }])
+        )
+        const failResult = yield* $(
+          store.bulkSet([{ ...result1, a: "another-string3" }]).result
+        )
+        expect(result1._etag).toBeTruthy()
+        expect(result2_1._etag).toBeTruthy()
+        expect(result2._etag).toBeTruthy()
+        expect(result3._etag).toBeTruthy()
+
+        expect(result2._etag).not.toEqual(result1._etag)
+        expect(result3._etag).not.toEqual(result2._etag)
+
+        expect(Exit.untraced(failResult)).toEqual(
+          Exit.fail(new OptimisticConcurrencyException("test", "1"))
+        )
+        console.log({ result1, result2 })
+      }))
+  })
+
+  describe("batchSet", () => {
+    it("works", () =>
+      Effect.gen(function*($) {
+        const existing = new Map<
+          string,
+          { _etag: string | undefined; id: string; a: string }
+        >()
+        const { make } = makeMemoryStore()
+        const store = yield* $(make("test", Effect(existing)))
+
+        const item1 = { id: "1", a: "string", _etag: undefined }
+        const item2 = { id: "2", a: "string", _etag: undefined }
+
+        yield* $(store.batchSet([item1, item2]))
+
+        const [result1, result2] = yield* $(
+          Effect.collectAll([store.find("1"), store.find("2")])
+        )
+        const failResult = yield* $(
+          store.batchSet([{ id: "1", a: "another-string3", _etag: "abc" }]).result
+        )
+        expect(result1).toEqual(Opt({ ...item1, _etag: expect.any(String) }))
+        expect(result2).toEqual(Opt({ ...item2, _etag: expect.any(String) }))
+        expect(Exit.untraced(failResult)).toEqual(
+          Exit.fail(new OptimisticConcurrencyException("test", "1"))
+        )
+      }))
+  })
+})

package/_src/services/Store/index.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as CosmosClient from "@effect-app/infra-adapters/cosmos-client"
+import * as RedisClient from "@effect-app/infra-adapters/redis-client"
+import { createClient } from "redis"
+
+import { makeCosmosStore } from "./Cosmos.js"
+import { makeDiskStore } from "./Disk.js"
+import { makeMemoryStore } from "./Memory.js"
+import { makeRedisStore } from "./Redis.js"
+import type { StorageConfig } from "./service.js"
+import { StoreMaker } from "./service.js"
+
+/**
+ * @tsplus static StoreMaker.Ops Live
+ */
+export function StoreMakerLive(config: Config<StorageConfig>) {
+  return config.config.flatMap(cfg => {
+    const storageUrl = cfg.url.value
+    if (storageUrl.startsWith("mem://")) {
+      console.log("Using in memory store")
+      return Effect(makeMemoryStore())
+    }
+    if (storageUrl.startsWith("disk://")) {
+      console.log("Using disk store at ./.data")
+      return makeDiskStore(cfg)
+    }
+    if (storageUrl.startsWith("redis://")) {
+      console.log("Using Redis store")
+      return RedisClient.makeRedisClient(makeRedis(storageUrl)).flatMap(client =>
+        makeRedisStore(cfg).provideService(
+          RedisClient.RedisClient,
+          client
+        )
+      )
+    }
+
+    console.log("Using Cosmos DB store")
+    return CosmosClient.makeCosmosClient(storageUrl, cfg.dbName).flatMap(client =>
+      makeCosmosStore(cfg).provideService(CosmosClient.CosmosClient, client)
+    )
+  })
+    .toScopedLayer(StoreMaker)
+}
+
+function makeRedis(storageUrl: string) {
+  const url = new URL(storageUrl)
+  const hostname = url.hostname
+  const password = url.password
+  return () =>
+    createClient(
+      storageUrl === "redis://"
+        ? ({
+          host: hostname,
+          port: 6380,
+          auth_pass: password,
+          tls: { servername: hostname }
+        } as any)
+        : (storageUrl as any)
+    )
+}
+
+export * from "./service.js"

package/_src/services/Store/service.ts

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { UniqueKey } from "@azure/cosmos"
+import type { Parser, ParserEnv } from "@effect-app/schema/custom/Parser"
+
+import type { These } from "@effect-app/prelude/schema"
+import type { OptimisticConcurrencyException } from "../../errors.js"
+
+export type StoreConfig<E> = {
+  uniqueKeys?: UniqueKey[]
+  maxBulkSize?: number
+  partitionValue: (e: E) => string | undefined
+}
+
+export type SupportedValues = string | boolean | number | null
+
+// default is eq
+export type Where = { key: string; t?: "eq" | "not-eq"; value: SupportedValues } | {
+  key: string
+  t: "in" | "not-in"
+  value: readonly (SupportedValues)[]
+}
+
+// default is where
+export type StoreWhereFilter = {
+  type?: "where"
+  mode?: "and" | "or" // default is and
+  where: readonly [
+    Where,
+    ...(Where[])
+  ]
+}
+export type LegacyFilter<E> =
+  | { by: keyof E; type: "startsWith"; value: any }
+  | { by: keyof E; type: "endsWith"; value: any }
+  | { by: keyof E; type: "contains"; value: any }
+export type JoinFindFilter = {
+  type: "join_find"
+  keys: readonly string[] /* value paths of E */
+  valueKey: string /* value paths of E[keys][valueKey] */
+  value: any /* value path[valueKey] of E */
+}
+export type Filter<E> =
+  | JoinFindFilter
+  | StoreWhereFilter
+  | LegacyFilter<E>
+
+export type FilterJoinSelect = {
+  type: "filter_join_select"
+  keys: readonly string[] /* value paths of E */
+  valueKey: string /* value paths of E[keys][valueKey] */
+  value: any /* value path[valueKey] of E */
+}
+
+export interface Store<PM extends PersistenceModelType<Id>, Id extends string> {
+  all: Effect<never, never, Chunk<PM>>
+  filter: (
+    filter: Filter<PM>,
+    cursor?: { limit?: number; skip?: number }
+  ) => Effect<never, never, Chunk<PM>>
+  filterJoinSelect: <T extends object>(
+    filter: FilterJoinSelect
+  ) => Effect<never, never, Chunk<T & { _rootId: string }>>
+  find: (id: Id) => Effect<never, never, Opt<PM>>
+  set: (e: PM) => Effect<never, OptimisticConcurrencyException, PM>
+  batchSet: (
+    items: NonEmptyReadonlyArray<PM>
+  ) => Effect<never, OptimisticConcurrencyException, NonEmptyReadonlyArray<PM>>
+  bulkSet: (
+    items: NonEmptyReadonlyArray<PM>
+  ) => Effect<never, OptimisticConcurrencyException, NonEmptyReadonlyArray<PM>>
+  /**
+   * Requires the PM type, not Id, because various stores may need to calculate e.g partition keys.
+   */
+  remove: (e: PM) => Effect<never, never, void>
+}
+
+export interface StoreMaker {
+  make: <E extends PersistenceModelType<Id>, Id extends string, Id2 extends Id>(
+    name: string,
+    existing?: Effect<never, never, ROMap<Id2, E>>,
+    config?: StoreConfig<E>
+  ) => Effect<never, never, Store<E, Id>>
+}
+
+/**
+ * @tsplus type StoreMaker.Ops
+ */
+export interface StoreMakerOps extends Tag<StoreMaker> {}
+export const StoreMaker: StoreMakerOps = Tag<StoreMaker>()
+
+/**
+ * @tsplus static ContextMap.Ops Make
+ */
+export const makeMap = Effect(() => {
+  const etags = ROMap.make<string, string>([])["|>"](ROMap.toMutable)
+  const getEtag = (id: string) => etags.get(id)
+  const setEtag = (id: string, eTag: string | undefined) => {
+    eTag === undefined ? etags.delete(id) : etags.set(id, eTag)
+  }
+
+  const parsedCache = ROMap.make<
+    Parser<any, any, any>,
+    Map<unknown, These.These<unknown, unknown>>
+  >([])["|>"](ROMap.toMutable)
+
+  const parserCache = ROMap.make<
+    Parser<any, any, any>,
+    (i: any) => These.These<any, any>
+  >([])["|>"](ROMap.toMutable)
+
+  const setAndReturn = <I, E, A>(
+    p: Parser<I, E, A>,
+    np: (i: I) => These.These<E, A>
+  ) => {
+    parserCache.set(p, np)
+    return np
+  }
+
+  const parserEnv: ParserEnv = {
+    // TODO: lax: true would turn off refinement checks, may help on large payloads
+    // but of course removes confirming of validation rules (which may be okay for a database owned by the app, as we write safely)
+    lax: false,
+    cache: {
+      getOrSetParser: p => parserCache.get(p) ?? setAndReturn(p, i => parserEnv.cache!.getOrSet(i, p)),
+      getOrSetParsers: parsers => {
+        return Object.entries(parsers).reduce((prev, [k, v]) => {
+          prev[k] = parserEnv.cache!.getOrSetParser(v)
+          return prev
+        }, {} as any)
+      },
+      getOrSet: (i, parse): any => {
+        const c = parsedCache.get(parse)
+        if (c) {
+          const f = c.get(i)
+          if (f) {
+            // console.log("$$$ cache hit", i)
+            return f
+          } else {
+            const nf = parse(i, parserEnv)
+            c.set(i, nf)
+            return nf
+          }
+        } else {
+          const nf = parse(i, parserEnv)
+          parsedCache.set(parse, ROMap.make([[i, nf]])["|>"](ROMap.toMutable))
+          return nf
+        }
+      }
+    }
+  }
+
+  return {
+    get: getEtag,
+    set: setEtag,
+    parserEnv
+  }
+})
+export interface ContextMap extends Effect.Success<typeof makeMap> {}
+/**
+ * @tsplus type ContextMap.Ops
+ */
+export interface ContextMapOps extends Tag<ContextMap> {}
+export const ContextMap: ContextMapOps = Tag<ContextMap>()
+
+export interface PersistenceModelType<Id extends string> {
+  id: Id
+  _etag: string | undefined
+}
+
+export interface StorageConfig {
+  url: ConfigSecret
+  prefix: string
+  dbName: string
+}

package/_src/services/Store/utils.ts

@@ -0,0 +1,126 @@
+import { get } from "@effect-app/prelude/utils"
+
+import { OptimisticConcurrencyException } from "../../errors.js"
+
+import type { Filter, FilterJoinSelect, PersistenceModelType } from "./service.js"
+
+import objectHash from "object-hash"
+
+export const makeETag = <E extends PersistenceModelType<Id>, Id extends string>(
+  { _etag, ...e }: E
+): E =>
+  ({
+    ...e,
+    _etag: objectHash(e)
+  }) as any
+export const makeUpdateETag = (name: string) =>
+  <E extends PersistenceModelType<Id>, Id extends string>(e: E, current: Opt<E>) =>
+    Effect.gen(function*($) {
+      if (current.isSome() && current.value._etag !== e._etag) {
+        return yield* $(
+          Effect.fail(new OptimisticConcurrencyException(name, current.value.id, current.value._etag, e._etag))
+        )
+      }
+      const newE = makeETag(e)
+      return newE
+    })
+
+export function codeFilter<E extends { id: string }, NE extends E>(filter: Filter<NE>) {
+  return (x: E) =>
+    filter.type === "startsWith"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ? lowercaseIfString((x as any)[filter.by]).startsWith(filter.value.toLowerCase())
+        ? Opt(x as unknown as NE)
+        : Opt.none
+      : filter.type === "endsWith"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ? lowercaseIfString((x as any)[filter.by]).endsWith(filter.value.toLowerCase())
+        ? Opt(x as unknown as NE)
+        : Opt.none
+      : filter.type === "contains"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      ? lowercaseIfString((x as any)[filter.by]).includes(filter.value.toLowerCase())
+        ? Opt(x as unknown as NE)
+        : Opt.none
+      : filter.type === "join_find"
+      ? filter.keys.some(k => {
+          const value = get(x, k) as Record<string, unknown>[]
+          // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
+          return (
+            value &&
+            value.some(v => compareCaseInsensitive(v[filter.valueKey], filter.value))
+          )
+        })
+        ? Opt(x as unknown as NE)
+        : Opt.none
+      : // TODO: support mixed or/and
+        filter.mode === "or"
+        ? filter.where
+            .some(p =>
+              p.t === "in"
+                ? p.value.includes(get(x, p.key))
+                : p.t === "not-in"
+                ? !p.value.includes(get(x, p.key))
+                : p.t === "not-eq"
+                ? !compareCaseInsensitive(get(x, p.key), p.value)
+                : compareCaseInsensitive(get(x, p.key), p.value)
+            )
+          ? Opt(x as unknown as NE)
+          : Opt.none
+        : filter.where
+            .every(p =>
+              p.t === "in"
+                ? p.value.includes(get(x, p.key))
+                : p.t === "not-in"
+                ? !p.value.includes(get(x, p.key))
+                : p.t === "not-eq"
+                ? p.key.includes(".-1.")
+                  ? (get(x, p.key.split(".-1.")[0]) as any[])
+                    // TODO: or vs and
+                    .every(_ => !compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
+                  : !compareCaseInsensitive(get(x, p.key), p.value)
+                : p.key.includes(".-1.")
+                ? (get(x, p.key.split(".-1.")[0]) as any[])
+                  // TODO: or vs and
+                  .some(_ => compareCaseInsensitive(get(_, p.key.split(".-1.")[1]!), p.value))
+                : compareCaseInsensitive(get(x, p.key), p.value)
+            )
+        ? Opt(x as unknown as NE)
+        : Opt.none
+}
+
+export function codeFilterJoinSelect<E extends { id: string }, NE>(
+  filter: FilterJoinSelect
+) {
+  return (x: E) =>
+    filter.keys.filterMap(k => {
+      const value = get(x, k)
+      // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
+      return value
+        ? Opt(
+          (value as readonly NE[]).filterMap(v =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            compareCaseInsensitive((v as any)[filter.valueKey], filter.value)
+              ? Opt({ ...v, _rootId: x.id })
+              : Opt.none
+          )
+        )
+        : Opt.none
+    })
+      .flatMap(_ => _)
+      .toChunk
+}
+
+function lowercaseIfString<T>(val: T) {
+  if (typeof val === "string") {
+    return val.toLowerCase()
+  }
+  return val
+}
+
+function compareCaseInsensitive(valA: unknown, valB: unknown) {
+  return typeof valB === "string" && typeof valA === "string"
+    ? valA.toLowerCase() === valB.toLowerCase()
+    : valA === valB
+}

package/_src/services/Store.ts

@@ -0,0 +1 @@
+export * from "./Store/service.js"

package/_src/services/memQueue.ts

@@ -0,0 +1,30 @@
+import { Queue as Q } from "@effect/io/Queue"
+
+export interface MemQueue {
+  getOrCreateQueue: (k: string) => Effect<never, never, Queue<string>>
+}
+
+/**
+ * @tsplus type MemQueue.Ops
+ */
+
+export interface MemQueueOps extends Tag<MemQueue> {}
+export const MemQueue: MemQueueOps = Tag<MemQueue>()
+
+/**
+ * @tsplus static MemQueue.Ops Live
+ */
+export const LiveMemQueue = Effect.gen(function*($) {
+  const store = yield* $(Effect(new Map<string, Queue<string>>()))
+
+  return {
+    getOrCreateQueue: (k: string) =>
+      Effect.gen(function*($) {
+        const q = store.get(k)
+        if (q) return q
+        const newQ = yield* $(Q.unbounded<string>())
+        store.set(k, newQ)
+        return newQ
+      })
+  }
+}).toLayer(MemQueue)