@effect/platform 0.42.6 → 0.43.0

package/src/internal/http/serverRequest.ts

@@ -25,13 +25,13 @@ export const serverRequestTag = Context.Tag<ServerRequest.ServerRequest>(TypeId)
 export const multipartPersisted = Effect.flatMap(serverRequestTag, (request) => request.multipart)
 
 /** @internal */
-export const schemaHeaders = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<R, I, A>) => {
   const parse = IncomingMessage.schemaHeaders(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
-export const schemaBodyJson = <I, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
   const parse = IncomingMessage.schemaBodyJson(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
@@ -40,13 +40,13 @@ const isMultipart = (request: ServerRequest.ServerRequest) =>
   request.headers["content-type"]?.toLowerCase().includes("multipart/form-data")
 
 /** @internal */
-export const schemaBodyForm = <I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<I, A>
+export const schemaBodyForm = <R, I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
   const parseMultipart = Multipart.schemaPersisted(schema)
-  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<any, A>)
+  const parseUrlParams = IncomingMessage.schemaBodyUrlParams(schema as Schema.Schema<R, any, A>)
   return Effect.flatMap(serverRequestTag, (request): Effect.Effect<
-    ServerRequest.ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+    R | ServerRequest.ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
     Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
     A
   > => {
@@ -58,21 +58,23 @@ export const schemaBodyForm = <I extends Multipart.Persisted, A>(
 }
 
 /** @internal */
-export const schemaBodyUrlParams = <I extends Readonly<Record<string, string>>, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<R, I, A>
+) => {
   const parse = IncomingMessage.schemaBodyUrlParams(schema)
   return Effect.flatMap(serverRequestTag, parse)
 }
 
 /** @internal */
-export const schemaBodyMultipart = <I extends Multipart.Persisted, A>(
-  schema: Schema.Schema<I, A>
+export const schemaBodyMultipart = <R, I extends Multipart.Persisted, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
   const parse = Multipart.schemaPersisted(schema)
   return Effect.flatMap(multipartPersisted, parse)
 }
 
 /** @internal */
-export const schemaBodyFormJson = <I, A>(schema: Schema.Schema<I, A>) => {
+export const schemaBodyFormJson = <R, I, A>(schema: Schema.Schema<R, I, A>) => {
   const parseMultipart = Multipart.schemaJson(schema)
   const parseUrlParams = UrlParams.schemaJson(schema)
   return (field: string) =>
@@ -81,7 +83,7 @@ export const schemaBodyFormJson = <I, A>(schema: Schema.Schema<I, A>) => {
       (
         request
       ): Effect.Effect<
-        FileSystem.FileSystem | Path.Path | Scope.Scope | ServerRequest.ServerRequest,
+        R | FileSystem.FileSystem | Path.Path | Scope.Scope | ServerRequest.ServerRequest,
         ParseResult.ParseError | Error.RequestError,
         A
       > => {

package/src/internal/http/serverResponse.ts

@@ -117,14 +117,14 @@ export const unsafeJson = (
   )
 
 /** @internal */
-export const schemaJson = <I, A>(
-  schema: Schema.Schema<I, A>
+export const schemaJson = <R, I, A>(
+  schema: Schema.Schema<R, I, A>
 ) => {
   const encode = internalBody.jsonSchema(schema)
   return (
     body: A,
     options?: ServerResponse.Options.WithContent
-  ): Effect.Effect<never, Body.BodyError, ServerResponse.ServerResponse> =>
+  ): Effect.Effect<R, Body.BodyError, ServerResponse.ServerResponse> =>
     Effect.map(encode(body), (body) =>
       new ServerResponseImpl(
         options?.status ?? 200,

package/src/internal/keyValueStore.ts

@@ -68,12 +68,12 @@ export const SchemaStoreTypeId: KeyValueStore.SchemaStoreTypeId = Symbol.for(
 ) as KeyValueStore.SchemaStoreTypeId
 
 /** @internal */
-const makeSchemaStore = <I, A>(
+const makeSchemaStore = <R, I, A>(
   store: KeyValueStore.KeyValueStore,
-  schema: Schema.Schema<I, A>
-): KeyValueStore.SchemaStore<A> => {
+  schema: Schema.Schema<R, I, A>
+): KeyValueStore.SchemaStore<R, A> => {
   const jsonSchema = Schema.parseJson(schema)
-  const parse = Schema.parse(jsonSchema)
+  const parse = Schema.decodeUnknown(jsonSchema)
   const encode = Schema.encode(jsonSchema)
 
   const get = (key: string) =>
@@ -166,11 +166,11 @@ export const layerFileSystem = (directory: string) =>
   )
 
 /** @internal */
-export const layerSchema = <I, A>(
-  schema: Schema.Schema<I, A>,
+export const layerSchema = <R, I, A>(
+  schema: Schema.Schema<R, I, A>,
   tagIdentifier?: unknown
 ) => {
-  const tag = Context.Tag<KeyValueStore.SchemaStore<A>>(tagIdentifier)
+  const tag = Context.Tag<KeyValueStore.SchemaStore<R, A>>(tagIdentifier)
   const layer = Layer.effect(tag, Effect.map(keyValueStoreTag, (store) => store.forSchema(schema)))
   return { tag, layer } as const
 }

package/src/internal/workerRunner.ts

@@ -163,13 +163,15 @@ export const layer = <I, R, E, O>(
 
 /** @internal */
 export const makeSerialized = <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
 ): Effect.Effect<
+  | R
   | WorkerRunner.PlatformRunner
   | Scope.Scope
   | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
@@ -179,7 +181,7 @@ export const makeSerialized = <
   Effect.gen(function*(_) {
     const scope = yield* _(Effect.scope)
     let context = Context.empty() as Context.Context<any>
-    const parseRequest = Schema.parse(schema)
+    const parseRequest = Schema.decodeUnknown(schema) as (_: unknown) => Effect.Effect<never, never, A>
 
     return yield* _(make((request: A) => {
       const result = (handlers as any)[request._tag](request)
@@ -219,13 +221,15 @@ export const makeSerialized = <
 
 /** @internal */
 export const layerSerialized = <
+  R,
   I,
   A extends Schema.TaggedRequest.Any,
   const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<I, A>,
+  schema: Schema.Schema<R, I, A>,
   handlers: Handlers
 ): Layer.Layer<
+  | R
   | WorkerRunner.PlatformRunner
   | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
   WorkerError.WorkerError,