alchemy 2.0.0-beta.60 → 2.0.0-beta.62

package/src/Planetscale/OAuthClient.ts

@@ -0,0 +1,307 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import crypto from "node:crypto";
+import http from "node:http";
+import { AUTH_ERROR_URL, AUTH_SUCCESS_URL } from "../Auth/AuthProvider.ts";
+
+export class OAuthError extends Data.TaggedError("OAuthError")<{
+  error: string;
+  errorDescription: string;
+}> {}
+
+export interface OAuthCredentials {
+  type: "oauth";
+  access: string;
+  refresh: string;
+  expires: number;
+  scopes: string[];
+}
+
+export interface Authorization {
+  url: string;
+  state: string;
+}
+
+/**
+ * Registered PlanetScale OAuth application credentials.
+ *
+ * Unlike Cloudflare, PlanetScale OAuth has **no public-client flow** — the
+ * token endpoint requires client authentication for every grant (PKCE is
+ * advertised in their discovery doc but does not lift that requirement), so
+ * exchanging the authorization code (and refreshing the token) requires the
+ * application's `client_secret`. There is no way to keep that secret out of
+ * a distributed CLI, so it ships here: the exposure is the same posture as a
+ * public `client_id` (a stolen refresh token is usable, exactly like
+ * Cloudflare's secret-less refresh), and it can be rotated by cutting a new
+ * release. PlanetScale's own CLI ships its OAuth `client_secret` in source
+ * the same way:
+ * https://github.com/planetscale/cli/blob/main/internal/auth/authenticator.go
+ *
+ * Registered at https://app.planetscale.com with redirect URI
+ * {@link OAUTH_REDIRECT_URI}. Scopes are configured on the application
+ * itself, not requested per-authorization. Rotate by registering a new
+ * secret and cutting a release.
+ */
+export const OAUTH_CLIENT_ID = "pscale_app_aa12e3938baebb788aac443f66e422da";
+export const OAUTH_CLIENT_SECRET =
+  "pscale_app_secret_yyZ3Q8oe99GP9_yA5wrA5er6RuN6Lz9dC66Bj1OJzpg";
+
+export const OAUTH_REDIRECT_URI = "http://localhost:9976/auth/callback";
+export const OAUTH_ENDPOINTS = {
+  // PlanetScale's own .well-known OAuth discovery doc declares this as
+  // the authorization_endpoint — NOT auth.planetscale.com/oauth/authorize
+  // (which their public docs cite). The auth.planetscale.com alias does
+  // render a consent screen but emits codes whose resulting tokens lack
+  // a `sub` claim, so the resource API at api.planetscale.com rejects
+  // them as invalid. Use the canonical endpoint.
+  authorize: "https://app.planetscale.com/oauth/authorize",
+  token: "https://auth.planetscale.com/oauth/token",
+};
+
+function generateState(length = 32): string {
+  return crypto.randomBytes(length).toString("base64url");
+}
+
+function extractCredentials(json: {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+  scope: string;
+}): OAuthCredentials {
+  return {
+    type: "oauth",
+    access: json.access_token,
+    refresh: json.refresh_token,
+    expires: Date.now() + json.expires_in * 1000,
+    scopes: json.scope ? json.scope.split(" ") : [],
+  };
+}
+
+const tokenRequest = (
+  params: Record<string, string>,
+): Effect.Effect<OAuthCredentials, OAuthError> =>
+  Effect.gen(function* () {
+    // PlanetScale's docs show the token endpoint with all parameters in
+    // the query string (https://planetscale.com/docs/api/reference/oauth).
+    // Their .well-known discovery doc advertises client_secret_basic /
+    // client_secret_post instead, but both behave identically to the
+    // query-string form in practice, so we follow the public docs
+    // literally.
+    const url = new URL(OAUTH_ENDPOINTS.token);
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, v);
+    }
+
+    const res = yield* Effect.tryPromise({
+      try: () =>
+        fetch(url.toString(), {
+          method: "POST",
+          headers: { Accept: "application/json" },
+        }),
+      catch: (err) =>
+        new OAuthError({
+          error: "network_error",
+          errorDescription: `Token request failed: ${err}`,
+        }),
+    });
+
+    if (!res.ok) {
+      const json = yield* Effect.tryPromise({
+        try: () =>
+          res.json() as Promise<{ error: string; error_description: string }>,
+        catch: () =>
+          new OAuthError({
+            error: "parse_error",
+            errorDescription: `Token endpoint returned ${res.status}`,
+          }),
+      });
+      return yield* new OAuthError({
+        error: json.error,
+        errorDescription: json.error_description,
+      });
+    }
+
+    const json = yield* Effect.tryPromise({
+      try: () =>
+        res.json() as Promise<{
+          access_token: string;
+          refresh_token: string;
+          expires_in: number;
+          scope: string;
+        }>,
+      catch: () =>
+        new OAuthError({
+          error: "parse_error",
+          errorDescription: "Failed to parse token response",
+        }),
+    });
+    return extractCredentials(json);
+  });
+
+/**
+ * Generate a PlanetScale authorization URL.
+ *
+ * No `scope` parameter is sent: PlanetScale scopes are configured on the
+ * OAuth application itself, not requested per-authorization, so the
+ * consent screen shows whatever the app is registered with.
+ */
+export function authorize(): Authorization {
+  const state = generateState();
+  const url = new URL(OAUTH_ENDPOINTS.authorize);
+  url.searchParams.set("client_id", OAUTH_CLIENT_ID);
+  url.searchParams.set("redirect_uri", OAUTH_REDIRECT_URI);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("state", state);
+  return { url: url.toString(), state };
+}
+
+/**
+ * Exchange an authorization code for OAuth credentials.
+ */
+export const exchange = (
+  code: string,
+): Effect.Effect<OAuthCredentials, OAuthError> =>
+  tokenRequest({
+    grant_type: "authorization_code",
+    code,
+    client_id: OAUTH_CLIENT_ID,
+    client_secret: OAUTH_CLIENT_SECRET,
+    redirect_uri: OAUTH_REDIRECT_URI,
+  });
+
+/**
+ * Refresh expired OAuth credentials.
+ */
+export const refresh = (
+  credentials: OAuthCredentials,
+): Effect.Effect<OAuthCredentials, OAuthError> =>
+  tokenRequest({
+    grant_type: "refresh_token",
+    refresh_token: credentials.refresh,
+    client_id: OAUTH_CLIENT_ID,
+    client_secret: OAUTH_CLIENT_SECRET,
+  });
+
+/**
+ * Start a local HTTP server to listen for the OAuth callback, exchange
+ * the authorization code, and return the credentials.
+ *
+ * Times out after 5 minutes.
+ */
+export const callback = (
+  authorization: Authorization,
+): Effect.Effect<OAuthCredentials, OAuthError> =>
+  Effect.tryPromise({
+    try: () => callbackPromise(authorization),
+    catch: (err) => {
+      if (err instanceof OAuthError) return err;
+      return new OAuthError({
+        error: "callback_error",
+        errorDescription: `OAuth callback failed: ${err}`,
+      });
+    },
+  });
+
+function callbackPromise(
+  authorization: Authorization,
+): Promise<OAuthCredentials> {
+  const { pathname, port } = new URL(OAUTH_REDIRECT_URI);
+
+  return new Promise<OAuthCredentials>((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+
+      if (url.pathname !== pathname) {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return;
+      }
+
+      const error = url.searchParams.get("error");
+      const errorDescription = url.searchParams.get("error_description");
+      if (error) {
+        res.writeHead(302, { Location: AUTH_ERROR_URL });
+        res.end();
+        cleanup();
+        reject(
+          new OAuthError({
+            error,
+            errorDescription: errorDescription ?? "An unknown error occurred.",
+          }),
+        );
+        return;
+      }
+
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      if (!code || !state) {
+        res.writeHead(302, { Location: AUTH_ERROR_URL });
+        res.end();
+        cleanup();
+        reject(
+          new OAuthError({
+            error: "invalid_request",
+            errorDescription: "Missing code or state",
+          }),
+        );
+        return;
+      }
+
+      if (state !== authorization.state) {
+        res.writeHead(302, { Location: AUTH_ERROR_URL });
+        res.end();
+        cleanup();
+        reject(
+          new OAuthError({
+            error: "invalid_request",
+            errorDescription: "Invalid state",
+          }),
+        );
+        return;
+      }
+
+      try {
+        const credentials = await Effect.runPromise(exchange(code));
+        res.writeHead(302, { Location: AUTH_SUCCESS_URL });
+        res.end();
+        cleanup();
+        resolve(credentials);
+      } catch (err) {
+        res.writeHead(302, { Location: AUTH_ERROR_URL });
+        res.end();
+        cleanup();
+        reject(err);
+      }
+    });
+
+    const timeout = setTimeout(
+      () => {
+        cleanup();
+        reject(
+          new OAuthError({
+            error: "timeout",
+            errorDescription: "The authorization process timed out.",
+          }),
+        );
+      },
+      5 * 60 * 1000,
+    );
+
+    function cleanup() {
+      clearTimeout(timeout);
+      server.close();
+    }
+
+    server.on("error", (err) => {
+      cleanup();
+      reject(
+        new OAuthError({
+          error: "server_error",
+          errorDescription: `Failed to start callback server: ${err.message}`,
+        }),
+      );
+    });
+
+    server.listen(Number(port));
+  });
+}

package/src/Planetscale/Postgres/PostgresClusterSize.ts

@@ -60,9 +60,10 @@ export function toPostgresClusterSku(input: {
  * routinely take longer than the default 10-minute polling budget, so
  * give change requests a 60-minute budget (720 × 5s).
  */
-const changeRequestSchedule = Schedule.spaced("5 seconds").pipe(
-  Schedule.both(Schedule.recurs(720)),
-);
+const changeRequestSchedule = Schedule.max([
+  Schedule.spaced("5 seconds"),
+  Schedule.recurs(720),
+]);
 
 /**
  * Polls branch change requests until all visible changes are in a terminal

package/src/Planetscale/Postgres/PostgresMigrations.ts

@@ -203,9 +203,10 @@ const withTemporaryPostgresRole = <A, E, R>(
           // Already-deleted roles are a success: nothing to clean up.
           Effect.catchTag("NotFound", () => Effect.void),
           Effect.retry({
-            schedule: Schedule.exponential("500 millis").pipe(
-              Schedule.both(Schedule.recurs(5)),
-            ),
+            schedule: Schedule.max([
+              Schedule.exponential("500 millis"),
+              Schedule.recurs(5),
+            ]),
           }),
           // Migrations succeeded; don't fail the parent over a release-step
           // hiccup. The role's TTL bounds the orphan window; log loudly so

package/src/Planetscale/Postgres/PostgresRole.ts

@@ -199,8 +199,8 @@ export const PostgresRoleProvider = () =>
       if (newBranch !== oldBranch) {
         return { action: "replace" } as const;
       }
-      const newRoles = resolveInheritedRoles(news.inheritedRoles);
-      const oldRoles = output?.inheritedRoles ?? [];
+      const newRoles = [...resolveInheritedRoles(news.inheritedRoles)].sort();
+      const oldRoles = [...(output?.inheritedRoles ?? [])].sort();
       if (!deepEqual(newRoles, oldRoles)) {
         return { action: "replace" } as const;
       }

package/src/Planetscale/Util.ts

@@ -35,9 +35,10 @@ export class PlanetscaleConflict extends Data.TaggedError(
  * database creates routinely run 10-12 minutes, so a 10-minute budget
  * regularly false-positives as "stuck".
  */
-const defaultSchedule = Schedule.spaced("5 seconds").pipe(
-  Schedule.both(Schedule.recurs(360)),
-);
+const defaultSchedule = Schedule.max([
+  Schedule.spaced("5 seconds"),
+  Schedule.recurs(360),
+]);
 
 /**
  * Generic polling helper that retries until `predicate(value)` returns true

package/src/Platform.ts

@@ -9,13 +9,12 @@ import * as Effectable from "effect/Effectable";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
-import type { Scope } from "effect/Scope";
+import { Scope } from "effect/Scope";
 import type * as Stream from "effect/Stream";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import type { Dependencies } from "./Dependencies.ts";
-import type { ExecutionContext } from "./ExecutionContext.ts";
 import type { HttpEffect } from "./Http.ts";
 import type { InputProps } from "./Input.ts";
 import type { Named, Tag } from "./Named.ts";
@@ -44,6 +43,44 @@ export interface PlatformProps {
   isExternal?: boolean;
 }
 
+/**
+ * Provide the platform class's layer (`cls.make(props, impl)`) with a
+ * lifetime that matches the phase.
+ *
+ * **At runtime** (`__ALCHEMY_RUNTIME__`, folded to `true` in every bundled
+ * artifact) the layer builds against the AMBIENT scope. `Effect.provide` is
+ * implemented with `scopedWith`, so its transient region scope would tear
+ * the layer down — firing init-level finalizers and releasing
+ * `Layer.scoped` services — the moment init completes. The runtime bridges
+ * evaluate the entrypoint under the instance-lifetime build scope (closed
+ * at instance shutdown where the platform offers one — Lambda's SIGTERM
+ * window — and never on workerd), so building against it keeps instance
+ * services alive for the instance.
+ *
+ * **At plan/deploy** it stays `Effect.provide`: the transient region evicts
+ * the layer's memo entry when each `yield*` of the class completes, so
+ * every deploy in a session re-evaluates the resource and re-registers its
+ * Output sources. Building on the session scope would keep the memo alive
+ * across deploys and a second `stack.deploy` would skip source
+ * registration (`MissingSourceError`).
+ */
+const provideClassLayer =
+  <ROut, E2, RIn>(layer: Layer.Layer<ROut, E2, RIn>) =>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E | E2, RIn | Scope | Exclude<R, ROut>> =>
+    (globalThis.__ALCHEMY_RUNTIME__
+      ? Effect.flatMap(Effect.scope, (scope) =>
+          Effect.flatMap(Layer.buildWithScope(layer, scope), (context) =>
+            Effect.provideContext(self, context),
+          ),
+        )
+      : Effect.provide(self, layer)) as Effect.Effect<
+      A,
+      E | E2,
+      RIn | Scope | Exclude<R, ROut>
+    >;
+
 export type Main<InitServices = never> = void | {
   fetch?:
     | HttpEffect<InitServices | PlatformServices | RuntimeContext | Scope>
@@ -98,14 +135,17 @@ export type MakeShape<Shape, BaseShape> = [
   ? Exclude<BaseShape, void | undefined>
   : Exclude<Shape, void | undefined> & Exclude<BaseShape, void | undefined>;
 
-// services provided to the Resource
+// Services provided to the Resource's init/props effects. Deliberately does
+// NOT include `Scope`: init runs once per instance under a build scope that
+// closes at instance shutdown at best (Lambda's SIGTERM window; never on
+// workerd), so init code that needs a scope must not typecheck. Handlers get
+// a fresh per-event `Scope` from the bridge — note the explicit `| Scope` on
+// the handler positions in `Main` / `MainRpc` above.
 export type PlatformServices =
   | NodeServices
-  | ExecutionContext
   | HttpClient
   | Provider<any>
   | ProviderCollectionLike
-  | Scope
   | Stack
   | StackServices
   | Stage;
@@ -324,7 +364,7 @@ export const Platform = <
         );
       return Object.assign(
         function (props: Props, impl: Impl) {
-          return cls.Self.pipe(Effect.provide(cls.make(props, impl)));
+          return cls.Self.pipe(provideClassLayer(cls.make(props, impl)));
         },
         // we splice in the Effect so this can be yielded to indicate a non-Effect native instance
         // e.g. here, we yield it - in this case we don't want to provide an implementation
@@ -345,7 +385,10 @@ export const Platform = <
       // e.g.
       // export default Cloudflare.Worker("id", { main: "./src/worker.ts" }, Effect.gen(function* () { .. })
       const cls = makeClass(id);
-      return cls.Self.pipe(Effect.provide(cls.make(props, impl)), effectClass);
+      return cls.Self.pipe(
+        provideClassLayer(cls.make(props, impl)),
+        effectClass,
+      );
     }
   };
 
@@ -367,6 +410,18 @@ export const Platform = <
               Effect.context<never>(),
             ]),
             Effect.fn(function* ([props, runtimeContext, outerServices]) {
+              // The init effect (`impl`) is evaluated inside an
+              // `Effect.provide(...)` region below, whose implementation
+              // (`scopedWith`) would otherwise shadow the ambient `Scope`
+              // with a transient one that closes the moment init returns.
+              // Pin init's ambient scope to this layer's build scope
+              // instead: under the runtime bridges that scope belongs to
+              // the instance-lifetime build, so init-level finalizers run
+              // at instance shutdown or not at all — never per event
+              // (workerd never closes it; the Lambda entry closes it in the
+              // SIGTERM window). Request-coupled cleanup belongs in
+              // handlers, where the bridge provides a per-event scope.
+              const buildScope = yield* Effect.scope;
               const instance = Object.assign(
                 yield* resource(id, props as any).pipe(
                   Effect.flatMap(
@@ -455,6 +510,18 @@ export const Platform = <
                   ).pipe(
                     Layer.provideMerge(
                       Layer.mergeAll(
+                        // Pin init's ambient `Scope` to this layer's build
+                        // scope. `Effect.provide` (`scopedWith`) would
+                        // otherwise shadow it with a transient scope that
+                        // closes the moment init returns; the build scope
+                        // lives for the instance under the runtime bridges,
+                        // so init-level finalizers run at instance shutdown
+                        // (Lambda's SIGTERM window) or never (workerd) —
+                        // request-coupled cleanup belongs in handlers, where
+                        // the bridge provides a per-event scope. It also
+                        // wins over any `Scope` captured in `outerServices`
+                        // below.
+                        Layer.succeed(Scope, buildScope),
                         Layer.succeed(Platform.Platform, runtimeContext),
                         Layer.succeed(PlatformContext, runtimeContext),
                         Layer.succeed(RuntimeContext, runtimeContext),

package/src/Provider.ts

@@ -102,6 +102,14 @@ export interface ProviderService<
    * @default 0
    */
   version?: number;
+  /**
+   * Legacy type names this provider also answers to. Copied from the
+   * resource class's `aliases` option by {@link succeed}/{@link effect} so
+   * state persisted under a pre-rename type (e.g. `"Cloudflare.Queue"`
+   * before the `"Cloudflare.Queues.Queue"` rename) still resolves to this
+   * provider via {@link tryFindProviderByType}.
+   */
+  aliases?: readonly string[];
   /**
    * Account-wide teardown (`alchemy unsafe nuke`) behaviour. Providers whose
    * resources can't meaningfully be deleted opt out here so nuke doesn't
@@ -148,6 +156,11 @@ export interface ProviderService<
    */
   tail?(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     instanceId: string;
     props: Props<Res>;
     output: Res["Attributes"];
@@ -158,6 +171,11 @@ export interface ProviderService<
    */
   logs?(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     instanceId: string;
     props: Props<Res>;
     output: Res["Attributes"];
@@ -170,6 +188,11 @@ export interface ProviderService<
   // branch?() {}
   read?(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     instanceId: string;
     olds: Props<Res>;
     // what is the ARN?
@@ -181,6 +204,11 @@ export interface ProviderService<
   stables?: Extract<keyof Res["Attributes"], string>[];
   diff?(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     instanceId: string;
     olds: Props<Res>;
     // Note: we do not resolve (Res["Props"]) here because diff runs during plan
@@ -193,6 +221,11 @@ export interface ProviderService<
   // dev?:() => Effect.Effect<void, any, DevReq>;
   precreate?(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     news: Props<Res>;
     instanceId: string;
     session: ScopedPlanStatusSession;
@@ -222,6 +255,11 @@ export interface ProviderService<
    */
   reconcile(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     instanceId: string;
     news: Props<Res>;
     olds: Props<Res> | undefined;
@@ -231,6 +269,11 @@ export interface ProviderService<
   }): Effect.Effect<Res["Attributes"], any, ReconcileReq>;
   delete(input: {
     id: string;
+    /**
+     * Fully-qualified name (namespace path + logical id, see `./FQN.ts`) —
+     * globally unique, so providers can stamp ownership metadata on cloud objects.
+     */
+    fqn: string;
     instanceId: string;
     olds: Props<Res>;
     output: Res["Attributes"];
@@ -275,8 +318,14 @@ export const effect = <
     LifecycleServices
   >
 > =>
-  // @ts-expect-error
-  Layer.effect(Provider(cls.Type), eff) as any;
+  Layer.effect(
+    // @ts-expect-error
+    Provider(cls.Type),
+    Effect.map(eff, (service) => ({
+      aliases: "Aliases" in cls ? cls.Aliases : undefined,
+      ...service,
+    })),
+  ) as any;
 
 export const succeed = <
   R extends ResourceLike,
@@ -310,7 +359,10 @@ export const succeed = <
   >
 > =>
   // @ts-expect-error
-  Layer.succeed(Provider(cls.Type), service);
+  Layer.succeed(Provider(cls.Type), {
+    aliases: "Aliases" in cls ? cls.Aliases : undefined,
+    ...service,
+  });
 
 export interface ProviderCollectionLike {
   kind: "ProviderCollection";
@@ -398,6 +450,20 @@ const isProviderCollectionService = (
   );
 };
 
+/**
+ * Structural check for a {@link ProviderService} living in the Effect
+ * context. Providers are keyed by their canonical resource type; when
+ * searching for a legacy alias, the tag key won't match, so lookup has to
+ * recognize provider services by shape.
+ */
+const isProviderService = (value: unknown): value is ProviderService =>
+  typeof value === "object" &&
+  value !== null &&
+  "reconcile" in value &&
+  typeof (value as ProviderService).reconcile === "function" &&
+  "delete" in value &&
+  typeof (value as ProviderService).delete === "function";
+
 export const findProviderByType: {
   <R extends ResourceLike>(
     resourceType: R["Type"],
@@ -448,5 +514,24 @@ export const tryFindProviderByType: {
       }
     }
   }
+
+  // State persisted before a type rename carries the legacy name, so no
+  // provider is keyed under it. Fall back to a provider that declares the
+  // name in its `aliases` — scanning both bare Provider layers and the
+  // members of every ProviderCollection.
+  for (const value of context.mapUnsafe.values()) {
+    if (isProviderCollectionService(value)) {
+      for (const provider of Object.values(value.providers)) {
+        if (provider.aliases?.includes(resourceType)) {
+          return Option.some(provider);
+        }
+      }
+    } else if (
+      isProviderService(value) &&
+      value.aliases?.includes(resourceType)
+    ) {
+      return Option.some(value);
+    }
+  }
   return Option.none();
 }) as any;