effect 4.0.0-beta.43 → 4.0.0-beta.44

package/src/unstable/httpapi/OpenApi.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import type { NonEmptyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import { constFalse } from "../../Function.ts"
 import * as JsonPatch from "../../JsonPatch.ts"
 import { escapeToken } from "../../JsonPointer.ts"
@@ -11,7 +12,6 @@ import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
 import * as SchemaRepresentation from "../../SchemaRepresentation.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpMethod from "../http/HttpMethod.ts"
 import * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
@@ -24,38 +24,38 @@ import type { HttpApiSecurity } from "./HttpApiSecurity.ts"
  * @since 4.0.0
  * @category annotations
  */
-export class Identifier extends ServiceMap.Service<Identifier, string>()("effect/httpapi/OpenApi/Identifier") {}
+export class Identifier extends Context.Service<Identifier, string>()("effect/httpapi/OpenApi/Identifier") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Title extends ServiceMap.Service<Title, string>()("effect/httpapi/OpenApi/Title") {}
+export class Title extends Context.Service<Title, string>()("effect/httpapi/OpenApi/Title") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Version extends ServiceMap.Service<Version, string>()("effect/httpapi/OpenApi/Version") {}
+export class Version extends Context.Service<Version, string>()("effect/httpapi/OpenApi/Version") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Description extends ServiceMap.Service<Description, string>()("effect/httpapi/OpenApi/Description") {}
+export class Description extends Context.Service<Description, string>()("effect/httpapi/OpenApi/Description") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class License extends ServiceMap.Service<License, OpenAPISpecLicense>()("effect/httpapi/OpenApi/License") {}
+export class License extends Context.Service<License, OpenAPISpecLicense>()("effect/httpapi/OpenApi/License") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
 export class ExternalDocs
-  extends ServiceMap.Service<ExternalDocs, OpenAPISpecExternalDocs>()("effect/httpapi/OpenApi/ExternalDocs")
+  extends Context.Service<ExternalDocs, OpenAPISpecExternalDocs>()("effect/httpapi/OpenApi/ExternalDocs")
 {}
 
 /**
@@ -63,40 +63,38 @@ export class ExternalDocs
  * @category annotations
  */
 export class Servers
-  extends ServiceMap.Service<Servers, ReadonlyArray<OpenAPISpecServer>>()("effect/httpapi/OpenApi/Servers")
+  extends Context.Service<Servers, ReadonlyArray<OpenAPISpecServer>>()("effect/httpapi/OpenApi/Servers")
 {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Format extends ServiceMap.Service<Format, string>()("effect/httpapi/OpenApi/Format") {}
+export class Format extends Context.Service<Format, string>()("effect/httpapi/OpenApi/Format") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Summary extends ServiceMap.Service<Summary, string>()("effect/httpapi/OpenApi/Summary") {}
+export class Summary extends Context.Service<Summary, string>()("effect/httpapi/OpenApi/Summary") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Deprecated extends ServiceMap.Service<Deprecated, boolean>()("effect/httpapi/OpenApi/Deprecated") {}
+export class Deprecated extends Context.Service<Deprecated, boolean>()("effect/httpapi/OpenApi/Deprecated") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export class Override
-  extends ServiceMap.Service<Override, Record<string, unknown>>()("effect/httpapi/OpenApi/Override")
-{}
+export class Override extends Context.Service<Override, Record<string, unknown>>()("effect/httpapi/OpenApi/Override") {}
 
 /**
  * @since 4.0.0
  * @category annotations
  */
-export const Exclude = ServiceMap.Reference<boolean>("effect/httpapi/OpenApi/Exclude", {
+export const Exclude = Context.Reference<boolean>("effect/httpapi/OpenApi/Exclude", {
   defaultValue: constFalse
 })
 
@@ -106,24 +104,24 @@ export const Exclude = ServiceMap.Reference<boolean>("effect/httpapi/OpenApi/Exc
  * @since 4.0.0
  * @category annotations
  */
-export class Transform extends ServiceMap.Service<
+export class Transform extends Context.Service<
   Transform,
   (openApiSpec: Record<string, any>) => Record<string, any>
 >()("effect/httpapi/OpenApi/Transform") {}
 
-const servicesPartial = <Tags extends Record<string, ServiceMap.Key<any, any> | ServiceMap.Key<never, any>>>(
+const servicesPartial = <Tags extends Record<string, Context.Key<any, any> | Context.Key<never, any>>>(
   tags: Tags
 ): (
   options: {
-    readonly [K in keyof Tags]?: ServiceMap.Service.Shape<Tags[K]> | undefined
+    readonly [K in keyof Tags]?: Context.Service.Shape<Tags[K]> | undefined
   }
-) => ServiceMap.ServiceMap<never> => {
+) => Context.Context<never> => {
   const entries = Object.entries(tags)
   return (options) => {
-    let context = ServiceMap.empty()
+    let context = Context.empty()
     for (const [key, tag] of entries) {
       if (options[key] !== undefined) {
-        context = ServiceMap.add(context, tag as any, options[key]!)
+        context = Context.add(context, tag as any, options[key]!)
       }
     }
     return context
@@ -150,7 +148,7 @@ export const annotations: (
     readonly exclude?: boolean | undefined
     readonly transform?: ((openApiSpec: Record<string, any>) => Record<string, any>) | undefined
   }
-) => ServiceMap.ServiceMap<never> = servicesPartial({
+) => Context.Context<never> = servicesPartial({
   identifier: Identifier,
   title: Title,
   version: Version,
@@ -174,11 +172,11 @@ const apiCache = new WeakMap<HttpApi.Any, OpenAPISpec>()
  * callback function to it. If the tag is not found, the function does nothing.
  */
 function processAnnotation<Services, S, I>(
-  ctx: ServiceMap.ServiceMap<Services>,
-  annotation: ServiceMap.Key<I, S>,
+  ctx: Context.Context<Services>,
+  annotation: Context.Key<I, S>,
   f: (s: S) => void
 ) {
-  const o = ServiceMap.getOption(ctx, annotation)
+  const o = Context.getOption(ctx, annotation)
   if (Option.isSome(o)) {
     f(o.value)
   }
@@ -269,11 +267,11 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
 
   HttpApi.reflect(api, {
     onGroup({ group }) {
-      if (ServiceMap.get(group.annotations, Exclude)) {
+      if (Context.get(group.annotations, Exclude)) {
         return
       }
       let tag: OpenAPISpecTag = {
-        name: ServiceMap.getOrElse(group.annotations, Title, () => group.identifier)
+        name: Context.getOrElse(group.annotations, Title, () => group.identifier)
       }
       processAnnotation(group.annotations, Description, (description) => {
         tag.description = description
@@ -291,12 +289,12 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       spec.tags.push(tag)
     },
     onEndpoint({ endpoint, group, mergedAnnotations, middleware }) {
-      if (ServiceMap.get(mergedAnnotations, Exclude)) {
+      if (Context.get(mergedAnnotations, Exclude)) {
         return
       }
       let op: OpenAPISpecOperation = {
-        tags: [ServiceMap.getOrElse(group.annotations, Title, () => group.identifier)],
-        operationId: ServiceMap.getOrElse(
+        tags: [Context.getOrElse(group.annotations, Title, () => group.identifier)],
+        operationId: Context.getOrElse(
           endpoint.annotations,
           Identifier,
           () => group.topLevel ? endpoint.name : `${group.identifier}.${endpoint.name}`
@@ -667,7 +665,7 @@ const makeSecurityScheme = (security: HttpApiSecurity): OpenAPISecurityScheme =>
       }
     }
     case "Bearer": {
-      const format = ServiceMap.getOption(security.annotations, Format).pipe(
+      const format = Context.getOption(security.annotations, Format).pipe(
         Option.map((format) => ({ bearerFormat: format })),
         Option.getOrUndefined
       )

package/src/unstable/observability/OtlpExporter.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -9,7 +10,6 @@ import * as Num from "../../Number.ts"
 import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Headers from "../../unstable/http/Headers.ts"
 import * as HttpClient from "../../unstable/http/HttpClient.ts"
 import * as HttpClientError from "../../unstable/http/HttpClientError.ts"
@@ -53,14 +53,14 @@ export const make: (
   never,
   HttpClient.HttpClient | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
-  const services = yield* Effect.services<Scope.Scope | HttpClient.HttpClient>()
-  const clock = ServiceMap.get(services, Clock)
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Scope.Scope | HttpClient.HttpClient>()
+  const clock = Context.get(services, Clock)
+  const scope = Context.get(services, Scope.Scope)
   const runFork = Effect.runForkWith(services)
   const exportInterval = Duration.max(Duration.fromInputUnsafe(options.exportInterval), Duration.zero)
   let disabledUntil: number | undefined = undefined
 
-  const client = HttpClient.filterStatusOk(ServiceMap.get(services, HttpClient.HttpClient)).pipe(
+  const client = HttpClient.filterStatusOk(Context.get(services, HttpClient.HttpClient)).pipe(
     HttpClient.retryTransient({ schedule: policy, times: 3 })
   )
 

package/src/unstable/observability/OtlpMetrics.ts

@@ -79,7 +79,7 @@ export const make: (options: {
     name: OtlpResource.serviceNameUnsafe(resource)
   }
 
-  const services = yield* Effect.services<never>()
+  const services = yield* Effect.context<never>()
 
   // State for delta temporality tracking
   let previousExportTimeNanos: bigint = startTimeNanos

package/src/unstable/observability/OtlpSerialization.ts

@@ -1,8 +1,8 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as otlpProtobuf from "./internal/otlpProtobuf.ts"
 import type { LogsData } from "./OtlpLogger.ts"
@@ -13,7 +13,7 @@ import type { TraceData } from "./OtlpTracer.ts"
  * @since 4.0.0
  * @category Services
  */
-export class OtlpSerialization extends ServiceMap.Service<OtlpSerialization, {
+export class OtlpSerialization extends Context.Service<OtlpSerialization, {
   readonly traces: (data: TraceData) => HttpBody.HttpBody
   readonly metrics: (data: MetricsData) => HttpBody.HttpBody
   readonly logs: (data: LogsData) => HttpBody.HttpBody

package/src/unstable/observability/OtlpTracer.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import type * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
@@ -9,7 +10,6 @@ import { flow } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
 import * as Tracer from "../../Tracer.ts"
 import type { ExtractTag, Mutable } from "../../Types.ts"
 import type * as Headers from "../http/Headers.ts"
@@ -152,7 +152,7 @@ type RemainingSpanImpl = Omit<Tracer.Span, (keyof typeof SpanProto) | "traceId"
 const makeSpan = (options: {
   readonly name: string
   readonly parent: Option.Option<Tracer.AnySpan>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   readonly status: Tracer.SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
   readonly links: ReadonlyArray<Tracer.SpanLink>

package/src/unstable/observability/PrometheusMetrics.ts

@@ -27,10 +27,10 @@
  *
  * @since 4.0.0
  */
+import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Metric from "../../Metric.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
 
@@ -114,7 +114,7 @@ export interface HttpOptions extends FormatOptions {
  */
 export const format: (options?: FormatOptions | undefined) => Effect.Effect<string> = Effect.fnUntraced(
   function*(options) {
-    const services = yield* Effect.services<never>()
+    const services = yield* Effect.context<never>()
     return formatUnsafe(services, options)
   }
 )
@@ -122,17 +122,17 @@ export const format: (options?: FormatOptions | undefined) => Effect.Effect<stri
 /**
  * Synchronously format all metrics in the registry to Prometheus exposition format.
  *
- * This is a low-level function that requires access to the service map.
+ * This is a low-level function that requires access to the context.
  * Most users should use `format` instead.
  *
  * @since 4.0.0
  * @category Formatting
  */
 export const formatUnsafe = (
-  services: ServiceMap.ServiceMap<never>,
+  context: Context.Context<never>,
   options?: FormatOptions | undefined
 ): string => {
-  const snapshot = Metric.snapshotUnsafe(services)
+  const snapshot = Metric.snapshotUnsafe(context)
   const prefix = options?.prefix ? sanitizeMetricName(options.prefix) + "_" : ""
   const mapper = options?.metricNameMapper ?? ((name: string) => name)
   const lines: Array<string> = []

package/src/unstable/persistence/KeyValueStore.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Encoding from "../../Encoding.ts"
@@ -13,8 +14,9 @@ import type { PlatformError } from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
+import * as SqlClient from "../sql/SqlClient.ts"
+import type { SqlError } from "../sql/SqlError.ts"
 
 const TypeId = "~effect/persistence/KeyValueStore" as const
 
@@ -170,10 +172,10 @@ export class KeyValueStoreError extends Data.TaggedError("KeyValueStoreError")<{
  * @since 4.0.0
  * @category tags
  */
-export const KeyValueStore: ServiceMap.Service<
+export const KeyValueStore: Context.Service<
   KeyValueStore,
   KeyValueStore
-> = ServiceMap.Service("effect/persistence/KeyValueStore")
+> = Context.Service("effect/persistence/KeyValueStore")
 
 /**
  * @since 4.0.0
@@ -391,6 +393,227 @@ export const layerFileSystem = (
     })
   }))
 
+/**
+ * @since 4.0.0
+ * @category layers
+ */
+export interface LayerSqlOptions {
+  /**
+   * The SQL table name used to store values.
+   *
+   * @default "effect_key_value_store"
+   */
+  readonly table?: string
+}
+
+/**
+ * @since 4.0.0
+ * @category layers
+ */
+export const layerSql = (
+  options: LayerSqlOptions = {}
+): Layer.Layer<KeyValueStore, never, SqlClient.SqlClient> =>
+  Layer.effect(KeyValueStore)(
+    Effect.gen(function*() {
+      const sql = (yield* SqlClient.SqlClient).withoutTransforms()
+      const table = sql(options.table ?? "effect_key_value_store")
+
+      yield* sql.onDialectOrElse({
+        mysql: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id VARCHAR(191) PRIMARY KEY,
+            value BLOB NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        pg: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id TEXT PRIMARY KEY,
+            value BYTEA NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        mssql: () =>
+          sql`
+          IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${table} AND xtype='U')
+          CREATE TABLE ${table} (
+            id NVARCHAR(450) PRIMARY KEY,
+            value VARBINARY(MAX) NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        // sqlite
+        orElse: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id TEXT PRIMARY KEY,
+            value BLOB NOT NULL,
+            value_type INTEGER NOT NULL
+          )
+        `
+      }).pipe(Effect.orDie)
+
+      type UpsertFn = (entry: {
+        id: string
+        value: Uint8Array
+        value_type: number
+      }) => Effect.Effect<unknown, SqlError>
+
+      const upsert = sql.onDialectOrElse({
+        pg: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON CONFLICT (id) DO UPDATE SET value=EXCLUDED.value, value_type=EXCLUDED.value_type
+        `.unprepared,
+        mysql: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON DUPLICATE KEY UPDATE value=VALUES(value), value_type=VALUES(value_type)
+        `,
+        mssql: (): UpsertFn => (entry) =>
+          sql`
+          MERGE ${table} AS target
+          USING (SELECT ${entry.id} AS id, ${entry.value} AS value, ${entry.value_type} AS value_type) AS source
+          ON target.id = source.id
+          WHEN MATCHED THEN UPDATE SET value = source.value, value_type = source.value_type
+          WHEN NOT MATCHED THEN INSERT (id, value, value_type)
+          VALUES (source.id, source.value, source.value_type);
+        `,
+        // sqlite
+        orElse: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON CONFLICT(id) DO UPDATE SET value=excluded.value, value_type=excluded.value_type
+        `.unprepared
+      })
+
+      const encoder = new TextEncoder()
+      const decoder = new TextDecoder()
+      const ValueTypeString = 0
+      const ValueTypeUint8Array = 1
+
+      type Row = {
+        value: Uint8Array
+        value_type: number
+      }
+
+      return make({
+        get: (key: string) =>
+          sql<Row>`SELECT value, value_type FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "get",
+                key,
+                message: `Unable to get item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.flatMap((rows) => {
+              if (rows.length === 0) {
+                return Effect.undefined
+              }
+              const row = rows[0]
+              switch (row.value_type) {
+                case ValueTypeString:
+                  return Effect.succeed(decoder.decode(row.value))
+                case ValueTypeUint8Array:
+                  return Effect.succeed(Encoding.encodeBase64(row.value))
+                default:
+                  return Effect.fail(
+                    new KeyValueStoreError({
+                      method: "get",
+                      key,
+                      message: `Invalid stored value type for key ${key}: ${row.value_type}`
+                    })
+                  )
+              }
+            })
+          ),
+        getUint8Array: (key: string) =>
+          sql<Row>`SELECT value, value_type FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "getUint8Array",
+                key,
+                message: `Unable to get item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.flatMap((rows) => {
+              if (rows.length === 0) {
+                return Effect.undefined
+              }
+              const row = rows[0]
+              switch (row.value_type) {
+                case ValueTypeString:
+                  return Effect.succeed(row.value)
+                case ValueTypeUint8Array:
+                  return Effect.succeed(row.value)
+                default:
+                  return Effect.fail(
+                    new KeyValueStoreError({
+                      method: "getUint8Array",
+                      key,
+                      message: `Invalid stored value type for key ${key}: ${row.value_type}`
+                    })
+                  )
+              }
+            })
+          ),
+        set: (key: string, value: string | Uint8Array) =>
+          upsert({
+            id: key,
+            value: typeof value === "string" ? encoder.encode(value) : value,
+            value_type: typeof value === "string" ? ValueTypeString : ValueTypeUint8Array
+          }).pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "set",
+                key,
+                message: `Unable to set item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.asVoid
+          ),
+        remove: (key: string) =>
+          sql`DELETE FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "remove",
+                key,
+                message: `Unable to remove item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.asVoid
+          ),
+        clear: sql`DELETE FROM ${table}`.pipe(
+          Effect.mapError((cause) =>
+            new KeyValueStoreError({
+              method: "clear",
+              message: `Unable to clear storage`,
+              cause
+            })
+          ),
+          Effect.asVoid
+        ),
+        size: sql<{ count: number }>`SELECT COUNT(*) as count FROM ${table}`.pipe(
+          Effect.mapError((cause) =>
+            new KeyValueStoreError({
+              method: "size",
+              message: `Unable to get size`,
+              cause
+            })
+          ),
+          Effect.map((rows) => rows.length === 0 ? 0 : Number(rows[0].count))
+        )
+      })
+    })
+  )
+
 const SchemaStoreTypeId = "~effect/persistence/KeyValueStore/SchemaStore" as const
 
 /**

package/src/unstable/persistence/PersistedCache.ts

@@ -41,9 +41,8 @@ export const make: <
   K extends Persistable.Any,
   R = never,
   ServiceMode extends "lookup" | "construction" = never
->(options: {
+>(lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>, options: {
   readonly storeId: string
-  readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
@@ -56,32 +55,36 @@ export const make: <
   K extends Persistable.Any,
   R = never,
   ServiceMode extends "lookup" | "construction" = never
->(options: {
-  readonly storeId: string
-  readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
-  readonly timeToLive: Persistable.TimeToLiveFn<K>
-  readonly inMemoryCapacity?: number | undefined
-  readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
-  readonly requireServicesAt?: ServiceMode | undefined
-}) {
+>(
+  lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>,
+  options: {
+    readonly storeId: string
+    readonly timeToLive: Persistable.TimeToLiveFn<K>
+    readonly inMemoryCapacity?: number | undefined
+    readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+    readonly requireServicesAt?: ServiceMode | undefined
+  }
+) {
   const store = yield* (yield* Persistence.Persistence).make({
     storeId: options.storeId,
     timeToLive: options.timeToLive as any
   })
-  const inMemory = yield* Cache.makeWith({
-    lookup: Effect.fnUntraced(function*(key: K) {
+  const inMemory = yield* Cache.makeWith(
+    Effect.fnUntraced(function*(key: K) {
       const exit = yield* (store.get(key) as Effect.Effect<Exit<Persistable.Success<K>, Persistable.Error<K>>>)
       if (exit) {
         return yield* exit
       }
-      const result = yield* Effect.exit(options.lookup(key))
+      const result = yield* Effect.exit(lookup(key))
       yield* (store.set(key, result) as Effect.Effect<void>)
       return yield* result
     }),
-    timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
-    capacity: options.inMemoryCapacity ?? 1024,
-    requireServicesAt: options.requireServicesAt
-  })
+    {
+      timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
+      capacity: options.inMemoryCapacity ?? 1024,
+      requireServicesAt: options.requireServicesAt
+    }
+  )
   return identity<PersistedCache<K, "lookup" extends ServiceMode ? R : never>>({
     [TypeId]: TypeId,
     inMemory,