liminal 0.17.11 → 0.17.12

package/platform/KeyValueStore.ts

@@ -1,112 +0,0 @@
-import { Effect, Layer } from "effect"
-import { KeyValueStore } from "effect/unstable/persistence"
-
-import { R2 } from "../R2.ts"
-
-export const layerR2 = ({ root }: { readonly root?: string | undefined } = {}) => {
-  const prefix = root === undefined ? "" : root.endsWith("/") ? root : `${root}/`
-  const toKey = (key: string) => `${prefix}${key}`
-  const lsOptions = (cursor: string | undefined): R2ListOptions =>
-    cursor
-      ? prefix
-        ? { cursor, limit: 1000, prefix }
-        : { cursor, limit: 1000 }
-      : prefix
-        ? { limit: 1000, prefix }
-        : { limit: 1000 }
-
-  return Layer.effect(
-    KeyValueStore.KeyValueStore,
-    Effect.gen(function* () {
-      const r2 = yield* R2
-      return KeyValueStore.make({
-        get: (key) =>
-          Effect.tryPromise({
-            try: async () => {
-              const object = await r2.get(toKey(key))
-              return object === null ? undefined : await object.text()
-            },
-            catch: (cause) =>
-              new KeyValueStore.KeyValueStoreError({
-                method: "get",
-                key,
-                message: `Unable to get item with key ${key}`,
-                cause,
-              }),
-          }),
-        getUint8Array: (key) =>
-          Effect.tryPromise({
-            try: async () => {
-              const object = await r2.get(toKey(key))
-              return object === null ? undefined : new Uint8Array(await object.arrayBuffer())
-            },
-            catch: (cause) =>
-              new KeyValueStore.KeyValueStoreError({
-                method: "getUint8Array",
-                key,
-                message: `Unable to get item with key ${key}`,
-                cause,
-              }),
-          }),
-        set: (key, value) =>
-          Effect.tryPromise({
-            try: () => r2.put(toKey(key), value),
-            catch: (cause) =>
-              new KeyValueStore.KeyValueStoreError({
-                method: "set",
-                key,
-                message: `Unable to set item with key ${key}`,
-                cause,
-              }),
-          }).pipe(Effect.asVoid),
-        remove: (key) =>
-          Effect.tryPromise({
-            try: () => r2.delete(toKey(key)),
-            catch: (cause) =>
-              new KeyValueStore.KeyValueStoreError({
-                method: "remove",
-                key,
-                message: `Unable to remove item with key ${key}`,
-                cause,
-              }),
-          }),
-        clear: Effect.tryPromise({
-          try: async () => {
-            let cursor: string | undefined
-            do {
-              const listed = await r2.list(lsOptions(cursor))
-              if (listed.objects.length > 0) {
-                await r2.delete(listed.objects.map((o) => o.key))
-              }
-              cursor = listed.truncated ? listed.cursor : undefined
-            } while (cursor)
-          },
-          catch: (cause) =>
-            new KeyValueStore.KeyValueStoreError({
-              method: "clear",
-              message: `Unable to clear storage`,
-              cause,
-            }),
-        }),
-        size: Effect.tryPromise({
-          try: async () => {
-            let total = 0
-            let cursor: string | undefined
-            do {
-              const listed = await r2.list(lsOptions(cursor))
-              total += listed.objects.length
-              cursor = listed.truncated ? listed.cursor : undefined
-            } while (cursor)
-            return total
-          },
-          catch: (cause) =>
-            new KeyValueStore.KeyValueStoreError({
-              method: "size",
-              message: `Unable to get size`,
-              cause,
-            }),
-        }),
-      })
-    }),
-  )
-}

package/platform/index.ts

@@ -1 +0,0 @@
-export * as KeyValueStore from "./KeyValueStore.ts"

package/util/Diagnostic.ts

@@ -1,16 +0,0 @@
-import { Effect, Tracer } from "effect"
-
-export const module = (module: string) => ({
-  debug: (event: string, annotations?: Record<string, unknown>) =>
-    Effect.logDebug(event).pipe(
-      Effect.annotateLogs({
-        package: "liminal",
-        module,
-        ...annotations,
-      }),
-    ),
-  span:
-    (operation: string, options?: Tracer.SpanOptions | undefined) =>
-    <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-      Effect.withSpan(effect, `liminal.${module}.${operation}`, options),
-})

package/util/boundLayer.ts

@@ -1,11 +0,0 @@
-import { References, Effect, Layer } from "effect"
-
-import { logCause } from "./logCause.ts"
-
-export const boundLayer = (boundary: string) =>
-  Layer.provideMerge(
-    Layer.effect(
-      References.CurrentLogAnnotations,
-      Effect.map(References.CurrentLogAnnotations.asEffect(), (existing) => ({ ...existing, _boundary: boundary })),
-    ).pipe(Layer.tapCause(logCause), Layer.provideMerge(Layer.succeed(References.MinimumLogLevel, "All"))),
-  )

package/util/logCause.ts

@@ -1,8 +0,0 @@
-import { Cause, Effect, Schema as S, flow } from "effect"
-
-const formatReason = <E>(reason: Cause.Reason<E>): unknown => {
-  const value = Cause.isFailReason(reason) ? reason.error : Cause.isDieReason(reason) ? reason.defect : reason
-  return S.isSchemaError(value) ? value.toString() : value
-}
-
-export const logCause = <E>(cause: Cause.Cause<E>) => Effect.forEach(cause.reasons, flow(formatReason, Effect.logError))