dfx 1.0.3 → 1.0.5

package/dist/src/Cache/memoryTTL.ts

@@ -0,0 +1,225 @@
+import type { CacheDriver, ParentCacheDriver } from "./driver.ts"
+import { createDriver, createParentDriver } from "./driver.ts"
+import * as Array from "effect/Array"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+
+declare const global: typeof globalThis & {
+  gc?: () => void
+}
+
+export interface MemoryTTLOpts {
+  /** The approx. number of milliseconds to keep items */
+  readonly ttl: Duration.Duration
+
+  /**
+   * How often items should be cleared.
+   */
+  readonly resolution?: Duration.Duration
+
+  /**
+   * What sweep strategy to use.
+   *
+   * "activity" means the TTL is reset for every `set` OR `get` operation
+   * "usage" means the TTL is only reset for the `get` operation
+   *
+   * Defaults to "usage"
+   */
+  readonly strategy?: "activity" | "usage" | "expiry"
+}
+
+interface CacheItem<T> {
+  resource: T
+}
+
+interface TTLBucket<T> {
+  readonly expires: number
+  readonly items: Array<CacheItem<T>>
+}
+
+const make = <T>({
+  resolution = Duration.minutes(1),
+  strategy = "usage",
+  ttl,
+}: MemoryTTLOpts): CacheDriver<never, T> => {
+  const resolutionMs = Duration.toMillis(resolution)
+  const additionalMilliseconds =
+    (Math.floor(Duration.toMillis(ttl) / resolutionMs) + 1) * resolutionMs
+
+  const items = new Map<string, WeakRef<CacheItem<T>>>()
+  const buckets: Array<TTLBucket<T>> = []
+
+  const refreshTTL = (item: CacheItem<T>) => {
+    const now = Date.now()
+    const remainder = now % resolutionMs
+    const expires = now - remainder + additionalMilliseconds
+    let currentBucket = buckets[buckets.length - 1]
+
+    if ((currentBucket?.expires || 0) < expires) {
+      currentBucket = {
+        expires,
+        items: [],
+      }
+      buckets.push(currentBucket)
+    }
+
+    currentBucket.items.push(item)
+  }
+
+  const sweep = () => {
+    const now = Date.now()
+    const remainder = now % resolutionMs
+    const currentExpires = now - remainder
+
+    while (buckets.length && buckets[0].expires <= currentExpires) {
+      buckets.shift()!
+    }
+
+    if (global.gc) {
+      global.gc()
+    }
+  }
+
+  const getSync = (resourceId: string) => {
+    const ref = items.get(resourceId)
+    if (!ref) return undefined
+
+    const item = ref.deref()
+    if (!item) {
+      items.delete(resourceId)
+      return undefined
+    }
+
+    if (strategy !== "expiry") {
+      refreshTTL(item)
+    }
+
+    return item.resource
+  }
+
+  return createDriver({
+    size: Effect.sync(() => items.size),
+
+    get: resourceId =>
+      Effect.sync(
+        (): Option.Option<T> => Option.fromNullishOr(getSync(resourceId)),
+      ),
+
+    refreshTTL: id =>
+      Effect.sync(() => {
+        getSync(id)
+      }),
+
+    set: (resourceId, resource) =>
+      Effect.sync(() => {
+        const item = items.get(resourceId)?.deref()
+
+        if (item && strategy !== "activity") {
+          item.resource = resource
+        } else {
+          const newItem = { resource }
+          refreshTTL(newItem)
+          items.set(resourceId, new WeakRef(newItem))
+        }
+      }),
+
+    delete: resourceId =>
+      Effect.sync(() => {
+        items.delete(resourceId)
+      }),
+
+    run: Effect.sync(sweep).pipe(
+      Effect.delay(Duration.times(resolution, 0.5)),
+      Effect.forever,
+    ),
+  })
+}
+
+export const create = <T>(
+  opts: MemoryTTLOpts,
+): Effect.Effect<CacheDriver<never, T>> => Effect.sync(() => make<T>(opts))
+
+export const createWithParent = <T>(
+  opts: MemoryTTLOpts,
+): Effect.Effect<ParentCacheDriver<never, T>> =>
+  Effect.sync(() => {
+    const store = make<T>(opts)
+    const parentIds = new Map<string, Set<string>>()
+
+    return createParentDriver({
+      size: store.size,
+      sizeForParent: parentId =>
+        Effect.sync(() => parentIds.get(parentId)?.size ?? 0),
+
+      refreshTTL: (_, id) => store.refreshTTL(id),
+
+      get: (_, id) => store.get(id),
+
+      getForParent: parentId =>
+        Effect.fromNullishOr(parentIds.get(parentId)).pipe(
+          Effect.flatMap(ids =>
+            Effect.forEach(
+              ids,
+              id =>
+                store.get(id).pipe(
+                  Effect.tap(item =>
+                    Effect.sync(() => {
+                      if (item._tag === "None") {
+                        ids.delete(id)
+                      }
+                    }),
+                  ),
+                  Effect.map(item => [id, item] as const),
+                ),
+              { concurrency: "unbounded" },
+            ),
+          ),
+          Effect.map(
+            Array.reduce(new Map<string, T>(), (acc, [id, item]) =>
+              item._tag === "Some" ? acc.set(id, item.value) : acc,
+            ),
+          ),
+          Effect.catchNoSuchElement,
+        ),
+
+      set: (parentId, resourceId, resource) =>
+        Effect.andThen(
+          store.set(resourceId, resource),
+          Effect.sync(() => {
+            if (!parentIds.has(parentId)) {
+              parentIds.set(parentId, new Set())
+            }
+            parentIds.get(parentId)!.add(resourceId)
+          }),
+        ),
+
+      delete: (parentId, resourceId) =>
+        Effect.andThen(
+          store.delete(resourceId),
+          Effect.sync(() => {
+            parentIds.get(parentId)?.delete(resourceId)
+          }),
+        ),
+
+      parentDelete: parentId =>
+        Effect.suspend(() => {
+          const ids = parentIds.get(parentId)
+          parentIds.delete(parentId)
+
+          const effects: Array<Effect.Effect<void>> = []
+          if (ids) {
+            ids.forEach(id => {
+              effects.push(store.delete(id))
+            })
+          }
+
+          return Effect.all(effects, {
+            concurrency: "unbounded",
+            discard: true,
+          })
+        }),
+
+      run: store.run,
+    })
+  })

package/dist/src/Cache/prelude.ts

@@ -0,0 +1,279 @@
+import * as Effect from "effect/Effect"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import type { DiscordRESTError } from "../DiscordREST.ts"
+import { DiscordREST } from "../DiscordREST.ts"
+import type {
+  CacheDriver,
+  CacheOp,
+  ParentCacheDriver,
+  ParentCacheOp,
+  Cache,
+  ParentCache,
+} from "../Cache.ts"
+import { CacheMissError, make, makeWithParent } from "../Cache.ts"
+import { DiscordGateway } from "../DiscordGateway.ts"
+import type * as Discord from "../types.ts"
+
+export interface OptsWithParentOptions<E, A> {
+  readonly id: (a: A) => string
+  readonly fromParent: Stream.Stream<
+    [parentId: string, resources: ReadonlyArray<A>],
+    E
+  >
+  readonly create: Stream.Stream<[parentId: string, resource: A], E>
+  readonly update: Stream.Stream<[parentId: string, resource: A], E>
+  readonly remove: Stream.Stream<[parentId: string, id: string], E>
+  readonly parentRemove: Stream.Stream<string, E>
+}
+
+export const opsWithParent = <E, T>({
+  create,
+  fromParent,
+  id,
+  parentRemove,
+  remove,
+  update,
+}: OptsWithParentOptions<E, T>): Stream.Stream<ParentCacheOp<T>, E> => {
+  const fromParentOps = Stream.flatMap(fromParent, ([parentId, a]) =>
+    Stream.fromIterable(
+      a.map(
+        (resource): ParentCacheOp<T> => ({
+          op: "create",
+          parentId,
+          resourceId: id(resource),
+          resource,
+        }),
+      ),
+    ),
+  )
+
+  const createOps = Stream.map(
+    create,
+    ([parentId, resource]): ParentCacheOp<T> => ({
+      op: "create",
+      parentId,
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const updateOps = Stream.map(
+    update,
+    ([parentId, resource]): ParentCacheOp<T> => ({
+      op: "update",
+      parentId,
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const removeOps = Stream.map(
+    remove,
+    ([parentId, resourceId]): ParentCacheOp<T> => ({
+      op: "delete",
+      parentId,
+      resourceId,
+    }),
+  )
+
+  const parentRemoveOps = Stream.map(
+    parentRemove,
+    (parentId): ParentCacheOp<T> => ({
+      op: "parentDelete",
+      parentId,
+    }),
+  )
+
+  return Stream.merge(fromParentOps, createOps).pipe(
+    Stream.merge(updateOps),
+    Stream.merge(removeOps),
+    Stream.merge(parentRemoveOps),
+  )
+}
+
+export interface OpsOptions<E, A> {
+  id: (a: A) => string
+  create: Stream.Stream<A, E>
+  update: Stream.Stream<A, E>
+  remove: Stream.Stream<string, E>
+}
+
+export const ops = <E, T>({
+  create,
+  id,
+  remove,
+  update,
+}: OpsOptions<E, T>): Stream.Stream<CacheOp<T>, E> => {
+  const createOps = Stream.map(
+    create,
+    (resource): CacheOp<T> => ({
+      op: "create",
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const updateOps = Stream.map(
+    update,
+    (resource): CacheOp<T> => ({
+      op: "update",
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const removeOps = Stream.map(
+    remove,
+    (resourceId): CacheOp<T> => ({
+      op: "delete",
+      resourceId,
+    }),
+  )
+
+  return Stream.merge(createOps, updateOps).pipe(Stream.merge(removeOps))
+}
+
+export const guilds = <RM, EM, E>(
+  makeDriver: Effect.Effect<CacheDriver<E, Discord.GuildResponse>, EM, RM>,
+): Effect.Effect<
+  Cache<E, DiscordRESTError, Discord.GuildResponse>,
+  EM,
+  RM | DiscordGateway | DiscordREST | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const driver = yield* makeDriver
+    const gateway = yield* DiscordGateway
+    const rest = yield* DiscordREST
+
+    return yield* make({
+      driver,
+      id: _ => _.id,
+      ops: ops({
+        id: (g: Discord.GuildResponse) => g.id,
+        create: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => ({
+          ...g,
+          channels: [],
+          roles: [],
+          emojis: [],
+          members: [],
+        })),
+        update: gateway.fromDispatch("GUILD_UPDATE"),
+        remove: Stream.map(gateway.fromDispatch("GUILD_DELETE"), a => a.id),
+      }),
+      onMiss: id => rest.getGuild(id, {}),
+    })
+  })
+
+export const channels = <RM, EM, E>(
+  makeDriver: Effect.Effect<
+    ParentCacheDriver<E, Discord.GetChannel200>,
+    EM,
+    RM
+  >,
+): Effect.Effect<
+  ParentCache<E, DiscordRESTError, DiscordRESTError, Discord.GetChannel200>,
+  EM,
+  DiscordGateway | DiscordREST | RM | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const driver = yield* makeDriver
+    const gateway = yield* DiscordGateway
+    const rest = yield* DiscordREST
+
+    return yield* makeWithParent({
+      driver,
+      id: _ =>
+        Effect.succeed([(_ as Discord.GuildChannelResponse).guild_id, _.id]),
+      ops: opsWithParent({
+        id: (a: Discord.GetChannel200) => a.id,
+        fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
+          g.id,
+          g.channels.concat(g.threads as any),
+        ]),
+        create: Stream.merge(
+          gateway.fromDispatch("CHANNEL_CREATE"),
+          gateway.fromDispatch("THREAD_CREATE"),
+        ).pipe(Stream.map(c => [c.guild_id, c])),
+        update: Stream.merge(
+          gateway.fromDispatch("CHANNEL_UPDATE"),
+          gateway.fromDispatch("THREAD_UPDATE"),
+        ).pipe(Stream.map(c => [c.guild_id, c])),
+        remove: Stream.merge(
+          gateway.fromDispatch("CHANNEL_DELETE"),
+          gateway.fromDispatch("THREAD_DELETE"),
+        ).pipe(Stream.map(a => [a.guild_id, a.id])),
+        parentRemove: Stream.map(
+          gateway.fromDispatch("GUILD_DELETE"),
+          g => g.id,
+        ),
+      }),
+      onMiss: (_, id) => rest.getChannel(id),
+      onParentMiss: guildId =>
+        Effect.map(rest.listGuildChannels(guildId), guildChannels =>
+          guildChannels.map(
+            channel => [channel.id, channel as Discord.GetChannel200] as const,
+          ),
+        ),
+    })
+  })
+
+export const roles = <RM, EM, E>(
+  makeDriver: Effect.Effect<
+    ParentCacheDriver<E, Discord.GuildRoleResponse>,
+    EM,
+    RM
+  >,
+): Effect.Effect<
+  ParentCache<E, CacheMissError, DiscordRESTError, Discord.GuildRoleResponse>,
+  EM,
+  DiscordGateway | DiscordREST | RM | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const driver = yield* makeDriver
+    const gateway = yield* DiscordGateway
+    const rest = yield* DiscordREST
+
+    return yield* makeWithParent({
+      driver,
+      id: _ =>
+        Effect.fail(
+          new CacheMissError({ cacheName: "RolesCache/id", id: _.id }),
+        ),
+      ops: opsWithParent({
+        id: (a: Discord.GuildRoleResponse) => a.id,
+        fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
+          g.id,
+          g.roles,
+        ]),
+        create: Stream.map(
+          gateway.fromDispatch("GUILD_ROLE_CREATE"),
+          (r: Discord.GatewayGuildRoleCreateDispatchData) => [
+            r.guild_id,
+            r.role,
+          ],
+        ),
+        update: Stream.map(
+          gateway.fromDispatch("GUILD_ROLE_UPDATE"),
+          (r: Discord.GatewayGuildRoleUpdateDispatchData) => [
+            r.guild_id,
+            r.role,
+          ],
+        ),
+        remove: Stream.map(gateway.fromDispatch("GUILD_ROLE_DELETE"), r => [
+          r.guild_id,
+          r.role_id,
+        ]),
+        parentRemove: Stream.map(
+          gateway.fromDispatch("GUILD_DELETE"),
+          g => g.id,
+        ),
+      }),
+      onMiss: (_, id) =>
+        Effect.fail(new CacheMissError({ cacheName: "RolesCache", id })),
+      onParentMiss: guildId =>
+        rest
+          .listGuildRoles(guildId)
+          .pipe(Effect.map(_ => _.map(role => [role.id, role]))),
+    })
+  })