@effect-app/infra 4.0.0-beta.327 → 4.0.0-beta.328

package/dist/Store/jsonDocument.js

@@ -1,10 +1,14 @@
+import * as Option from "effect-app/Option";
 import * as S from "effect-app/Schema";
+import * as Result from "effect/Result";
 import { toJsonQueryValue } from "./utils.js";
 const splitEtag = (doc) => {
     const { _etag, ...rest } = doc;
     return { rest: rest, _etag };
 };
 const joinEtag = (rest, _etag) => (_etag === undefined ? rest : { ...rest, _etag });
+/** JSON document ↔ Encoded document codec for a store's domain schema. */
+const jsonCodec = (schema) => S.toCodecJson(S.toEncoded(schema));
 /**
  * Encoded document ↔ JSON document. Prefer `Schema.toCodecJson(toEncoded(schema))`
  * when the store has a schema; otherwise lower Date/Map/Set structurally.
@@ -13,18 +17,17 @@ const joinEtag = (rest, _etag) => (_etag === undefined ? rest : { ...rest, _etag
  * document that does not match the Encoded shape fails loudly rather than being
  * read back half-decoded.
  *
- * Migrating a legacy-shaped document is therefore not this codec's job: the
- * store applies `StoreConfig.jitM` to the raw JSON document *before* calling
- * `decode` (see {@link makeStoredDecode}), which is the only place where a
- * document can be repaired. A document `jitM` does not repair is a genuine
- * failure and throws here.
+ * This is the **write** path codec: `encode` on the way to the database, and
+ * `decode` to hand the just-written document back. The read path uses
+ * {@link makeStoredDecode}, which applies `jitM` first and reports a document it
+ * does not repair as a typed `S.SchemaError` instead of throwing.
  *
  * `_etag` is infrastructure metadata rather than part of the domain document,
  * so it is split off before the codec runs and re-attached afterwards.
  */
 export const makeJsonDocumentCodec = (schema) => {
     if (schema) {
-        const codec = S.toCodecJson(S.toEncoded(schema));
+        const codec = jsonCodec(schema);
         return {
             encode: (doc) => {
                 const { rest, _etag } = splitEtag(doc);
@@ -44,30 +47,61 @@ export const makeJsonDocumentCodec = (schema) => {
 /**
  * The store *read* boundary: apply `jitM` to the raw JSON document - after the
  * adapter merged `defaultValues` into it - and only then decode JSON→Encoded
- * with the strict {@link makeJsonDocumentCodec} codec.
+ * with the strict `Schema.toCodecJson(Schema.toEncoded(schema))` codec.
  *
  * This is the one place a legacy-shaped document can be repaired, and why
  * `jitM` can fix things no schema decode could - an explicit `null` where a
  * `Date` is expected, a key added after the document was written. It runs
- * before any schema decode sees the document; a document it does not repair
- * still fails loudly in `codec.decode`.
+ * before any schema decode sees the document.
+ *
+ * Nothing here is lenient: a document `jitM` does not repair still fails. It
+ * fails as a typed `S.SchemaError` in a `Result` (via `S.decodeUnknownResult`)
+ * rather than by throwing, so adapters can turn it into `Effect.fail` and
+ * callers - `Repository.validateSample` in particular - can inspect it per
+ * document instead of losing the whole run to a defect.
  *
  * `_etag` is infrastructure metadata rather than part of the domain document,
  * so it is split off first and `jitM` never sees it.
- *
- * Returns `codec.decode` unchanged when there is no `jitM`; the write path,
- * which must not run migrations, keeps using `codec.decode` directly.
  */
-export const makeStoredDecode = (codec, jitM) => {
-    if (jitM === undefined)
-        return codec.decode;
+export const makeStoredDecode = (schema, jitM) => {
+    if (schema === undefined) {
+        // schemaless store: the stored document is already the Encoded document,
+        // so there is nothing to decode - only `jitM` to apply.
+        if (jitM === undefined)
+            return Result.succeed;
+        return (doc) => {
+            const { rest, _etag } = splitEtag(doc);
+            return Result.succeed(joinEtag(jitM(rest), _etag));
+        };
+    }
+    const decode = S.decodeUnknownResult(jsonCodec(schema));
     return (doc) => {
         const { rest, _etag } = splitEtag(doc);
         // adapters type the stored document as the Encoded persistence model, but
         // at this point it is still the raw JSON document that `jitM` is written
-        // against - and `jitM` returns JSON, which is what `codec.decode` consumes.
-        const migrated = jitM(rest);
-        return codec.decode(joinEtag(migrated, _etag));
+        // against - and `jitM` returns JSON, which is what the codec consumes.
+        const json = jitM === undefined ? rest : jitM(rest);
+        return Result.map(decode(json), (decoded) => joinEtag(decoded, _etag));
     };
 };
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Decode a whole result set, failing fast on the first bad document.
+ *
+ * One synchronous loop and one `Result` for the batch: no Effect per document,
+ * and no allocation beyond the decoded array (plus a `Result` wrapper) on the
+ * happy path. Adapters lift the returned `Result` with `Effect.fromResult`
+ * once, at the end.
+ */
+export const decodeStoredMany = (docs, decode) => {
+    const decoded = [];
+    for (const doc of docs) {
+        const result = decode(doc);
+        if (Result.isFailure(result))
+            return Result.fail(result.failure);
+        decoded.push(result.success);
+    }
+    return Result.succeed(decoded);
+};
+/** Decode an optional stored document; `None` short-circuits without decoding. */
+export const decodeStoredOption = (doc, decode) => Option.isNone(doc) ? Result.succeed(Option.none()) : Result.map(decode(doc.value), Option.some);
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "4.0.0-beta.327",
+  "version": "4.0.0-beta.328",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -16,7 +16,7 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "8.4.0",
     "query-string": "^9.4.0",
-    "effect-app": "4.0.0-beta.327"
+    "effect-app": "4.0.0-beta.328"
   },
   "devDependencies": {
     "@azure/cosmos": "^4.9.3",

package/src/Store/Cosmos.ts

@@ -19,7 +19,7 @@ import { DatabaseError, OptimisticConcurrencyException } from "../errors.ts"
 import { InfraLogger } from "../logger.ts"
 import { annotateCosmosResponse, annotateDb } from "../otel.ts"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.ts"
-import { makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
+import { decodeStoredMany, decodeStoredOption, makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
 import { makeJsonLower } from "./utils.ts"
 
 const makeMapId =
@@ -99,7 +99,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ autoscaleMaxThroughput, pr
       const mapId = makeMapId<IdKey, Encoded>(idKey)
       const mapReverseId = makeReverseMapId<IdKey, Encoded>(idKey)
       const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
-      const decodeStored = makeStoredDecode<Encoded>(codec, config?.jitM)
+      const decodeStored = makeStoredDecode<Encoded>(config?.schema, config?.jitM)
       const json = makeJsonLower(config)
       const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
       // stored JSON -> defaultValues -> jitM -> JSON→Encoded decode
@@ -458,7 +458,9 @@ const makeCosmosStore = Effect.fnUntraced(function*({ autoscaleMaxThroughput, pr
                     container.items.query<PMCosmos>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                   )
                   yield* annotateFeed(response)
-                  return response.resources.map((_) => fromStored(_ as unknown as Encoded))
+                  return yield* Effect.fromResult(
+                    decodeStoredMany(response.resources, (_) => fromStored(_ as unknown as Encoded))
+                  )
                 })
                 .pipe(
                   annotateDb({
@@ -532,7 +534,10 @@ const makeCosmosStore = Effect.fnUntraced(function*({ autoscaleMaxThroughput, pr
                         container.items.query<{ f: M }>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                       )
                       yield* annotateFeed(response)
-                      return response.resources.map(({ f }) => fromStored(f as Encoded) as any)
+                      const decoded = yield* Effect.fromResult(
+                        decodeStoredMany(response.resources, ({ f }) => fromStored(f as Encoded))
+                      )
+                      return decoded as any
                     })
                     .pipe(
                       annotateDb({
@@ -557,8 +562,8 @@ const makeCosmosStore = Effect.fnUntraced(function*({ autoscaleMaxThroughput, pr
                     .read<Encoded>()
                 )
                 yield* annotateItem(response)
-                return Option.fromNullishOr(response.resource).pipe(
-                  Option.map((_) => fromStored(_))
+                return yield* Effect.fromResult(
+                  decodeStoredOption(Option.fromNullishOr(response.resource), fromStored)
                 )
               })
               .pipe(annotateDb({

package/src/Store/Disk.ts

@@ -10,7 +10,7 @@ import * as Console from "effect/Console"
 import { flow } from "effect/Function"
 import * as Semaphore from "effect/Semaphore"
 import { annotateDb } from "../otel.ts"
-import { makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
+import { decodeStoredMany, makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
 import { makeMemoryStoreInt } from "./Memory.ts"
 import { type JsonLower, makeJsonLower } from "./utils.ts"
 
@@ -30,7 +30,7 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
   const codec = makeJsonDocumentCodec<Encoded>(schema)
   // the file is the raw JSON boundary for this adapter:
   // stored JSON -> jitM -> JSON→Encoded decode
-  const decodeStored = makeStoredDecode<Encoded>(codec, jitM)
+  const decodeStored = makeStoredDecode<Encoded>(schema, jitM)
   return Effect.gen(function*() {
     if (namespace !== "primary") {
       dir = dir + "/" + namespace
@@ -53,7 +53,8 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
             extra: fileExtra
           }),
           Effect.flatMap((x) =>
-            Effect.sync(() => (JSON.parse(x) as PM[]).map((row) => decodeStored(row))).pipe(
+            Effect.sync(() => JSON.parse(x) as PM[]).pipe(
+              Effect.flatMap((docs) => Effect.fromResult(decodeStoredMany(docs, decodeStored))),
               annotateDb({
                 operation: "read.parse",
                 system: "disk",

package/src/Store/Memory.ts

@@ -18,7 +18,7 @@ import * as Struct from "effect/Struct"
 import { InfraLogger } from "../logger.ts"
 import { annotateDb } from "../otel.ts"
 import { codeFilter, codeFilter3_ } from "./codeFilter.ts"
-import { makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
+import { decodeStoredMany, decodeStoredOption, makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
 import { get, jsonifyFilter, type JsonLower, makeJsonLower, makeUpdateETag, toJsonQueryValue } from "./utils.ts"
 
 export { get } from "./utils.ts"
@@ -344,7 +344,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
     const codec = makeJsonDocumentCodec<Encoded>(schema)
     const encodeDoc = (e: Encoded | PM): PM => codec.encode({ _etag: undefined, ...e })
     // read path: stored JSON -> jitM -> JSON→Encoded decode
-    const decodeDoc = makeStoredDecode<Encoded>(codec, jitM)
+    const decodeDoc = makeStoredDecode<Encoded>(schema, jitM)
     const items_ = yield* seed ?? Effect.sync(() => [])
     const toJson = json?.toJson ?? toJsonQueryValue
     const lowerFilter = json?.jsonifyFilter ?? jsonifyFilter
@@ -362,7 +362,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
     const values = Effect.map(Ref.get(store), (s) => s.values())
 
     const allStored = Effect.map(values, Array.fromIterable)
-    const all = Effect.map(allStored, (rows) => rows.map(decodeDoc))
+    const all = Effect.flatMap(allStored, (rows) => Effect.fromResult(decodeStoredMany(rows, decodeDoc)))
 
     const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
       Effect
@@ -384,7 +384,9 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
                 )
             ),
           Effect
-            .map((items) => items.map(decodeDoc) as unknown as NonEmptyReadonlyArray<PM>),
+            .flatMap((items) => Effect.fromResult(decodeStoredMany(items, decodeDoc))),
+          Effect
+            .map((items) => items as unknown as NonEmptyReadonlyArray<PM>),
           withPermit
         )
 
@@ -430,7 +432,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
         Ref
           .get(store)
           .pipe(
-            Effect.map((_) => Option.fromNullishOr(_.get(id)).pipe(Option.map(decodeDoc))),
+            Effect.flatMap((_) => Effect.fromResult(decodeStoredOption(Option.fromNullishOr(_.get(id)), decodeDoc))),
             annotateDb({
               operation: "find",
               system: "memory",
@@ -445,10 +447,13 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
           .pipe(
             Effect.tap(() => logQuery(f, encodedDefaults)),
             Effect.map(memFilter({ ...f, filter: f.filter ? lowerFilter(f.filter) : f.filter })),
-            Effect.map((rows): (U extends undefined ? Encoded : Pick<Encoded, U>)[] =>
+            Effect.flatMap((rows) =>
               f.select
-                ? rows as (U extends undefined ? Encoded : Pick<Encoded, U>)[]
-                : rows.map(decodeDoc) as (U extends undefined ? Encoded : Pick<Encoded, U>)[]
+                ? Effect.succeed(rows as (U extends undefined ? Encoded : Pick<Encoded, U>)[])
+                : Effect.map(
+                  Effect.fromResult(decodeStoredMany(rows, decodeDoc)),
+                  (decoded) => decoded as (U extends undefined ? Encoded : Pick<Encoded, U>)[]
+                )
             ),
             annotateDb({
               operation: "filter",
@@ -470,7 +475,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
                   Effect.flatMap((_) => Ref.set(store, _))
                 )
               ),
-            Effect.map(decodeDoc),
+            Effect.flatMap((stored) => Effect.fromResult(decodeDoc(stored))),
             withPermit,
             annotateDb({
               operation: "set",

package/src/Store/SQL/Pg.ts

@@ -12,7 +12,7 @@ import { SqlClient } from "effect/unstable/sql"
 import { DatabaseError, OptimisticConcurrencyException } from "../../errors.ts"
 import { InfraLogger } from "../../logger.ts"
 import { annotateDb } from "../../otel.ts"
-import { makeJsonDocumentCodec, makeStoredDecode } from "../jsonDocument.ts"
+import { decodeStoredMany, decodeStoredOption, makeJsonDocumentCodec, makeStoredDecode } from "../jsonDocument.ts"
 import { makeETag, makeJsonLower, toJsonQueryValue } from "../utils.ts"
 import { buildWhereSQLQuery, logQuery, pgDialect } from "./query.ts"
 
@@ -34,17 +34,19 @@ const preserveStoreError = (e: unknown): DatabaseError | OptimisticConcurrencyEx
   return toDatabaseError(e)
 }
 
+/**
+ * Row -> raw stored JSON document. Decoding it is a separate step
+ * (`makeStoredDecode`), so a document `jitM` does not repair fails as a typed
+ * `S.SchemaError` rather than throwing out of here.
+ */
 const parseRow = <Encoded extends FieldValues>(
   row: { id: string; _etag: string | null; data: unknown },
   idKey: PropertyKey,
-  defaultValues: Partial<Encoded>,
-  decode: (doc: PersistenceModelType<Encoded>) => PersistenceModelType<Encoded> = (doc) => doc
+  defaultValues: Partial<Encoded>
 ): PersistenceModelType<Encoded> => {
   const data = (typeof row.data === "string" ? JSON.parse(row.data) : row.data) as object
   const jsonDefaults = toJsonQueryValue(defaultValues) as Partial<Encoded>
-  return decode(
-    { ...jsonDefaults, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
-  )
+  return { ...jsonDefaults, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
 }
 
 const parseSelectRow = (
@@ -79,7 +81,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
       const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
       const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
       // read path: stored JSON -> defaultValues -> jitM -> JSON→Encoded decode
-      const decodeStored = makeStoredDecode<Encoded>(codec, config?.jitM)
+      const decodeStored = makeStoredDecode<Encoded>(config?.schema, config?.jitM)
+      const decodeRow = (row: { id: string; _etag: string | null; data: unknown }) =>
+        decodeStored(parseRow<Encoded>(row, idKey, defaultValues))
 
       const resolveNamespace = !config?.allowNamespace
         ? Effect.succeed("primary")
@@ -202,9 +206,7 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
             const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = $1`
             return exec(sqlText, [ns])
               .pipe(
-                Effect.map((rows) =>
-                  (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues, decodeStored))
-                ),
+                Effect.flatMap((rows) => Effect.fromResult(decodeStoredMany(rows as any[], decodeRow))),
                 annotateDb({
                   operation: "all",
                   system: "postgresql",
@@ -223,12 +225,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
               const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE id = $1 AND _namespace = $2`
               return exec(sqlText, [id, ns])
                 .pipe(
-                  Effect.map((rows) => {
-                    const row = (rows as any[])[0]
-                    return row
-                      ? Option.some(parseRow<Encoded>(row, idKey, defaultValues, decodeStored))
-                      : Option.none()
-                  }),
+                  Effect.flatMap((rows) =>
+                    Effect.fromResult(decodeStoredOption(Option.fromNullishOr((rows as any[])[0]), decodeRow))
+                  ),
                   annotateDb({
                     operation: "find",
                     system: "postgresql",
@@ -286,9 +285,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                 Effect.tap((q) => Effect.annotateCurrentSpan({ "db.query.text": q.sql })),
                 Effect.flatMap((q) =>
                   exec(q.sql, q.params).pipe(
-                    Effect.map((rows) => {
+                    Effect.flatMap((rows) => {
                       if (f.select) {
-                        return (rows as any[]).map((r) => {
+                        return Effect.succeed((rows as any[]).map((r) => {
                           const selected = parseSelectRow(r, idKey, {})
                           return {
                             ...Struct.pick(
@@ -297,10 +296,11 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                             ),
                             ...selected
                           } as M
-                        })
+                        }))
                       }
-                      return (rows as any[]).map((r) =>
-                        parseRow<Encoded>(r, idKey, defaultValues, decodeStored) as any as M
+                      return Effect.map(
+                        Effect.fromResult(decodeStoredMany(rows as any[], decodeRow)),
+                        (decoded) => decoded as any as M[]
                       )
                     })
                   )

package/src/Store/SQL.ts

@@ -15,7 +15,7 @@ import { SqlClient } from "effect/unstable/sql"
 import { DatabaseError, OptimisticConcurrencyException } from "../errors.ts"
 import { InfraLogger } from "../logger.ts"
 import { annotateDb, type DbSystem } from "../otel.ts"
-import { makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
+import { decodeStoredMany, decodeStoredOption, makeJsonDocumentCodec, makeStoredDecode } from "./jsonDocument.ts"
 import { buildWhereSQLQuery, logQuery, type SQLDialect, sqliteDialect } from "./SQL/query.ts"
 import { makeETag, makeJsonLower, toJsonQueryValue } from "./utils.ts"
 
@@ -43,18 +43,22 @@ export class WithNsTransaction
   extends Context.Service<WithNsTransaction, WithNsTransactionFn>()("effect-app/WithNsTransaction")
 {}
 
-/** @internal */
+/**
+ * Row -> raw stored JSON document: `data` parsed, `defaultValues` merged, `id`
+ * and `_etag` re-injected from their columns. Decoding it is a separate step
+ * (`makeStoredDecode`), so a document `jitM` does not repair fails as a typed
+ * `S.SchemaError` rather than throwing out of here.
+ *
+ * @internal
+ */
 export const parseRow = <Encoded extends FieldValues>(
   row: { id: string; _etag: string | null; data: string },
   idKey: PropertyKey,
-  defaultValues: Partial<Encoded>,
-  decode: (doc: PersistenceModelType<Encoded>) => PersistenceModelType<Encoded> = (doc) => doc
+  defaultValues: Partial<Encoded>
 ): PersistenceModelType<Encoded> => {
   const data = (typeof row.data === "string" ? JSON.parse(row.data) : row.data) as object
   const jsonDefaults = toJsonQueryValue(defaultValues) as Partial<Encoded>
-  return decode(
-    { ...jsonDefaults, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
-  )
+  return { ...jsonDefaults, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
 }
 
 const parseSelectRow = (
@@ -95,7 +99,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
         const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
         const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
         // read path: stored JSON -> defaultValues -> jitM -> JSON→Encoded decode
-        const decodeStored = makeStoredDecode<Encoded>(codec, config?.jitM)
+        const decodeStored = makeStoredDecode<Encoded>(config?.schema, config?.jitM)
+        const decodeRow = (row: { id: string; _etag: string | null; data: string }) =>
+          decodeStored(parseRow<Encoded>(row, idKey, defaultValues))
 
         const resolveNamespace = !config?.allowNamespace
           ? Effect.succeed("primary")
@@ -218,9 +224,7 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
               const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = ?`
               return exec(sqlText, [ns])
                 .pipe(
-                  Effect.map((rows) =>
-                    (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues, decodeStored))
-                  ),
+                  Effect.flatMap((rows) => Effect.fromResult(decodeStoredMany(rows as any[], decodeRow))),
                   annotateDb({
                     operation: "all",
                     system,
@@ -239,12 +243,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                 const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE id = ? AND _namespace = ?`
                 return exec(sqlText, [id, ns])
                   .pipe(
-                    Effect.map((rows) => {
-                      const row = (rows as any[])[0]
-                      return row
-                        ? Option.some(parseRow<Encoded>(row, idKey, defaultValues, decodeStored))
-                        : Option.none()
-                    }),
+                    Effect.flatMap((rows) =>
+                      Effect.fromResult(decodeStoredOption(Option.fromNullishOr((rows as any[])[0]), decodeRow))
+                    ),
                     annotateDb({
                       operation: "find",
                       system,
@@ -302,9 +303,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                       Effect.tap((q) => Effect.annotateCurrentSpan({ "db.query.text": q.sql })),
                       Effect.flatMap((q) =>
                         exec(q.sql, q.params).pipe(
-                          Effect.map((rows) => {
+                          Effect.flatMap((rows) => {
                             if (f.select) {
-                              return (rows as any[]).map((r) => {
+                              return Effect.succeed((rows as any[]).map((r) => {
                                 const selected = parseSelectRow(r, idKey)
                                 return {
                                   ...Struct.pick(
@@ -313,10 +314,11 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                                   ),
                                   ...selected
                                 } as M
-                              })
+                              }))
                             }
-                            return (rows as any[]).map((r) =>
-                              parseRow<Encoded>(r, idKey, defaultValues, decodeStored) as any as M
+                            return Effect.map(
+                              Effect.fromResult(decodeStoredMany(rows as any[], decodeRow)),
+                              (decoded) => decoded as any as M[]
                             )
                           })
                         )
@@ -436,7 +438,9 @@ function makeSQLiteStorePerNs(
       const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
       const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
       // read path: stored JSON -> defaultValues -> jitM -> JSON→Encoded decode
-      const decodeStored = makeStoredDecode<Encoded>(codec, config?.jitM)
+      const decodeStored = makeStoredDecode<Encoded>(config?.schema, config?.jitM)
+      const decodeRow = (row: { id: string; _etag: string | null; data: string }) =>
+        decodeStored(parseRow<Encoded>(row, idKey, defaultValues))
 
       const resolveNamespace = !config?.allowNamespace
         ? Effect.succeed("primary")
@@ -567,9 +571,7 @@ function makeSQLiteStorePerNs(
           const sqlText = `SELECT id, _etag, data FROM "${tableName}"`
           return exec(ns, sqlText)
             .pipe(
-              Effect.map((rows) =>
-                (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues, decodeStored))
-              ),
+              Effect.flatMap((rows) => Effect.fromResult(decodeStoredMany(rows as any[], decodeRow))),
               annotateDb({
                 operation: "all",
                 system: "sqlite",
@@ -587,12 +589,9 @@ function makeSQLiteStorePerNs(
               const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE id = ?`
               return exec(ns, sqlText, [id])
                 .pipe(
-                  Effect.map((rows) => {
-                    const row = (rows as any[])[0]
-                    return row
-                      ? Option.some(parseRow<Encoded>(row, idKey, defaultValues, decodeStored))
-                      : Option.none()
-                  }),
+                  Effect.flatMap((rows) =>
+                    Effect.fromResult(decodeStoredOption(Option.fromNullishOr((rows as any[])[0]), decodeRow))
+                  ),
                   annotateDb({
                     operation: "find",
                     system: "sqlite",
@@ -650,9 +649,9 @@ function makeSQLiteStorePerNs(
                     Effect.tap((q) => Effect.annotateCurrentSpan({ "db.query.text": q.sql })),
                     Effect.flatMap((q) =>
                       exec(ns, q.sql, q.params).pipe(
-                        Effect.map((rows) => {
+                        Effect.flatMap((rows) => {
                           if (f.select) {
-                            return (rows as any[]).map((r) => {
+                            return Effect.succeed((rows as any[]).map((r) => {
                               const selected = parseSelectRow(r, idKey)
                               return {
                                 ...Struct.pick(
@@ -661,10 +660,11 @@ function makeSQLiteStorePerNs(
                                 ),
                                 ...selected
                               } as M
-                            })
+                            }))
                           }
-                          return (rows as any[]).map((r) =>
-                            parseRow<Encoded>(r, idKey, defaultValues, decodeStored) as any as M
+                          return Effect.map(
+                            Effect.fromResult(decodeStoredMany(rows as any[], decodeRow)),
+                            (decoded) => decoded as any as M[]
                           )
                         })
                       )