dfx 0.66.2 → 0.66.4

package/src/Cache/memoryTTL.ts

@@ -2,6 +2,7 @@ import * as Duration from "effect/Duration"
 import * as Option from "effect/Option"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 import * as Effect from "effect/Effect"
+import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
 import { createDriver, createParentDriver } from "dfx/Cache/driver"
 
 export interface MemoryTTLOpts {
@@ -37,7 +38,7 @@ const make = <T>({
   resolution = Duration.minutes(1),
   strategy = "usage",
   ttl,
-}: MemoryTTLOpts) => {
+}: MemoryTTLOpts): CacheDriver<never, T> => {
   const resolutionMs = Duration.toMillis(resolution)
   const additionalMilliseconds =
     (Math.floor(Duration.toMillis(ttl) / resolutionMs) + 1) * resolutionMs
@@ -131,10 +132,14 @@ const make = <T>({
   })
 }
 
-export const create = <T>(opts: MemoryTTLOpts) =>
+export const create = <T>(
+  opts: MemoryTTLOpts,
+): Effect.Effect<never, never, CacheDriver<never, T>> =>
   Effect.sync(() => make<T>(opts))
 
-export const createWithParent = <T>(opts: MemoryTTLOpts) =>
+export const createWithParent = <T>(
+  opts: MemoryTTLOpts,
+): Effect.Effect<never, never, ParentCacheDriver<never, T>> =>
   Effect.sync(() => {
     const store = make<T>(opts)
     const parentIds = new Map<string, Set<string>>()

package/src/Cache/prelude.ts

@@ -1,11 +1,15 @@
 import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
-import { DiscordREST } from "dfx"
+import type { DiscordRESTError } from "dfx/DiscordREST"
+import { DiscordREST } from "dfx/DiscordREST"
+import type { ResponseError } from "@effect/platform/Http/ClientError"
 import type {
   CacheDriver,
   CacheOp,
   ParentCacheDriver,
   ParentCacheOp,
+  Cache,
+  ParentCache,
 } from "dfx/Cache"
 import { CacheMissError, make, makeWithParent } from "dfx/Cache"
 import { DiscordGateway } from "dfx/DiscordGateway"
@@ -31,7 +35,7 @@ export const opsWithParent = <E, T>({
   parentRemove,
   remove,
   update,
-}: OptsWithParentOptions<E, T>) => {
+}: OptsWithParentOptions<E, T>): Stream.Stream<never, E, ParentCacheOp<T>> => {
   const fromParentOps = Stream.flatMap(fromParent, ([parentId, a]) =>
     Stream.fromIterable(
       a.map(
@@ -96,7 +100,12 @@ export interface OpsOptions<E, A> {
   remove: Stream.Stream<never, E, string>
 }
 
-export const ops = <E, T>({ create, id, remove, update }: OpsOptions<E, T>) => {
+export const ops = <E, T>({
+  create,
+  id,
+  remove,
+  update,
+}: OpsOptions<E, T>): Stream.Stream<never, E, CacheOp<T>> => {
   const createOps = Stream.map(
     create,
     (resource): CacheOp<T> => ({
@@ -128,7 +137,11 @@ export const ops = <E, T>({ create, id, remove, update }: OpsOptions<E, T>) => {
 
 export const guilds = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
-) =>
+): Effect.Effect<
+  RM | DiscordGateway | DiscordREST,
+  EM,
+  Cache<never, E, ResponseError | DiscordRESTError, Discord.Guild>
+> =>
   Effect.gen(function* (_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
@@ -155,7 +168,17 @@ export const guilds = <RM, EM, E>(
 
 export const channels = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
-) =>
+): Effect.Effect<
+  DiscordGateway | DiscordREST | RM,
+  EM,
+  ParentCache<
+    never,
+    E,
+    ResponseError | DiscordRESTError,
+    ResponseError | DiscordRESTError,
+    Discord.Channel
+  >
+> =>
   Effect.gen(function* (_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
@@ -198,7 +221,17 @@ export const channels = <RM, EM, E>(
 
 export const roles = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
-) =>
+): Effect.Effect<
+  DiscordGateway | DiscordREST | RM,
+  EM,
+  ParentCache<
+    never,
+    E,
+    CacheMissError,
+    ResponseError | DiscordRESTError,
+    Discord.Role
+  >
+> =>
   Effect.gen(function* (_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)

package/src/Cache.ts

@@ -24,6 +24,43 @@ export type CacheOp<T> =
   | { op: "update"; resourceId: string; resource: T }
   | { op: "delete"; resourceId: string }
 
+export interface ParentCache<EOps, EDriver, EMiss, EPMiss, A> {
+  readonly get: (
+    parentId: string,
+    id: string,
+  ) => Effect.Effect<never, EDriver | EMiss, A>
+  readonly put: (_: A) => Effect.Effect<never, EDriver | EMiss, void>
+  readonly update: <R, E>(
+    parentId: string,
+    id: string,
+    f: (_: A) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<R, EDriver | EMiss | E, A>
+  readonly getForParent: (
+    parentId: string,
+  ) => Effect.Effect<never, EDriver | EPMiss, ReadonlyMap<string, A>>
+  readonly run: Effect.Effect<never, EOps | EDriver, void>
+  readonly size: Effect.Effect<never, EDriver, number>
+  readonly sizeForParent: (
+    parentId: string,
+  ) => Effect.Effect<never, EDriver, number>
+  readonly set: (
+    parentId: string,
+    resourceId: string,
+    resource: A,
+  ) => Effect.Effect<never, EDriver, void>
+  readonly delete: (
+    parentId: string,
+    resourceId: string,
+  ) => Effect.Effect<never, EDriver, void>
+  readonly parentDelete: (
+    parentId: string,
+  ) => Effect.Effect<never, EDriver, void>
+  readonly refreshTTL: (
+    parentId: string,
+    resourceId: string,
+  ) => Effect.Effect<never, EDriver, void>
+}
+
 export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   driver,
   id,
@@ -40,7 +77,7 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   onParentMiss: (
     parentId: string,
   ) => Effect.Effect<never, EPMiss, Array<[id: string, resource: A]>>
-}) => {
+}): ParentCache<EOps, EDriver, EMiss, EPMiss, A> => {
   const sync = Stream.runDrain(
     Stream.tap(ops, (op): Effect.Effect<never, EDriver, void> => {
       switch (op.op) {
@@ -109,7 +146,26 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
       concurrency: "unbounded",
       discard: true,
     }),
-  }
+  } as const
+}
+
+export interface Cache<EOps, EDriver, EMiss, A> {
+  readonly get: (id: string) => Effect.Effect<never, EDriver | EMiss, A>
+  readonly put: (_: A) => Effect.Effect<never, EDriver, void>
+  readonly update: <R, E>(
+    id: string,
+    f: (_: A) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<R, EDriver | EMiss | E, A>
+  readonly run: Effect.Effect<never, EOps | EDriver, void>
+  readonly size: Effect.Effect<never, EDriver, number>
+  readonly set: (
+    resourceId: string,
+    resource: A,
+  ) => Effect.Effect<never, EDriver, void>
+  readonly delete: (resourceId: string) => Effect.Effect<never, EDriver, void>
+  readonly refreshTTL: (
+    resourceId: string,
+  ) => Effect.Effect<never, EDriver, void>
 }
 
 export const make = <EOps, EDriver, EMiss, A>({
@@ -122,7 +178,7 @@ export const make = <EOps, EDriver, EMiss, A>({
   ops?: Stream.Stream<never, EOps, CacheOp<A>>
   id: (_: A) => string
   onMiss: (id: string) => Effect.Effect<never, EMiss, A>
-}) => {
+}): Cache<EOps, EDriver, EMiss, A> => {
   const sync = Stream.runDrain(
     Stream.tap(ops, (op): Effect.Effect<never, EDriver, void> => {
       switch (op.op) {
@@ -162,7 +218,7 @@ export const make = <EOps, EDriver, EMiss, A>({
       concurrency: "unbounded",
       discard: true,
     }),
-  }
+  } as const
 }
 
 export class CacheMissError {