dfx 0.42.2 → 0.42.4

package/package.json

@@ -1,54 +1,52 @@
 {
-  "name": "dfx",
-  "version": "0.42.2",
-  "type": "module",
-  "publishConfig": {
-    "access": "public",
-    "directory": "dist"
-  },
-  "description": "Effect-TS discord library",
-  "author": "Tim Smart <hello@timsmart.co>",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tim-smart/dfx.git"
-  },
-  "license": "MIT",
-  "scripts": {
-    "prepublishOnly": "pnpm run clean && pnpm run build:tsc && cp package.json README.md dist/",
-    "build:tsc": "tsc -p tsconfig.json",
-    "types": "discord-api-codegen ./discord-api-docs -l typescript -o 'imports=RestResponse|dfx/DiscordREST/types' 'endpointReturnType=RestResponse' > src/types.ts && prettier -w src/types.ts",
-    "clean": "rm -rf dist/ *.tsbuildinfo"
-  },
-  "exports": {
-    ".": "./index.js",
-    "./gateway": "./gateway.js",
-    "./webhooks": "./webhooks.js",
-    "./*": "./*.js"
-  },
-  "devDependencies": {
-    "@tim-smart/discord-api-docs-parser": "^0.5.2",
-    "@tsplus-types/effect__data": "0.12.2-3b576ba",
-    "@tsplus-types/effect__io": "0.25.8-3b576ba",
-    "@tsplus-types/effect__stream": "0.21.0-3b576ba",
-    "@types/ws": "^8.5.4",
-    "dotenv": "^16.0.3",
-    "lerna": "^6.6.1",
-    "madge": "^6.0.0",
-    "typescript": "https://cdn.jsdelivr.net/npm/@tsplus/installer@0.0.171/compiler/typescript.tgz"
-  },
-  "dependencies": {
-    "@effect-http/client": "^0.24.2",
-    "@effect/data": "^0.12.2",
-    "@effect/io": "~0.25.8",
-    "@effect/stream": "~0.21.0",
-    "tweetnacl": "^1.0.3"
-  },
-  "optionalDependencies": {
-    "bufferutil": "^4.0.7",
-    "isomorphic-ws": "^5.0.0",
-    "utf-8-validate": "^6.0.3",
-    "ws": "^8.13.0"
-  },
-  "sideEffects": false,
-  "gitHead": "3885d0874380e6814794f3b287e0b706cd3ff0af"
+    "name": "dfx",
+    "version": "0.42.4",
+    "type": "module",
+    "publishConfig": {
+        "access": "public",
+        "directory": "dist"
+    },
+    "description": "Effect-TS discord library",
+    "author": "Tim Smart <hello@timsmart.co>",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/tim-smart/dfx.git"
+    },
+    "license": "MIT",
+    "scripts": {
+        "prepublishOnly": "make build",
+        "types": "discord-api-codegen ./discord-api-docs -l typescript -o 'imports=RestResponse|dfx/DiscordREST/types' 'endpointReturnType=RestResponse' > src/types.ts && prettier -w src/types.ts"
+    },
+    "exports": {
+        ".": "./index.js",
+        "./gateway": "./gateway.js",
+        "./webhooks": "./webhooks.js",
+        "./*": "./*.js"
+    },
+    "devDependencies": {
+        "@tim-smart/discord-api-docs-parser": "^0.5.2",
+        "@tsplus-types/effect__data": "0.12.2-3b576ba",
+        "@tsplus-types/effect__io": "0.25.8-3b576ba",
+        "@tsplus-types/effect__stream": "0.21.1-3b576ba",
+        "@types/ws": "^8.5.4",
+        "dotenv": "^16.0.3",
+        "lerna": "^6.6.1",
+        "madge": "^6.0.0",
+        "typescript": "https://cdn.jsdelivr.net/npm/@tsplus/installer@0.0.171/compiler/typescript.tgz"
+    },
+    "dependencies": {
+        "@effect-http/client": "^0.24.2",
+        "@effect/data": "^0.12.2",
+        "@effect/io": "~0.25.8",
+        "@effect/stream": "~0.21.1",
+        "tweetnacl": "^1.0.3"
+    },
+    "optionalDependencies": {
+        "bufferutil": "^4.0.7",
+        "isomorphic-ws": "^5.0.0",
+        "utf-8-validate": "^6.0.3",
+        "ws": "^8.13.0"
+    },
+    "sideEffects": false,
+    "gitHead": "b126c63501e8a26a235c2eec43c8332c6dde5f5c"
 }

package/src/Cache/driver.ts

@@ -0,0 +1,31 @@
+export interface ParentCacheDriver<E, T> {
+  readonly size: Effect<never, E, number>
+  sizeForParent: (parentId: string) => Effect<never, E, number>
+  get: (parentId: string, resourceId: string) => Effect<never, E, Maybe<T>>
+  getForParent: (
+    parentId: string,
+  ) => Effect<never, E, Maybe<ReadonlyMap<string, T>>>
+  set: (
+    parentId: string,
+    resourceId: string,
+    resource: T,
+  ) => Effect<never, E, void>
+  delete: (parentId: string, resourceId: string) => Effect<never, E, void>
+  parentDelete: (parentId: string) => Effect<never, E, void>
+  refreshTTL: (parentId: string, resourceId: string) => Effect<never, E, void>
+  readonly run: Effect<never, E, never>
+}
+
+export const createParentDriver = <E, T>(driver: ParentCacheDriver<E, T>) =>
+  driver
+
+export interface CacheDriver<E, T> {
+  readonly size: Effect<never, E, number>
+  get: (resourceId: string) => Effect<never, E, Maybe<T>>
+  set: (resourceId: string, resource: T) => Effect<never, E, void>
+  delete: (resourceId: string) => Effect<never, E, void>
+  refreshTTL: (resourceId: string) => Effect<never, E, void>
+  readonly run: Effect<never, E, never>
+}
+
+export const createDriver = <E, T>(driver: CacheDriver<E, T>) => driver

package/src/Cache/memory.ts

@@ -0,0 +1,76 @@
+import { createDriver, createParentDriver } from "./driver.js"
+
+export const createWithParent = <T>() =>
+  Effect.sync(() => {
+    const map = new Map<string, Map<string, T>>()
+
+    return createParentDriver({
+      size: Effect.sync(() => {
+        let count = 0
+        for (const a of map.values()) {
+          count += a.size
+        }
+        return count
+      }),
+
+      sizeForParent: parentId =>
+        Effect.sync(() => map.get(parentId)?.size ?? 0),
+
+      get: (parentId, resourceId) =>
+        Effect.sync(
+          (): Maybe<T> =>
+            Maybe.fromNullable(map.get(parentId)?.get(resourceId)),
+        ),
+
+      getForParent: parentId =>
+        Effect.sync(() => Maybe.fromNullable(map.get(parentId))),
+
+      set: (parentId, resourceId, resource) =>
+        Effect.sync(() => {
+          if (!map.has(parentId)) {
+            map.set(parentId, new Map())
+          }
+          map.get(parentId)!.set(resourceId, resource)
+        }),
+
+      delete: (parentId, resourceId) =>
+        Effect.sync(() => {
+          map.get(parentId)?.delete(resourceId)
+        }),
+
+      parentDelete: parentId =>
+        Effect.sync(() => {
+          map.delete(parentId)
+        }),
+
+      refreshTTL: () => Effect.unit(),
+
+      run: Effect.never(),
+    })
+  })
+
+export const create = <T>() =>
+  Effect.sync(() => {
+    const map = new Map<string, T>()
+
+    return createDriver({
+      size: Effect.sync(() => map.size),
+
+      get: resourceId =>
+        Effect.sync((): Maybe<T> => Maybe.fromNullable(map.get(resourceId))),
+
+      set: (resourceId, resource) =>
+        Effect.sync(() => {
+          map.set(resourceId, resource)
+        }),
+
+      delete: resourceId =>
+        Effect.sync(() => {
+          map.delete(resourceId)
+        }),
+
+      refreshTTL: () => Effect.unit(),
+
+      run: Effect.never(),
+    })
+  })

package/src/Cache/memoryTTL.ts

@@ -0,0 +1,201 @@
+import { createDriver, createParentDriver } from "./driver.js"
+
+export interface MemoryTTLOpts {
+  /** The approx. number of milliseconds to keep items */
+  ttl: Duration
+
+  /**
+   * How often items should be cleared.
+   */
+  resolution?: 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"
+   */
+  strategy?: "activity" | "usage" | "expiry"
+}
+
+interface CacheItem<T> {
+  resource: T
+}
+
+interface TTLBucket<T> {
+  expires: number
+  items: CacheItem<T>[]
+}
+
+const make = <T>({
+  ttl,
+  resolution = Duration.minutes(1),
+  strategy = "usage",
+}: MemoryTTLOpts) => {
+  const additionalMilliseconds =
+    (Math.floor(ttl.millis / resolution.millis) + 1) * resolution.millis
+
+  const items = new Map<string, WeakRef<CacheItem<T>>>()
+  const buckets: TTLBucket<T>[] = []
+
+  const refreshTTL = (item: CacheItem<T>) => {
+    const now = Date.now()
+    const remainder = now % resolution.millis
+    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 % resolution.millis
+    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((): Maybe<T> => Maybe.fromNullable(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).delay(resolution * 0.5).forever,
+  })
+}
+
+export const create = <T>(opts: MemoryTTLOpts) =>
+  Effect.sync(() => make<T>(opts))
+
+export const createWithParent = <T>(opts: MemoryTTLOpts) =>
+  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 =>
+        Do($ => {
+          const ids = parentIds.get(parentId)
+          if (!ids) return Maybe.none()
+
+          const toGet: Effect<never, never, readonly [string, Maybe<T>]>[] = []
+          ids.forEach(id => {
+            toGet.push(
+              Do($ => {
+                const item = $(store.get(id))
+                if (item._tag === "None") {
+                  parentIds.delete(id)
+                }
+                return [id, item] as const
+              }),
+            )
+          })
+
+          const results = $(Effect.allPar(toGet))
+          const map = results.reduce(
+            (map, [id, a]) => (a._tag === "Some" ? map.set(id, a.value) : map),
+            new Map<string, T>(),
+          )
+
+          return Maybe.some(map)
+        }),
+
+      set: (parentId, resourceId, resource) =>
+        Do($ => {
+          $(store.set(resourceId, resource))
+
+          if (!parentIds.has(parentId)) {
+            parentIds.set(parentId, new Set())
+          }
+          parentIds.get(parentId)!.add(resourceId)
+        }),
+
+      delete: (parentId, resourceId) =>
+        Do($ => {
+          $(store.delete(resourceId))
+          parentIds.get(parentId)?.delete(resourceId)
+        }),
+
+      parentDelete: parentId =>
+        Do($ => {
+          const ids = parentIds.get(parentId)
+          parentIds.delete(parentId)
+
+          const effects: Effect<never, never, void>[] = []
+          if (ids) {
+            ids.forEach(id => {
+              effects.push(store.delete(id))
+            })
+          }
+
+          $(Effect.allParDiscard(effects))
+        }),
+
+      run: store.run,
+    })
+  })

package/src/Cache/prelude.ts

@@ -0,0 +1,215 @@
+import { DiscordREST } from "dfx"
+import { Discord, Effect, Stream } from "dfx/_common"
+import { DiscordGateway } from "dfx/gateway"
+import {
+  CacheDriver,
+  CacheMissError,
+  CacheOp,
+  ParentCacheDriver,
+  ParentCacheOp,
+  make,
+  makeWithParent,
+} from "../Cache.js"
+
+export interface OptsWithParentOptions<E, A> {
+  id: (a: A) => string
+  fromParent: Stream<never, E, [parentId: string, resources: A[]]>
+  create: Stream<never, E, [parentId: string, resource: A]>
+  update: Stream<never, E, [parentId: string, resource: A]>
+  remove: Stream<never, E, [parentId: string, id: string]>
+  parentRemove: Stream<never, E, string>
+}
+
+export const opsWithParent = <E, T>({
+  id,
+  fromParent,
+  create,
+  update,
+  remove,
+  parentRemove,
+}: OptsWithParentOptions<E, T>) => {
+  const fromParentOps = fromParent.flatMap(([parentId, a]) =>
+    Stream.fromIterable(
+      a.map(
+        (resource): ParentCacheOp<T> => ({
+          op: "create",
+          parentId,
+          resourceId: id(resource),
+          resource,
+        }),
+      ),
+    ),
+  )
+
+  const createOps = create.map(
+    ([parentId, resource]): ParentCacheOp<T> => ({
+      op: "create",
+      parentId,
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const updateOps = update.map(
+    ([parentId, resource]): ParentCacheOp<T> => ({
+      op: "update",
+      parentId,
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const removeOps = remove.map(
+    ([parentId, resourceId]): ParentCacheOp<T> => ({
+      op: "delete",
+      parentId,
+      resourceId,
+    }),
+  )
+
+  const parentRemoveOps = parentRemove.map(
+    (parentId): ParentCacheOp<T> => ({
+      op: "parentDelete",
+      parentId,
+    }),
+  )
+
+  return fromParentOps
+    .merge(createOps)
+    .merge(updateOps)
+    .merge(removeOps)
+    .merge(parentRemoveOps)
+}
+
+export interface OpsOptions<E, A> {
+  id: (a: A) => string
+  create: Stream<never, E, A>
+  update: Stream<never, E, A>
+  remove: Stream<never, E, string>
+}
+
+export const ops = <E, T>({ id, create, update, remove }: OpsOptions<E, T>) => {
+  const createOps = create.map(
+    (resource): CacheOp<T> => ({
+      op: "create",
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const updateOps = update.map(
+    (resource): CacheOp<T> => ({
+      op: "update",
+      resourceId: id(resource),
+      resource,
+    }),
+  )
+
+  const removeOps = remove.map(
+    (resourceId): CacheOp<T> => ({
+      op: "delete",
+      resourceId,
+    }),
+  )
+
+  return createOps.merge(updateOps).merge(removeOps)
+}
+
+export const guilds = <RM, EM, E>(
+  makeDriver: Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
+) =>
+  Do($ => {
+    const driver = $(makeDriver)
+    const gateway = $(DiscordGateway)
+    const rest = $(DiscordREST)
+
+    return make({
+      driver,
+      id: _ => _.id,
+      ops: ops({
+        id: (g: Discord.Guild) => g.id,
+        create: gateway.fromDispatch("GUILD_CREATE").map(g => ({
+          ...g,
+          channels: [],
+          roles: [],
+          emojis: [],
+          members: [],
+        })),
+        update: gateway.fromDispatch("GUILD_UPDATE"),
+        remove: gateway.fromDispatch("GUILD_DELETE").map(a => a.id),
+      }),
+      onMiss: id => rest.getGuild(id).flatMap(r => r.json),
+    })
+  })
+
+export const channels = <RM, EM, E>(
+  makeDriver: Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
+) =>
+  Do($ => {
+    const driver = $(makeDriver)
+    const gateway = $(DiscordGateway)
+    const rest = $(DiscordREST)
+
+    return makeWithParent({
+      driver,
+      id: _ => Effect.succeed([_.guild_id!, _.id]),
+      ops: opsWithParent({
+        id: (a: Discord.Channel) => a.id,
+        fromParent: gateway
+          .fromDispatch("GUILD_CREATE")
+          .map(g => [g.id, g.channels]),
+        create: gateway
+          .fromDispatch("CHANNEL_CREATE")
+          .map(c => [c.guild_id!, c]),
+        update: gateway
+          .fromDispatch("CHANNEL_UPDATE")
+          .map(c => [c.guild_id!, c]),
+        remove: gateway
+          .fromDispatch("CHANNEL_DELETE")
+          .map(a => [a.guild_id!, a.id]),
+        parentRemove: gateway.fromDispatch("GUILD_DELETE").map(g => g.id),
+      }),
+      onMiss: (_, id) => rest.getChannel(id).flatMap(r => r.json),
+      onParentMiss: guildId =>
+        rest
+          .getGuildChannels(guildId)
+          .flatMap(r => r.json)
+          .map(a => a.map(a => [a.id, a])),
+    })
+  })
+
+export const roles = <RM, EM, E>(
+  makeDriver: Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
+) =>
+  Do($ => {
+    const driver = $(makeDriver)
+    const gateway = $(DiscordGateway)
+    const rest = $(DiscordREST)
+
+    return makeWithParent({
+      driver,
+      id: _ => Effect.fail(new CacheMissError("RolesCache/id", _.id)),
+      ops: opsWithParent({
+        id: (a: Discord.Role) => a.id,
+        fromParent: gateway
+          .fromDispatch("GUILD_CREATE")
+          .map(g => [g.id, g.roles]),
+        create: gateway
+          .fromDispatch("GUILD_ROLE_CREATE")
+          .map(r => [r.guild_id, r.role]),
+        update: gateway
+          .fromDispatch("GUILD_ROLE_UPDATE")
+          .map(r => [r.guild_id, r.role]),
+        remove: gateway
+          .fromDispatch("GUILD_ROLE_DELETE")
+          .map(r => [r.guild_id, r.role_id]),
+        parentRemove: gateway.fromDispatch("GUILD_DELETE").map(g => g.id),
+      }),
+      onMiss: (_, id) => Effect.fail(new CacheMissError("RolesCache", id)),
+      onParentMiss: guildId =>
+        rest
+          .getGuildRoles(guildId)
+          .flatMap(r => r.json)
+          .map(_ => _.map(role => [role.id, role])),
+    })
+  })