@effect-app/infra 4.0.0-beta.25 → 4.0.0-beta.251

package/src/Store/codeFilter.ts

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { Array, Option } from "effect-app"
-import { assertUnreachable, get } from "effect-app/utils"
-import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
-import type { FieldValues } from "../Model/filter/types.js"
-import type { Filter } from "./service.js"
+import * as Array from "effect-app/Array"
+import type { FilterR, FilterResult } from "effect-app/Model/filter/filterApi"
+import type { FieldValues } from "effect-app/Model/filter/types"
+import * as Option from "effect-app/Option"
+import type { Filter } from "effect-app/Store"
+import { assertUnreachable } from "effect-app/utils"
+import { get } from "./Memory.js"
 import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
 
 const vAsArr = (v: string) => v as unknown as any[]
@@ -186,6 +188,7 @@ export const codeFilter3_ = <E>(state: readonly FilterResult[], sut: E): boolean
   const statements: any[] = [] // must be defined here to be used by eval.
   // always put everything inside a root scope.
   const s = codeFilter3__([{ t: "where-scope", result: state, relation: "some" }], sut, statements, null, false)
+  // oxlint-disable-next-line no-eval
   return eval(s)
 }
 

package/src/Store/index.ts

@@ -1,12 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, Redacted } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { RepositoryRegistryLive } from "effect-app/Model"
+import type { StorageConfig } from "effect-app/Store"
+import * as Redacted from "effect/Redacted"
+import type { SqlClient } from "effect/unstable/sql"
 import { CosmosStoreLayer } from "./Cosmos.js"
 import { DiskStoreLayer } from "./Disk.js"
 import { MemoryStoreLive } from "./Memory.js"
 // import { RedisStoreLayer } from "./Redis.js"
-import type { StorageConfig } from "./service.js"
+import { SQLiteStoreLayer } from "./SQL.js"
+import { PgStoreLayer } from "./SQL/Pg.js"
 
-export function StoreMakerLayer(cfg: StorageConfig) {
+export function StoreMakerLayer(
+  cfg: StorageConfig,
+  options?: { makeSqlClientLayer?: (namespace: string) => Layer.Layer<SqlClient.SqlClient> }
+) {
   return Effect
     .sync(() => {
       const storageUrl = Redacted.value(cfg.url)
@@ -19,6 +28,14 @@ export function StoreMakerLayer(cfg: StorageConfig) {
         console.log("Using disk store at " + dir)
         return DiskStoreLayer(cfg, dir)
       }
+      if (storageUrl.startsWith("sqlite://")) {
+        console.log("Using SQLite store")
+        return SQLiteStoreLayer(cfg, options)
+      }
+      if (storageUrl.startsWith("pg://")) {
+        console.log("Using PostgreSQL store")
+        return PgStoreLayer(cfg)
+      }
       // if (storageUrl.startsWith("redis://")) {
       //   console.log("Using Redis store")
       //   return RedisStoreLayer(cfg)
@@ -27,7 +44,5 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       console.log("Using Cosmos DB store")
       return CosmosStoreLayer(cfg)
     })
-    .pipe(Layer.unwrap)
+    .pipe(Layer.unwrap, Layer.merge(RepositoryRegistryLive))
 }
-
-export * from "./service.js"

package/src/Store/utils.ts

@@ -1,7 +1,8 @@
 import crypto from "crypto"
-import { Effect, Option } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import * as Option from "effect-app/Option"
+import type { PersistenceModelType, SupportedValues2 } from "effect-app/Store"
 import { OptimisticConcurrencyException } from "../errors.js"
-import type { PersistenceModelType, SupportedValues2 } from "./service.js"
 
 export const makeETag = <E extends PersistenceModelType<{}>>(
   { _etag, ...e }: E
@@ -12,33 +13,34 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
     _etag: crypto.createHash("sha256").update(JSON.stringify(e)).digest("hex")
   }) as any
 
-export const makeUpdateETag =
-  (type: string) =>
-  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option.Option<E>) =>
-    Effect.gen(function*() {
-      if (e._etag) {
-        if (Option.isNone(current)) {
-          return yield* new OptimisticConcurrencyException({
-            type,
-            id: e[idKey] as string,
-            current: "",
-            found: e._etag,
-            code: 409
-          })
-        }
-      }
-      if (Option.isSome(current) && current.value._etag !== e._etag) {
+export const makeUpdateETag = (type: string) =>
+  Effect.fnUntraced(function*<IdKey extends keyof E, E extends PersistenceModelType<{}>>(
+    e: E,
+    idKey: IdKey,
+    current: Option.Option<E>
+  ) {
+    if (e._etag) {
+      if (Option.isNone(current)) {
         return yield* new OptimisticConcurrencyException({
           type,
-          id: current.value[idKey] as string,
-          current: current.value._etag,
+          id: e[idKey] as string,
+          current: "",
           found: e._etag,
-          code: 412
+          code: 409
         })
       }
-      const newE = makeETag(e)
-      return newE
-    })
+    }
+    if (Option.isSome(current) && current.value._etag !== e._etag) {
+      return yield* new OptimisticConcurrencyException({
+        type,
+        id: current.value[idKey] as string,
+        current: current.value._etag,
+        found: e._etag,
+        code: 412
+      })
+    }
+    return makeETag(e)
+  })
 
 export function lowercaseIfString<T>(val: T) {
   if (typeof val === "string") {

package/src/arbs.ts

@@ -1,13 +1,15 @@
 // Do not import to frontend
 
 import { faker } from "@faker-js/faker"
-import { type S } from "effect-app"
 import { setFaker } from "effect-app/faker"
+import type * as S from "effect-app/Schema"
 import * as FastCheck from "effect/testing/FastCheck"
 import { Random } from "fast-check"
-import * as rand from "pure-rand"
+import { congruential32 } from "pure-rand/generator/congruential32"
 
-const rnd = new Random(rand.congruential32(5))
+const seed = 5
+const rng = congruential32(seed)
+const rnd = new Random(rng)
 
 setFaker(faker)
 

package/src/{adapters/cosmos-client.ts → cosmos-client.ts}

@@ -1,16 +1,18 @@
 import { CosmosClient as ComosClient_ } from "@azure/cosmos"
-import { Effect, Layer, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
 
 const withClient = (url: string) => Effect.sync(() => new ComosClient_(url))
 
 export const makeCosmosClient = (url: string, dbName: string) =>
   Effect.map(withClient(url), (x) => ({ db: x.database(dbName) }))
 
-export class CosmosClient extends ServiceMap.Service<CosmosClient, {
+export class CosmosClient extends Context.Service<CosmosClient, {
   readonly db: ReturnType<InstanceType<typeof ComosClient_>["database"]>
 }>()("@services/CosmosClient") {}
 
-export const db = CosmosClient.asEffect().pipe(Effect.map((_) => _.db))
+export const db = CosmosClient.pipe(Effect.map((_) => _.db))
 
 export const CosmosClientLayer = (cosmosUrl: string, dbName: string) =>
   Layer.effect(CosmosClient, makeCosmosClient(cosmosUrl, dbName))

package/src/errorReporter.ts

@@ -1,7 +1,9 @@
 import * as Sentry from "@sentry/node"
-import { Cause, Effect, type LogLevel } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import { getRC } from "effect-app/setupRequest"
 import { dropUndefined, LogLevelToSentry } from "effect-app/utils"
-import { getRC } from "./api/setupRequest.js"
+import * as Cause from "effect/Cause"
+import type * as LogLevel from "effect/LogLevel"
 import { CauseException, tryToJson, tryToReport } from "./errors.js"
 import { InfraLogger } from "./logger.js"
 
@@ -13,47 +15,41 @@ const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): CauseExcepti
   }
 }
 
-export function reportError(
-  name: string
-) {
-  return (
-    cause: Cause.Cause<unknown>,
-    extras?: Record<string, unknown>,
-    level: LogLevel.Severity = "Error"
-  ) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
-          return
-        }
-        const error = tryCauseException(cause, name)
-
-        yield* reportSentry(error, extras, LogLevelToSentry(level))
-        yield* InfraLogger
-          .logWithLevel(level, "Reporting error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              error: tryToReport(error),
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-          .pipe(
-            Effect.catchCause((cause) => InfraLogger.logWarning("Failed to log error", cause)),
-            Effect.catchCause(() => InfraLogger.logFatal("Failed to log error cause"))
-          )
+export function reportError(name: string) {
+  return Effect.fnUntraced(
+    function*(
+      cause: Cause.Cause<unknown>,
+      extras?: Record<string, unknown>,
+      level: LogLevel.Severity = "Error"
+    ) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
+        return
+      }
+      const error = tryCauseException(cause, name)
 
-        return error
-      })
-      .pipe(
-        Effect.tapCause((cause) =>
-          InfraLogger.logError("Failed to report error", cause).pipe(
-            Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
-          )
+      yield* reportSentry(error, extras, LogLevelToSentry(level))
+      yield* InfraLogger
+        .logWithLevel(level, "Reporting error", cause)
+        .pipe(
+          Effect.annotateLogs(dropUndefined({
+            extras,
+            error: tryToReport(error),
+            cause: tryToJson(cause),
+            __error_name__: name
+          })),
+          Effect.catchCause((cause) => InfraLogger.logWarning("Failed to log error", cause)),
+          Effect.catchCause(() => InfraLogger.logFatal("Failed to log error cause"))
         )
-      )
+
+      return error
+    },
+    (effect) =>
+      Effect.tapCause(effect, (cause) =>
+        InfraLogger.logError("Failed to report error", cause).pipe(
+          Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
+        ))
+  )
 }
 
 function reportSentry(
@@ -66,45 +62,39 @@ function reportSentry(
     scope.setLevel(level)
     if (context) scope.setContext("context", { ...context })
     if (extras) scope.setContext("extras", extras)
-    scope.setContext("error", { data: tryToReport(error) })
-    scope.setContext("cause", { data: tryToJson(error.originalCause) })
+    const squashed = Cause.squash(error.originalCause)
+    scope.setContext("mainError", tryToJson(squashed))
+    scope.setContext("error", tryToReport(error))
+    scope.setContext("cause", tryToJson(error.originalCause))
     Sentry.captureException(error, scope)
   }))
 }
 
-export function logError<E>(
-  name: string
-) {
-  return (cause: Cause.Cause<E>, extras?: Record<string, unknown>) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
-          return
-        }
-        yield* InfraLogger
-          .logWarning("Logging error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-      })
-      .pipe(
-        Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
-      )
+export function logError<E>(name: string) {
+  return Effect.fnUntraced(
+    function*(cause: Cause.Cause<E>, extras?: Record<string, unknown>) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
+        return
+      }
+      yield* InfraLogger
+        .logWarning("Logging error", cause)
+        .pipe(Effect.annotateLogs(dropUndefined({
+          extras,
+          cause: tryToJson(cause),
+          __error_name__: name
+        })))
+    },
+    (effect) => Effect.tapCause(effect, () => InfraLogger.logFatal("Failed to log error cause"))
+  )
 }
 
-export function reportMessage(message: string, extras?: Record<string, unknown>) {
-  return Effect.gen(function*() {
-    const context = yield* getRC
-    const scope = new Sentry.Scope()
-    if (context) scope.setContext("context", { ...context })
-    if (extras) scope.setContext("extras", extras)
-    Sentry.captureMessage(message, scope)
+export const reportMessage = Effect.fnUntraced(function*(message: string, extras?: Record<string, unknown>) {
+  const context = yield* getRC
+  const scope = new Sentry.Scope()
+  if (context) scope.setContext("context", { ...context })
+  if (extras) scope.setContext("extras", extras)
+  Sentry.captureMessage(message, scope)
 
-    console.warn(message, extras)
-  })
-}
+  console.warn(message, extras)
+})

package/src/fileUtil.ts

@@ -1,5 +1,5 @@
 import crypto from "crypto"
-import { Effect } from "effect-app"
+import * as Effect from "effect-app/Effect"
 import type { Abortable } from "events"
 import type { Mode, ObjectEncodingOptions, OpenMode } from "fs"
 import fs from "fs/promises"

package/src/index.ts

@@ -1 +1,2 @@
-export * as Model from "./Model.js"
+export * from "./logger.js"
+export * from "./Store/index.js"

package/src/{api/internal → internal}/RequestContextMiddleware.ts

@@ -1,8 +1,10 @@
-import { Effect } from "effect-app"
+import * as Effect from "effect-app/Effect"
 import { HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect-app/http"
+import * as Layer from "effect-app/Layer"
+import { Locale, LocaleRef, RequestContext, spanAttributes } from "effect-app/RequestContext"
 import { NonEmptyString255 } from "effect-app/Schema"
-import { Locale, RequestContext } from "../../RequestContext.js"
-import { setupRequestContext } from "../setupRequest.js"
+import { provideOnRequestScope } from "effect-app/setupRequest"
+import { ContextMapContainer, storeId } from "effect-app/Store"
 
 export const RequestContextMiddleware = (defaultLocale: Locale = "en") =>
   HttpMiddleware.make((app) =>
@@ -21,18 +23,33 @@ export const RequestContextMiddleware = (defaultLocale: Locale = "en") =>
       const namespace = NonEmptyString255((ns && (Array.isArray(ns) ? ns[0] : ns)) || "primary")
       const deviceId = req.headers["x-fe-device-id"]
 
-      const requestContext = new RequestContext({
+      const requestContext = RequestContext.make({
         span: {
           traceId: currentSpan.traceId,
           spanId: currentSpan.spanId,
           sampled: currentSpan.sampled
         },
-        name: NonEmptyString255(req.originalUrl), // set more detailed elsewhere
+        name: NonEmptyString255(`HTTP ${req.method} ${req.originalUrl.split("?")[0]}`), // set more detailed elsewhere
         locale,
         namespace,
         sourceId: deviceId ? NonEmptyString255(deviceId) : undefined
       })
-      const res = yield* setupRequestContext(app, requestContext)
+      yield* Effect.annotateCurrentSpan(spanAttributes(requestContext))
+      const layer = Layer.mergeAll(
+        ContextMapContainer.layer,
+        Layer.succeed(LocaleRef, requestContext.locale),
+        Layer.succeed(storeId, requestContext.namespace)
+      )
+      // Bind layer to the request scope so ContextMap's finalizer (clear()) runs only
+      // after the response body is fully drained — not when `app` returns its
+      // HttpServerResponse value. Streaming RPC responses keep producing chunks (and
+      // using ContextMap-cached etags) after `app` returns; a sub-scope from
+      // `Effect.provide(layer)` would close too early and wipe etags mid-stream,
+      // causing spurious OptimisticConcurrencyException on later writes.
+      const res = yield* app.pipe(
+        Effect.withLogSpan(requestContext.name),
+        provideOnRequestScope(layer)
+      )
 
       // TODO: how to set also on errors?
       return HttpServerResponse.setHeaders(res, {