@effect-app/infra 4.0.0-beta.266 → 4.0.0-beta.268

package/src/Emailer/Sendgrid.ts

@@ -7,7 +7,7 @@ import { dropUndefinedT } from "effect-app/utils"
 import * as Equivalence from "effect/Equivalence"
 import * as Redacted from "effect/Redacted"
 import { inspect } from "util"
-import { InfraLogger } from "../logger.js"
+import { InfraLogger } from "../logger.ts"
 
 export interface SendgridConfig {
   defaultReplyTo?: EmailData

package/src/Emailer/fake.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect-app/Effect"
 import { Emailer } from "effect-app/Emailer"
 import { pretty } from "effect-app/utils"
-import { InfraLogger } from "../logger.js"
+import { InfraLogger } from "../logger.ts"
 
 const makeFake = InfraLogger
   .logInfo("FAKE Emailer Service enabled")

package/src/MainFiberSet.ts

@@ -4,9 +4,9 @@ import * as Layer from "effect-app/Layer"
 import * as Fiber from "effect/Fiber"
 import * as FiberSet from "effect/FiberSet"
 
-import { InfraLogger } from "./logger.js"
-import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.js"
-import { setRootParentSpan } from "./RequestFiberSet.js"
+import { InfraLogger } from "./logger.ts"
+import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.ts"
+import { setRootParentSpan } from "./RequestFiberSet.ts"
 
 const make = Effect.gen(function*() {
   const set = yield* FiberSet.make<unknown, never>()

package/src/QueueMaker/SQLQueue.ts

@@ -11,9 +11,9 @@ import { pretty } from "effect-app/utils"
 import * as Fiber from "effect/Fiber"
 import * as Tracer from "effect/Tracer"
 import { SqlClient } from "effect/unstable/sql"
-import { InfraLogger } from "../logger.js"
-import { messagingSpanArgs } from "../otel.js"
-import { SQLModel } from "../SQL.js"
+import { InfraLogger } from "../logger.ts"
+import { messagingSpanArgs } from "../otel.ts"
+import { SQLModel } from "../SQL.ts"
 
 export const QueueId = S.Finite.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type

package/src/QueueMaker/memQueue.ts

@@ -9,10 +9,10 @@ import * as Fiber from "effect/Fiber"
 import { flow } from "effect/Function"
 import * as Q from "effect/Queue"
 import * as Tracer from "effect/Tracer"
-import { InfraLogger } from "../logger.js"
-import { MemQueue } from "../memQueue.js"
-import { messagingSpanArgs } from "../otel.js"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
+import { InfraLogger } from "../logger.ts"
+import { MemQueue } from "../memQueue.ts"
+import { messagingSpanArgs } from "../otel.ts"
+import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.ts"
 
 export const makeMemQueue = Effect.fnUntraced(function*<
   Evt extends { id: S.StringId; _tag: string },

package/src/QueueMaker/sbqueue.ts

@@ -8,10 +8,10 @@ import { pretty } from "effect-app/utils"
 import * as Cause from "effect/Cause"
 import { flow } from "effect/Function"
 import * as Tracer from "effect/Tracer"
-import { InfraLogger } from "../logger.js"
-import { messagingSpanArgs } from "../otel.js"
-import { Receiver, Sender } from "../ServiceBus.js"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
+import { InfraLogger } from "../logger.ts"
+import { messagingSpanArgs } from "../otel.ts"
+import { Receiver, Sender } from "../ServiceBus.ts"
+import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.ts"
 
 export function makeServiceBusQueue<
   Evt extends { id: StringId; _tag: string },

package/src/RequestFiberSet.ts

@@ -6,8 +6,8 @@ import * as Option from "effect-app/Option"
 import * as Fiber from "effect/Fiber"
 import * as FiberSet from "effect/FiberSet"
 import type * as Tracer from "effect/Tracer"
-import { InfraLogger } from "./logger.js"
-import { reportRequestError, reportUnknownRequestError } from "./reportError.js"
+import { InfraLogger } from "./logger.ts"
+import { reportRequestError, reportUnknownRequestError } from "./reportError.ts"
 
 const getRootParentSpan = Effect.gen(function*() {
   let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(

package/src/SQL/Model.ts

@@ -24,7 +24,7 @@ import * as VariantSchema from "effect/unstable/schema/VariantSchema"
 import { SqlClient } from "effect/unstable/sql/SqlClient"
 import * as SqlResolver from "effect/unstable/sql/SqlResolver"
 import * as SqlSchema from "effect/unstable/sql/SqlSchema"
-import { type DbSystem, withDbSpan } from "../otel.js"
+import { type DbSystem, withDbSpan } from "../otel.ts"
 
 const {
   Class,

package/src/SQL.ts

@@ -1 +1 @@
-export * as SQLModel from "./SQL/Model.js"
+export * as SQLModel from "./SQL/Model.ts"

package/src/ServiceBus.ts

@@ -7,7 +7,7 @@ import * as Cause from "effect/Cause"
 import * as Exit from "effect/Exit"
 import * as FiberSet from "effect/FiberSet"
 import type * as Scope from "effect/Scope"
-import { InfraLogger } from "./logger.js"
+import { InfraLogger } from "./logger.ts"
 
 const logged = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
   Effect.logInfo(name).pipe(

package/src/Store/Cosmos/query.ts

@@ -7,8 +7,8 @@ import type { FilterR, FilterResult, Ops } from "effect-app/Model/filter/filterA
 import type { AggregateIrExpression, ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "effect-app/Model/query"
 import type { SupportedValues } from "effect-app/Store"
 import { assertUnreachable } from "effect-app/utils"
-import { InfraLogger } from "../../logger.js"
-import { isRelationCheck } from "../codeFilter.js"
+import { InfraLogger } from "../../logger.ts"
+import { isRelationCheck } from "../codeFilter.ts"
 
 export function logQuery(q: {
   query: string

package/src/Store/Cosmos.ts

@@ -14,11 +14,11 @@ import * as Duration from "effect/Duration"
 import { pipe } from "effect/Function"
 import * as Redacted from "effect/Redacted"
 import * as Struct from "effect/Struct"
-import { CosmosClient, CosmosClientLayer } from "../cosmos-client.js"
-import { OptimisticConcurrencyException } from "../errors.js"
-import { InfraLogger } from "../logger.js"
-import { annotateCosmosResponse, annotateDb } from "../otel.js"
-import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
+import { CosmosClient, CosmosClientLayer } from "../cosmos-client.ts"
+import { DatabaseError, OptimisticConcurrencyException } from "../errors.ts"
+import { InfraLogger } from "../logger.ts"
+import { annotateCosmosResponse, annotateDb } from "../otel.ts"
+import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.ts"
 
 const makeMapId =
   <IdKey extends keyof Encoded, Encoded extends FieldValues>(idKey: IdKey) => ({ [idKey]: id, ...e }: Encoded) => ({
@@ -30,9 +30,34 @@ const makeReverseMapId =
   ({ id, ...t }: PersistenceModelType<Omit<Encoded, IdKey> & { id: string }>) =>
     ({ ...t, [idKey]: id }) as any as PersistenceModelType<Encoded>
 
-class CosmosDbOperationError {
-  constructor(readonly message: string, readonly raw?: unknown) {}
-} // TODO: Retry operation when running into RU limit.
+// Cosmos statuses worth retrying: request timeout, throttle, retry-with,
+// internal, and service unavailable.
+const RETRYABLE_COSMOS_STATUS = new Set([408, 429, 449, 500, 503])
+const statusIsTransient = (code: number) => RETRYABLE_COSMOS_STATUS.has(code)
+
+// A thrown SDK error is transient if its status/code is retryable or its message
+// looks like a timeout / throttle / dropped connection.
+const thrownIsTransient = (e: unknown): boolean => {
+  const code = (e as any)?.code ?? (e as any)?.statusCode
+  if (typeof code === "number" && RETRYABLE_COSMOS_STATUS.has(code)) return true
+  const msg = e instanceof Error ? e.message : String(e)
+  return /request timed out|timed out|\btimeout\b|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EAI_AGAIN|socket hang up|ServiceUnavailable|RequestTimeout|TooManyRequests|throttl/i
+    .test(msg)
+}
+
+// Wrap a Cosmos SDK promise so a rejection becomes a typed, serializable
+// `DatabaseError` (transient-classified) instead of a bare-`Error` defect — the
+// latter both bypasses retry and breaks JSON encoding of the failure channel.
+const tryCosmos = <A>(f: () => Promise<A>): Effect.Effect<A, DatabaseError> =>
+  Effect.tryPromise({
+    try: f,
+    catch: (e) =>
+      new DatabaseError({
+        message: `Cosmos request failed: ${e instanceof Error ? e.message : String(e)}`,
+        transient: thrownIsTransient(e),
+        cause: e
+      })
+  })
 
 const respBytes = (
   resp: { diagnostics?: { clientSideRequestStatistics?: { totalResponsePayloadLengthInBytes?: number } } }
@@ -209,8 +234,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
               batches
                 .map((x, i) => [i, x] as const),
               ([i, batch]) =>
-                Effect
-                  .promise(() => bulk(batch.map(([, op]) => op)))
+                tryCosmos(() => bulk(batch.map(([, op]) => op)))
                   .pipe(
                     Effect
                       .delay(Duration.millis(i === 0 ? 0 : 150)),
@@ -236,23 +260,21 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                             (x) => x.statusCode !== 424 && (x.statusCode > 299 || x.statusCode < 200)
                           )
                           if (r2) {
-                            return yield* Effect.die(
-                              new CosmosDbOperationError(
-                                "not able to update records: " + r2.statusCode,
-                                responses
-                              )
-                            )
+                            return yield* new DatabaseError({
+                              message: "not able to update records: " + r2.statusCode,
+                              transient: statusIsTransient(r2.statusCode),
+                              cause: responses
+                            })
                           }
                           const r3 = responses.find(
                             (x) => x.statusCode > 299 || x.statusCode < 200
                           )
                           if (r3) {
-                            return yield* Effect.die(
-                              new CosmosDbOperationError(
-                                "not able to update records: " + r3.statusCode,
-                                responses
-                              )
-                            )
+                            return yield* new DatabaseError({
+                              message: "not able to update records: " + r3.statusCode,
+                              transient: statusIsTransient(r3.statusCode),
+                              cause: responses
+                            })
                           }
                           return batch.map(([e], i) => ({
                             ...e,
@@ -317,8 +339,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
 
                 const ex = batch.map(([, c]) => c)
 
-                return Effect
-                  .promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))
+                return tryCosmos(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))
                   .pipe(Effect.flatMap(Effect.fnUntraced(function*(x) {
                     const result = x.result ?? []
                     const firstFailed = result.find(
@@ -330,9 +351,11 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                         return yield* new OptimisticConcurrencyException({ type: name, id: "batch", code })
                       }
 
-                      return yield* Effect.die(
-                        new CosmosDbOperationError("not able to update record: " + code)
-                      )
+                      return yield* new DatabaseError({
+                        message: "not able to update record: " + code,
+                        transient: statusIsTransient(code),
+                        cause: x
+                      })
                     }
 
                     return batch.map(([e], i) => ({
@@ -362,7 +385,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
               Effect.flatMap(({ ns, q }) =>
                 Effect
                   .gen(function*() {
-                    const response = yield* Effect.promise(() =>
+                    const response = yield* tryCosmos(() =>
                       container.items.query<Out>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                     )
                     yield* annotateFeed(response)
@@ -384,20 +407,19 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
             ),
         batchRemove: (ids, partitionKey?: string) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
-            Effect
-              .promise(() =>
-                execBatch(
-                  mutable(ids.map((id) =>
-                    dropUndefinedT({
-                      operationType: "Delete" as const,
-                      id
-                      // don't use this or we get an error that the request and some item partition key dont match - makese no sense
-                      // partitionKey: config?.partitionValue({ [idKey]: id } as Encoded)
-                    })
-                  )),
-                  partitionKey ?? nsBasePartitionKey(ns)
-                )
+            tryCosmos(() =>
+              execBatch(
+                mutable(ids.map((id) =>
+                  dropUndefinedT({
+                    operationType: "Delete" as const,
+                    id
+                    // don't use this or we get an error that the request and some item partition key dont match - makese no sense
+                    // partitionKey: config?.partitionValue({ [idKey]: id } as Encoded)
+                  })
+                )),
+                partitionKey ?? nsBasePartitionKey(ns)
               )
+            )
               .pipe(
                 annotateDb({
                   operation: "batchRemove",
@@ -421,7 +443,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
             Effect.flatMap(({ ns, q }) =>
               Effect
                 .gen(function*() {
-                  const response = yield* Effect.promise(() =>
+                  const response = yield* tryCosmos(() =>
                     container.items.query<PMCosmos>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                   )
                   yield* annotateFeed(response)
@@ -482,7 +504,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                   Effect
                     .gen(function*() {
                       if (f.select) {
-                        const response = yield* Effect.promise(() =>
+                        const response = yield* tryCosmos(() =>
                           container.items.query<M>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                         )
                         yield* annotateFeed(response)
@@ -494,7 +516,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                           ...mapReverseId(_ as any)
                         }))
                       }
-                      const response = yield* Effect.promise(() =>
+                      const response = yield* tryCosmos(() =>
                         container.items.query<{ f: M }>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                       )
                       yield* annotateFeed(response)
@@ -517,7 +539,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
           resolveNamespace.pipe(Effect.flatMap((ns) =>
             Effect
               .gen(function*() {
-                const response = yield* Effect.promise(() =>
+                const response = yield* tryCosmos(() =>
                   container
                     .item(id, nsPartitionValue(ns, { [idKey]: id } as Encoded))
                     .read<Encoded>()
@@ -541,20 +563,20 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
           )),
         set: (e) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
-            Option
-              .match(
-                Option
-                  .fromNullishOr(e._etag),
-                {
-                  onNone: () =>
-                    Effect.promise(() =>
+            // Annotate the result so the create/replace promise union collapses to
+            // one type (otherwise `A` infers as `unknown` and the chain degrades).
+            tryCosmos((): Promise<{ statusCode: number; etag: string }> =>
+              Option
+                .match(
+                  Option
+                    .fromNullishOr(e._etag),
+                  {
+                    onNone: () =>
                       container.items.create({
                         ...mapId(e),
                         _partitionKey: nsPartitionValue(ns, e)
-                      })
-                    ),
-                  onSome: (eTag) =>
-                    Effect.promise(() =>
+                      }),
+                    onSome: (eTag) =>
                       container.item(e[idKey], nsPartitionValue(ns, e)).replace(
                         { ...mapId(e), _partitionKey: nsPartitionValue(ns, e) },
                         {
@@ -564,22 +586,24 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                           }
                         }
                       )
-                    )
-                }
-              )
+                  }
+                )
+            )
               .pipe(
                 Effect
-                  .flatMap((x) => {
+                  .flatMap((x): Effect.Effect<PM, OptimisticConcurrencyException | DatabaseError> => {
                     if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
                       return Effect.fail(
                         new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode })
                       )
                     }
                     if (x.statusCode > 299 || x.statusCode < 200) {
-                      return Effect.die(
-                        new CosmosDbOperationError(
-                          "not able to update record: " + x.statusCode
-                        )
+                      return Effect.fail(
+                        new DatabaseError({
+                          message: "not able to update record: " + x.statusCode,
+                          transient: statusIsTransient(x.statusCode),
+                          cause: x
+                        })
                       )
                     }
                     return Effect.sync(() => ({

package/src/Store/Disk.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as fu from "../fileUtil.js"
+import * as fu from "../fileUtil.ts"
 
 import fs from "fs"
 
@@ -9,8 +9,8 @@ import { type PersistenceModelType, type StorageConfig, type Store, type StoreCo
 import * as Console from "effect/Console"
 import { flow } from "effect/Function"
 import * as Semaphore from "effect/Semaphore"
-import { annotateDb } from "../otel.js"
-import { makeMemoryStoreInt } from "./Memory.js"
+import { annotateDb } from "../otel.ts"
+import { makeMemoryStoreInt } from "./Memory.ts"
 
 function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
   prefix: string,
@@ -175,7 +175,9 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
         seed?: Effect.Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) {
-        const primary = yield* makeDiskStoreInt(prefix, idKey, "primary", dir, name, seed, config?.defaultValues)
+        const primary = yield* makeDiskStoreInt(prefix, idKey, "primary", dir, name, seed, config?.defaultValues).pipe(
+          Effect.orDie
+        )
         const stores = new Map<string, Store<IdKey, Encoded>>([["primary", primary]])
         const ctx = yield* Effect.context<R>()
         const semaphores = new Map<string, Semaphore.Semaphore>()

package/src/Store/Memory.ts

@@ -15,15 +15,12 @@ import * as Ref from "effect/Ref"
 import * as Result from "effect/Result"
 import * as Semaphore from "effect/Semaphore"
 import * as Struct from "effect/Struct"
-import { InfraLogger } from "../logger.js"
-import { annotateDb } from "../otel.js"
-import { codeFilter, codeFilter3_ } from "./codeFilter.js"
-import { makeUpdateETag } from "./utils.js"
+import { InfraLogger } from "../logger.ts"
+import { annotateDb } from "../otel.ts"
+import { codeFilter, codeFilter3_ } from "./codeFilter.ts"
+import { get, makeUpdateETag } from "./utils.ts"
 
-/** Traverse an object by a dot-separated path string, e.g. `"a.b.c"`. */
-export function get(obj: any, path: string): any {
-  return path.split(".").reduce((res: any, key: string) => (res != null ? res[key] : res), obj)
-}
+export { get } from "./utils.ts"
 
 const stripRelationFilterPaths = (state: readonly FilterResult[], relationPath: string): readonly FilterResult[] => {
   const prefix = `${relationPath}.-1.`

package/src/Store/SQL/Pg.ts

@@ -9,11 +9,11 @@ import * as Option from "effect-app/Option"
 import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, storeId, StoreMaker } from "effect-app/Store"
 import * as Struct from "effect/Struct"
 import { SqlClient } from "effect/unstable/sql"
-import { OptimisticConcurrencyException } from "../../errors.js"
-import { InfraLogger } from "../../logger.js"
-import { annotateDb } from "../../otel.js"
-import { makeETag } from "../utils.js"
-import { buildWhereSQLQuery, logQuery, pgDialect } from "./query.js"
+import { OptimisticConcurrencyException } from "../../errors.ts"
+import { InfraLogger } from "../../logger.ts"
+import { annotateDb } from "../../otel.ts"
+import { makeETag } from "../utils.ts"
+import { buildWhereSQLQuery, logQuery, pgDialect } from "./query.ts"
 
 const parseRow = <Encoded extends FieldValues>(
   row: { id: string; _etag: string | null; data: unknown },

package/src/Store/SQL/query.ts

@@ -4,8 +4,8 @@ import * as Effect from "effect-app/Effect"
 import type { FilterR, FilterResult } from "effect-app/Model/filter/filterApi"
 import type { AggregateIrExpression, ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "effect-app/Model/query"
 import { assertUnreachable } from "effect-app/utils"
-import { InfraLogger } from "../../logger.js"
-import { isRelationCheck } from "../codeFilter.js"
+import { InfraLogger } from "../../logger.ts"
+import { isRelationCheck } from "../codeFilter.ts"
 
 export interface SQLDialect {
   readonly jsonExtract: (path: string) => string

package/src/Store/SQL.ts

@@ -12,11 +12,19 @@ import * as Layer from "effect/Layer"
 import * as LayerMap from "effect/LayerMap"
 import * as Struct from "effect/Struct"
 import { SqlClient } from "effect/unstable/sql"
-import { OptimisticConcurrencyException } from "../errors.js"
-import { InfraLogger } from "../logger.js"
-import { annotateDb, type DbSystem } from "../otel.js"
-import { buildWhereSQLQuery, logQuery, type SQLDialect, sqliteDialect } from "./SQL/query.js"
-import { makeETag } from "./utils.js"
+import { DatabaseError, OptimisticConcurrencyException } from "../errors.ts"
+import { InfraLogger } from "../logger.ts"
+import { annotateDb, type DbSystem } from "../otel.ts"
+import { buildWhereSQLQuery, logQuery, type SQLDialect, sqliteDialect } from "./SQL/query.ts"
+import { makeETag } from "./utils.ts"
+
+const sqlErrorMessage = (e: unknown) => (e as any)?.message ? String((e as any).message) : String(e)
+const sqlIsTransient = (e: unknown) =>
+  /timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|connection|deadlock|too many connections/i.test(sqlErrorMessage(e))
+// Map a SqlError into a typed, serializable DatabaseError (instead of `.orDie`,
+// which would turn it into an opaque, non-serializable defect).
+const toDatabaseError = (e: unknown) =>
+  new DatabaseError({ message: `SQL request failed: ${sqlErrorMessage(e)}`, transient: sqlIsTransient(e), cause: e })
 
 export type WithNsTransactionFn = <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 
@@ -101,7 +109,8 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
           return { id, _etag: newE._etag!, data, item: newE }
         }
 
-        const exec = (query: string, params?: readonly unknown[]) => sql.unsafe(query, params as any).pipe(Effect.orDie)
+        const exec = (query: string, params?: readonly unknown[]) =>
+          sql.unsafe(query, params as any).pipe(Effect.mapError(toDatabaseError))
 
         const setInternal = Effect.fnUntraced(function*(e: PM, ns: string) {
           const row = toRow(e)
@@ -151,7 +160,7 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
             )
 
         const ctx = yield* Effect.context<R>()
-        const seedCache = new Map<string, Effect.Effect<void>>()
+        const seedCache = new Map<string, Effect.Effect<void, DatabaseError>>()
         const makeSeedEffect = Effect.fnUntraced(function*(ns: string) {
           yield* ensureTable
           if (!seed) return
@@ -365,8 +374,10 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
             )
         }
 
-        // Eagerly seed primary namespace on initialization
-        yield* seedNamespace("primary")
+        // Eagerly seed primary namespace on initialization. A seed failure at
+        // construction is fatal (orDie); the per-call `seedNamespace` still
+        // surfaces DatabaseError to callers.
+        yield* seedNamespace("primary").pipe(Effect.orDie)
 
         return s
       })
@@ -412,7 +423,7 @@ function makeSQLiteStorePerNs(
       }
 
       const exec = (ns: string, query: string, params?: readonly unknown[]) =>
-        withNsSql(ns, (sql) => sql.unsafe(query, params as any).pipe(Effect.orDie))
+        withNsSql(ns, (sql) => sql.unsafe(query, params as any).pipe(Effect.mapError(toDatabaseError)))
 
       const ensureTable = (ns: string) =>
         withNsSql(ns, (sql) =>
@@ -482,7 +493,7 @@ function makeSQLiteStorePerNs(
             ))
 
       const ctx = yield* Effect.context<R>()
-      const seedCache = new Map<string, Effect.Effect<void>>()
+      const seedCache = new Map<string, Effect.Effect<void, DatabaseError>>()
       const makeSeedEffect = Effect.fnUntraced(function*(ns: string) {
         yield* ensureTable(ns)
         if (!seed) return
@@ -696,7 +707,7 @@ function makeSQLiteStorePerNs(
           )
       }
 
-      yield* seedNamespace("primary")
+      yield* seedNamespace("primary").pipe(Effect.orDie)
 
       return s
     })

package/src/Store/codeFilter.ts

@@ -6,8 +6,7 @@ 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"
+import { compare, get, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.ts"
 
 const vAsArr = (v: string) => v as unknown as any[]
 

package/src/Store/index.test.ts.bak

@@ -2,9 +2,9 @@
 import * as Test from "@effect-ts/jest/Test"
 import { describe, expect } from "@jest/globals"
 
-import { OptimisticConcurrencyException } from "../../errors.js"
+import { OptimisticConcurrencyException } from "../../errors.ts"
 
-import { makeMemoryStore } from "./Memory.js"
+import { makeMemoryStore } from "./Memory.ts"
 
 const { it } = Test.runtime()
 

package/src/Store/index.ts

@@ -5,12 +5,12 @@ 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 { SQLiteStoreLayer } from "./SQL.js"
-import { PgStoreLayer } from "./SQL/Pg.js"
+import { CosmosStoreLayer } from "./Cosmos.ts"
+import { DiskStoreLayer } from "./Disk.ts"
+import { MemoryStoreLive } from "./Memory.ts"
+// import { RedisStoreLayer } from "./Redis.ts"
+import { SQLiteStoreLayer } from "./SQL.ts"
+import { PgStoreLayer } from "./SQL/Pg.ts"
 
 export function StoreMakerLayer(
   cfg: StorageConfig,

package/src/Store/utils.ts

@@ -2,7 +2,12 @@ import crypto from "crypto"
 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 { OptimisticConcurrencyException } from "../errors.ts"
+
+/** Traverse an object by a dot-separated path string, e.g. `"a.b.c"`. */
+export function get(obj: any, path: string): any {
+  return path.split(".").reduce((res: any, key: string) => (res != null ? res[key] : res), obj)
+}
 
 export const makeETag = <E extends PersistenceModelType<{}>>(
   { _etag, ...e }: E

package/src/WorkflowEngineCosmos.ts

@@ -45,9 +45,9 @@ import type * as Scope from "effect/Scope"
 import * as Workflow from "effect/unstable/workflow/Workflow"
 import { type Encoded, makeUnsafe, WorkflowEngine, WorkflowInstance } from "effect/unstable/workflow/WorkflowEngine"
 import { randomUUID } from "node:crypto"
-import { CosmosClient, CosmosClientLayer } from "./cosmos-client.js"
-import { OptimisticConcurrencyException } from "./errors.js"
-import { annotateCosmosResponse, annotateDb } from "./otel.js"
+import { CosmosClient, CosmosClientLayer } from "./cosmos-client.ts"
+import { OptimisticConcurrencyException } from "./errors.ts"
+import { annotateCosmosResponse, annotateDb } from "./otel.ts"
 
 export interface WorkflowEngineCosmosConfig {
   readonly url: Redacted.Redacted<string>