effect-app 4.0.0-beta.284 → 4.0.0-beta.286

package/dist/rpc/Invalidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Invalidation.d.ts","sourceRoot":"","sources":["../../src/rpc/Invalidation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Invalidation.d.ts","sourceRoot":"","sources":["../../src/rpc/Invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzC,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,wBAAwB,CAAA;AAC5E,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,gBAAgB,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,MAAM,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAEjC;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAAE,CAAA;AAmBjH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,uCAAS,CAAA;AAC5C,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEjF,6GAA6G;AAC7G,eAAO,MAAM,eAAe;;;CAAkC,CAAA;AAC9D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAA2B,CAAA;AACxD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAErE,wFAAwF;AACxF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,CAAC,iBAGpD,CAAA;AAED,eAAO,MAAM,YAAY,sBACJ,gBAAgB,qBACjB,gBAAgB,CAAC,iBAAiB,KACnD,eAA4D,CAAA;AAE/D,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyC,CAAA;AAE9G;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACZ,CAAA;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC2B,CAAA;AAE/F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK3D,CAAA;AAEJ,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAEjE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACc,CAAA;AAE1E,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAErH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW,mDAGvB,CAAA;AACD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAA;AAE5C,+EAA+E;AAC/E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,CACZ,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,oBAAoB,CAAC,KAC9D,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAA;IAC3D;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAA;CAC9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,QAAA,MAAM,kBAAkB,2CASvB,CAAA;AACD,eAAO,MAAM,eAAe;IAC1B;;;OAGG;iBACU,oBAAoB,GAAG,aAAa,CAAC,oBAAoB,CAAC;CAEvE,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,kBAAkB,CAAA;AAEvD,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,QAAS,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,KAAG,sBAIjF,CAAA;AAEF;;;;;;;;GAQG;AAEH,MAAM,WAAW,UAAW,SAAQ,GAAG,CAAC,MAAM;IAC5C,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAC1B,UAAU,CAAC,OAAO,2BAA2B,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EACvE,UAAU,CAAC,OAAO,0BAA0B,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CACrE,CAAA;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0TAIxB,CAAA;AAEH;;;GAGG;AAEH,MAAM,WAAW,SAAU,SAAQ,GAAG,CAAC,MAAM;IAC3C,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAC1B,UAAU,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAC/D,UAAU,CAAC,OAAO,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAC7D,CAAA;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0TAIvB,CAAA"}

package/dist/rpc/Invalidation.js

@@ -30,7 +30,10 @@ export const CommandMetaData = S.Struct({
     invalidateQueries: InvalidationKeys,
     dataDependencies: DataDependencies.DataDependencySet
 });
-export const emptyDataDependencies = { reads: [], writes: [] };
+export const emptyDataDependencies = {
+    reads: DataDependencies.empty(),
+    writes: DataDependencies.empty()
+};
 export const makeMetaData = (invalidateQueries, dataDependencies = emptyDataDependencies) => ({ invalidateQueries, dataDependencies });
 export const QueryResponseWithMetaData = (success) => S.Struct({ payload: success, metadata: S.Struct({ dataDependencies: DataDependencies.DataDependencySet }) });
 /**
@@ -172,4 +175,4 @@ export const makeStreamRpc = Rpc.custom(({ defect, error, success }) => ({
     error: StreamFailureChunk(error),
     defect
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/setupRequest.d.ts

@@ -11,6 +11,7 @@ export declare const getRC: Effect.Effect<{
 export interface SetupRequestOptions {
     readonly withTransaction?: boolean;
 }
+export declare const requestStateLayer: Layer.Layer<never, never, never>;
 export declare const provideOnRequestScope: <ROut, E2, RIn>(layer: Layer.Layer<ROut, E2, RIn>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, RIn | import("effect/Scope").Scope | Exclude<R, ROut>>;
 export declare const setupRequestContextFromCurrent: (name?: string, options?: Tracer.SpanOptions & SetupRequestOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<Exclude<R, Tracer.ParentSpan>, never>>;
 export declare const setupStreamingRequestContextFromCurrent: (name?: string, options?: Tracer.SpanOptions & SetupRequestOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, import("effect/Scope").Scope | Exclude<Exclude<R, Tracer.ParentSpan>, never>>;

package/dist/setupRequest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupRequest.d.ts","sourceRoot":"","sources":["../src/setupRequest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,OAAO,EAAa,cAAc,EAAkB,MAAM,qBAAqB,CAAA;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAW/C,eAAO,MAAM,iBAAiB,6CAe3B,CAAA;AAEH,eAAO,MAAM,KAAK;;;gBAGhB,CAAA;AAmBF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CACnC;AAMD,eAAO,MAAM,qBAAqB,GAC/B,IAAI,EAAE,EAAE,EAAE,GAAG,SAAS,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,oFASxF,CAAA;AAEN,eAAO,MAAM,8BAA8B,4BACZ,MAAM,CAAC,WAAW,GAAG,mBAAmB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,uEAM3G,CAAA;AAMP,eAAO,MAAM,uCAAuC,4BACrB,MAAM,CAAC,WAAW,GAAG,mBAAmB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,sGAK7G,CAAA;AAGL,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACzC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,cAAc,EAAE,cAAc,EAC9B,OAAO,CAAC,EAAE,mBAAmB,sEAa9B;AAED,wBAAgB,iCAAiC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACvD,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,cAAc,EAAE,cAAc,EAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,CAAC,WAAW,GAAG,mBAAmB,sEAanD"}
+{"version":3,"file":"setupRequest.d.ts","sourceRoot":"","sources":["../src/setupRequest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,OAAO,EAAa,cAAc,EAAkB,MAAM,qBAAqB,CAAA;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAW/C,eAAO,MAAM,iBAAiB,6CAe3B,CAAA;AAEH,eAAO,MAAM,KAAK;;;gBAGhB,CAAA;AAmBF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CACnC;AAED,eAAO,MAAM,iBAAiB,kCAA+E,CAAA;AAM7G,eAAO,MAAM,qBAAqB,GAC/B,IAAI,EAAE,EAAE,EAAE,GAAG,SAAS,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,oFASxF,CAAA;AAEN,eAAO,MAAM,8BAA8B,4BACZ,MAAM,CAAC,WAAW,GAAG,mBAAmB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,uEAM3G,CAAA;AAMP,eAAO,MAAM,uCAAuC,4BACrB,MAAM,CAAC,WAAW,GAAG,mBAAmB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,sGAK7G,CAAA;AAGL,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACzC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,cAAc,EAAE,cAAc,EAC9B,OAAO,CAAC,EAAE,mBAAmB,sEAa9B;AAED,wBAAgB,iCAAiC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACvD,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,cAAc,EAAE,cAAc,EAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,CAAC,WAAW,GAAG,mBAAmB,sEAanD"}

package/dist/setupRequest.js

@@ -1,9 +1,11 @@
 import * as Tracer from "effect/Tracer";
 import { SqlClient } from "effect/unstable/sql";
+import { DataDependencyRecorder } from "./DataDependencies.js";
 import * as Effect from "./Effect.js";
 import * as Layer from "./Layer.js";
 import * as Option from "./Option.js";
 import { LocaleRef, RequestContext, spanAttributes } from "./RequestContext.js";
+import * as RequestScopedDependencies from "./RequestScopedDependencies.js";
 import { NonEmptyString255 } from "./Schema.js";
 import { ContextMapContainer, storeId } from "./Store.js";
 const withSqlTransaction = (self) => Effect.serviceOption(SqlClient.SqlClient).pipe(Effect.flatMap(Option.match({
@@ -35,6 +37,7 @@ const withRequestSpan = (name = "request", options) => (f) => Effect.andThen(get
 // TODO: false
 // request context info is picked up directly in the logger for annotations.
 Effect.withLogSpan(name)));
+export const requestStateLayer = RequestScopedDependencies.layer(ContextMapContainer, DataDependencyRecorder);
 // Build `layer` against the ambient (request) scope rather than a sub-scope of the
 // returned Effect. Required when the returned value is a streaming HttpServerResponse:
 // the response body keeps producing chunks (and using layer-provided state) after the
@@ -49,21 +52,21 @@ export const provideOnRequestScope = (layer) => (self) => Effect.gen(function* (
     return yield* Effect.provide(self, ctx);
 });
 export const setupRequestContextFromCurrent = (name = "request", options) => (self) => self
-    .pipe(options?.withTransaction === true ? withSqlTransaction : (_) => _, withRequestSpan(name, options), Effect.provide(ContextMapContainer.layer, { local: true }));
+    .pipe(options?.withTransaction === true ? withSqlTransaction : (_) => _, withRequestSpan(name, options), Effect.provide(requestStateLayer, { local: true }));
 // Streaming variant: binds ContextMapContainer to the ambient (request) scope so its
 // finalizer (clear()) runs only after the response body is fully drained, not when the
 // outer Effect returns its HttpServerResponse value. Use for handlers that return a
 // streaming HttpServerResponse (e.g. SSE) — see RequestContextMiddleware for context.
-export const setupStreamingRequestContextFromCurrent = (name = "request", options) => (self) => self.pipe(options?.withTransaction === true ? withSqlTransaction : (_) => _, withRequestSpan(name, options), provideOnRequestScope(ContextMapContainer.layer));
+export const setupStreamingRequestContextFromCurrent = (name = "request", options) => (self) => self.pipe(options?.withTransaction === true ? withSqlTransaction : (_) => _, withRequestSpan(name, options), provideOnRequestScope(requestStateLayer));
 // TODO: consider integrating Effect.withParentSpan
 export function setupRequestContext(self, requestContext, options) {
-    const layer = Layer.mergeAll(ContextMapContainer.layer, Layer.succeed(LocaleRef, requestContext.locale), Layer.succeed(storeId, requestContext.namespace));
+    const layer = Layer.mergeAll(requestStateLayer, Layer.succeed(LocaleRef, requestContext.locale), Layer.succeed(storeId, requestContext.namespace));
     return self
         .pipe(options?.withTransaction === true ? withSqlTransaction : (_) => _, withRequestSpan(requestContext.name), Effect.provide(layer, { local: true }));
 }
 export function setupRequestContextWithCustomSpan(self, requestContext, name, options) {
-    const layer = Layer.mergeAll(ContextMapContainer.layer, Layer.succeed(LocaleRef, requestContext.locale), Layer.succeed(storeId, requestContext.namespace));
+    const layer = Layer.mergeAll(requestStateLayer, Layer.succeed(LocaleRef, requestContext.locale), Layer.succeed(storeId, requestContext.namespace));
     return self
         .pipe(options?.withTransaction === true ? withSqlTransaction : (_) => _, withRequestSpan(name, options), Effect.provide(layer, { local: true }));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.284",
+  "version": "4.0.0-beta.286",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -21,7 +21,7 @@
     "vitest": "^4.1.7"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.88"
+    "effect": "^4.0.0-beta.90"
   },
   "typesVersions": {
     "*": {

package/src/DataDependencies.ts

@@ -1,6 +1,7 @@
 import * as Ref from "effect/Ref"
-import * as Context from "./Context.ts"
+import * as Stream from "effect/Stream"
 import * as Effect from "./Effect.ts"
+import * as RequestScopedDependencies from "./RequestScopedDependencies.ts"
 import * as S from "./Schema.ts"
 
 export const DataDependency = S.Struct({
@@ -9,9 +10,11 @@ export const DataDependency = S.Struct({
 })
 export type DataDependency = S.Schema.Type<typeof DataDependency>
 
-export const DataDependencies = S.Array(DataDependency)
+export const DataDependencies = S.ReadonlySet(DataDependency)
 export type DataDependencies = S.Schema.Type<typeof DataDependencies>
 
+export const empty = (): DataDependencies => new Set()
+
 export const DataDependencySet = S.Struct({
   reads: DataDependencies,
   writes: DataDependencies
@@ -26,26 +29,50 @@ export interface DataDependencyRecorderService {
   readonly drainWrites: Effect.Effect<DataDependencies>
 }
 
-const containsDependency = (dependencies: ReadonlyArray<DataDependency>, dependency: DataDependency) =>
-  dependencies.some((_) => _.type === dependency.type && _.name === dependency.name)
+const containsDependency = (dependencies: ReadonlySet<DataDependency>, dependency: DataDependency) => {
+  for (const _ of dependencies) {
+    if (_.type === dependency.type && _.name === dependency.name) return true
+  }
+  return false
+}
 
 const appendDependency = (dependency: DataDependency) => (dependencies: DataDependencies): DataDependencies =>
-  containsDependency(dependencies, dependency) ? dependencies : [...dependencies, dependency]
+  containsDependency(dependencies, dependency) ? dependencies : new Set([...dependencies, dependency])
 
-export const DataDependencyRecorder = Context.Reference<DataDependencyRecorderService>(
+export const DataDependencyRecorder = RequestScopedDependencies.make(
   "effect-app/DataDependencyRecorder",
-  {
-    defaultValue: () => ({
-      read: (_dependency) => Effect.void,
-      write: (_dependency) => Effect.void,
-      get: Effect.succeed({ reads: [], writes: [] }),
-      drain: Effect.succeed({ reads: [], writes: [] }),
-      drainWrites: Effect.succeed([])
-    })
-  }
+  Effect.gen(function*() {
+    const readsRef = yield* Ref.make(empty())
+    const writesRef = yield* Ref.make(empty())
+    return makeDataDependencyRecorder(readsRef, writesRef)
+  })
 )
 export type DataDependencyRecorder = typeof DataDependencyRecorder
 
+export type DataDependencyRecorderNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError
+
+export const getDataDependencyRecorder = DataDependencyRecorder.current
+
+/**
+ * Guarantee a recorder is in scope for `self`, providing a fresh one per request when none is
+ * (e.g. a top-level client call with no parent query/command tracking its dependencies). An
+ * existing recorder is inherited, so nested calls forward into their parent rather than shadow it.
+ */
+export const ensureDataDependencyRecorder = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.flatMap(
+    DataDependencyRecorder,
+    (current) => current === "root" ? Effect.provide(self, DataDependencyRecorder.layer) : self
+  )
+
+/** Stream variant of {@link ensureDataDependencyRecorder}. */
+export const ensureDataDependencyRecorderStream = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+  Stream.unwrap(
+    Effect.map(
+      DataDependencyRecorder,
+      (current) => current === "root" ? Stream.provide(self, DataDependencyRecorder.layer) : self
+    )
+  )
+
 export const makeDataDependencyRecorder = (
   readsRef: Ref.Ref<DataDependencies>,
   writesRef: Ref.Ref<DataDependencies>
@@ -57,10 +84,10 @@ export const makeDataDependencyRecorder = (
     writes: Ref.get(writesRef)
   }),
   drain: Effect.all({
-    reads: Ref.getAndSet(readsRef, []),
-    writes: Ref.getAndSet(writesRef, [])
+    reads: Ref.getAndSet(readsRef, empty()),
+    writes: Ref.getAndSet(writesRef, empty())
   }),
-  drainWrites: Ref.getAndSet(writesRef, [])
+  drainWrites: Ref.getAndSet(writesRef, empty())
 })
 
 export const repo = (name: string): DataDependency => ({ type: "repo", name })
@@ -68,11 +95,20 @@ export const signal = (name: string): DataDependency => ({ type: "signal", name
 
 export const QueryReadDependenciesMetaKey = "effect-app.query.readDependencies"
 
-export const read = (dependency: DataDependency) => DataDependencyRecorder.use((_) => _.read(dependency))
+export const read = (dependency: DataDependency) =>
+  getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.read(dependency)))
 
-export const write = (dependency: DataDependency) => DataDependencyRecorder.use((_) => _.write(dependency))
+export const write = (dependency: DataDependency) =>
+  getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.write(dependency)))
 
 export const intersects = (
-  a: ReadonlyArray<DataDependency>,
-  b: ReadonlyArray<DataDependency>
-) => a.some((dependency) => containsDependency(b, dependency))
+  a: ReadonlySet<DataDependency>,
+  b: ReadonlySet<DataDependency>
+) => {
+  for (const dependency of a) {
+    if (containsDependency(b, dependency)) return true
+  }
+  return false
+}
+
+export const isNonEmpty = (dependencies: DataDependencies) => dependencies.size > 0

package/src/Model/Repository/internal/internal.ts

@@ -7,7 +7,6 @@ import * as HashSet from "effect/HashSet"
 import * as Pipeable from "effect/Pipeable"
 import * as Ref from "effect/Ref"
 import * as Result from "effect/Result"
-import * as SchemaAST from "../../../SchemaAST.ts"
 import type * as Scope from "effect/Scope"
 import * as Unify from "effect/Unify"
 import * as Array from "../../../Array.ts"
@@ -22,6 +21,7 @@ import { flatMapOption } from "../../../Effect.ts"
 import * as Option from "../../../Option.ts"
 import * as S from "../../../Schema.ts"
 import { type Codec, NonNegativeInt } from "../../../Schema.ts"
+import * as SchemaAST from "../../../SchemaAST.ts"
 import { setupRequestContextFromCurrent } from "../../../setupRequest.ts"
 import { type FilterArgs, getContextMap, type PersistenceModelType, type StoreConfig, storeId, StoreMaker } from "../../../Store.ts"
 import type { FieldValues } from "../../filter/types.ts"

package/src/Model/query/new-kid-interpreter.ts

@@ -2,11 +2,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import { identity, pipe } from "effect/Function"
 import * as Match from "effect/Match"
-import * as SchemaAST from "../../SchemaAST.ts"
 import * as Array from "../../Array.ts"
 import { toNonEmptyArray } from "../../Array.ts"
 import * as Option from "../../Option.ts"
 import * as S from "../../Schema.ts"
+import * as SchemaAST from "../../SchemaAST.ts"
 import { dropUndefinedT } from "../../utils.ts"
 import type { FilterResult } from "../filter/filterApi.ts"
 import type { FieldValues } from "../filter/types.ts"

package/src/RequestContext.ts

@@ -8,7 +8,7 @@ export type Locale = typeof Locale.Type
 
 export class LocaleRef extends Context.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
 
-const _RequestContext = S.Struct({
+export class RequestContext extends S.Opaque<RequestContext>()(S.Struct({
   span: S.Struct({
     traceId: S.String,
     spanId: S.String,
@@ -20,20 +20,7 @@ const _RequestContext = S.Struct({
   namespace: NonEmptyString255,
   /** @deprecated */
   userProfile: S.optional(S.Struct({ sub: UserProfileId })) //
-})
-
-// codegen:start {preset: modelFacade, className: _RequestContext, schema: S, base: true}
-class __RequestContext extends S.OpaqueFacade<
-  RequestContext,
-  RequestContext.Encoded,
-  RequestContext.Make,
-  RequestContext.DecodingServices,
-  RequestContext.EncodingServices
->()(_RequestContext) {}
-// codegen:end
-
-// eslint-disable-next-line typescript/no-unsafe-declaration-merging
-export class RequestContext extends __RequestContext {
+})) {
   static toMonitoring(this: void, self: RequestContext) {
     return {
       operationName: self.name,
@@ -59,37 +46,3 @@ export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace">
     }
     : {})
 })
-
-// codegen:start {preset: model, static: true, facade: true}
-//
-export interface RequestContext {
-  readonly span: { readonly traceId: string; readonly spanId: string; readonly sampled: boolean }
-  readonly name: S.NonEmptyString255
-  readonly locale: "en" | "de"
-  readonly namespace: S.NonEmptyString255
-  readonly sourceId?: undefined | S.NonEmptyString255
-  readonly userProfile?: undefined | { readonly sub: UserProfileId }
-}
-export namespace RequestContext {
-  export interface Encoded {
-    readonly span: { readonly traceId: string; readonly spanId: string; readonly sampled: boolean }
-    readonly name: string
-    readonly locale: "en" | "de"
-    readonly namespace: string
-    readonly sourceId?: undefined | string
-    readonly userProfile?: undefined | { readonly sub: string }
-  }
-  export interface Make {
-    readonly span: { readonly traceId: string; readonly spanId: string; readonly sampled: boolean }
-    readonly name: S.NonEmptyString255
-    readonly locale: "en" | "de"
-    readonly namespace: S.NonEmptyString255
-    readonly sourceId?: undefined | S.NonEmptyString255
-    readonly userProfile?: undefined | { readonly sub: UserProfileId }
-  }
-  export type DecodingServices = never
-  export type EncodingServices = never
-}
-//
-// codegen:end
-//

package/src/RequestScopedDependencies.ts

@@ -0,0 +1,45 @@
+import * as Data from "effect/Data"
+import type * as Scope from "effect/Scope"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+
+export type Root = "root"
+
+export class RequestScopedDependencyNotStartedError extends Data.TaggedError(
+  "RequestScopedDependencyNotStartedError"
+)<{ readonly key: string }> {}
+
+export interface RequestScopedDependency<Service, E = never, R = never> extends Context.Reference<Service | Root> {
+  readonly current: Effect.Effect<Service, RequestScopedDependencyNotStartedError>
+  readonly layer: Layer.Layer<never, E, R>
+}
+
+export const access = <Service>(
+  dependency: Context.Reference<Service | Root>,
+  key: string
+): Effect.Effect<Service, RequestScopedDependencyNotStartedError> =>
+  dependency.pipe(
+    Effect.filterOrFail((_): _ is Service => _ !== "root", () => new RequestScopedDependencyNotStartedError({ key }))
+  )
+
+export const make = <Service, E = never, R = never>(
+  key: string,
+  service: Effect.Effect<Service, E, R>
+): RequestScopedDependency<Service, E, Exclude<R, Scope.Scope>> => {
+  const dependency = Context.Reference<Service | Root>(key, { defaultValue: () => "root" })
+  return Object.assign(dependency, {
+    current: access(dependency, key),
+    layer: Layer.effect(dependency, service)
+  })
+}
+
+export const layer = <
+  Deps extends readonly [RequestScopedDependency<any, any, any>, ...Array<RequestScopedDependency<any, any, any>>]
+>(
+  ...dependencies: Deps
+): Layer.Layer<
+  never,
+  { [K in keyof Deps]: Deps[K] extends RequestScopedDependency<any, infer E, any> ? E : never }[number],
+  { [K in keyof Deps]: Deps[K] extends RequestScopedDependency<any, any, infer R> ? R : never }[number]
+> => dependencies.map((_) => _.layer).reduce((acc, l) => Layer.merge(acc, l)) as any

package/src/Schema/Class.ts

@@ -3,11 +3,11 @@ import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
-import * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaGetter from "effect/SchemaGetter"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import type { Struct as EffectAppStruct } from "../Schema.ts"
+import * as SchemaAST from "../SchemaAST.ts"
 import { copyOrigin } from "../utils.ts"
 import { concurrencyUnbounded } from "./ext.ts"
 import * as SchemaParser from "./SchemaParser.ts"

package/src/Schema/ext.ts

@@ -37,11 +37,11 @@ import * as Function from "effect/Function"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
 import { isDateValid } from "effect/Schema"
-import type * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import { type NonEmptyReadonlyArray } from "../Array.ts"
 import * as Context from "../Context.ts"
+import type * as SchemaAST from "../SchemaAST.ts"
 import { extendM, typedKeysOf } from "../utils.ts"
 import { type AST } from "./schema.ts"
 

package/src/Schema/moreStrings.ts

@@ -14,10 +14,10 @@ import type * as B from "effect/Brand"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"
 import validator from "validator"
+import type * as SchemaAST from "../SchemaAST.ts"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"
 import { type B as SchemaB } from "./schema.ts"

package/src/Schema/numbers.ts

@@ -11,8 +11,8 @@
 import { extendM } from "effect-app/utils"
 import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
+import type * as SchemaAST from "../SchemaAST.ts"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"
 import { type B } from "./schema.ts"

package/src/Schema/schema.ts

@@ -1,5 +1,5 @@
 import * as B from "effect/Brand"
-import * as AST from "../SchemaAST.ts"
 import * as P from "effect/SchemaParser"
+import * as AST from "../SchemaAST.ts"
 
 export { AST, B, P }

package/src/Schema/strings.ts

@@ -1,7 +1,7 @@
 import type * as B from "effect/Brand"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
+import type * as SchemaAST from "../SchemaAST.ts"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"
 

package/src/Schema.ts

@@ -1,5 +1,4 @@
 import * as S from "effect/Schema"
-import * as SchemaAST from "./SchemaAST.ts"
 import { type Simplify } from "effect/Struct"
 import type * as Tracer from "effect/Tracer"
 import type { RequiredKeys } from "effect/Types"
@@ -9,6 +8,7 @@ import { Email as EmailT, type Email as EmailType } from "./Schema/email.ts"
 import { concurrencyUnbounded, withDefaultMake, withDefaultParseOptions } from "./Schema/ext.ts"
 import { PhoneNumber as PhoneNumberT, type PhoneNumber as PhoneNumberType } from "./Schema/phoneNumber.ts"
 import { type AST } from "./Schema/schema.ts"
+import * as SchemaAST from "./SchemaAST.ts"
 import { copy, extendM, type StructuralCopyOrigin } from "./utils.ts"
 
 // ---------------------------------------------------------------------------

package/src/Store.ts

@@ -1,17 +1,16 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Data from "effect/Data"
 import type * as Redacted from "effect/Redacted"
 import * as Semaphore from "effect/Semaphore"
 import type { NonEmptyReadonlyArray } from "./Array.ts"
 import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.ts"
 import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
-import * as Layer from "./Layer.ts"
 import type { FilterResult } from "./Model/filter/filterApi.ts"
 import type { FieldValues } from "./Model/filter/types.ts"
 import type { FieldPath } from "./Model/filter/types/path/index.ts"
 import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.ts"
 import type * as Option from "./Option.ts"
+import * as RequestScopedDependencies from "./RequestScopedDependencies.ts"
 import { NonEmptyString255 } from "./Schema.ts"
 
 /**
@@ -235,17 +234,14 @@ const makeMap = Effect.acquireRelease(
 export class ContextMap extends Context.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
 }
 
-export class ContextMapContainer extends Context.Reference("ContextMapContainer", {
-  defaultValue: (): ContextMap | "root" => "root"
-}) {
-  static readonly layer = Layer.effect(this, ContextMap.make.pipe(Effect.map(ContextMap.of)))
-}
+export const ContextMapContainer = RequestScopedDependencies.make(
+  "ContextMapContainer",
+  ContextMap.make.pipe(Effect.map(ContextMap.of))
+)
 
-export class ContextMapNotStartedError extends Data.TaggedError("ContextMapNotStartedError") {}
+export type ContextMapNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError
 
-export const getContextMap = ContextMapContainer.pipe(
-  Effect.filterOrFail((_) => _ !== "root", () => new ContextMapNotStartedError())
-)
+export const getContextMap = ContextMapContainer.current
 
 /**
  * Runs `make` at most once per ContextMap (i.e. per request) and caches the