effect 4.0.0-beta.97 → 4.0.0-beta.99

package/src/unstable/httpapi/OpenApi.ts

@@ -11,7 +11,9 @@
 import * as Arr from "../../Array.ts"
 import type { NonEmptyArray } from "../../Array.ts"
 import * as Context from "../../Context.ts"
+import * as Equal from "../../Equal.ts"
 import { constFalse } from "../../Function.ts"
+import * as internalRecord from "../../internal/record.ts"
 import * as JsonPatch from "../../JsonPatch.ts"
 import { escapeToken } from "../../JsonPointer.ts"
 import * as JsonSchema from "../../JsonSchema.ts"
@@ -208,7 +210,7 @@ export const annotations: (
   transform: Transform
 })
 
-const apiCache = new WeakMap<HttpApi.Any, OpenAPISpec>()
+const apiCache = new WeakMap<HttpApi.Constraint, OpenAPISpec>()
 
 /**
  * This function checks if a given tag exists within the provided context. If
@@ -246,7 +248,7 @@ function processAnnotation<Services, S, I>(
  * @category constructors
  * @since 4.0.0
  */
-export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
+export function fromApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
   api: HttpApi.HttpApi<Id, Groups>
 ): OpenAPISpec {
   const cached = apiCache.get(api)
@@ -279,6 +281,8 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       readonly path: ReadonlyArray<string>
     }
   > = []
+  const pathOperations = new Set<string>()
+  const operationIds = new Set<string>()
 
   processAnnotation(api.annotations, Title, (title) => {
     spec.info.title = title
@@ -331,7 +335,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         operationId: Context.getOrElse(
           endpoint.annotations,
           Identifier,
-          () => group.topLevel ? endpoint.name : `${group.identifier}.${endpoint.name}`
+          () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`
         ),
         parameters: [],
         security: [],
@@ -341,31 +345,6 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       const path = endpoint.path.replace(/:(\w+)\??/g, "{$1}")
       const method = endpoint.method.toLowerCase() as OpenAPISpecMethodName
 
-      function processRequestBodies(payloadMap: HttpApiEndpoint.PayloadMap) {
-        if (payloadMap.size > 0) {
-          const c: OpenApiSpecContent = {}
-          let hasContent = false
-          payloadMap.forEach(({ encoding, schemas }, contentType) => {
-            const filtered = schemas.filter((s) => !HttpApiSchema.isNoContent(s.ast))
-            if (filtered.length === 0) return
-            hasContent = true
-            const asts = filtered.map(SchemaAST.getAST)
-            const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts, "anyOf")
-            pathOps.push({
-              _tag: "schema",
-              ast: toEncodingAST(ast, encoding._tag),
-              path: ["paths", path, method, "requestBody", "content", contentType, "schema"]
-            })
-            c[contentType] = {
-              schema: {}
-            }
-          })
-          if (hasContent) {
-            op.requestBody = { content: c, required: true }
-          }
-        }
-      }
-
       function processResponseBodies(bodies: ResponseBodies, defaultDescription: () => string) {
         for (const [status, { content, descriptions, streamContent }] of bodies) {
           const description = descriptions.size > 0 ? Array.from(descriptions).join(" | ") : defaultDescription()
@@ -502,15 +481,53 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         name: string,
         security: HttpApiSecurity
       ) {
-        if (spec.components.securitySchemes[name] !== undefined) {
+        const scheme = makeSecurityScheme(security)
+        if (!Object.hasOwn(spec.components.securitySchemes, name)) {
+          internalRecord.set(spec.components.securitySchemes, name, scheme)
           return
         }
-        spec.components.securitySchemes[name] = makeSecurityScheme(security)
+        if (
+          !Equal.equals(
+            securitySchemeForComparison(spec.components.securitySchemes[name]),
+            securitySchemeForComparison(scheme)
+          )
+        ) {
+          throw new globalThis.Error(`Conflicting OpenAPI security scheme: ${name}`)
+        }
       }
 
       const hasBody = HttpMethod.hasBody(endpoint.method)
       if (hasBody) {
-        processRequestBodies(endpoint.payload)
+        const schemasByContentType = new Map<string, {
+          readonly encoding: HttpApiSchema.PayloadEncoding
+          readonly schemas: Array<Schema.Top>
+        }>()
+        for (const schema of HttpApiEndpoint.getPayloadSchemas(endpoint)) {
+          if (HttpApiSchema.isNoContent(schema.ast)) continue
+          const encoding = HttpApiSchema.getPayloadEncoding(schema.ast, endpoint.method)
+          const existing = schemasByContentType.get(encoding.contentType)
+          if (existing === undefined) {
+            schemasByContentType.set(encoding.contentType, { encoding, schemas: [schema] })
+          } else {
+            existing.schemas.push(schema)
+          }
+        }
+        if (schemasByContentType.size > 0) {
+          const content: OpenApiSpecContent = {}
+          for (const [contentType, { encoding, schemas }] of schemasByContentType) {
+            const asts = schemas.map(SchemaAST.getAST)
+            const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts, "anyOf")
+            pathOps.push({
+              _tag: "schema",
+              ast: toEncodingAST(ast, encoding._tag),
+              path: ["paths", path, method, "requestBody", "content", contentType, "schema"]
+            })
+            content[contentType] = {
+              schema: {}
+            }
+          }
+          op.requestBody = { content, required: true }
+        }
       }
 
       processParameters(endpoint.params, "path")
@@ -534,10 +551,6 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         () => "Error"
       )
 
-      if (!spec.paths[path]) {
-        spec.paths[path] = {}
-      }
-
       processAnnotation(endpoint.annotations, Override, (override) => {
         Object.assign(op, override)
       })
@@ -545,6 +558,21 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         op = transformFn(op) as OpenAPISpecOperation
       })
 
+      const pathOperation = `${method} ${path.replace(/\{[^}]+\}/g, "{}")}`
+      if (pathOperations.has(pathOperation)) {
+        throw new globalThis.Error(`Duplicate OpenAPI operation for ${endpoint.method} ${path}`)
+      }
+      const operationId = op.operationId
+      if (operationId !== undefined) {
+        if (operationIds.has(operationId)) {
+          throw new globalThis.Error(`Duplicate OpenAPI operationId: ${operationId}`)
+        }
+        operationIds.add(operationId)
+      }
+      pathOperations.add(pathOperation)
+      if (!spec.paths[path]) {
+        spec.paths[path] = {}
+      }
       spec.paths[path][method] = op
     }
   })
@@ -627,7 +655,7 @@ type ResponseBodies = Map<
 
 const reservedStreamFailureEvent = "effect/httpapi/stream/failure"
 
-function extractSuccessResponseBodies(endpoint: HttpApiEndpoint.AnyWithProps): ResponseBodies {
+function extractSuccessResponseBodies(endpoint: HttpApiEndpoint.Top): ResponseBodies {
   return extractResponseBodies(
     HttpApiEndpoint.getSuccessSchemas(endpoint),
     HttpApiSchema.getStatusSuccess,
@@ -814,6 +842,16 @@ const makeSecurityScheme = (security: HttpApiSecurity): OpenAPISecurityScheme =>
   }
 }
 
+const securitySchemeForComparison = (scheme: OpenAPISecurityScheme): OpenAPISecurityScheme => {
+  if (scheme.type === "http") {
+    return { ...scheme, scheme: scheme.scheme.toLowerCase() }
+  }
+  if (scheme.in === "header") {
+    return { ...scheme, name: scheme.name.toLowerCase() }
+  }
+  return scheme
+}
+
 /**
  * This model describes the OpenAPI specification (version 3.1.0) returned by
  * {@link fromApi}. It is not intended to describe the entire OpenAPI

package/src/unstable/httpapi/internal/html.ts

@@ -1,11 +1,11 @@
-const ESCAPE_SCRIPT_END = /<\/script>/gi
+const ESCAPE_SCRIPT_DATA = /</g
 
 const ESCAPE_LINE_TERMS = /[\u2028\u2029]/g
 
 /** @internal */
 export function escapeJson(spec: unknown): string {
   return JSON.stringify(spec)
-    .replace(ESCAPE_SCRIPT_END, "<\\/script>")
+    .replace(ESCAPE_SCRIPT_DATA, "\\u003c")
     .replace(ESCAPE_LINE_TERMS, (c) => c === "\u2028" ? "\\u2028" : "\\u2029")
 }
 
@@ -16,3 +16,10 @@ export function escape(str: string): string {
     .replace(/</g, "&lt;")
     .replace(/>/g, "&gt;")
 }
+
+/** @internal */
+export function escapeAttribute(str: string): string {
+  return escape(str)
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;")
+}

package/src/unstable/httpapi/internal/mediaType.ts

@@ -0,0 +1,6 @@
+/** @internal */
+export function normalize(contentType: string): string {
+  const normalized = contentType.toLowerCase().trim()
+  const index = normalized.indexOf(";")
+  return index === -1 ? normalized : normalized.slice(0, index).trim()
+}

package/src/unstable/persistence/PersistedQueue.ts

@@ -170,19 +170,13 @@ export const makeFactory = Effect.gen(function*() {
             }
           ),
         take: (f, opts) =>
-          Effect.uninterruptibleMask(Effect.fnUntraced(function*(restore) {
-            const scope = yield* Scope.make()
+          Effect.scopedWith(Effect.fnUntraced(function*(scope) {
             const item = yield* store.take({
               name: options.name,
               maxAttempts: opts?.maxAttempts ?? 10
-            }).pipe(
-              Scope.provide(scope),
-              restore
-            )
+            }).pipe(Scope.provide(scope))
             const decoded = yield* decodeUnknown(item.element)
-            const exit = yield* Effect.exit(restore(f(decoded, { id: item.id, attempts: item.attempts })))
-            yield* Scope.close(scope, exit)
-            return yield* exit
+            return yield* f(decoded, { id: item.id, attempts: item.attempts })
           }))
       })
     }
@@ -613,7 +607,9 @@ local key_pending = KEYS[2]
 local prefix = ARGV[1]
 
 local entries = redis.call("HGETALL", key_pending)
-for id, payload in pairs(entries) do
+for i = 1, #entries, 2 do
+  local id = entries[i]
+  local payload = entries[i + 1]
   local lock_key = prefix .. id .. ":lock"
   local exists = redis.call("EXISTS", lock_key)
   if exists == 0 then
@@ -673,7 +669,7 @@ redis.call("DEL", key_lock)
 redis.call("HDEL", key_pending, id)
 redis.call("RPUSH", key_failed, payload)
 `,
-    numberOfKeys: 2
+    numberOfKeys: 3
   }
 )
 
@@ -936,10 +932,12 @@ export const makeStoreSql: (
   const elementIds = new Set<number>()
   const refreshLocks: Effect.Effect<void, SqlError> = Effect.suspend((): Effect.Effect<void, SqlError> => {
     if (elementIds.size === 0) return Effect.void
+    const ids = Array.from(elementIds)
     return sql`
       UPDATE ${tableNameSql}
       SET acquired_at = ${sqlNow}
-      WHERE acquired_by = ${workerIdSql}
+      WHERE sequence IN (${sql.literal(ids.join(","))})
+      AND acquired_by = ${workerIdSql}
     `
   })
   const complete = (sequence: number, attempts: number) => {
@@ -1110,7 +1108,7 @@ export const makeStoreSql: (
           takenLatch.closeUnsafe()
           for (let i = 0; i < results.length; i++) {
             const element = results[i]
-            element.element = JSON.parse(element.element)
+            elementIds.add(element.sequence)
           }
           yield* Queue.offerAll(queue, results)
           yield* takenLatch.await
@@ -1165,7 +1163,11 @@ export const makeStoreSql: (
                   : retry(element.sequence, element.attempts + 1, cause),
               onSuccess: () => complete(element.sequence, element.attempts + 1)
             }))
-          )
+          ),
+          Effect.map((element) => ({
+            ...element,
+            element: JSON.parse(element.element)
+          }))
         )
       )
   })

package/src/unstable/persistence/Redis.ts

@@ -11,8 +11,10 @@
  */
 import * as Cache from "../../Cache.ts"
 import * as Context from "../../Context.ts"
+import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
+import * as Exit from "../../Exit.ts"
 import { constant, identity } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
 import * as Schema from "../../Schema.ts"
@@ -50,10 +52,13 @@ export const make = Effect.fnUntraced(function*(
     readonly send: <A = unknown>(command: string, ...args: ReadonlyArray<string>) => Effect.Effect<A, RedisError>
   }
 ) {
-  const scriptCache = yield* Cache.make({
-    lookup: (script: Script<any>) => options.send<string>("SCRIPT", "LOAD", script.lua),
-    capacity: Number.POSITIVE_INFINITY
-  })
+  const scriptCache = yield* Cache.makeWith(
+    (script: Script<any>) => options.send<string>("SCRIPT", "LOAD", script.lua),
+    {
+      capacity: Number.POSITIVE_INFINITY,
+      timeToLive: (exit) => Exit.isSuccess(exit) ? Duration.infinity : Duration.zero
+    }
+  )
 
   const eval_ = <
     Config extends {

package/src/unstable/reactivity/Atom.ts

@@ -2650,7 +2650,7 @@ export const kvs = <S extends Schema.ConstraintCodec<any, any>, const Mode exten
       },
     (ctx, value: S["Type"]) => {
       ctx.set(setAtom, value as any)
-      ctx.setSelf(value)
+      ctx.setSelf(options.mode === "async" ? AsyncResult.success(value) : value)
     }
   ) as any
 }