effect-app 0.181.3 → 0.181.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @effect-app/prelude
 
+## 0.181.5
+
+### Patch Changes
+
+- Updated dependencies [09bc0d5]
+  - @effect-app/schema@0.203.1
+
+## 0.181.4
+
+### Patch Changes
+
+- Updated dependencies [e355a45]
+  - @effect-app/schema@0.203.0
+
 ## 0.181.3
 
 ### Patch Changes

package/dist/Request.d.ts

@@ -13,7 +13,7 @@ export declare const responseWithJsonBody: (response: ClientResponse) => Effect.
 /**
  * @tsplus fluent effect/platform/Http/Client schemaJsonBody
  */
-export declare const schemaJsonBody: <R, To, From, A, B>(client: HttpClient.Client<A, B, ClientResponse>, schema: Schema<To, From, R>) => HttpClient.Client<R | A, HttpClientError.ResponseError | S.ParseResult.ParseError | B, To>;
+export declare const schemaJsonBody: <R, To, From, A, B>(client: HttpClient.Client<A, B, ClientResponse>, schema: Schema<To, From, R>) => HttpClient.Client<R | A, HttpClientError.ResponseError | B | S.ParseResult.ParseError, To>;
 /**
  * @tsplus fluent effect/platform/Http/Client schemaJsonBodyUnsafe
  */
@@ -25,7 +25,7 @@ export declare const responseWithSchemaBody: <R, From extends {
     readonly status?: number;
     readonly headers?: Headers;
     readonly body?: unknown;
-}, To, A, B>(client: HttpClient.Client<A, B, ClientResponse>, schema: Schema<To, From, R>) => HttpClient.Client<R | A, HttpClientError.ResponseError | S.ParseResult.ParseError | B, {
+}, To, A, B>(client: HttpClient.Client<A, B, ClientResponse>, schema: Schema<To, From, R>) => HttpClient.Client<R | A, HttpClientError.ResponseError | B | S.ParseResult.ParseError, {
     body: To;
     headers: Headers;
     status: number;

package/dist/client/errors.d.ts

@@ -1,15 +1,15 @@
 import { S } from "../lib.js";
 declare const NotFoundError_base: import("@effect/schema/Schema").Class<{
     readonly _tag: "NotFoundError";
-    readonly type: string;
     readonly id: unknown;
+    readonly type: string;
 }, {
     readonly _tag: "NotFoundError";
-    readonly type: string;
     readonly id: unknown;
-}, never, {
     readonly type: string;
+}, never, {
     readonly id: unknown;
+    readonly type: string;
 }, NotFoundError<ItemType>, {
     type: S.Schema<string, string, never>;
     id: S.Schema<unknown, unknown, never>;
@@ -130,16 +130,16 @@ export declare class OptimisticConcurrencyException extends OptimisticConcurrenc
         message: string;
     }, disableValidation?: boolean);
 }
-export declare const SupportedErrors: S.Schema<InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | LoginError | UnauthorizedError | ValidationError, {
-    readonly _tag: "InvalidStateError";
-    readonly message: string;
+export declare const SupportedErrors: S.Schema<NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | LoginError | UnauthorizedError | OptimisticConcurrencyException, {
+    readonly _tag: "NotFoundError";
+    readonly id: unknown;
+    readonly type: string;
 } | {
-    readonly _tag: "OptimisticConcurrencyException";
+    readonly _tag: "InvalidStateError";
     readonly message: string;
 } | {
-    readonly _tag: "NotFoundError";
-    readonly type: string;
-    readonly id: unknown;
+    readonly _tag: "ValidationError";
+    readonly errors: readonly unknown[];
 } | {
     readonly _tag: "NotLoggedInError";
     readonly message?: string | undefined;
@@ -150,20 +150,20 @@ export declare const SupportedErrors: S.Schema<InvalidStateError | OptimisticCon
     readonly _tag: "UnauthorizedError";
     readonly message?: string | undefined;
 } | {
-    readonly _tag: "ValidationError";
-    readonly errors: readonly unknown[];
+    readonly _tag: "OptimisticConcurrencyException";
+    readonly message: string;
 }, never>;
 export type SupportedErrors = S.Schema.To<typeof SupportedErrors>;
-export declare const MutationErrors: S.Schema<InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | LoginError | UnauthorizedError | ValidationError, {
-    readonly _tag: "InvalidStateError";
-    readonly message: string;
+export declare const MutationErrors: S.Schema<NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | LoginError | UnauthorizedError | OptimisticConcurrencyException, {
+    readonly _tag: "NotFoundError";
+    readonly id: unknown;
+    readonly type: string;
 } | {
-    readonly _tag: "OptimisticConcurrencyException";
+    readonly _tag: "InvalidStateError";
     readonly message: string;
 } | {
-    readonly _tag: "NotFoundError";
-    readonly type: string;
-    readonly id: unknown;
+    readonly _tag: "ValidationError";
+    readonly errors: readonly unknown[];
 } | {
     readonly _tag: "NotLoggedInError";
     readonly message?: string | undefined;
@@ -173,20 +173,20 @@ export declare const MutationErrors: S.Schema<InvalidStateError | OptimisticConc
 } | {
     readonly _tag: "UnauthorizedError";
     readonly message?: string | undefined;
-} | {
-    readonly _tag: "ValidationError";
-    readonly errors: readonly unknown[];
-}, never>;
-export declare const QueryErrors: S.Schema<InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | LoginError | UnauthorizedError | ValidationError, {
-    readonly _tag: "InvalidStateError";
-    readonly message: string;
 } | {
     readonly _tag: "OptimisticConcurrencyException";
     readonly message: string;
-} | {
+}, never>;
+export declare const QueryErrors: S.Schema<NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | LoginError | UnauthorizedError | OptimisticConcurrencyException, {
     readonly _tag: "NotFoundError";
-    readonly type: string;
     readonly id: unknown;
+    readonly type: string;
+} | {
+    readonly _tag: "InvalidStateError";
+    readonly message: string;
+} | {
+    readonly _tag: "ValidationError";
+    readonly errors: readonly unknown[];
 } | {
     readonly _tag: "NotLoggedInError";
     readonly message?: string | undefined;
@@ -197,8 +197,8 @@ export declare const QueryErrors: S.Schema<InvalidStateError | OptimisticConcurr
     readonly _tag: "UnauthorizedError";
     readonly message?: string | undefined;
 } | {
-    readonly _tag: "ValidationError";
-    readonly errors: readonly unknown[];
+    readonly _tag: "OptimisticConcurrencyException";
+    readonly message: string;
 }, never>;
 export type MutationErrors = S.Schema.To<typeof MutationErrors>;
 export type QueryErrors = S.Schema.To<typeof QueryErrors>;

package/dist/client/fetch.d.ts

@@ -16,12 +16,12 @@ export declare function fetchApi(method: Method, path: string, body?: unknown):
     status: number;
     body: unknown;
     headers: import("@effect/platform/Http/Headers").Headers;
-} | FetchResponse<unknown>, HttpRequestError | InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | ValidationError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError, HttpClient.Client.Default | ApiConfig>;
+} | FetchResponse<unknown>, NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | OptimisticConcurrencyException | HttpRequestError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError, HttpClient.Client.Default | ApiConfig>;
 export declare function fetchApi2S<RequestR, RequestFrom, RequestTo, ResponseR, ResponseFrom, ResponseTo>(request: Schema<RequestTo, RequestFrom, RequestR>, response: Schema<ResponseTo, ResponseFrom, ResponseR>): (method: Method, path: Path) => (req: RequestTo) => Effect.Effect<{
     body: ResponseTo;
     headers: Headers;
     status: number;
-}, HttpRequestError | ResError | InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | ValidationError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError | S.ParseResult.ParseError, HttpClient.Client.Default | ApiConfig | RequestR | ResponseR>;
+}, S.ParseResult.ParseError | NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | OptimisticConcurrencyException | HttpRequestError | ResError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError, HttpClient.Client.Default | ApiConfig | RequestR | ResponseR>;
 export declare function fetchApi3S<RequestA, RequestE, ResponseE = unknown, ResponseA = void>({ Request, Response }: {
     Request: REST.RequestSchemed<RequestA, RequestE>;
     Response: REST.ReqRes<ResponseA, ResponseE, any>;
@@ -29,11 +29,11 @@ export declare function fetchApi3S<RequestA, RequestE, ResponseE = unknown, Resp
     body: ResponseA;
     headers: Headers;
     status: number;
-}, HttpRequestError | ResError | InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | ValidationError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError | S.ParseResult.ParseError, any>;
+}, S.ParseResult.ParseError | NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | OptimisticConcurrencyException | HttpRequestError | ResError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError, any>;
 export declare function fetchApi3SE<RequestA, RequestE, ResponseE = unknown, ResponseA = void>({ Request, Response }: {
     Request: REST.RequestSchemed<RequestA, RequestE>;
     Response: REST.ReqRes<ResponseA, ResponseE, any>;
-}): (req: RequestA) => Effect.Effect<FetchResponse<ResponseE>, HttpRequestError | ResError | InvalidStateError | OptimisticConcurrencyException | NotFoundError<ItemType> | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | ValidationError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError | S.ParseResult.ParseError, any>;
+}): (req: RequestA) => Effect.Effect<FetchResponse<ResponseE>, S.ParseResult.ParseError | NotFoundError<ItemType> | InvalidStateError | ValidationError | NotLoggedInError | import("./errors.js").LoginError | UnauthorizedError | OptimisticConcurrencyException | HttpRequestError | ResError | HttpResponseError<unknown> | import("@effect/platform/Http/Body").BodyError, any>;
 export declare function makePathWithQuery(path: Path, pars: Record<string, string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>): string;
 export declare function makePathWithBody(path: Path, pars: Record<string, string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>): string;
 export declare function mapResponse<T, A>(map: (t: T) => A): (r: FetchResponse<T>) => FetchResponse<A>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "0.181.3",
+  "version": "0.181.5",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -13,9 +13,9 @@
     "ts-pattern": "^5.0.8",
     "uuid": "^9.0.1",
     "validator": "^13.11.0",
-    "@effect-app/schema": "0.202.5",
     "@effect-app/core": "0.150.5",
-    "@effect-app/fluent-extensions": "0.143.4"
+    "@effect-app/fluent-extensions": "0.143.4",
+    "@effect-app/schema": "0.203.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",