effect 4.0.0-beta.105 → 4.0.0-beta.106

package/src/unstable/eventlog/EventLogServerEncrypted.ts

@@ -67,10 +67,10 @@ export const layerRpcHandlers = Layer.unwrap(Effect.gen(function*() {
         })
       }
       if (request.encryptedEntries.length === 0) return
-      const entries = request.encryptedEntries.map(({ encryptedEntry, entryId }) =>
+      const entries = request.encryptedEntries.map(({ encryptedEntry, entryId, iv }) =>
         new PersistedEntry({
           entryId,
-          iv: request.iv,
+          iv,
           encryptedEntry
         })
       )

package/src/unstable/http/HttpServerRequest.ts

@@ -436,14 +436,19 @@ export const toClientRequest = (request: HttpServerRequest): HttpClientRequest.H
     Option.getOrElse(toURL(request), () => request.url)
   )
 
-const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody =>
-  hasBody(request.method)
+const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody => {
+  if (!hasBody(request.method)) {
+    return HttpBody.empty
+  }
+  const formData = getFormDataBody(request)
+  return formData === undefined
     ? HttpBody.stream(
       request.stream,
       request.headers["content-type"],
       parseContentLength(request.headers["content-length"])
     )
-    : HttpBody.empty
+    : HttpBody.formData(formData)
+}
 
 const parseContentLength = (contentLength: string | undefined): number | undefined => {
   if (contentLength === undefined) {

package/src/unstable/http/MultipartParser/internal/multipart.ts

@@ -74,7 +74,8 @@ export function make({
     isFile: false,
     fieldChunks: [] as Array<Uint8Array>,
     fieldSize: 0,
-    done: false
+    done: false,
+    stopped: false
   }
 
   function skipBody() {
@@ -88,6 +89,10 @@ export function make({
   const split = Search.make(
     `\r\n--${boundary}`,
     function(index, chunk) {
+      if (state.stopped) {
+        return
+      }
+
       if (index === 0) {
         // data before the first boundary
         skipBody()
@@ -127,12 +132,14 @@ export function make({
 
         state.parts++
         if (state.parts > maxParts) {
-          onError(errMaxParts)
+          state.stopped = true
+          return onError(errMaxParts)
         }
       }
 
       if ((state.partSize += chunk.length) > maxPartSize) {
-        onError(errMaxPartSize)
+        state.stopped = true
+        return onError(errMaxPartSize)
       }
 
       if (state.state === State.headers) {
@@ -199,7 +206,8 @@ export function make({
           } else {
             const buf = chunk.subarray(result.endPosition)
             if ((state.fieldSize += buf.length) > maxFieldSize) {
-              onError(errMaxFieldSize)
+              state.stopped = true
+              return onError(errMaxFieldSize)
             }
             state.fieldChunks.push(buf)
           }
@@ -208,7 +216,8 @@ export function make({
         state.onChunk(chunk)
       } else {
         if ((state.fieldSize += chunk.length) > maxFieldSize) {
-          onError(errMaxFieldSize)
+          state.stopped = true
+          return onError(errMaxFieldSize)
         }
         state.fieldChunks.push(chunk)
       }
@@ -219,6 +228,9 @@ export function make({
 
   return {
     write(chunk: Uint8Array) {
+      if (state.stopped) {
+        return
+      }
       if ((state.totalSize += chunk.length) > maxTotalSize) {
         return onError(errMaxTotalSize)
       }
@@ -226,7 +238,7 @@ export function make({
     },
     end() {
       split.end()
-      if (!state.done) {
+      if (!state.done && !state.stopped) {
         onError(errEndNotReached)
       }
 
@@ -240,6 +252,7 @@ export function make({
       state.fieldChunks = []
       state.fieldSize = 0
       state.done = false
+      state.stopped = false
     }
   } as const
 }

package/src/unstable/httpapi/OpenApi.ts

@@ -220,7 +220,10 @@ type CompileSchemas = (
 const compileSchemas: CompileSchemas = (asts) =>
   JsonSchema.toMultiDocumentOpenApi3_1(
     InternalToJsonSchemaDocument.toJsonSchemaMultiDocument(
-      InternalToRepresentation.toRepresentations(Arr.map(asts, Schema.toCodecJsonAST))
+      InternalToRepresentation.toRepresentations(
+        Arr.map(asts, Schema.toCodecJsonAST),
+        InternalToJsonSchemaDocument.toRepresentationOptions
+      )
     )
   )
 

package/src/unstable/rpc/RpcClient.ts

@@ -1299,6 +1299,11 @@ export const makeProtocolWorker = (
           undefined
       }).pipe(
         Effect.tapCause((cause) => {
+          for (const [requestId, entry] of entries) {
+            if (entry.worker !== backing) continue
+            entries.delete(requestId)
+            entry.latch.openUnsafe()
+          }
           const error = Cause.findError(cause)
           return broadcast({
             _tag: "ClientProtocolError",

package/src/unstable/sql/SqlResolver.ts

@@ -134,7 +134,8 @@ export const ordered = <Req extends Schema.Constraint, Res extends Schema.Constr
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, encodedEntries] = yield* partitionRequests(entries, options.Request)
-      const results = yield* options.execute(inputs as any).pipe(
+      if (!Arr.isArrayNonEmpty(inputs)) return
+      const results = yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       if (results.length !== inputs.length) {
@@ -190,8 +191,9 @@ export const grouped = <Req extends Schema.Constraint, Res extends Schema.Constr
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs] = yield* partitionRequests(entries, options.Request)
+      if (!Arr.isArrayNonEmpty(inputs)) return
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
-      const results = yield* options.execute(inputs as any).pipe(
+      const results = yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
@@ -258,7 +260,8 @@ export const findById = <Id extends Schema.Constraint, Res extends Schema.Constr
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
-      const results = yield* options.execute(inputs as any).pipe(
+      if (!Arr.isArrayNonEmpty(inputs)) return
+      const results = yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
@@ -311,7 +314,8 @@ const void_ = <Req extends Schema.Constraint, _, E, R>(
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs] = yield* partitionRequests(entries, options.Request)
-      yield* options.execute(inputs as any).pipe(
+      if (!Arr.isArrayNonEmpty(inputs)) return
+      yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
@@ -366,35 +370,39 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
   const len = requests.length
   const inputs = Arr.empty<InE>()
   const byIdMap = MutableHashMap.empty<In, Request.Entry<SqlRequest<In, A, E, R>>>()
-  let entry!: Request.Entry<SqlRequest<In, A, E, R>>
-  const encode = Schema.encodeEffect(schema)
-  const handle = Effect.matchCauseEager({
-    onFailure(cause: Cause.Cause<Schema.SchemaError>) {
-      entry.completeUnsafe(Exit.failCause(cause))
-    },
-    onSuccess(value: InE) {
-      inputs.push(value)
-    }
-  })
 
   for (let i = 0; i < len; i++) {
-    entry = requests[i]
+    const entry = requests[i]
     const existing = MutableHashMap.get(byIdMap, entry.request.payload)
     if (Option.isSome(existing)) {
-      const duplicate = entry
+      const previous = existing.value
       MutableHashMap.set(byIdMap, entry.request.payload, {
-        ...existing.value,
+        ...previous,
         completeUnsafe(exit) {
-          existing.value.completeUnsafe(exit)
-          duplicate.completeUnsafe(exit)
+          previous.completeUnsafe(exit)
+          entry.completeUnsafe(exit)
         }
       })
     } else {
-      yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
       MutableHashMap.set(byIdMap, entry.request.payload, entry)
     }
   }
 
+  const encode = Schema.encodeEffect(schema)
+  for (const [, entry] of byIdMap) {
+    yield* Effect.provideContext(
+      Effect.matchCauseEager(encode(entry.request.payload), {
+        onFailure(cause) {
+          entry.completeUnsafe(Exit.failCause(cause))
+        },
+        onSuccess(value) {
+          inputs.push(value)
+        }
+      }),
+      entry.context
+    )
+  }
+
   return [inputs, byIdMap] as const
 }
 

package/src/unstable/workers/Worker.ts

@@ -165,6 +165,17 @@ export const makePlatform = <W>() =>
         const spawn = (yield* Spawner) as SpawnerFn<W>
         let currentPort: P | undefined
         const buffer: Array<[unknown, ReadonlyArray<unknown> | undefined]> = []
+        const sendToPort = (port: P, message: unknown, transfers?: ReadonlyArray<unknown>) =>
+          Effect.try({
+            try: () => port.postMessage([0, message], transfers as any),
+            catch: (cause) =>
+              new WorkerError({
+                reason: new WorkerSendError({
+                  message: "Failed to send message to worker",
+                  cause
+                })
+              })
+          })
 
         const run = <A, E, R>(
           handler: (_: O) => Effect.Effect<A, E, R>,
@@ -209,7 +220,7 @@ export const makePlatform = <W>() =>
                 currentPort = port
                 if (buffer.length > 0) {
                   for (const [message, transfers] of buffer) {
-                    port.postMessage([0, message], transfers as any)
+                    yield* sendToPort(port, message, transfers)
                   }
                   buffer.length = 0
                 }
@@ -224,19 +235,7 @@ export const makePlatform = <W>() =>
               buffer.push([message, transfers])
               return Effect.void
             }
-            try {
-              currentPort.postMessage([0, message], transfers as any)
-              return Effect.void
-            } catch (cause) {
-              return Effect.fail(
-                new WorkerError({
-                  reason: new WorkerSendError({
-                    message: "Failed to send message to worker",
-                    cause
-                  })
-                })
-              )
-            }
+            return sendToPort(currentPort, message, transfers)
           })
 
         return { run, send }