@effect-app/infra 0.219.2 → 0.220.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @effect-app/infra
 
+## 0.220.0
+
+### Minor Changes
+
+- 51253a2: update packages
+
+### Patch Changes
+
+- Updated dependencies [51253a2]
+  - @effect-app/fluent-extensions@0.148.0
+  - @effect-app/infra-adapters@0.142.0
+  - effect-app@0.187.0
+  - @effect-app/schema@0.208.0
+  - @effect-app/core@0.154.0
+
 ## 0.219.2
 
 ### Patch Changes

package/dist/RequestContext.d.ts

@@ -22,8 +22,8 @@ declare const RequestContextParent_base: S.EnhancedClass<RequestContextParent, {
     createdAt: S.PropertySignature<":", Date, never, ":", string, true, never>;
 }, {
     readonly _tag: "RequestContext";
-    readonly name: string & S.NonEmptyString255Brand;
     readonly id: NonEmptyString255;
+    readonly name: string & S.NonEmptyString255Brand;
     readonly locale: "en" | "de";
     readonly createdAt: Date;
     readonly userProfile?: {
@@ -31,16 +31,16 @@ declare const RequestContextParent_base: S.EnhancedClass<RequestContextParent, {
     } | undefined;
 }, {
     readonly _tag: "RequestContext";
-    readonly name: string;
     readonly id: string;
+    readonly name: string;
     readonly locale: "en" | "de";
     readonly createdAt: string;
     readonly userProfile?: {
         readonly sub: string;
     } | undefined;
 }, never, {
-    readonly name: string & S.NonEmptyString255Brand;
     readonly id: NonEmptyString255;
+    readonly name: string & S.NonEmptyString255Brand;
     readonly locale: "en" | "de";
     readonly userProfile?: {
         readonly sub: string & import("effect-app/ids").UserProfileIdBrand;
@@ -62,8 +62,8 @@ declare const RequestContext_base: S.EnhancedClass<RequestContext, {
     };
     parent: S.PropertySignature<"?:", RequestContextParent | undefined, never, "?:", {
         readonly _tag: "RequestContext";
-        readonly name: string;
         readonly id: string;
+        readonly name: string;
         readonly locale: "en" | "de";
         readonly createdAt: string;
         readonly userProfile?: {
@@ -72,19 +72,19 @@ declare const RequestContext_base: S.EnhancedClass<RequestContext, {
     } | undefined, false, never>;
     namespace: S.PropertySignature<"?:", (string & S.NonEmptyString255Brand) | undefined, never, "?:", string | undefined, false, never>;
     name: S.WithDefaults<S.Schema<string & S.NonEmptyString255Brand, string, never>> & S.Schema<string & S.NonEmptyString255Brand, string, never>;
-    locale: S.Schema<"en" | "de", "en" | "de", never> & {
-        literals: ["en", "de"];
-    };
     userProfile: S.PropertySignature<"?:", {
         readonly sub: string & import("effect-app/ids").UserProfileIdBrand;
     } | undefined, never, "?:", {
         readonly sub: string;
     } | undefined, false, never>;
+    locale: S.Schema<"en" | "de", "en" | "de", never> & {
+        literals: ["en", "de"];
+    };
     createdAt: S.PropertySignature<":", Date, never, ":", string, true, never>;
 }, {
     readonly _tag: "RequestContext";
-    readonly name: string & S.NonEmptyString255Brand;
     readonly id: NonEmptyString255;
+    readonly name: string & S.NonEmptyString255Brand;
     readonly locale: "en" | "de";
     readonly createdAt: Date;
     readonly rootId: NonEmptyString255;
@@ -95,8 +95,8 @@ declare const RequestContext_base: S.EnhancedClass<RequestContext, {
     readonly namespace?: (string & S.NonEmptyString255Brand) | undefined;
 }, {
     readonly _tag: "RequestContext";
-    readonly name: string;
     readonly id: string;
+    readonly name: string;
     readonly locale: "en" | "de";
     readonly createdAt: string;
     readonly rootId: string;
@@ -105,8 +105,8 @@ declare const RequestContext_base: S.EnhancedClass<RequestContext, {
     } | undefined;
     readonly parent?: {
         readonly _tag: "RequestContext";
-        readonly name: string;
         readonly id: string;
+        readonly name: string;
         readonly locale: "en" | "de";
         readonly createdAt: string;
         readonly userProfile?: {

package/dist/api/routing/base.d.ts

@@ -37,11 +37,11 @@ export declare function parseRequestParams<PathA extends Struct.Fields, CookieA
     params: unknown;
     query: unknown;
 }) => Effect.Effect<{
-    body: Option<Simplify<Struct.Type<BodyA, Struct.TypeTokenKeys<BodyA>>>>;
-    cookie: Option<Simplify<Struct.Type<CookieA, Struct.TypeTokenKeys<CookieA>>>>;
-    headers: Option<Simplify<Struct.Type<HeaderA, Struct.TypeTokenKeys<HeaderA>>>>;
-    path: Option<Simplify<Struct.Type<PathA, Struct.TypeTokenKeys<PathA>>>>;
-    query: Option<Simplify<Struct.Type<QueryA, Struct.TypeTokenKeys<QueryA>>>>;
+    body: Option<Simplify<Struct.Type<BodyA>>>;
+    cookie: Option<Simplify<Struct.Type<CookieA>>>;
+    headers: Option<Simplify<Struct.Type<HeaderA>>>;
+    path: Option<Simplify<Struct.Type<PathA>>>;
+    query: Option<Simplify<Struct.Type<QueryA>>>;
 }, ValidationError, never>;
 export declare function makeRequestParsers<R, M, PathA extends Struct.Fields, CookieA extends Struct.Fields, QueryA extends Struct.Fields, BodyA extends Struct.Fields, HeaderA extends Struct.Fields, ReqA extends PathA & QueryA & BodyA, ResA extends Struct.Fields, Errors, PPath extends `/${string}`, CTX, Context, Config>(Request: RequestHandler<R, M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, Errors, PPath, CTX, Context, Config>["Request"]): RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA>;
 type Decode<A> = (u: unknown) => Effect<A, unknown>;

package/dist/api/routing/match.d.ts

@@ -8,5 +8,5 @@ import type { HttpServerRequest, HttpServerResponse } from "effect-app/http";
 import type { RequestHandler } from "./base.js";
 import type { Middleware } from "./makeRequestHandler.js";
 export declare const RouteDescriptors: Context.Tag<Ref<RouteDescriptorAny[]>, Ref<RouteDescriptorAny[]>>;
-export declare function match<R, M, PathA extends Struct.Fields, CookieA extends Struct.Fields, QueryA extends Struct.Fields, BodyA extends Struct.Fields, HeaderA extends Struct.Fields, ReqA extends PathA & QueryA & BodyA, ResA extends Struct.Fields, ResE, MiddlewareE, PPath extends `/${string}`, R2, PR, RErr, CTX, Context, Config>(requestHandler: RequestHandler<R, M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, ResE, PPath, CTX, Context, Config>, errorHandler: <R>(req: HttpServerRequest.ServerRequest, res: HttpServerResponse.ServerResponse, r2: Effect<HttpServerResponse.ServerResponse, ValidationError | MiddlewareE | ResE, R>) => Effect<HttpServerResponse.ServerResponse, never, Exclude<RErr | R, HttpServerRequest.ServerRequest | HttpRouter.RouteContext | Scope>>, middleware?: Middleware<R, M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, ResE, MiddlewareE, PPath, R2, PR, CTX, Context, Config>): Effect.Effect<HttpRouter.Route<import("src/services/RequestContextContainer.js").RequestContextContainer | import("src/services/Store/ContextMapContainer.js").ContextMapContainer | Exclude<R2, HttpServerRequest.ServerRequest | Scope.Scope | HttpRouter.RouteContext> | Exclude<RErr, HttpServerRequest.ServerRequest | Scope.Scope | HttpRouter.RouteContext> | Exclude<Exclude<Exclude<R, import("effect-app/utils").EnforceNonEmptyRecord<M>>, PR>, HttpServerRequest.ServerRequest | Scope.Scope | HttpRouter.RouteContext>, import("@effect/platform/Http/ServerError").RequestError>, never, never>;
+export declare function match<R, M, PathA extends Struct.Fields, CookieA extends Struct.Fields, QueryA extends Struct.Fields, BodyA extends Struct.Fields, HeaderA extends Struct.Fields, ReqA extends PathA & QueryA & BodyA, ResA extends Struct.Fields, ResE, MiddlewareE, PPath extends `/${string}`, R2, PR, RErr, CTX, Context, Config>(requestHandler: RequestHandler<R, M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, ResE, PPath, CTX, Context, Config>, errorHandler: <R>(req: HttpServerRequest.ServerRequest, res: HttpServerResponse.ServerResponse, r2: Effect<HttpServerResponse.ServerResponse, ValidationError | MiddlewareE | ResE, R>) => Effect<HttpServerResponse.ServerResponse, never, Exclude<RErr | R, HttpServerRequest.ServerRequest | HttpRouter.RouteContext | Scope>>, middleware?: Middleware<R, M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, ResE, MiddlewareE, PPath, R2, PR, CTX, Context, Config>): Effect.Effect<HttpRouter.Route<import("src/services/RequestContextContainer.js").RequestContextContainer | import("src/services/Store/ContextMapContainer.js").ContextMapContainer | Exclude<R2, Scope.Scope | HttpServerRequest.ServerRequest | HttpRouter.RouteContext> | Exclude<RErr, Scope.Scope | HttpServerRequest.ServerRequest | HttpRouter.RouteContext> | Exclude<Exclude<Exclude<R, import("effect-app/utils").EnforceNonEmptyRecord<M>>, PR>, Scope.Scope | HttpServerRequest.ServerRequest | HttpRouter.RouteContext>, import("@effect/platform/Http/ServerError").RequestError>, never, never>;
 //# sourceMappingURL=match.d.ts.map

package/dist/services/Operations.d.ts

@@ -40,7 +40,7 @@ declare const Operations_base: (abstract new (service: {
         register: Effect.Effect<StringId, never, Scope.Scope>;
         find: (id: StringId) => Effect.Effect<Option.Option<Operation>, never, never>;
         update: (id: StringId, progress: OperationProgress) => Effect.Effect<void, never, never>;
-    }) => X) => X extends Effect<infer A_3, infer E_5, infer R_5> ? Effect<A_3, E_5, Operations | R_5> : Effect<X, never, Operations>;
+    }) => X) => X extends Effect<infer A_3, infer E_5, infer R_5> ? Effect<A_3, E_5, R_5 | Operations> : Effect<X, never, Operations>;
 };
 export declare class Operations extends Operations_base {
     static readonly Live: Layer.Layer<Operations, never, never>;

package/dist/services/QueueMaker/service.d.ts

@@ -16,12 +16,12 @@ export declare const QueueMaker: QueueMakerOps;
 export declare const QueueMeta: import("@effect/schema/Schema").struct<{
     requestContext: typeof RequestContext;
     span: S.PropertySignature<"?:", {
-        readonly traceId: string;
         readonly spanId: string;
+        readonly traceId: string;
         readonly sampled?: boolean | undefined;
     } | undefined, never, "?:", {
-        readonly traceId: string;
         readonly spanId: string;
+        readonly traceId: string;
         readonly sampled?: boolean | undefined;
     } | undefined, false, never>;
 }>;

package/dist/services/Repository/ext.d.ts

@@ -21,7 +21,7 @@ export declare function log<T extends {
  */
 export declare function byIdAndSaveWithPure<T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"]): <R, A, E, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, T, S2>>) => Effect.Effect<A, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E | NotFoundError<ItemType>, Exclude<R, {
+}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"]): <R, A, E, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, T, S2>>) => Effect.Effect<A, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | NotFoundError<ItemType> | E, Exclude<R, {
     env: import("effect-app/Pure").PureEnv<Evt, T, S2>;
 }>>;
 /**
@@ -32,7 +32,7 @@ export declare function handleByIdAndSaveWithPure<T extends {
     id: unknown;
 }, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>): <Req extends {
     id: T["id"];
-}, Context, R, A, E, S2 extends T>(pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>) => (req: Req, ctx: Context) => Effect.Effect<A, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E | NotFoundError<ItemType>, Exclude<R, {
+}, Context, R, A, E, S2 extends T>(pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>) => (req: Req, ctx: Context) => Effect.Effect<A, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E | NotFoundError<ItemType>, Exclude<R, {
     env: import("effect-app/Pure").PureEnv<Evt, T, S2>;
 }>>;
 /**
@@ -40,7 +40,7 @@ export declare function handleByIdAndSaveWithPure<T extends {
  */
 export declare function saveManyWithPure_<R, T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, A, E, Evt, S1 extends T, S2 extends T, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, items: Iterable<S1>, pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>): Effect.Effect<A, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E, Exclude<R, {
+}, PM extends PersistenceModelType<string>, A, E, Evt, S1 extends T, S2 extends T, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, items: Iterable<S1>, pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>): Effect.Effect<A, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E, Exclude<R, {
     env: import("effect-app/Pure").PureEnv<Evt, readonly S1[], readonly S2[]>;
 }>>;
 /**
@@ -48,18 +48,18 @@ export declare function saveManyWithPure_<R, T extends {
  */
 export declare function saveWithPure_<R, T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, A, E, Evt, S1 extends T, S2 extends T, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, item: S1, pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>): Effect.Effect<A, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E, Exclude<R, {
+}, PM extends PersistenceModelType<string>, A, E, Evt, S1 extends T, S2 extends T, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, item: S1, pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>): Effect.Effect<A, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E, Exclude<R, {
     env: import("effect-app/Pure").PureEnv<Evt, S1, S2>;
 }>>;
 export declare function saveAllWithEffectInt<T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, P extends T, Evt, ItemType extends string, R, E, A>(self: RepositoryBaseC<T, PM, Evt, ItemType>, gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>): Effect.Effect<A, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E, R>;
+}, PM extends PersistenceModelType<string>, P extends T, Evt, ItemType extends string, R, E, A>(self: RepositoryBaseC<T, PM, Evt, ItemType>, gen: Effect<readonly [Iterable<P>, Iterable<Evt>, A], E, R>): Effect.Effect<A, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E, R>;
 /**
  * @tsplus fluent Repository saveManyWithPureBatched
  */
 export declare function saveManyWithPureBatched<T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, batchSize?: number): <R, A, E, S1 extends T, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>) => (items: Iterable<S1>) => Effect.Effect<A[], import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E, Exclude<R, {
+}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, batchSize?: number): <R, A, E, S1 extends T, S2 extends T>(pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>) => (items: Iterable<S1>) => Effect.Effect<A[], import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E, Exclude<R, {
     env: import("effect-app/Pure").PureEnv<Evt, readonly S1[], readonly S2[]>;
 }>>;
 /**
@@ -67,7 +67,7 @@ export declare function saveManyWithPureBatched<T extends {
  */
 export declare function saveManyWithPureBatched_<R, T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, A, E, Evt, S1 extends T, S2 extends T, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, items: Iterable<S1>, pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>, batchSize?: number): Effect.Effect<A[], import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E, Exclude<R, {
+}, PM extends PersistenceModelType<string>, A, E, Evt, S1 extends T, S2 extends T, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>, items: Iterable<S1>, pure: Effect<A, E, FixEnv<R, Evt, readonly S1[], readonly S2[]>>, batchSize?: number): Effect.Effect<A[], import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E, Exclude<R, {
     env: import("effect-app/Pure").PureEnv<Evt, readonly S1[], readonly S2[]>;
 }>>;
 /**
@@ -75,25 +75,25 @@ export declare function saveManyWithPureBatched_<R, T extends {
  */
 export declare function save<T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>): (items_0: T, ...items_1: T[]) => Effect<void, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException>;
+}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>): (items_0: T, ...items_1: T[]) => Effect<void, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError>;
 /**
  * @tsplus getter Repository saveWithEvents
  */
 export declare function saveWithEvents<T extends {
     id: unknown;
-}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>): (events: Iterable<Evt>) => (items_0: T, ...items_1: T[]) => Effect<void, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException>;
+}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(self: RepositoryBaseC<T, PM, Evt, ItemType>): (events: Iterable<Evt>) => (items_0: T, ...items_1: T[]) => Effect<void, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError>;
 /**
  * @tsplus fluent Repository updateWithEffect
  */
 export declare function itemUpdateWithEffect<R, E, T extends {
     id: string;
-}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(repo: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"], mod: (item: T) => Effect<T, E, R>): Effect.Effect<void, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | E | NotFoundError<ItemType>, R>;
+}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(repo: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"], mod: (item: T) => Effect<T, E, R>): Effect.Effect<void, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | E | NotFoundError<ItemType>, R>;
 /**
  * @tsplus fluent Repository update
  */
 export declare function itemUpdate<T extends {
     id: string;
-}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(repo: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"], mod: (item: T) => T): Effect.Effect<void, import("effect-app/client/errors").InvalidStateError | import("effect-app/client/errors").OptimisticConcurrencyException | NotFoundError<ItemType>, never>;
+}, PM extends PersistenceModelType<string>, Evt, ItemType extends string>(repo: RepositoryBaseC<T, PM, Evt, ItemType>, id: T["id"], mod: (item: T) => T): Effect.Effect<void, import("effect-app/client/errors").OptimisticConcurrencyException | import("effect-app/client/errors").InvalidStateError | NotFoundError<ItemType>, never>;
 /**
  * only use this as a shortcut if you don't have the item already
  * @tsplus fluent Repository removeById

package/dist/services/RepositoryBase.d.ts

@@ -68,15 +68,15 @@ export declare class RepositoryBaseC2<T extends {
 }, PM extends PersistenceModelType<string>, Evt, ItemType extends string> extends RepositoryBaseC1<T, PM, Evt, ItemType> {
     protected readonly impl: Repository<T, PM, Evt, ItemType>;
     constructor(itemType: ItemType, impl: Repository<T, PM, Evt, ItemType>);
-    saveAndPublish: (items: Iterable<T>, events?: Iterable<Evt> | undefined) => Effect<void, InvalidStateError | OptimisticConcurrencyException>;
+    saveAndPublish: (items: Iterable<T>, events?: Iterable<Evt> | undefined) => Effect<void, OptimisticConcurrencyException | InvalidStateError>;
     removeAndPublish: (items: Iterable<T>, events?: Iterable<Evt> | undefined) => Effect<void>;
     find: (id: T["id"]) => Effect<Option<T>>;
     all: Effect<T[]>;
     changeFeed: PubSub.PubSub<[T[], "save" | "remove"]>;
     mapped: Mapped<PM, Omit<PM, "_etag">>;
     query: {
-        <A, R, From extends FieldValues, TType extends "many" | "one" | "count" = "many">(q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R, TType>): Effect.Effect<TType extends "many" ? readonly A[] : TType extends "count" ? number & S.NonNegativeIntBrand : A, (TType extends "many" ? never : NotFoundError<ItemType>) | (TType extends "count" ? never : ParseResult.ParseError), R>;
-        <R_1 = never, TType_1 extends "many" | "one" = "many">(q: (initial: Query<Omit<PM, "_etag">>) => QAll<Omit<PM, "_etag">, T, R_1, TType_1>): Effect.Effect<TType_1 extends "many" ? readonly T[] : T, TType_1 extends "many" ? never : NotFoundError<ItemType>, R_1>;
+        <A, R, From extends FieldValues, TType extends "one" | "many" | "count" = "many">(q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R, TType>): Effect.Effect<TType extends "many" ? readonly A[] : TType extends "count" ? number & S.NonNegativeIntBrand : A, (TType extends "many" ? never : NotFoundError<ItemType>) | (TType extends "count" ? never : ParseResult.ParseError), R>;
+        <R_1 = never, TType_1 extends "one" | "many" = "many">(q: (initial: Query<Omit<PM, "_etag">>) => QAll<Omit<PM, "_etag">, T, R_1, TType_1>): Effect.Effect<TType_1 extends "many" ? readonly T[] : T, TType_1 extends "many" ? never : NotFoundError<ItemType>, R_1>;
     };
 }
 export declare class RepositoryBaseC3<T extends {
@@ -85,8 +85,8 @@ export declare class RepositoryBaseC3<T extends {
     get(id: T["id"]): Effect.Effect<T, NotFoundError<ItemType>, never>;
     readonly log: (evt: Evt) => import("effect-app/Pure").PureLogT<any>;
     removeById(id: T["id"]): Effect.Effect<void, NotFoundError<ItemType>, never>;
-    readonly save: (items_0: T, ...items_1: T[]) => Effect<void, InvalidStateError | OptimisticConcurrencyException>;
-    readonly saveWithEvents: (events: Iterable<Evt>) => (items_0: T, ...items_1: T[]) => Effect<void, InvalidStateError | OptimisticConcurrencyException>;
+    readonly save: (items_0: T, ...items_1: T[]) => Effect<void, OptimisticConcurrencyException | InvalidStateError>;
+    readonly saveWithEvents: (events: Iterable<Evt>) => (items_0: T, ...items_1: T[]) => Effect<void, OptimisticConcurrencyException | InvalidStateError>;
     readonly queryAndSavePure: {
         <A, E2, R2, T2 extends T>(q: (q: Query<Omit<PM, "_etag">>) => QueryEnd<Omit<PM, "_etag">, "one">, pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>): Effect.Effect<A, InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E2, Exclude<R2, {
             env: PureEnv<Evt, T, T2>;
@@ -103,7 +103,7 @@ export declare class RepositoryBaseC3<T extends {
      */
     readonly handleByIdAndSaveWithPure: <Req extends {
         id: T["id"];
-    }, Context, R, A, E, S2 extends T>(pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>) => (req: Req, ctx: Context) => Effect.Effect<A, InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | E, Exclude<R, {
+    }, Context, R, A, E, S2 extends T>(pure: (req: Req, ctx: Context) => Effect<A, E, FixEnv<R, Evt, T, S2>>) => (req: Req, ctx: Context) => Effect.Effect<A, OptimisticConcurrencyException | InvalidStateError | NotFoundError<ItemType> | E, Exclude<R, {
         env: PureEnv<Evt, T, S2>;
     }>>;
     saveManyWithPure: {
@@ -119,7 +119,7 @@ export declare class RepositoryBaseC3<T extends {
             env: PureEnv<Evt, T, S2>;
         }>>;
     };
-    saveWithPure<R, A, E, S1 extends T, S2 extends T>(item: S1, pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>): Effect.Effect<A, InvalidStateError | OptimisticConcurrencyException | E, Exclude<R, {
+    saveWithPure<R, A, E, S1 extends T, S2 extends T>(item: S1, pure: Effect<A, E, FixEnv<R, Evt, S1, S2>>): Effect.Effect<A, OptimisticConcurrencyException | InvalidStateError | E, Exclude<R, {
         env: PureEnv<Evt, S1, S2>;
     }>>;
 }
@@ -146,7 +146,7 @@ export declare function makeRepo<PM extends {
         config?: Omit<StoreConfig<PM>, "partitionValue"> & {
             partitionValue?: (a: PM) => string;
         };
-    }) => Effect.Effect<Repository<T, PM, Evt, ItemType>, E, ContextMapContainer | R | StoreMaker | RInitial | R2>;
+    }) => Effect.Effect<Repository<T, PM, Evt, ItemType>, E, StoreMaker | ContextMapContainer | R | RInitial | R2>;
     Q: Query<Omit<PM, "_etag">>;
 };
 export declare function makeStore<PM extends {
@@ -158,7 +158,7 @@ export declare function makeStore<PM extends {
     id: unknown;
 }>(name: ItemType, schema: S.Schema<T, E, R>, mapTo: (e: E, etag: string | undefined) => PM) => <RInitial = never, EInitial = never>(makeInitial?: Effect<readonly T[], EInitial, RInitial>, config?: (Omit<StoreConfig<PM>, "partitionValue"> & {
     partitionValue?: (a: PM) => string;
-}) | undefined) => Effect.Effect<import("src/services/Store/service.js").Store<PM, string>, EInitial, R | StoreMaker | RInitial>;
+}) | undefined) => Effect.Effect<import("src/services/Store/service.js").Store<PM, string>, EInitial, StoreMaker | R | RInitial>;
 export interface Repos<T extends {
     id: unknown;
 }, PM extends {

package/dist/services/RequestContextContainer.d.ts

@@ -26,7 +26,7 @@ declare const RequestContextContainer_base: (abstract new (service: {
         requestContext: Effect<RequestContext>;
         update: (f: (rc: RequestContext) => RequestContext) => Effect<RequestContext>;
         start: (f: RequestContext) => Effect<void>;
-    }) => X) => X extends Effect<infer A_3, infer E_4, infer R_4> ? Effect<A_3, E_4, RequestContextContainer | R_4> : Effect<X, never, RequestContextContainer>;
+    }) => X) => X extends Effect<infer A_3, infer E_4, infer R_4> ? Effect<A_3, E_4, R_4 | RequestContextContainer> : Effect<X, never, RequestContextContainer>;
 };
 /**
  * @tsplus type RequestContextContainer

package/dist/services/Store/index.d.ts

@@ -2,6 +2,6 @@ import type { StorageConfig } from "./service.js";
 /**
  * @tsplus static StoreMaker.Ops Layer
  */
-export declare function StoreMakerLayer(cfg: StorageConfig): import("effect/Layer").Layer<import("./service.js").StoreMaker, never, never>;
+export declare function StoreMakerLayer(cfg: StorageConfig): import("effect-app").Layer<import("./service.js").StoreMaker, never, never>;
 export * from "./service.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/services/Store/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/Store/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,iFAkBjD;AAED,cAAc,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/Store/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,+EAkBjD;AAED,cAAc,cAAc,CAAA"}

package/dist/services/Store/service.d.ts

@@ -72,7 +72,7 @@ declare const StoreMaker_base: (abstract new (service: {
 } & import("effect/Context").Tag<StoreMaker, StoreMaker> & {} & {
     use: <X>(body: (_: {
         make: <PM extends PersistenceModelType<Id>, Id extends string, R = never, E = never>(name: string, seed?: Effect<Iterable<PM>, E, R> | undefined, config?: StoreConfig<PM> | undefined) => Effect<Store<PM, Id>, E, R>;
-    }) => X) => X extends Effect<infer A_3, infer E_4, infer R_4> ? Effect<A_3, E_4, R_4 | StoreMaker> : Effect<X, never, StoreMaker>;
+    }) => X) => X extends Effect<infer A_3, infer E_4, infer R_4> ? Effect<A_3, E_4, StoreMaker | R_4> : Effect<X, never, StoreMaker>;
 };
 /**
  * @tsplus type StoreMaker

package/dist/services/query/new-kid-interpreter.d.ts

@@ -14,7 +14,7 @@ export declare const toFilter: <TFieldValues extends FieldValues, A, R>(q: QAll<
         key: import("../../filter/types/path/eager.js").Path<TFieldValues>;
         direction: "ASC" | "DESC";
     }[]];
-    ttype: "many" | "one" | "count";
+    ttype: "one" | "many" | "count";
     mode: "project" | "collect" | "transform";
     filter: QueryBuilder<any>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "0.219.2",
+  "version": "0.220.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -18,17 +18,17 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "6.0.4",
     "redlock": "^4.2.0",
-    "@effect-app/fluent-extensions": "0.147.0",
-    "@effect-app/infra-adapters": "0.141.2",
-    "@effect-app/schema": "0.207.1",
-    "effect-app": "0.186.2",
-    "@effect-app/core": "0.153.0"
+    "@effect-app/core": "0.154.0",
+    "@effect-app/fluent-extensions": "0.148.0",
+    "effect-app": "0.187.0",
+    "@effect-app/infra-adapters": "0.142.0",
+    "@effect-app/schema": "0.208.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",
     "@sentry/node": "^7.106.1",
     "@types/express": "^4.17.21",
-    "@types/node": "~20.11.26",
+    "@types/node": "~20.11.27",
     "@types/proper-lockfile": "^4.1.4",
     "@types/redis": "^2.8.32",
     "@types/redlock": "^4.0.7",
@@ -43,9 +43,9 @@
   },
   "peerDependencies": {
     "express": "^4.18.3",
-    "@effect/platform": "^0.48.0",
-    "@effect/schema": "^0.64.0",
-    "effect": "^2.4.4"
+    "@effect/platform": "^0.48.1",
+    "@effect/schema": "^0.64.1",
+    "effect": "^2.4.5"
   },
   "typesVersions": {
     "*": {

package/test/dist/query.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjE,qBAAa,CAAE,SAAQ,MAOrB;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;IACzB,KAAY,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9C;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjE,qBAAa,CAAE,SAAQ,MAKrB;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;IACzB,KAAY,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9C;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}

package/test/query.test.ts

@@ -16,9 +16,7 @@ export class s extends S.Class<s>()({
   id: S.StringId.withDefault,
   displayName: S.NonEmptyString255,
   n: S.Date.withDefault,
-  union: S.propertySignature(someUnion, {
-    default: () => ({ _tag: "string", value: "hi" }) as S.Schema.Type<typeof someUnion>
-  })
+  union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
 }) {}
 export declare namespace s {
   export type From = S.Schema.Encoded<typeof s>