sst 2.0.0-rc.9 → 2.0.1

package/cli/ui/deploy.js

@@ -3,66 +3,39 @@ import { Box, Text } from "ink";
 import { useBus } from "../../bus.js";
 import { Stacks } from "../../stacks/index.js";
 import inkSpinner from "ink-spinner";
-import { useProject } from "../../app.js";
-import { blue, bold, green, red } from "colorette";
+import { Colors } from "../colors.js";
+import { useProject } from "../../project.js";
 // @ts-ignore
 const { default: Spinner } = inkSpinner;
-const FullScreen = (props) => {
-    const [size, setSize] = useState({
-        columns: process.stdout.columns,
-        rows: process.stdout.rows,
-    });
-    useEffect(() => {
-        function onResize() {
-            setSize({
-                columns: process.stdout.columns,
-                rows: process.stdout.rows,
-            });
-        }
-        process.stdout.on("resize", onResize);
-        return () => {
-            process.stdout.off("resize", onResize);
-        };
-    }, []);
-    return (React.createElement(Box, { width: size.columns, height: size.rows, flexDirection: "column" }, props.children));
-};
 export const DeploymentUI = (props) => {
-    const [stacks, setStacks] = useState(Object.fromEntries(props.stacks.map((s) => [s, ""])));
     const [resources, setResources] = useState({});
     useEffect(() => {
+        Colors.gap();
         const bus = useBus();
-        const update = bus.subscribe("stack.updated", (payload) => {
-            setStacks((prev) => ({
-                ...prev,
-                [payload.properties.stackID]: "",
-            }));
-        });
-        const status = bus.subscribe("stack.status", (payload) => {
-            setStacks((prev) => ({
-                ...prev,
-                [payload.properties.stackID]: payload.properties.status,
-            }));
-        });
-        const resourcesSub = bus.subscribe("stack.resources", (payload) => {
+        const event = bus.subscribe("stack.event", (payload) => {
+            const { event } = payload.properties;
+            // if (event.ResourceType === "AWS::CloudFormation::Stack") return;
             setResources((previous) => {
-                const existing = previous[payload.properties.stackID] || [];
-                const filtered = (payload.properties.resources || []).filter((r) => {
-                    if (existing.some((p) => p.LogicalResourceId === r.LogicalResourceId))
-                        return true;
-                    if (!Stacks.isFinal(r.ResourceStatus))
-                        return true;
-                    return false;
-                });
+                if (Stacks.isFinal(event.ResourceStatus)) {
+                    const readable = logicalIdToCdkPath(props.assembly, event.StackName, event.LogicalResourceId);
+                    Colors.line(Colors.warning(Colors.prefix), readable
+                        ? Colors.dim(`${stackNameToId(event.StackName)} ${readable} ${event.ResourceType}`)
+                        : Colors.dim(`${stackNameToId(event.StackName)} ${event.ResourceType}`), Stacks.isFailed(event.ResourceStatus)
+                        ? Colors.danger(event.ResourceStatus)
+                        : Colors.dim(event.ResourceStatus), Stacks.isFailed(event.ResourceStatus) && event.ResourceStatusReason
+                        ? event.ResourceStatusReason
+                        : "");
+                    const { [event.LogicalResourceId]: _, ...next } = previous;
+                    return next;
+                }
                 return {
                     ...previous,
-                    [payload.properties.stackID]: filtered,
+                    [payload.properties.event.LogicalResourceId]: payload.properties.event,
                 };
             });
         });
         return () => {
-            bus.unsubscribe(resourcesSub);
-            bus.unsubscribe(update);
-            bus.unsubscribe(status);
+            bus.unsubscribe(event);
         };
     }, []);
     function color(status) {
@@ -72,71 +45,98 @@ export const DeploymentUI = (props) => {
             return "green";
         return "yellow";
     }
-    return (React.createElement(FullScreen, null,
-        React.createElement(Text, null,
-            "Deploying ",
-            React.createElement(Text, { color: "bold" }, props.stacks.length),
-            " stacks for stage ",
-            React.createElement(Text, { color: "blue" }, useProject().stage)),
-        Object.entries(stacks).map(([stackID, status]) => {
-            return (React.createElement(React.Fragment, { key: stackID },
+    return (React.createElement(Box, { flexDirection: "column" },
+        Object.entries(resources)
+            .slice(0, process.stdout.rows - 2)
+            .map(([_, evt], index) => {
+            const readable = logicalIdToCdkPath(props.assembly, evt.StackName, evt.LogicalResourceId);
+            return (React.createElement(Box, { key: index },
                 React.createElement(Text, null,
-                    !Stacks.isFinal(status) && React.createElement(Spinner, null),
-                    Stacks.isSuccess(status) && React.createElement(Text, { color: color(status) }, "\u2714"),
-                    Stacks.isFailed(status) && React.createElement(Text, { color: color(status) }, "\u2716"),
-                    React.createElement(Text, null, " " + stackID),
-                    status && React.createElement(Text, { color: color(status) },
-                        " ",
-                        status)),
-                resources[stackID]?.map((resource) => (React.createElement(Box, { key: resource.LogicalResourceId },
-                    React.createElement(Text, null,
-                        "  ",
-                        !Stacks.isFinal(resource.ResourceStatus || "") && (React.createElement(Spinner, null)),
-                        Stacks.isSuccess(resource.ResourceStatus || "") && (React.createElement(Text, { color: "green" }, "\u2714")),
-                        Stacks.isFailed(resource.ResourceStatus || "") && (React.createElement(Text, { color: "red" }, "\u2716")),
-                        " ",
-                        resource.ResourceType,
-                        " ",
-                        resource.LogicalResourceId,
-                        " ",
-                        resource.ResourceStatusReason,
-                        " "),
-                    React.createElement(Text, { color: color(resource.ResourceStatus || "") }, resource.ResourceStatus))))));
-        })));
+                    React.createElement(Spinner, null),
+                    "  ",
+                    readable
+                        ? `${stackNameToId(evt.StackName)} ${readable} ${evt.ResourceType}`
+                        : `${stackNameToId(evt.StackName)} ${evt.ResourceType}`,
+                    " "),
+                React.createElement(Text, { color: color(evt.ResourceStatus || "") }, evt.ResourceStatus)));
+        }),
+        Object.entries(resources).length === 0 && (React.createElement(Box, null,
+            React.createElement(Text, null,
+                React.createElement(Spinner, null),
+                "  ",
+                React.createElement(Text, { dimColor: true }, "Deploying..."))))));
 };
-export function printDeploymentResults(results) {
-    console.log();
-    console.log(`----------------------------`);
-    console.log(`| Stack deployment results |`);
-    console.log(`----------------------------`);
-    for (const [stack, result] of Object.entries(results)) {
-        const icon = (() => {
-            if (Stacks.isSuccess(result.status))
-                return green("✔");
-            if (Stacks.isFailed(result.status))
-                return red("✖");
-        })();
-        console.log(`${icon} ${stack}`);
-        const outputs = Object.entries(result.outputs).filter(([key, _]) => {
-            if (key.startsWith("Export"))
-                return false;
-            if (key.includes("SstSiteEnv"))
-                return false;
-            return true;
-        });
-        if (outputs.length > 0) {
-            console.log(`  ${blue("Outputs:")}`);
-            for (const key of Object.keys(Object.fromEntries(outputs)).sort()) {
-                const value = result.outputs[key];
-                console.log(bold(`    ${key}: ${value}`));
+export function printDeploymentResults(assembly, results, remove) {
+    // Print success stacks
+    const success = Object.entries(results).filter(([_stack, result]) => Stacks.isSuccess(result.status));
+    if (success.length) {
+        Colors.gap();
+        Colors.line(Colors.success(`✔`), Colors.bold(remove ? `  Removed:` : ` Deployed:`));
+        for (const [stack, result] of success) {
+            const outputs = Object.entries(result.outputs).filter(([key, _]) => !key.includes("SstSiteEnv"));
+            Colors.line(`   ${Colors.dim(stackNameToId(stack))}`);
+            if (outputs.length > 0) {
+                for (const key of Object.keys(Object.fromEntries(outputs)).sort()) {
+                    const value = result.outputs[key];
+                    Colors.line(`   ${Colors.bold.dim(key + ":")} ${value}`);
+                }
             }
         }
-        if (Object.entries(result.errors).length > 0) {
-            console.log(`  ${red("Errors:")}`);
+        Colors.gap();
+    }
+    // Print failed stacks
+    const failed = Object.entries(results).filter(([_stack, result]) => Stacks.isFailed(result.status));
+    if (failed.length) {
+        Colors.gap();
+        Colors.line(`${Colors.danger(`✖`)}  ${Colors.bold.dim(`Errors`)}`);
+        for (const [stack, result] of failed) {
+            Colors.line(`   ${Colors.dim(stackNameToId(stack))} ${Colors.dim(result.status)}`);
             for (const [id, error] of Object.entries(result.errors)) {
-                console.log(bold(`    ${id}: ${error}`));
+                const readable = logicalIdToCdkPath(assembly, stack, id) || id;
+                Colors.line(`   ${Colors.danger.bold(readable + ":")} ${error}`);
+                const helper = getHelper(error);
+                if (helper) {
+                    Colors.line(`   ${Colors.warning.bold("⮑  Hint:")} ${helper}`);
+                }
             }
         }
+        Colors.gap();
+    }
+}
+function stackNameToId(stack) {
+    const project = useProject();
+    const prefix = `${project.config.stage}-${project.config.name}-`;
+    return stack.startsWith(prefix) ? stack.substring(prefix.length) : stack;
+}
+function logicalIdToCdkPath(assembly, stack, logicalId) {
+    const found = Object.entries(assembly.manifest.artifacts?.[stack].metadata || {}).find(([_key, value]) => value[0]?.type === "aws:cdk:logicalId" && value[0]?.data === logicalId)?.[0];
+    if (!found) {
+        return;
+    }
+    return found.split("/").filter(Boolean).slice(1, -1).join("/");
+}
+function getHelper(error) {
+    return (getApiAccessLogPermissionsHelper(error) ||
+        getAppSyncMultiResolverHelper(error) ||
+        getApiLogRoleHelper(error));
+}
+function getApiAccessLogPermissionsHelper(error) {
+    // Can run into this issue when enabling access logs for API Gateway
+    // note: this should be handled in SST as access log group names are now
+    //       hardcoded with /aws/vendedlogs/apis prefix.
+    if (error.indexOf("Insufficient permissions to enable logging") > -1) {
+        return `This is a common deploy error. Check out this GitHub issue for more details - https://github.com/serverless-stack/sst/issues/125`;
+    }
+}
+function getAppSyncMultiResolverHelper(error) {
+    // Can run into this issue when updating an AppSyncApi resolver
+    if (error.indexOf("Only one resolver is allowed per field. (Service: AWSAppSync") > -1) {
+        return `This is a common error for deploying AppSync APIs. Check out this GitHub issue for more details - https://github.com/aws/aws-cdk/issues/13269`;
+    }
+}
+function getApiLogRoleHelper(error) {
+    // Can run into this issue when enabling access logs for WebSocketApi
+    if (error.indexOf("CloudWatch Logs role ARN must be set in account settings to enable logging (Service: AmazonApiGatewayV2") > -1) {
+        return `This is a common error when configuring Access Log for WebSocket APIs. The AWS API Gateway service in your AWS account does not have permissions to the CloudWatch logs service. Follow this article to create an IAM role for logging to CloudWatch - https://aws.amazon.com/premiumsupport/knowledge-center/api-gateway-cloudwatch-logs/`;
     }
-    console.log();
 }

package/cli/ui/functions.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" resolution-mode="require"/>
+export declare function Functions(): JSX.Element;

package/cli/ui/functions.js

@@ -0,0 +1,132 @@
+import { dim } from "colorette";
+import { Text } from "ink";
+import inkSpinner from "ink-spinner";
+import React, { useEffect, useState } from "react";
+import { useBus } from "../../bus.js";
+import { useFunctions } from "../../constructs/Function.js";
+import { Colors } from "../colors.js";
+// @ts-ignore
+const { default: Spinner } = inkSpinner;
+export function Functions() {
+    const [functions, setFunctions] = useState({});
+    useEffect(() => {
+        const bus = useBus();
+        const invoke = bus.subscribe("function.invoked", (evt) => {
+            setFunctions((functions) => {
+                setTimeout(() => {
+                    setFunctions((functions) => {
+                        const existing = functions[evt.properties.requestID];
+                        if (!existing)
+                            return functions;
+                        return { ...functions };
+                    });
+                }, 500);
+                return {
+                    ...functions,
+                    [evt.properties.requestID]: {
+                        requestID: evt.properties.requestID,
+                        functionID: evt.properties.functionID,
+                        started: Date.now(),
+                        logs: [],
+                    },
+                };
+            });
+        });
+        const stdout = bus.subscribe("worker.stdout", (evt) => {
+            setFunctions((functions) => {
+                const existing = functions[evt.properties.requestID];
+                if (!existing)
+                    return functions;
+                return {
+                    ...functions,
+                    [evt.properties.requestID]: {
+                        ...existing,
+                        logs: [...existing.logs, evt.properties.message],
+                    },
+                };
+            });
+        });
+        // This is all ugly but the timeouts are for UI smootheness
+        const success = bus.subscribe("function.success", (evt) => {
+            function print(input, diff) {
+                setTimeout(() => {
+                    console.log(Colors.primary(`  ➜ `), useFunctions().fromID(input.functionID).handler);
+                    for (const log of input.logs) {
+                        console.log(`     ${dim(log)}`);
+                    }
+                    console.log(`     ${dim(`Done in ${diff}ms`)}`);
+                    console.log();
+                }, diff > 500 ? 60 : 0);
+            }
+            setFunctions((functions) => {
+                const { [evt.properties.requestID]: existing, ...next } = functions;
+                if (!existing)
+                    return functions;
+                const diff = Date.now() - existing.started;
+                if (diff > 500 && diff < 1500) {
+                    setTimeout(() => {
+                        setFunctions((functions) => {
+                            const { [evt.properties.requestID]: existing, ...next } = functions;
+                            print(existing, diff);
+                            return next;
+                        });
+                    }, 1500 - diff);
+                    return functions;
+                }
+                print(existing, diff);
+                return next;
+            });
+        });
+        const error = bus.subscribe("function.error", (evt) => {
+            function print(input, diff) {
+                setTimeout(() => {
+                    console.log(Colors.primary(`  ➜ `), useFunctions().fromID(input.functionID).handler);
+                    for (const log of input.logs) {
+                        console.log(`     ${dim(log)}`);
+                    }
+                    console.log(`     ${Colors.danger(evt.properties.errorMessage)}`);
+                    for (const line of evt.properties.trace || []) {
+                        console.log(`     ${dim(line)}`);
+                    }
+                    console.log();
+                }, diff > 500 ? 60 : 0);
+            }
+            setFunctions((functions) => {
+                const { [evt.properties.requestID]: existing, ...next } = functions;
+                if (!existing)
+                    return functions;
+                const diff = Date.now() - existing.started;
+                if (diff > 500 && diff < 1500) {
+                    setTimeout(() => {
+                        setFunctions((functions) => {
+                            const { [evt.properties.requestID]: existing, ...next } = functions;
+                            print(existing, diff);
+                            return next;
+                        });
+                    }, 1500 - diff);
+                    return functions;
+                }
+                print(existing, diff);
+                return next;
+            });
+        });
+        return () => {
+            bus.unsubscribe(invoke);
+            bus.unsubscribe(success);
+            bus.unsubscribe(error);
+            bus.unsubscribe(stdout);
+        };
+    }, []);
+    return (React.createElement(React.Fragment, null, Object.values(functions)
+        .filter((f) => Date.now() - f.started >= 500)
+        .map((evt) => (React.createElement(React.Fragment, { key: evt.requestID },
+        React.createElement(Text, null,
+            "  ",
+            React.createElement(Spinner, null),
+            "  ",
+            useFunctions().fromID(evt.functionID).handler),
+        evt.logs.map((log, index) => (React.createElement(Text, { dimColor: true, key: index },
+            "     ",
+            log))),
+        React.createElement(Text, null, " "))))));
+}

package/cli/ui/header.d.ts

@@ -0,0 +1,5 @@
+export declare function printHeader(input: {
+    console?: boolean;
+    hint?: string;
+}): Promise<void>;
+export declare function printConsole(): void;

package/cli/ui/header.js

@@ -0,0 +1,16 @@
+import { useProject } from "../../project.js";
+import { Colors } from "../colors.js";
+import { useLocalServerConfig } from "../local/server.js";
+export async function printHeader(input) {
+    const project = useProject();
+    Colors.line(`${Colors.primary.bold(`SST v${project.version}`)}  ${input.hint ? Colors.dim(`ready!`) : ""}`);
+    Colors.gap();
+    Colors.line(`${Colors.primary(`➜`)}  ${Colors.bold("App:")}     ${project.config.name}`);
+    Colors.line(`${Colors.primary(` `)}  ${Colors.bold("Stage:")}   ${project.config.stage}`);
+    if (input.console) {
+        const local = await useLocalServerConfig();
+        Colors.line(`${Colors.primary(` `)}  ${Colors.bold("Console:")} ${Colors.link(local.url)}`);
+    }
+    Colors.gap();
+}
+export function printConsole() { }

package/cli/ui/stack.d.ts

@@ -0,0 +1 @@
+export declare function stackNameToId(stack: string): string;

package/cli/ui/stack.js

@@ -0,0 +1,6 @@
+import { useProject } from "../../project.js";
+export function stackNameToId(stack) {
+    const project = useProject();
+    const prefix = `${project.config.stage}-${project.config.name}-`;
+    return stack.startsWith(prefix) ? stack.substring(prefix.length) : stack;
+}

package/config.d.ts

@@ -6,7 +6,7 @@ export declare namespace Config {
     function parameters(): Promise<({
         type: string;
         id: string;
-        prop: string[];
+        prop: string;
     } & {
         value: string;
     })[]>;

package/config.js

@@ -1,7 +1,7 @@
 import { DeleteParameterCommand, GetParameterCommand, GetParametersByPathCommand, PutParameterCommand, SSMClient, } from "@aws-sdk/client-ssm";
 import { GetFunctionConfigurationCommand, LambdaClient, UpdateFunctionConfigurationCommand, } from "@aws-sdk/client-lambda";
 import { pipe, map } from "remeda";
-import { useProject } from "./app.js";
+import { useProject } from "./project.js";
 import { useAWSClient } from "./credentials.js";
 import { Stacks } from "./stacks/index.js";
 export var Config;
@@ -30,7 +30,7 @@ export var Config;
     }
     Config.parameters = parameters;
     function envFor(input) {
-        return `SST_${input.type}_${input.prop}_${input.id}`;
+        return `SST_${input.type}_${input.prop}_${normalizeID(input.id)}`;
     }
     Config.envFor = envFor;
     function pathFor(input) {
@@ -62,9 +62,9 @@ export var Config;
         const project = useProject();
         const parameters = await Config.parameters();
         const env = {
-            SST_APP: project.name,
-            SST_STAGE: project.stage,
-            ...pipe(parameters, map((p) => [`SST_${p.type}_${p.prop}_${p.id}`, p.value]), Object.fromEntries),
+            SST_APP: project.config.name,
+            SST_STAGE: project.config.stage,
+            ...pipe(parameters, map((p) => [envFor(p), p.value]), Object.fromEntries),
         };
         return env;
     }
@@ -156,11 +156,11 @@ const SECRET_UPDATED_AT_ENV = "SST_ADMIN_SECRET_UPDATED_AT";
 const PREFIX = {
     get STAGE() {
         const project = useProject();
-        return `/sst/${project.name}/${project.stage}/`;
+        return `/sst/${project.config.name}/${project.config.stage}/`;
     },
     get FALLBACK() {
         const project = useProject();
-        return `/sst/${project.name}/${FALLBACK_STAGE}/`;
+        return `/sst/${project.config.name}/${FALLBACK_STAGE}/`;
     },
 };
 function parse(ssmName) {
@@ -168,6 +168,6 @@ function parse(ssmName) {
     return {
         type: parts[4],
         id: parts[5],
-        prop: parts.slice(6),
+        prop: parts.slice(6).join("/"),
     };
 }

package/constructs/Api.d.ts

@@ -14,8 +14,8 @@ import * as apigV2Cors from "./util/apiGatewayV2Cors.js";
 import * as apigV2Domain from "./util/apiGatewayV2Domain.js";
 import * as apigV2AccessLog from "./util/apiGatewayV2AccessLog.js";
 declare const PayloadFormatVersions: readonly ["1.0", "2.0"];
-export declare type ApiPayloadFormatVersion = typeof PayloadFormatVersions[number];
-export declare type ApiAuthorizer = ApiUserPoolAuthorizer | ApiJwtAuthorizer | ApiLambdaAuthorizer;
+export type ApiPayloadFormatVersion = (typeof PayloadFormatVersions)[number];
+export type ApiAuthorizer = ApiUserPoolAuthorizer | ApiJwtAuthorizer | ApiLambdaAuthorizer;
 interface ApiBaseAuthorizer {
     /**
      * The name of the authorizer.
@@ -393,7 +393,7 @@ export interface ApiProps<Authorizers extends Record<string, ApiAuthorizer> = Re
         httpStages?: Omit<apig.HttpStageProps, "httpApi">[];
     };
 }
-export declare type ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition | ApiFunctionRouteProps<AuthorizerKeys> | ApiHttpRouteProps<AuthorizerKeys> | ApiAlbRouteProps<AuthorizerKeys> | ApiGraphQLRouteProps<AuthorizerKeys> | ApiPothosRouteProps<AuthorizerKeys>;
+export type ApiRouteProps<AuthorizerKeys> = FunctionInlineDefinition | ApiFunctionRouteProps<AuthorizerKeys> | ApiHttpRouteProps<AuthorizerKeys> | ApiAlbRouteProps<AuthorizerKeys> | ApiGraphQLRouteProps<AuthorizerKeys>;
 interface ApiBaseRouteProps<AuthorizerKeys = string> {
     authorizer?: "none" | "iam" | (string extends AuthorizerKeys ? Omit<AuthorizerKeys, "none" | "iam"> : AuthorizerKeys);
     authorizationScopes?: string[];
@@ -485,63 +485,6 @@ export interface ApiAlbRouteProps<AuthorizersKeys> extends ApiBaseRouteProps<Aut
         integration?: apigIntegrations.HttpAlbIntegrationProps;
     };
 }
-/**
- * Specify a route handler that handles GraphQL queries using Pothos
- * @deprecated "pothos" routes are deprecated for the Api construct, and will be removed in SST v2. Use "graphql" routes instead. Read more about how to upgrade here — https://docs.sst.dev/upgrade-guide#upgrade-to-v118
- * @example
- * ```js
- * // Change
- * api.addRoutes(stack, {
- *   "POST /graphql": {
- *     type: "pothos",
- *     function: {
- *       handler: "functions/graphql/graphql.ts",
- *     },
- *     schema: "backend/functions/graphql/schema.ts",
- *     output: "graphql/schema.graphql",
- *     commands: [
- *       "./genql graphql/graphql.schema graphql/
- *     ]
- *   }
- * })
- *
- * // To
- * api.addRoutes(stack, {
- *   "POST /graphql": {
- *     type: "graphql",
- *     function: {
- *       handler: "functions/graphql/graphql.ts",
- *     },
- *     pothos: {
- *       schema: "backend/functions/graphql/schema.ts",
- *       output: "graphql/schema.graphql",
- *       commands: [
- *         "./genql graphql/graphql.schema graphql/
- *       ]
- *     }
- *   }
- * })
- * ```
- */
-export interface ApiPothosRouteProps<AuthorizerKeys> extends ApiBaseRouteProps<AuthorizerKeys> {
-    type: "pothos";
-    /**
-     * The function definition used to create the function for this route. Must be a graphql handler
-     */
-    function: FunctionDefinition;
-    /**
-     * Path to pothos schema
-     */
-    schema?: string;
-    /**
-     * File to write graphql schema to
-     */
-    output?: string;
-    /**
-     * Commands to run after generating schema. Useful for code generation steps
-     */
-    commands?: string[];
-}
 /**
  * Specify a route handler that handles GraphQL queries using Pothos
  *
@@ -752,16 +695,6 @@ export declare class Api<Authorizers extends Record<string, ApiAuthorizer> = Rec
                 schema?: undefined;
                 output?: undefined;
                 commands?: undefined;
-            } | {
-                type: "pothos";
-                route: string;
-                fn: {
-                    node: string;
-                    stack: string;
-                } | undefined;
-                schema: string | undefined;
-                output: string | undefined;
-                commands: string[] | undefined;
             } | {
                 type: "graphql";
                 route: string;
@@ -798,7 +731,6 @@ export declare class Api<Authorizers extends Record<string, ApiAuthorizer> = Rec
     private addRoute;
     private createHttpIntegration;
     private createAlbIntegration;
-    protected createPothosIntegration(scope: Construct, routeKey: string, routeProps: ApiPothosRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
     protected createGraphQLIntegration(scope: Construct, routeKey: string, routeProps: ApiGraphQLRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
     protected createCdkFunctionIntegration(scope: Construct, routeKey: string, routeProps: ApiFunctionRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;
     protected createFunctionIntegration(scope: Construct, routeKey: string, routeProps: ApiFunctionRouteProps<keyof Authorizers>, postfixName: string): apig.HttpRouteIntegration;