`scope="request"`(기본값)로 의존성을 선언하면, 모든 하위 의존성도 `scope`가 `"request"`여야 합니다.

하지만 `scope`가 `"function"`인 의존성은 `scope`가 `"function"`인 의존성과 `"request"`인 의존성을 모두 의존성으로 가질 수 있습니다.

이는 어떤 의존성이든, 종료 코드에서 하위 의존성을 계속 사용해야 할 수도 있으므로, 하위 의존성보다 먼저 종료 코드를 실행할 수 있어야 하기 때문입니다.

```mermaid
sequenceDiagram

participant client as Client
participant dep_req as Dep scope="request"
participant dep_func as Dep scope="function"

                )
            return message

        return inner

    async def __call__(self, scope, receive, send):
        if scope["type"] != "http" or self.max_content_size is None:
            await self.app(scope, receive, send)
            return

        wrapper = self.receive_wrapper(receive)
        await self.app(scope, wrapper, send)


@router.post("/middleware")

      <artifactId>a</artifactId>
      <version>0.2</version>
      <scope>system</scope>
      <systemPath>should-use-variables-and-not-hard-code-this-path</systemPath>
    </dependency>
    <dependency>
      <groupId>test</groupId>
      <artifactId>b</artifactId>
      <version>0.1</version>
      <scope>system</scope>
      <systemPath>${java.home}/lib/good.jar</systemPath>
    </dependency>
  </dependencies>

        return datum;
    }

    public void setDatum(Object datum) {
        this.datum = datum;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

    @Override
    public String toString() {
        return getGroupId() + ":" + getArtifactId() + ":" + getVersion() + ":"

The spec also states that the `username` and `password` must be sent as form data (so, no JSON here).

### `scope` { #scope }

The spec also says that the client can send another form field "`scope`".

The form field name is `scope` (in singular), but it is actually a long string with "scopes" separated by spaces.

Each "scope" is just a string (without spaces).

They are normally used to declare specific security permissions, for example:

  <dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-api-core</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

    // ------------------------------------------------------------------------
    public MetadataTreeNode(ArtifactMetadata md, MetadataTreeNode parent, boolean resolved, ArtifactScopeEnum scope) {
        if (md != null) {
            md.setArtifactScope(ArtifactScopeEnum.checkScope(scope));
            md.setResolved(resolved);
        }

        this.md = md;
        this.parent = parent;
    }

* `"request"`：在處理請求的路徑操作函式之前啟動相依（與使用 `"function"` 類似），但在回應送回用戶端之後才結束相依。所以，相依函式會在整個**請求**與回應循環的「周圍」執行。

如果未指定且相依使用了 `yield`，則預設 `scope` 為 `"request"`。

### 子相依的 `scope` { #scope-for-sub-dependencies }

當你宣告一個 `scope="request"`（預設值）的相依時，任何子相依也需要有 `"request"` 的 `scope`。

但一個 `scope` 為 `"function"` 的相依，可以擁有 `scope` 為 `"function"` 或 `"request"` 的子相依。

這是因為任何相依都需要能在子相依之前執行其結束程式碼，因為它可能在結束程式碼中仍需要使用那些子相依。

```mermaid
sequenceDiagram

                xml.append("            <version>").append(dependency.version).append("</version>\n");
                if (dependency.scope != null) {
                    xml.append("            <scope>").append(dependency.scope).append("</scope>\n");
                }
                xml.append("        </dependency>\n");
            }
            xml.append("    </dependencies>\n");
        }

 */
@Experimental
@Immutable
@SuppressWarnings("checkstyle:InterfaceIsType")
public interface ProjectScope extends ExtensibleEnum {

    /**
     * Main scope.
     */
    ProjectScope MAIN = projectScope("main");

    /**
     * Test scope.
     */
    ProjectScope TEST = projectScope("test");