@effect/platform 0.68.6 → 0.69.0

package/src/Worker.ts

@@ -1,16 +1,15 @@
 /**
  * @since 1.0.0
  */
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
-import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
 import type * as Deferred from "effect/Deferred"
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
 import type { LazyArg } from "effect/Function"
 import type * as Layer from "effect/Layer"
+import type * as ParseResult from "effect/ParseResult"
 import type * as Pool from "effect/Pool"
+import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import * as internal from "./internal/worker.js"
@@ -260,12 +259,12 @@ export interface SerializedWorker<I extends Schema.TaggedRequest.All> {
   readonly id: number
   readonly execute: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
+  ) => Req extends Schema.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
+  ) => Req extends Schema.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
     : never
 }
@@ -295,17 +294,17 @@ export interface SerializedWorkerPool<I extends Schema.TaggedRequest.All> {
   readonly backing: Pool.Pool<SerializedWorker<I>, WorkerError>
   readonly broadcast: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer _A, infer _I, infer E, infer _EI, infer R>
+  ) => Req extends Schema.WithResult<infer _A, infer _I, infer E, infer _EI, infer R>
     ? Effect.Effect<void, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly execute: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
+  ) => Req extends Schema.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
+  ) => Req extends Schema.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
     : never
 }

package/src/WorkerError.ts

@@ -1,9 +1,9 @@
 /**
  * @since 1.0.0
  */
-import * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
 import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
 import * as internal from "./internal/workerError.js"
 
 /**

package/src/WorkerRunner.ts

@@ -1,11 +1,10 @@
 /**
  * @since 1.0.0
  */
-import type * as Schema from "@effect/schema/Schema"
-import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
 import type * as Layer from "effect/Layer"
+import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import * as internal from "./internal/workerRunner.js"
@@ -128,7 +127,7 @@ export declare namespace SerializedRunner {
     readonly [K in A["_tag"]]: Extract<
       A,
       { readonly _tag: K }
-    > extends Serializable.SerializableWithResult<
+    > extends Schema.SerializableWithResult<
       infer S,
       infer _SI,
       infer _SR,

package/src/index.ts

@@ -73,6 +73,11 @@ export * as HttpApiError from "./HttpApiError.js"
  */
 export * as HttpApiGroup from "./HttpApiGroup.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as HttpApiMiddleware from "./HttpApiMiddleware.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/httpBody.ts

@@ -1,9 +1,9 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import * as Schema from "@effect/schema/Schema"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import { identity } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import * as FileSystem from "../FileSystem.js"

package/src/internal/httpClientRequest.ts

@@ -1,11 +1,11 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
 import * as Redacted from "effect/Redacted"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"

package/src/internal/httpClientResponse.ts

@@ -1,10 +1,10 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import * as Stream from "effect/Stream"
 import type { Unify } from "effect/Unify"
 import * as Cookies from "../Cookies.js"

package/src/internal/httpRouter.ts

@@ -1,5 +1,3 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
@@ -12,6 +10,8 @@ import * as Inspectable from "effect/Inspectable"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import * as Tracer from "effect/Tracer"
 import type { Mutable } from "effect/Types"
 import * as FindMyWay from "find-my-way-ts"

package/src/internal/httpServer.ts

@@ -9,6 +9,10 @@ import * as ClientRequest from "../HttpClientRequest.js"
 import type * as Middleware from "../HttpMiddleware.js"
 import type * as Server from "../HttpServer.js"
 import type * as ServerRequest from "../HttpServerRequest.js"
+import * as internalEtag from "./etag.js"
+import * as internalFileSystem from "./fileSystem.js"
+import * as internalPlatform from "./httpPlatform.js"
+import * as internalPath from "./path.js"
 
 /** @internal */
 export const TypeId: Server.TypeId = Symbol.for("@effect/platform/HttpServer") as Server.TypeId
@@ -181,3 +185,12 @@ export const makeTestClient = addressWith((address) =>
 
 /** @internal */
 export const layerTestClient = Layer.effect(Client.HttpClient, makeTestClient)
+
+/** @internal */
+export const layerContext = Layer.mergeAll(
+  internalPlatform.layer,
+  internalPath.layer,
+  internalEtag.layerWeak
+).pipe(
+  Layer.provideMerge(internalFileSystem.layerNoop({}))
+)

package/src/internal/httpServerRequest.ts

@@ -1,12 +1,12 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
 import type { ReadonlyRecord } from "effect/Record"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Cookies from "../Cookies.js"

package/src/internal/httpServerResponse.ts

@@ -1,11 +1,11 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Runtime from "effect/Runtime"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import * as Stream from "effect/Stream"
 import * as Cookies from "../Cookies.js"
 import type * as PlatformError from "../Error.js"

package/src/internal/keyValueStore.ts

@@ -1,4 +1,3 @@
-import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
@@ -7,6 +6,7 @@ import type { LazyArg } from "effect/Function"
 import { dual, identity, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
 import * as PlatformError from "../Error.js"
 import * as FileSystem from "../FileSystem.js"
 import type * as KeyValueStore from "../KeyValueStore.js"

package/src/internal/multipart.ts

@@ -1,6 +1,3 @@
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
@@ -10,8 +7,11 @@ import { dual, flow, pipe } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
 import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Scope from "effect/Scope"
 import type * as AsyncInput from "effect/SingleProducerAsyncInput"
 import * as Stream from "effect/Stream"

package/src/internal/worker.ts

@@ -1,5 +1,3 @@
-import * as Schema from "@effect/schema/Schema"
-import * as Serializable from "@effect/schema/Serializable"
 import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
@@ -13,6 +11,7 @@ import * as Mailbox from "effect/Mailbox"
 import * as Option from "effect/Option"
 import * as Pool from "effect/Pool"
 import * as Schedule from "effect/Schedule"
+import * as Schema from "effect/Schema"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Tracer from "effect/Tracer"
@@ -298,14 +297,14 @@ export const makeSerialized = <
       ...options as any,
       encode(message) {
         return Effect.mapError(
-          Serializable.serialize(message as any),
+          Schema.serialize(message as any),
           (cause) => new WorkerError({ reason: "encode", cause })
         )
       }
     })
     const execute = <Req extends I>(message: Req) => {
-      const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
-      const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
+      const parseSuccess = Schema.decode(Schema.successSchema(message as any))
+      const parseFailure = Schema.decode(Schema.failureSchema(message as any))
       return pipe(
         backing.execute(message),
         Stream.catchAll((error) => Effect.flatMap(parseFailure(error), Effect.fail)),
@@ -313,8 +312,8 @@ export const makeSerialized = <
       )
     }
     const executeEffect = <Req extends I>(message: Req) => {
-      const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
-      const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
+      const parseSuccess = Schema.decode(Schema.successSchema(message as any))
+      const parseFailure = Schema.decode(Schema.failureSchema(message as any))
       return Effect.matchEffect(backing.executeEffect(message), {
         onFailure: (error) => Effect.flatMap(parseFailure(error), Effect.fail),
         onSuccess: parseSuccess

package/src/internal/workerRunner.ts

@@ -1,5 +1,3 @@
-import * as Schema from "@effect/schema/Schema"
-import * as Serializable from "@effect/schema/Serializable"
 import * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
@@ -9,6 +7,7 @@ import * as Fiber from "effect/Fiber"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Schedule from "effect/Schedule"
+import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Transferable from "../Transferable.js"
@@ -189,13 +188,13 @@ export const makeSerialized = <
       },
       encodeError(request, message) {
         return Effect.mapError(
-          Serializable.serializeFailure(request as any, message),
+          Schema.serializeFailure(request as any, message),
           (cause) => new WorkerError({ reason: "encode", cause })
         )
       },
       encodeOutput(request, message) {
         return Effect.catchAllCause(
-          Serializable.serializeSuccess(request as any, message),
+          Schema.serializeSuccess(request as any, message),
           (cause) => new WorkerError({ reason: "encode", cause })
         )
       }