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

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[]
                           )
                         })
                       )

package/src/Store/jsonDocument.ts

@@ -1,6 +1,8 @@
 import type { FieldValues } from "effect-app/Model/filter/types"
+import * as Option from "effect-app/Option"
 import * as S from "effect-app/Schema"
 import type { PersistenceModelType, StoreConfig } from "effect-app/Store"
+import * as Result from "effect/Result"
 import { toJsonQueryValue } from "./utils.ts"
 
 export interface JsonDocumentCodec<E extends FieldValues> {
@@ -8,6 +10,18 @@ export interface JsonDocumentCodec<E extends FieldValues> {
   readonly decode: (doc: PersistenceModelType<E>) => PersistenceModelType<E>
 }
 
+/**
+ * The store *read* boundary decode: a stored JSON document in, either the
+ * Encoded document or the `S.SchemaError` saying why it is not one.
+ *
+ * Synchronous on purpose: it runs once per document over whole result sets, so
+ * it must not allocate an Effect per row. Adapters lift the `Result` into their
+ * Effect channel once per operation (see {@link decodeStoredMany}).
+ */
+export type StoredDecode<E extends FieldValues> = (
+  doc: PersistenceModelType<E>
+) => Result.Result<PersistenceModelType<E>, S.SchemaError>
+
 const splitEtag = <E extends FieldValues>(doc: PersistenceModelType<E>) => {
   const { _etag, ...rest } = doc
   return { rest: rest as E, _etag }
@@ -18,6 +32,9 @@ const joinEtag = <E extends FieldValues>(
   _etag: string | undefined
 ): PersistenceModelType<E> => (_etag === undefined ? rest : { ...rest, _etag })
 
+/** JSON document ↔ Encoded document codec for a store's domain schema. */
+const jsonCodec = <E extends FieldValues>(schema: S.Top) => S.toCodecJson(S.toEncoded(schema)) as S.Codec<E, S.Json>
+
 /**
  * Encoded document ↔ JSON document. Prefer `Schema.toCodecJson(toEncoded(schema))`
  * when the store has a schema; otherwise lower Date/Map/Set structurally.
@@ -26,18 +43,17 @@ const joinEtag = <E extends FieldValues>(
  * 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 = <E extends FieldValues>(schema?: S.Top): JsonDocumentCodec<E> => {
   if (schema) {
-    const codec = S.toCodecJson(S.toEncoded(schema)) as S.Codec<E, S.Json>
+    const codec = jsonCodec<E>(schema)
     return {
       encode: (doc) => {
         const { rest, _etag } = splitEtag(doc)
@@ -58,31 +74,70 @@ export const makeJsonDocumentCodec = <E extends FieldValues>(schema?: S.Top): Js
 /**
  * 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 = <E extends FieldValues>(
-  codec: JsonDocumentCodec<E>,
+  schema: StoreConfig<E>["schema"],
   jitM: StoreConfig<E>["jitM"]
-): JsonDocumentCodec<E>["decode"] => {
-  if (jitM === undefined) return codec.decode
+): StoredDecode<E> => {
+  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) as unknown as E, _etag))
+    }
+  }
+  const decode = S.decodeUnknownResult(jsonCodec<E>(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) as unknown as E
-    return codec.decode(joinEtag(migrated, _etag))
+    // against - and `jitM` returns JSON, which is what the codec consumes.
+    const json = jitM === undefined ? rest : jitM(rest) as unknown as E
+    return Result.map(decode(json), (decoded) => joinEtag(decoded, _etag))
+  }
+}
+
+/**
+ * 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 = <A, B>(
+  docs: readonly A[],
+  decode: (doc: A) => Result.Result<B, S.SchemaError>
+): Result.Result<B[], S.SchemaError> => {
+  const decoded: B[] = []
+  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 = <A, B>(
+  doc: Option.Option<A>,
+  decode: (doc: A) => Result.Result<B, S.SchemaError>
+): Result.Result<Option.Option<B>, S.SchemaError> =>
+  Option.isNone(doc) ? Result.succeed(Option.none()) : Result.map(decode(doc.value), Option.some)

package/test/cosmos-query.test.ts

@@ -3,6 +3,7 @@ import { and, computed, make, project, projectComputed, relation, toFilter, wher
 import * as S from "effect-app/Schema"
 import { describe, expect, it } from "vitest"
 import { buildWhereCosmosQuery3 } from "../src/Store/Cosmos/query.js"
+import { makeJsonLower } from "../src/Store/utils.js"
 
 class Order extends S.Class<Order>("Order")({
   id: S.String,
@@ -321,3 +322,47 @@ describe("cosmos query: aggregate (GROUP BY + agg functions)", () => {
     expect(result.query).toMatch(/GROUP BY f(?:\.address\.city|\["address"\]\["city"\])/)
   })
 })
+
+describe("cosmos query defaultValues are already JSON-lowered", () => {
+  class Item extends S.Class<Item>("CosmosDefaultValuesItem")({
+    id: S.String,
+    at: S.Date
+  }) {}
+
+  const json = makeJsonLower({ schema: Item })
+  const at = new Date("2024-06-01T00:00:00.000Z")
+  const lowered = json.toJson({ at }) as Record<string, unknown>
+
+  it("does not re-encode store-lowered Date defaults on select-only filter", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [],
+      "Item",
+      lowered,
+      ["id"],
+      undefined,
+      undefined,
+      undefined,
+      json
+    )
+    expect(result.query).toContain("SELECT f[\"id\"]")
+  })
+
+  it("embeds already-lowered Date defaults as JSON literals", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "at", op: "eq", value: at }],
+      "Item",
+      lowered,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      json
+    )
+    expect(result.query).toContain("?? \"2024-06-01T00:00:00.000Z\"")
+    expect(result.parameters).toEqual(
+      expect.arrayContaining([{ name: "@v0", value: "2024-06-01T00:00:00.000Z" }])
+    )
+  })
+})

package/test/json-lower.test.ts

@@ -2,7 +2,7 @@ import type { Ops } from "effect-app/Model/filter/filterApi"
 import * as S from "effect-app/Schema"
 import * as Getter from "effect/SchemaGetter"
 import { describe, expect, it } from "vitest"
-import { jsonifyFilter } from "../src/Store/utils.js"
+import { jsonifyFilter, makeJsonLower } from "../src/Store/utils.js"
 
 class Day {
   readonly ymd: string
@@ -113,3 +113,17 @@ describe("jsonifyFilter Encoded key paths", () => {
     ])
   })
 })
+
+describe("makeJsonLower Date defaultValues", () => {
+  class Item extends S.Class<Item>("JsonLowerDateItem")({
+    id: S.String,
+    at: S.Date
+  }) {}
+
+  it("is not idempotent: a second pass over ISO strings throws Expected a valid Date", () => {
+    const json = makeJsonLower({ schema: Item })
+    const once = json.toJson({ at: new Date("2024-06-01T00:00:00.000Z") })
+    expect(once).toEqual({ at: "2024-06-01T00:00:00.000Z" })
+    expect(() => json.toJson(once)).toThrow(/Expected a valid Date/)
+  })
+})

package/test/repository-legacy-document.test.ts

@@ -9,8 +9,11 @@ import * as S from "effect-app/Schema"
 import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
 import type { JsonRecord } from "effect-app/Store"
 import { StoreMaker } from "effect-app/Store"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import * as Result from "effect/Result"
 import { describe, expect, it } from "vitest"
-import { makeJsonDocumentCodec, makeStoredDecode } from "../src/Store/jsonDocument.js"
+import { decodeStoredMany, decodeStoredOption, makeStoredDecode } from "../src/Store/jsonDocument.js"
 import { makeMemoryStoreInt } from "../src/Store/Memory.js"
 import { makeJsonLower } from "../src/Store/utils.js"
 
@@ -39,12 +42,15 @@ const LegacyDocStoreLive = (docs: readonly Record<string, unknown>[]) =>
           makeJsonLower(config)
         ),
         (store) => {
-          const decode = makeStoredDecode<any>(makeJsonDocumentCodec<any>(config?.schema), config?.jitM)
+          const decode = makeStoredDecode<any>(config?.schema, config?.jitM)
           return {
             ...store,
-            all: Effect.map(store.all, (rows) => rows.map(decode)),
-            find: (id: any) => Effect.map(store.find(id), Option.map(decode)),
-            filter: (f: any) => Effect.map(store.filter(f), (rows: any[]) => f.select ? rows : rows.map(decode))
+            all: Effect.flatMap(store.all, (rows) => Effect.fromResult(decodeStoredMany(rows, decode))),
+            find: (id: any) =>
+              Effect.flatMap(store.find(id), (doc) => Effect.fromResult(decodeStoredOption(doc, decode))),
+            filter: (f: any) =>
+              Effect.flatMap(store.filter(f), (rows: any[]) =>
+                f.select ? Effect.succeed(rows) : Effect.fromResult(decodeStoredMany(rows, decode)))
           }
         }
       )) as any
@@ -63,6 +69,12 @@ class Shop extends S.Class<Shop>("LegacyDocShop")({
 // `vatRate` was added later; stored documents from before that do not have it.
 const jitM = (json: JsonRecord): JsonRecord => "vatRate" in json ? json : { ...json, vatRate: 19 }
 
+/** does *not* repair `vatRate`, so `legacyDoc` cannot decode at the store boundary */
+const jitMThatDoesNotRepair = (json: JsonRecord): JsonRecord => ({
+  ...json,
+  updatedAt: json["updatedAt"] ?? "2024-06-03T00:00:00.000Z"
+})
+
 const legacyDoc = {
   id: "shop-legacy",
   name: "Legacy Shop",
@@ -270,53 +282,106 @@ describe("repository reads of legacy documents", () => {
   /**
    * The store boundary decode is deliberately **strict**: `jitM` is the one and
    * only place a legacy document can be repaired, and a document it does not
-   * repair must fail loudly rather than be read back half-decoded. This test
-   * pins that behaviour down on purpose - do not "fix" it by making the decode
-   * lenient.
+   * repair must fail rather than be read back half-decoded. This test pins that
+   * behaviour down on purpose - do not "fix" it by making the decode lenient.
+   *
+   * It fails as a *typed* `S.SchemaError` in the store's error channel (it used
+   * to throw out of `decodeSync` as a defect), which is what lets
+   * `validateSample` report the document instead of losing the whole run.
    */
-  it("a document jitM does not repair fails loudly at the store boundary", async () => {
-    const program = Effect
+  it("a document jitM does not repair fails as a typed SchemaError at the store boundary", () =>
+    Effect
       .gen(function*() {
+        const { make } = yield* StoreMaker
         // `vatRate` is still missing after this jitM ran: it only touches `updatedAt`
-        const repo = yield* makeRepo("LegacyDocShop", Shop, {
-          jitM: (json) => ({ ...json, updatedAt: json["updatedAt"] ?? "2024-06-03T00:00:00.000Z" })
+        const store = yield* make<"id", any>("LegacyDocShop", "id", undefined, {
+          partitionValue: () => "primary",
+          schema: Shop,
+          jitM: jitMThatDoesNotRepair
         })
 
-        return yield* repo.all
+        // `Effect.result` only catches typed failures - a defect would reject here
+        const result = yield* store.all.pipe(Effect.result)
+
+        expect(Result.isFailure(result)).toBe(true)
+        if (!Result.isFailure(result)) return
+        const failure = result.failure
+        expect(S.isSchemaError(failure)).toBe(true)
+        expect((failure as S.SchemaError)._tag).toBe("SchemaError")
+        // the strict `toCodecJson(toEncoded(schema))` decode still reports the
+        // key jitM failed to add, with the path to it
+        expect((failure as S.SchemaError).message).toContain("Missing key")
+        expect((failure as S.SchemaError).message).toContain("vatRate")
       })
       .pipe(
         Effect.provide(TestLive),
         setupRequestContextFromCurrent(),
         Effect.scoped,
         Effect.runPromise
-      )
-
-    let caught: unknown = undefined
-    try {
-      await program
-    } catch (e) {
-      caught = e
-    }
-
-    expect(caught).toBeDefined()
-    const message = caught instanceof Error ? caught.message : String(caught)
-    // the strict `toCodecJson(toEncoded(schema))` decode reports the key jitM
-    // failed to add, with the path to it
-    expect(message).toContain("Missing key")
-    expect(message).toContain("vatRate")
-  })
+      ))
+
+  /**
+   * ...and the *public* repository surface is unchanged: `Repository.find`/`all`
+   * declare only `DatabaseError`, so the store's `SchemaError` becomes a defect
+   * when the public members are produced.
+   */
+  it("the same document still dies on a public repository read", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM: jitMThatDoesNotRepair })
+
+        const exit = yield* repo.all.pipe(Effect.exit)
+        expect(Exit.isFailure(exit)).toBe(true)
+        if (Exit.isFailure(exit)) {
+          expect(Cause.hasDies(exit.cause)).toBe(true)
+          expect(Cause.hasFails(exit.cause)).toBe(false)
+        }
+
+        // a defect is not catchable as a typed failure
+        const notCaught = yield* repo.find("shop-legacy").pipe(Effect.result, Effect.exit)
+        expect(Exit.isFailure(notCaught)).toBe(true)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
+
+  it("validateSample reports a document that fails at the store boundary and keeps going", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("LegacyDocShop", Shop, { jitM: jitMThatDoesNotRepair })
+
+        const result = yield* repo.validateSample({ percentage: 1.0 })
+
+        expect(result.total).toBe(2)
+        expect(result.sampled).toBe(2)
+        // `shop-current` decodes, `shop-legacy` does not
+        expect(result.valid).toBe(1)
+        expect(result.errors).toHaveLength(1)
+        const error = result.errors[0]!
+        expect(error.id).toBe("shop-legacy")
+        expect(S.isSchemaError(error.error)).toBe(true)
+      })
+      .pipe(
+        Effect.provide(TestLive),
+        setupRequestContextFromCurrent(),
+        Effect.scoped,
+        Effect.runPromise
+      ))
 
   it("_etag is not visible to jitM and survives the round trip", () => {
     const seen: JsonRecord[] = []
     const decode = makeStoredDecode<any>(
-      makeJsonDocumentCodec<any>(Shop),
+      Shop,
       (json) => {
         seen.push(json)
         return { ...json, vatRate: 19 }
       }
     )
 
-    const decoded = decode({ ...legacyDoc, _etag: "etag-1" } as any)
+    const decoded = Result.getOrThrow(decode({ ...legacyDoc, _etag: "etag-1" } as any))
 
     // jitM sees the document without the infra metadata
     expect(seen).toHaveLength(1)

package/test/sql-store.test.ts

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type Sqlite from "better-sqlite3"
 import BetterSqlite from "better-sqlite3"
+import * as S from "effect-app/Schema"
 import { describe, expect, it } from "vitest"
 import { parseRow } from "../src/Store/SQL.js"
 import { buildWhereSQLQuery, pgDialect, sqliteDialect } from "../src/Store/SQL/query.js"
-import { makeETag } from "../src/Store/utils.js"
+import { makeETag, makeJsonLower } from "../src/Store/utils.js"
 
 const query = (db: Sqlite.Database, sql: string, params: unknown[] = []) =>
   db.prepare(sql).all(...params as any[]) as any[]
@@ -64,6 +65,31 @@ describe("SQL query builder (SQLite dialect)", () => {
     expect(result.params).toContain("2024-06-01")
   })
 
+  it("does not re-encode store-lowered Date defaultValues", () => {
+    class Item extends S.Class<Item>("SqlDefaultValuesItem")({
+      id: S.String,
+      at: S.Date
+    }) {}
+    const json = makeJsonLower({ schema: Item })
+    const at = new Date("2024-06-01T00:00:00.000Z")
+    const lowered = json.toJson({ at }) as Record<string, unknown>
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "at", op: "eq", value: at }],
+      "items",
+      lowered,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      json
+    )
+    expect(result.sql).toContain("COALESCE(")
+    expect(result.params).toContain("2024-06-01T00:00:00.000Z")
+  })
+
   it("where in Set binds array values", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,