effect-app 4.0.0-beta.33 → 4.0.0-beta.330

package/dist/Model/Repository/internal/internal.js

@@ -0,0 +1,611 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Equivalence from "effect/Equivalence";
+import { flow, pipe } from "effect/Function";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import * as Metric from "effect/Metric";
+import * as Pipeable from "effect/Pipeable";
+import * as Ref from "effect/Ref";
+import * as Result from "effect/Result";
+import * as Unify from "effect/Unify";
+import * as Array from "../../../Array.js";
+import { toNonEmptyArray } from "../../../Array.js";
+import * as Chunk from "../../../Chunk.js";
+import { NotFoundError } from "../../../client/errors.js";
+import * as Context from "../../../Context.js";
+import * as DataDependencies from "../../../DataDependencies.js";
+import * as Effect from "../../../Effect.js";
+import { flatMapOption } from "../../../Effect.js";
+import * as Option from "../../../Option.js";
+import * as S from "../../../Schema.js";
+import { NonNegativeInt } from "../../../Schema.js";
+import * as SchemaAST from "../../../SchemaAST.js";
+import { setupRequestContextFromCurrent } from "../../../setupRequest.js";
+import { getContextMap, storeId, StoreMaker } from "../../../Store.js";
+import * as Q from "../../query.js";
+import { repositoryDependencyPaths } from "../dependency.js";
+import { ValidationError, ValidationResult } from "../validation.js";
+const dedupe = Array.dedupeWith(Equivalence.String);
+// ms buckets: dense under 100ms (common path), then mid-tail and multi-second stalls.
+// Rare 0.5–1s+ encodes (fat aggregates) must not collapse into a single overflow bin.
+const schemaDurationBoundaries = [
+    0.1,
+    0.5,
+    1,
+    2,
+    5,
+    10,
+    25,
+    50,
+    100,
+    150,
+    200,
+    300,
+    500,
+    750,
+    1_000,
+    1_500,
+    2_000,
+    5_000
+];
+// Event-loop-relevant stall floor: encodes/decodes above this are rare but block Node.
+const SCHEMA_SLOW_MS = 100;
+const schemaDecodeDuration = Metric.histogram("app.schema.decode.duration", { boundaries: schemaDurationBoundaries });
+const schemaEncodeDuration = Metric.histogram("app.schema.encode.duration", { boundaries: schemaDurationBoundaries });
+const schemaItemCount = Metric.histogram("app.schema.item_count", {
+    boundaries: [0, 1, 2, 5, 10, 25, 50, 100, 250, 500, 1_000, 5_000]
+});
+const schemaSlow = Metric.counter("app.schema.slow", {
+    description: `Repository schema encode/decode slower than ${SCHEMA_SLOW_MS}ms`,
+    incremental: true
+});
+const entityStateFromItems = (items) => {
+    const first = items[0];
+    if (first === null || typeof first !== "object" || !("_tag" in first))
+        return undefined;
+    const tag = first._tag;
+    return typeof tag === "string" ? tag : undefined;
+};
+const timeSchema = (operation, entity, queryMode, itemCount, entityState) => (self) => Effect.clockWith((clock) => {
+    const startedAt = clock.currentTimeNanosUnsafe();
+    const attributes = {
+        "app.entity": entity,
+        "app.schema.operation": operation,
+        ...(queryMode !== undefined && { "app.query.mode": queryMode }),
+        ...(entityState !== undefined && { "app.entity.state": entityState })
+    };
+    return Effect.onExit(self, () => {
+        const durationMs = Number(clock.currentTimeNanosUnsafe() - startedAt) / 1_000_000;
+        const slow = durationMs >= SCHEMA_SLOW_MS;
+        return Effect.all([
+            Effect.annotateCurrentSpan({
+                [`app.schema.${operation}.duration_ms`]: durationMs,
+                "app.schema.item_count": itemCount,
+                "app.schema.slow": slow,
+                ...(queryMode !== undefined && { "app.query.mode": queryMode }),
+                ...(entityState !== undefined && { "app.entity.state": entityState })
+            }),
+            Metric.update(Metric.withAttributes(operation === "decode" ? schemaDecodeDuration : schemaEncodeDuration, attributes), durationMs),
+            Metric.update(Metric.withAttributes(schemaItemCount, attributes), itemCount),
+            ...(slow
+                ? [Metric.update(Metric.withAttributes(schemaSlow, attributes), 1)]
+                : [])
+        ], { discard: true });
+    });
+});
+/**
+ * A base implementation to create a repository.
+ */
+export function makeRepoInternal() {
+    return (name, schema, mapTo, idKey) => {
+        function mapToPersistenceModel(e, getEtag) {
+            return mapTo(e, getEtag(e[idKey]));
+        }
+        function mapReverse({ _etag, ...e }, setEtag) {
+            setEtag(e[idKey], _etag);
+            // the store already applied `jitM` and decoded JSON→Encoded
+            return e;
+        }
+        const mkStore = makeStore()(name, schema, mapTo, idKey);
+        function make(args) {
+            return Effect
+                .gen(function* () {
+                const rctx = args.schemaContext ?? Context.empty();
+                const provideRctx = Effect.provide(rctx);
+                const encodeMany = (items) => S.encodeEffect(S.Array(schema))(items).pipe(provideRctx, timeSchema("encode", name, undefined, items.length, entityStateFromItems(items)));
+                const decode = flow(S.decodeEffectConcurrently(schema), provideRctx);
+                const decodeMany = flow(S.decodeEffectConcurrently(S.Array(schema)), provideRctx);
+                const store = yield* mkStore(args.makeInitial, args.config);
+                const dependencyPaths = repositoryDependencyPaths(schema);
+                const recordRead = DataDependencies.readRepo(name);
+                const entityDependency = (ids) => DataDependencies.repo(name, [String(ids[0]), ...ids.slice(1).map(String)]);
+                const valuesAtPath = (value, path) => {
+                    if (path.length === 0)
+                        return [value];
+                    const [head, ...tail] = path.split(".");
+                    if (head === undefined)
+                        return [value];
+                    if (head === "-1") {
+                        return globalThis.Array.isArray(value)
+                            ? value.flatMap((item) => valuesAtPath(item, tail.join(".")))
+                            : [];
+                    }
+                    return typeof value === "object" && value !== null
+                        ? valuesAtPath(value[head], tail.join("."))
+                        : [];
+                };
+                const dependencyIds = (item) => {
+                    const configured = dependencyPaths
+                        .flatMap((path) => valuesAtPath(item, String(path)))
+                        .filter((value) => typeof value === "string") ?? [];
+                    const ids = args.dependencyIds?.(item) ?? [String(item[idKey]), ...configured];
+                    return [ids[0], ...ids.slice(1)];
+                };
+                const itemDependencies = (item) => {
+                    const ids = dependencyIds(item);
+                    return [
+                        DataDependencies.repo(name, ids),
+                        ...(args.additionalWriteDependencies?.(item) ?? [])
+                    ];
+                };
+                const queryDependencyIds = (filter) => {
+                    if (!filter)
+                        return [];
+                    const paths = new Set([String(idKey), ...dependencyPaths]);
+                    const visit = (items) => {
+                        if (items.some((item) => item.t === "or" || item.t === "or-scope"))
+                            return [];
+                        return items.flatMap((item) => {
+                            if ("result" in item)
+                                return visit(item.result);
+                            if (!paths.has(item.path))
+                                return [];
+                            const value = item.value;
+                            if (item.op === "eq" && typeof value === "string")
+                                return [value];
+                            if (item.op === "in" && globalThis.Array.isArray(value)) {
+                                return value.filter((entry) => typeof entry === "string");
+                            }
+                            return [];
+                        });
+                    };
+                    return [...new Set(visit(filter))];
+                };
+                const recordEntityRead = (id) => DataDependencies.read(entityDependency([id]));
+                const recordEntityWrite = (ids) => DataDependencies.write(entityDependency(ids));
+                const recordItemWrite = (items) => Effect.forEach(DataDependencies.merge(new Set(items.flatMap(itemDependencies))), DataDependencies.write, { discard: true });
+                const cms = Effect.map(getContextMap.pipe(Effect.orDie), (_) => ({
+                    get: (id) => _.get(`${name}.${id}`),
+                    set: (id, etag) => _.set(`${name}.${id}`, etag)
+                }));
+                const pub = "publishEvents" in args
+                    ? args.publishEvents
+                    : () => Effect.void;
+                const changeFeedByNamespace = yield* Ref.make(HashMap.empty());
+                const changeFeedWildcard = yield* Ref.make(HashSet.empty());
+                // clear all handlers when the repository's scope closes
+                yield* Effect.addFinalizer(() => Effect.all([
+                    Ref.set(changeFeedByNamespace, HashMap.empty()),
+                    Ref.set(changeFeedWildcard, HashSet.empty())
+                ], { discard: true }));
+                const changeFeed = {
+                    publish: ([items, op]) => Effect.gen(function* () {
+                        const ns = yield* storeId;
+                        const evt = [items, op, ns];
+                        const map = yield* Ref.get(changeFeedByNamespace);
+                        const wild = yield* Ref.get(changeFeedWildcard);
+                        const targeted = Option.getOrElse(HashMap.get(map, ns), () => HashSet.empty());
+                        const all = HashSet.union(targeted, wild);
+                        yield* Effect.forEach(all, (h) => h(evt), { concurrency: "unbounded", discard: true });
+                    }),
+                    subscribe: (handler, options) => {
+                        const ns = options?.namespace;
+                        if (ns === undefined) {
+                            return Effect.acquireRelease(Ref.update(changeFeedWildcard, HashSet.add(handler)), () => Ref.update(changeFeedWildcard, HashSet.remove(handler)));
+                        }
+                        return Effect.acquireRelease(Ref.update(changeFeedByNamespace, (m) => {
+                            const cur = Option.getOrElse(HashMap.get(m, ns), () => HashSet.empty());
+                            return HashMap.set(m, ns, HashSet.add(cur, handler));
+                        }), () => Ref.update(changeFeedByNamespace, (m) => {
+                            const cur = Option.getOrElse(HashMap.get(m, ns), () => HashSet.empty());
+                            const next = HashSet.remove(cur, handler);
+                            return HashSet.size(next) === 0 ? HashMap.remove(m, ns) : HashMap.set(m, ns, next);
+                        }));
+                    }
+                };
+                const allE = cms
+                    .pipe(Effect.flatMap((cm) => Effect.map(store.all, (_) => _.map((_) => mapReverse(_, cm.set)))));
+                const all = Effect
+                    .flatMap(allE, (items) => decodeMany(items).pipe(Effect.orDie, timeSchema("decode", name, undefined, items.length)))
+                    .pipe(Effect.tap(() => recordRead), Effect.map((_) => _), Effect.withSpan("Repository.all", {
+                    kind: "client",
+                    attributes: { "app.entity": name }
+                }, { captureStackTrace: false }));
+                const fieldsSchema = schema;
+                // assumes the id field never needs a service...
+                const i = ("fields" in fieldsSchema ? S.Struct(fieldsSchema["fields"]) : schema)
+                    .pipe((_) => {
+                    let ast = _.ast;
+                    if (ast._tag === "Declaration")
+                        ast = ast.typeParameters[0];
+                    const pickIdFromAst = (a) => {
+                        // Unwrap Declaration (e.g. TaggedClass) to get the underlying Objects AST
+                        let inner = a;
+                        if (inner._tag === "Declaration")
+                            inner = inner.typeParameters[0];
+                        // Pick from the original AST to preserve the full encoding chain (e.g. decodeTo transformations).
+                        // Using toEncoded would lose transformation info needed to encode Type -> Encoded.
+                        if (SchemaAST.isObjects(inner)) {
+                            const field = inner.propertySignatures.find((_) => _.name === idKey);
+                            if (field) {
+                                return S.Struct({ [idKey]: S.make(field.type) });
+                            }
+                        }
+                        return S.make(a);
+                    };
+                    return ast._tag === "Union"
+                        // we need to get the Objects (TypeLiteral), in case of class it has encoding chain...
+                        ? S.Union(ast.types.map((_) => pickIdFromAst(_)))
+                        : pickIdFromAst(ast);
+                });
+                const encodeId = flow(S.encodeEffect(i), provideRctx);
+                const encodeIdOnly = (id) => encodeId({ [idKey]: id }).pipe(Effect.map((_) => _[idKey]));
+                const findEId = Effect.fnUntraced(function* (id) {
+                    yield* Effect.annotateCurrentSpan({ "app.entity.id": id });
+                    return yield* Effect.flatMap(store.find(id), (item) => Effect.gen(function* () {
+                        const { set } = yield* cms;
+                        return item.pipe(Option.map((_) => mapReverse(_, set)));
+                    }));
+                });
+                // TODO: select the particular field, instead of as struct
+                const findE = Effect.fnUntraced(function* (id) {
+                    yield* Effect.annotateCurrentSpan({ "app.entity.id": id });
+                    return yield* pipe(encodeId({ [idKey]: id }), Effect.orDie, Effect.map((_) => _[idKey]), Effect.flatMap(findEId));
+                });
+                const loadExistingItems = (ids) => Effect
+                    .forEach(ids, (id) => findE(id).pipe(Effect.flatMap(Option.match({
+                    onNone: () => Effect.succeed(Option.none()),
+                    onSome: (encoded) => decode(encoded).pipe(Effect.orDie, Effect.map(Option.some))
+                }))))
+                    .pipe(Effect.map(Array.getSomes));
+                const find = Effect.fn("Repository.find", {
+                    kind: "client",
+                    attributes: { "app.entity": name }
+                })(function* (id) {
+                    yield* recordEntityRead(id);
+                    yield* Effect.annotateCurrentSpan({ "app.entity.id": id });
+                    return yield* flatMapOption(findE(id), (_) => Effect.orDie(decode(_)));
+                });
+                const saveAllE = (a) => flatMapOption(Effect
+                    .sync(() => toNonEmptyArray([...a])), (a) => Effect.gen(function* () {
+                    const { get, set } = yield* cms;
+                    const items = a.map((_) => mapToPersistenceModel(_, get));
+                    const ret = yield* store.batchSet(items);
+                    ret.forEach((_) => set(_[idKey], _._etag));
+                }))
+                    .pipe(Effect.asVoid);
+                const saveAll = (a) => encodeMany(Array.fromIterable(a))
+                    .pipe(Effect.orDie, Effect.andThen(saveAllE));
+                const saveAndPublish = Effect.fn("Repository.saveAndPublish", { attributes: { "app.entity": name } })(function* (items, events = []) {
+                    const it = Chunk.fromIterable(items);
+                    if (Chunk.isNonEmpty(it)) {
+                        const values = Chunk.toReadonlyArray(it);
+                        const previous = args.additionalWriteDependencies || args.dependencyIds || dependencyPaths.length > 0
+                            ? yield* loadExistingItems(values.map((item) => item[idKey]))
+                            : [];
+                        yield* recordItemWrite([values[0], ...values.slice(1), ...previous]);
+                    }
+                    const evts = [...events];
+                    yield* Effect.annotateCurrentSpan({
+                        "app.entity.ids": Chunk.map(it, (_) => _[idKey]),
+                        "app.event.count": evts.length
+                    });
+                    return yield* saveAll(it)
+                        .pipe(Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))), 
+                    // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                    (_) => flatMapOption(_, pub), Effect.andThen(changeFeed.publish([Chunk.toArray(it), "save"])), Effect.asVoid);
+                });
+                const removeAndPublish = Effect.fn("Repository.removeAndPublish", { attributes: { "app.entity": name } })(function* (a, events = []) {
+                    const { set } = yield* cms;
+                    const it = [...a];
+                    if (Array.isReadonlyArrayNonEmpty(it)) {
+                        yield* recordItemWrite(it);
+                    }
+                    const evts = [...events];
+                    yield* Effect.annotateCurrentSpan({
+                        "app.entity.ids": it.map((_) => _[idKey]),
+                        "app.event.count": evts.length
+                    });
+                    const items = yield* encodeMany(it).pipe(Effect.orDie);
+                    if (Array.isReadonlyArrayNonEmpty(items)) {
+                        yield* store.batchRemove(items.map((_) => (_[idKey])), args.config?.partitionValue?.(items[0]));
+                        for (const e of items) {
+                            set(e[idKey], undefined);
+                        }
+                        yield* Effect
+                            .sync(() => toNonEmptyArray(evts))
+                            // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                            .pipe((_) => flatMapOption(_, pub));
+                        yield* changeFeed.publish([it, "remove"]);
+                    }
+                });
+                const removeById = Effect.fn("Repository.removeById", { attributes: { "app.entity": name } })(function* (idOrIds) {
+                    const ids = globalThis.Array.isArray(idOrIds)
+                        ? idOrIds
+                        : [idOrIds];
+                    if (!Array.isReadonlyArrayNonEmpty(ids)) {
+                        return;
+                    }
+                    yield* recordEntityWrite(ids);
+                    if (args.additionalWriteDependencies || args.dependencyIds || dependencyPaths.length > 0) {
+                        const previous = yield* loadExistingItems(ids);
+                        if (Array.isReadonlyArrayNonEmpty(previous))
+                            yield* recordItemWrite(previous);
+                    }
+                    const { set } = yield* cms;
+                    const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_)).pipe(Effect.orDie);
+                    yield* Effect.annotateCurrentSpan({ "app.entity.ids": eids });
+                    yield* store.batchRemove(eids);
+                    for (const id of eids) {
+                        set(id, undefined);
+                    }
+                    yield* changeFeed.publish([[], "remove"]);
+                });
+                const parseMany = Effect.fnUntraced(function* (items) {
+                    const cm = yield* cms;
+                    return yield* decodeMany(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie, timeSchema("decode", name, "transform", items.length));
+                });
+                const decodeManyCache = new WeakMap();
+                const getDecodeMany = (s) => {
+                    let dec = decodeManyCache.get(s);
+                    if (!dec) {
+                        dec = S.decodeEffectConcurrently(S.Array(s));
+                        decodeManyCache.set(s, dec);
+                    }
+                    return dec;
+                };
+                const parseMany2 = Effect.fnUntraced(function* (items, schema) {
+                    const cm = yield* cms;
+                    return yield* getDecodeMany(schema)(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie, timeSchema("decode", name, "transform", items.length));
+                });
+                const filter = (args) => store
+                    .filter(
+                // always enforce id and _etag because they are system fields, required for etag tracking etc
+                {
+                    ...args,
+                    select: args.select
+                        ? dedupe([...args.select, idKey, "_etag"])
+                        : undefined
+                })
+                    .pipe(Effect.tap((items) => Effect.map(cms, ({ set }) => items.forEach((_) => set(_[idKey], _._etag)))));
+                // TODO: For raw we should use S.from, and drop the R...
+                const query = ((q) => {
+                    const a = Q.toFilter(q, schema);
+                    const scopedIds = queryDependencyIds(a.filter);
+                    const recordQueryRead = Array.isReadonlyArrayNonEmpty(scopedIds)
+                        ? DataDependencies.read(DataDependencies.repo(name, scopedIds))
+                        : recordRead;
+                    // Mode dispatch — see `Q.project` JSDoc for the contract:
+                    //   aggregate: GROUP BY + aggregate functions at DB level; decode raw rows with schema; SchemaError surfaces.
+                    //   project  : decode raw encoded rows with schema; no PM reverse-mapping; SchemaError surfaces.
+                    //   collect  : same as project, but schema yields Option and None rows are dropped.
+                    //   transform: PM reverse-map (re-inject _etag/PM state from cms cache) then decode; orDie.
+                    const eff = a.mode === "aggregate"
+                        ? store
+                            // `a.select` contains `{ key, aggregate }` items not expressible in FilterFunc<Encoded, U>'s
+                            // `U extends keyof Encoded` generic. Cast is unavoidable until FilterFunc supports aggregate mode.
+                            .filter(a)
+                            // Decode raw aggregate rows directly — no PM reverse-mapping, no id/_etag needed.
+                            .pipe(Effect.andThen((items) => S.decodeEffectConcurrently(S.Array(S.toCodecJson(a.schema ?? schema)))(items).pipe(provideRctx, timeSchema("decode", name, "aggregate", items.length))))
+                        : a.mode === "project"
+                            ? filter(a)
+                                // TODO: mapFrom but need to support per field and dependencies
+                                .pipe(Effect.andThen((items) => S.decodeEffectConcurrently(S.Array(S.toCodecJson(a.schema ?? schema)))(items).pipe(provideRctx, timeSchema("decode", name, "project", items.length))))
+                            : a.mode === "collect"
+                                ? filter(a)
+                                    // TODO: mapFrom but need to support per field and dependencies
+                                    .pipe(Effect.flatMap((items) => S.decodeEffectConcurrently(S.Array(S.toCodecJson(a.schema)))(items).pipe(Effect.map(Array.getSomes), provideRctx, timeSchema("decode", name, "collect", items.length))))
+                                : Effect.flatMap(filter(a), (_) => Unify.unify(a.schema
+                                    // TODO: partial may not match?
+                                    ? parseMany2(_, a.schema)
+                                    : parseMany(_)));
+                    return pipe(a.ttype === "one"
+                        ? Effect.flatMap(eff, flow(Array.head, Option.match({
+                            onNone: () => Effect.fail(new NotFoundError({ id: "query", /* TODO */ type: name })),
+                            onSome: Effect.succeed
+                        })))
+                        : a.ttype === "count"
+                            ? Effect
+                                .map(eff, (_) => NonNegativeInt(_.length))
+                                .pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e)))
+                            : eff, Effect.tap((r) => Effect.annotateCurrentSpan({
+                        "app.query.ttype": a.ttype,
+                        "app.query.mode": a.mode,
+                        "db.response.returned_rows": Array.isArray(r) ? r.length : 1
+                    })), Effect.tap(() => recordQueryRead), Effect.withSpan("Repository.query", {
+                        kind: "client",
+                        attributes: { "app.entity": name }
+                    }, { captureStackTrace: false }));
+                });
+                const validateSample = Effect.fn("Repository.validateSample", { attributes: { "app.entity": name } })(function* (options) {
+                    const percentage = options?.percentage ?? 0.1; // default 10%
+                    const maxItems = options?.maxItems;
+                    // 1. get all IDs with projection (bypasses main schema decode)
+                    const allIds = yield* store
+                        .filter({
+                        t: null,
+                        select: [idKey]
+                    })
+                        .pipe(
+                    // a projection never decodes a whole document, so the store's
+                    // document decode cannot fail here
+                    Effect.catchTag("SchemaError", (e) => Effect.die(e)), Effect.withSpan("Repository.filter", {
+                        kind: "client",
+                        attributes: { "app.entity": name }
+                    }, { captureStackTrace: false }));
+                    // 2. random subset
+                    const shuffled = [...allIds].sort(() => Math.random() - 0.5);
+                    const sampleSize = Math.min(maxItems ?? Infinity, Math.ceil(allIds.length * percentage));
+                    const sample = shuffled.slice(0, sampleSize);
+                    // 3. validate each item
+                    const errors = [];
+                    for (const item of sample) {
+                        const id = item[idKey];
+                        const stored = yield* store.find(id).pipe(Effect.result, Effect.withSpan("Repository.find", {
+                            kind: "client",
+                            attributes: { "app.entity": name, "app.entity.id": id }
+                        }, { captureStackTrace: false }));
+                        // a store-boundary failure: `defaultValues` + `jitM` did not
+                        // produce a document the Encoded shape accepts, so the store
+                        // failed with `S.SchemaError` instead of returning one. Report
+                        // that document and keep sampling - it used to kill the run.
+                        if (Result.isFailure(stored)) {
+                            const failure = stored.failure;
+                            if (!S.isSchemaError(failure))
+                                return yield* Effect.fail(failure);
+                            errors.push(ValidationError.make({
+                                id,
+                                // the store failed before it could hand back a document
+                                rawData: undefined,
+                                jitMResult: undefined,
+                                error: failure
+                            }));
+                            continue;
+                        }
+                        const rawResult = stored.success;
+                        if (Option.isNone(rawResult))
+                            continue;
+                        // the store merged `defaultValues`, applied `jitM` on the raw
+                        // JSON document and decoded JSON→Encoded, so this is exactly
+                        // what the repository decodes into the domain type.
+                        const rawData = rawResult.value;
+                        // the repository's own decode of a document the store accepted
+                        const decodeResult = yield* S.decodeEffectConcurrently(schema)(rawData).pipe(Effect.result, provideRctx);
+                        if (Result.isFailure(decodeResult)) {
+                            errors.push(ValidationError.make({
+                                id,
+                                rawData,
+                                jitMResult: rawData,
+                                error: decodeResult.failure
+                            }));
+                        }
+                    }
+                    return ValidationResult.make({
+                        total: NonNegativeInt(allIds.length),
+                        sampled: NonNegativeInt(sample.length),
+                        valid: NonNegativeInt(sample.length - errors.length),
+                        errors
+                    });
+                });
+                // The store fails with `S.SchemaError` when a stored document does not
+                // decode - see `Store.all` / `Store.find`. The internals above let that
+                // failure propagate; producing the public members is the single
+                // boundary where it becomes a defect, because these signatures declare
+                // only `DatabaseError`. `queryRaw`, `query` and `mapped` already
+                // declare `S.SchemaError`, and `validateSample` reports it per
+                // document instead of dying.
+                const r = {
+                    changeFeed,
+                    itemType: name,
+                    idKey,
+                    find: (id) => find(id).pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e))),
+                    all: all.pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e))),
+                    saveAndPublish: (items, events) => saveAndPublish(items, events).pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e))),
+                    removeAndPublish,
+                    removeById: (idOrIds) => removeById(idOrIds).pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e))),
+                    seedNamespace: (namespace) => store.seedNamespace(namespace),
+                    validateSample,
+                    queryRaw(schema, q) {
+                        return store.queryRaw(q).pipe(Effect.flatMap((items) => S.decodeEffectConcurrently(S.Array(S.toCodecJson(schema)))(items).pipe(timeSchema("decode", name, undefined, items.length))), Effect.tap(() => recordRead), Effect.withSpan("Repository.queryRaw", {
+                            kind: "client",
+                            attributes: { "app.entity": name }
+                        }, { captureStackTrace: false }));
+                    },
+                    query(q) {
+                        // eslint-disable-next-line prefer-rest-params
+                        return query(typeof q === "function" ? Pipeable.pipeArguments(Q.make(), arguments) : q);
+                    },
+                    /**
+                     * @internal
+                     */
+                    mapped: (schema) => {
+                        const dec = S.decodeEffectConcurrently(schema);
+                        const encMany = S.encodeEffect(S.Array(schema));
+                        const decMany = S.decodeEffectConcurrently(S.Array(schema));
+                        const spanAttrs = { kind: "client", attributes: { "app.entity": name } };
+                        return {
+                            all: allE.pipe(Effect.flatMap((items) => decMany(items).pipe(timeSchema("decode", name, undefined, items.length))), Effect.tap(() => recordRead), Effect.map((_) => _), Effect.withSpan("Repository.mapped.all", spanAttrs, { captureStackTrace: false })),
+                            find: (id) => flatMapOption(findE(id), dec).pipe(Effect.tap(() => recordEntityRead(id)), Effect.withSpan("Repository.mapped.find", {
+                                ...spanAttrs,
+                                attributes: { ...spanAttrs.attributes, "app.entity.id": id }
+                            }, { captureStackTrace: false })),
+                            // query: (q: any) => {
+                            //   const a = Q.toFilter(q)
+                            //   return filter(a)
+                            //     .pipe(
+                            //       Effect.flatMap(decMany),
+                            //       Effect.map((_) => _ as any[]),
+                            //       Effect.withSpan("Repository.mapped.query [effect-app/infra]", {
+                            //  captureStackTrace: false,
+                            //         attributes: {
+                            //           "repository.model_name": name,
+                            //           query: { ...a, schema: a.schema ? "__SCHEMA__" : a.schema, filter: a.filter.build() }
+                            //         }
+                            //       })
+                            //     )
+                            // },
+                            save: (...xes) => Effect
+                                .flatMap(encMany(xes).pipe(timeSchema("encode", name, undefined, xes.length, entityStateFromItems(xes))), (_) => saveAllE(_))
+                                .pipe(Effect.tap(() => Array.isReadonlyArrayNonEmpty(xes)
+                                ? recordEntityWrite([xes[0][idKey], ...xes.slice(1).map((_) => _[idKey])])
+                                : Effect.void), Effect.withSpan("Repository.mapped.save", spanAttrs, { captureStackTrace: false }))
+                        };
+                    }
+                };
+                return r;
+            })
+                .pipe(Effect
+                // .withSpan("Repository.make [effect-app/infra]", { attributes: { "repository.model_name": name } })
+                .withLogSpan("Repository.make: " + name));
+        }
+        return {
+            make,
+            Q: Q.make()
+        };
+    };
+}
+const pluralize = (s) => s.endsWith("s")
+    ? s + "es"
+    : s.endsWith("y")
+        ? s.substring(0, s.length - 1) + "ies"
+        : s + "s";
+export function makeStore() {
+    return (name, schema, mapTo, idKey) => {
+        function makeStore(makeInitial, config) {
+            function encodeToEncoded() {
+                const getEtag = () => undefined;
+                return (t) => S.encodeEffect(schema)(t).pipe(Effect.orDie, Effect.map((_) => mapToPersistenceModel(_, getEtag)));
+            }
+            function mapToPersistenceModel(e, getEtag) {
+                return mapTo(e, getEtag(e[idKey]));
+            }
+            return Effect.gen(function* () {
+                const { make } = yield* StoreMaker;
+                const store = yield* make(pluralize(name), idKey, makeInitial
+                    ? makeInitial
+                        .pipe(Effect.flatMap(Effect.forEach(encodeToEncoded())), setupRequestContextFromCurrent("Repository.makeInitial [effect-app/infra]", {
+                        attributes: { "app.entity": name }
+                    }))
+                    : undefined, {
+                    ...config,
+                    schema,
+                    partitionValue: config?.partitionValue
+                        ?? ((_) => "primary") /*(isIntegrationEvent(r) ? r.companyId : r.id*/
+                });
+                return store;
+            });
+        }
+        return makeStore;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../../../src/Model/Repository/internal/internal.ts"],"names":[],"mappings":"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"}