dfx 1.0.5 → 1.0.7

package/dist/src/Cache/memoryTTL.ts

@@ -1,225 +0,0 @@
-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

@@ -1,279 +0,0 @@
-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]))),
-    })
-  })