@liflig/cdk 3.0.22 → 3.1.1

package/lib/api-gateway/authorizer-lambdas/basic-auth-authorizer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This lambda verifies authorization header against static basic auth credentials saved in Secret
+ * Manager.
+ *
+ * Expects the following environment variables:
+ * - CREDENTIALS_SECRET_NAME
+ *   - Secret value should follow this format: `{"username":"<username>","password":"<password>"}`
+ */
+import type { APIGatewayRequestAuthorizerEventV2, APIGatewaySimpleAuthorizerResult } from "aws-lambda";
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+export declare const handler: (event: APIGatewayRequestAuthorizerEventV2) => Promise<APIGatewaySimpleAuthorizerResult>;
+/** For overriding dependency creation in tests. */
+export declare const dependencies: {
+    createSecretsManager: () => SecretsManager;
+};

package/lib/api-gateway/authorizer-lambdas/basic-auth-authorizer.js

@@ -0,0 +1,61 @@
+/**
+ * This lambda verifies authorization header against static basic auth credentials saved in Secret
+ * Manager.
+ *
+ * Expects the following environment variables:
+ * - CREDENTIALS_SECRET_NAME
+ *   - Secret value should follow this format: `{"username":"<username>","password":"<password>"}`
+ */
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+export const handler = async (event) => {
+    const authHeader = event.headers?.authorization;
+    if (!authHeader || !authHeader.startsWith("Basic ")) {
+        return { isAuthorized: false };
+    }
+    const expectedAuthHeader = await getExpectedAuthHeader();
+    return { isAuthorized: authHeader === expectedAuthHeader };
+};
+/** Cache this value, so that subsequent lambda invocations don't have to refetch. */
+let cachedAuthHeader = undefined;
+async function getExpectedAuthHeader() {
+    if (cachedAuthHeader === undefined) {
+        const secretName = process.env["CREDENTIALS_SECRET_NAME"];
+        if (!secretName) {
+            console.error("CREDENTIALS_SECRET_NAME env variable is not defined");
+            throw new Error();
+        }
+        cachedAuthHeader = await getSecretAsBasicAuthHeader(secretName);
+    }
+    return cachedAuthHeader;
+}
+async function getSecretAsBasicAuthHeader(secretName) {
+    const credentials = await getSecretValue(secretName);
+    if (!secretHasExpectedFormat(credentials)) {
+        console.error(`Basic auth credentials secret did not follow expected format (secret name: '${secretName}')`);
+        throw new Error();
+    }
+    return ("Basic " +
+        Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64"));
+}
+/** For overriding dependency creation in tests. */
+export const dependencies = {
+    createSecretsManager: () => new SecretsManager(),
+};
+async function getSecretValue(secretName) {
+    const client = dependencies.createSecretsManager();
+    const secret = await client.getSecretValue({ SecretId: secretName });
+    if (!secret.SecretString) {
+        console.error(`Secret value not found for '${secretName}'`);
+        throw new Error();
+    }
+    return JSON.parse(secret.SecretString);
+}
+function secretHasExpectedFormat(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "username" in value &&
+        typeof value.username === "string" &&
+        "password" in value &&
+        typeof value.password === "string");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api-gateway/authorizer-lambdas/cognito-user-pool-authorizer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * This lambda verifies bearer token in authorization header using Cognito.
+ *
+ * Expects the following environment variables:
+ * - USER_POOL_ID
+ * - REQUIRED_SCOPE (optional)
+ *   - Set this to require that the bearer token payload contains the given scope
+ * - CREDENTIALS_FOR_INTERNAL_AUTHORIZATION (optional)
+ *   - Secret name from which to get basic auth credentials that should be forwarded to backend
+ *     integration if authentication succeeds
+ *   - Secret value should follow this format: `{"username":"<username>","password":"<password>"}`
+ */
+import type { APIGatewayRequestAuthorizerEventV2, APIGatewaySimpleAuthorizerResult } from "aws-lambda";
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+import type { CognitoAccessTokenPayload } from "aws-jwt-verify/jwt-model";
+type AuthorizerResult = APIGatewaySimpleAuthorizerResult & {
+    /**
+     * Returning a context object from our authorizer allows our API Gateway to access these variables
+     * via `${context.authorizer.<property>}`.
+     * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging-variables.html
+     */
+    context?: {
+        /**
+         * If the token is verified, we return the auth client ID from the token's claims as a context
+         * variable (named `authorizer.clientId`). You can then use this for parameter mapping on the
+         * API Gateway (see `AlbIntegrationProps.mapParameters` on the `ApiGateway` construct), if for
+         * example you want to forward this to the backend integration.
+         */
+        clientId: string;
+        /**
+         * If `CREDENTIALS_FOR_INTERNAL_AUTHORIZATION` is provided, we want to forward basic auth
+         * credentials to our backend, as an additional authentication layer. See the docstring on
+         * `CognitoUserPoolAuthorizerProps.basicAuthForInternalAuthorization` in the `ApiGateway`
+         * construct for more on this.
+         */
+        internalAuthorizationHeader?: string;
+    };
+};
+export declare const handler: (event: APIGatewayRequestAuthorizerEventV2) => Promise<AuthorizerResult>;
+export type TokenVerifier = {
+    verify: (accessToken: string) => Promise<CognitoAccessTokenPayload>;
+};
+/** For overriding dependency creation in tests. */
+export declare const dependencies: {
+    createTokenVerifier: () => TokenVerifier;
+    createSecretsManager: () => SecretsManager;
+};
+export {};

package/lib/api-gateway/authorizer-lambdas/cognito-user-pool-authorizer.js

@@ -0,0 +1,129 @@
+/**
+ * This lambda verifies bearer token in authorization header using Cognito.
+ *
+ * Expects the following environment variables:
+ * - USER_POOL_ID
+ * - REQUIRED_SCOPE (optional)
+ *   - Set this to require that the bearer token payload contains the given scope
+ * - CREDENTIALS_FOR_INTERNAL_AUTHORIZATION (optional)
+ *   - Secret name from which to get basic auth credentials that should be forwarded to backend
+ *     integration if authentication succeeds
+ *   - Secret value should follow this format: `{"username":"<username>","password":"<password>"}`
+ */
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+import { CognitoJwtVerifier } from "aws-jwt-verify";
+export const handler = async (event) => {
+    const authHeader = event.headers?.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        return { isAuthorized: false };
+    }
+    const result = await verifyAccessToken(authHeader.substring(7)); // substring(7) == after 'Bearer '
+    switch (result) {
+        case "INVALID":
+            return { isAuthorized: false };
+        case "EXPIRED":
+            // We want to return 401 Unauthorized for expired tokens, so the client knows to refresh
+            // their token when receiving this status code. API Gateway authorizer lambdas return
+            // 403 Forbidden for {isAuthorized: false}, but there is a way to return 401: throwing an
+            // error with this exact string. https://stackoverflow.com/a/71965890
+            throw new Error("Unauthorized");
+        default: {
+            return {
+                isAuthorized: true,
+                context: {
+                    clientId: result.client_id,
+                    internalAuthorizationHeader: await getInternalAuthorizationHeader(),
+                },
+            };
+        }
+    }
+};
+/** Decodes and verifies the given token against Cognito. */
+async function verifyAccessToken(token) {
+    try {
+        const tokenVerifier = getTokenVerifier();
+        // Must await here instead of returning the promise directly, so that errors can be caught in
+        // this function
+        return await tokenVerifier.verify(token);
+    }
+    catch (e) {
+        // If the JWT has expired, aws-jwt-verify throws this error:
+        // https://github.com/awslabs/aws-jwt-verify/blob/8d8f714d7281913ecd660147f5c30311479601c1/src/jwt.ts#L197
+        // We can't check instanceof on that error class, since it's not exported, so this is the next
+        // best thing.
+        if (e instanceof Error && e.message?.includes("Token expired")) {
+            return "EXPIRED";
+        }
+        else {
+            return "INVALID";
+        }
+    }
+}
+/**
+ * We cache the verifier in this global variable, so that subsequent invocations of a hot lambda
+ * will re-use this.
+ */
+let cachedTokenVerifier = undefined;
+function getTokenVerifier() {
+    if (cachedTokenVerifier === undefined) {
+        cachedTokenVerifier = dependencies.createTokenVerifier();
+    }
+    return cachedTokenVerifier;
+}
+/** For overriding dependency creation in tests. */
+export const dependencies = {
+    createTokenVerifier: () => {
+        const userPoolId = process.env["USER_POOL_ID"];
+        if (!userPoolId) {
+            console.error("USER_POOL_ID env variable is not defined");
+            throw new Error();
+        }
+        return CognitoJwtVerifier.create({
+            userPoolId,
+            tokenUse: "access",
+            clientId: null,
+            scope: process.env.REQUIRED_SCOPE || undefined, // `|| undefined` to discard empty string
+        });
+    },
+    createSecretsManager: () => new SecretsManager(),
+};
+/** Cache this value, so that subsequent lambda invocations don't have to refetch. */
+let cachedInternalAuthorizationHeader = undefined;
+async function getInternalAuthorizationHeader() {
+    if (cachedInternalAuthorizationHeader === undefined) {
+        const secretName = process.env["CREDENTIALS_FOR_INTERNAL_AUTHORIZATION"];
+        if (!secretName) {
+            return undefined;
+        }
+        cachedInternalAuthorizationHeader =
+            await getSecretAsBasicAuthHeader(secretName);
+    }
+    return cachedInternalAuthorizationHeader;
+}
+async function getSecretAsBasicAuthHeader(secretName) {
+    const credentials = await getSecretValue(secretName);
+    if (!secretHasExpectedFormat(credentials)) {
+        console.error(`Basic auth credentials secret did not follow expected format (secret name: '${secretName}')`);
+        throw new Error();
+    }
+    return ("Basic " +
+        Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64"));
+}
+async function getSecretValue(secretName) {
+    const client = dependencies.createSecretsManager();
+    const secret = await client.getSecretValue({ SecretId: secretName });
+    if (!secret.SecretString) {
+        console.error(`Secret value not found for '${secretName}'`);
+        throw new Error();
+    }
+    return JSON.parse(secret.SecretString);
+}
+function secretHasExpectedFormat(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "username" in value &&
+        typeof value.username === "string" &&
+        "password" in value &&
+        typeof value.password === "string");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognito-user-pool-authorizer.js","sourceRoot":"","sources":["../../../src/api-gateway/authorizer-lambdas/cognito-user-pool-authorizer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This lambda verifies bearer token in authorization header using Cognito.\n *\n * Expects the following environment variables:\n * - USER_POOL_ID\n * - REQUIRED_SCOPE (optional)\n *   - Set this to require that the bearer token payload contains the given scope\n * - CREDENTIALS_FOR_INTERNAL_AUTHORIZATION (optional)\n *   - Secret name from which to get basic auth credentials that should be forwarded to backend\n *     integration if authentication succeeds\n *   - Secret value should follow this format: `{\"username\":\"<username>\",\"password\":\"<password>\"}`\n */\n\nimport type {\n  APIGatewayRequestAuthorizerEventV2,\n  APIGatewaySimpleAuthorizerResult,\n} from \"aws-lambda\"\nimport { SecretsManager } from \"@aws-sdk/client-secrets-manager\"\nimport { CognitoJwtVerifier } from \"aws-jwt-verify\"\nimport type { CognitoAccessTokenPayload } from \"aws-jwt-verify/jwt-model\"\n\ntype AuthorizerResult = APIGatewaySimpleAuthorizerResult & {\n  /**\n   * Returning a context object from our authorizer allows our API Gateway to access these variables\n   * via `${context.authorizer.<property>}`.\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging-variables.html\n   */\n  context?: {\n    /**\n     * If the token is verified, we return the auth client ID from the token's claims as a context\n     * variable (named `authorizer.clientId`). You can then use this for parameter mapping on the\n     * API Gateway (see `AlbIntegrationProps.mapParameters` on the `ApiGateway` construct), if for\n     * example you want to forward this to the backend integration.\n     */\n    clientId: string\n    /**\n     * If `CREDENTIALS_FOR_INTERNAL_AUTHORIZATION` is provided, we want to forward basic auth\n     * credentials to our backend, as an additional authentication layer. See the docstring on\n     * `CognitoUserPoolAuthorizerProps.basicAuthForInternalAuthorization` in the `ApiGateway`\n     * construct for more on this.\n     */\n    internalAuthorizationHeader?: string\n  }\n}\n\nexport const handler = async (\n  event: APIGatewayRequestAuthorizerEventV2,\n): Promise<AuthorizerResult> => {\n  const authHeader = event.headers?.authorization\n  if (!authHeader || !authHeader.startsWith(\"Bearer \")) {\n    return { isAuthorized: false }\n  }\n\n  const result = await verifyAccessToken(authHeader.substring(7)) // substring(7) == after 'Bearer '\n  switch (result) {\n    case \"INVALID\":\n      return { isAuthorized: false }\n    case \"EXPIRED\":\n      // We want to return 401 Unauthorized for expired tokens, so the client knows to refresh\n      // their token when receiving this status code. API Gateway authorizer lambdas return\n      // 403 Forbidden for {isAuthorized: false}, but there is a way to return 401: throwing an\n      // error with this exact string. https://stackoverflow.com/a/71965890\n      throw new Error(\"Unauthorized\")\n    default: {\n      return {\n        isAuthorized: true,\n        context: {\n          clientId: result.client_id,\n          internalAuthorizationHeader: await getInternalAuthorizationHeader(),\n        },\n      }\n    }\n  }\n}\n\n/** Decodes and verifies the given token against Cognito. */\nasync function verifyAccessToken(\n  token: string,\n): Promise<CognitoAccessTokenPayload | \"EXPIRED\" | \"INVALID\"> {\n  try {\n    const tokenVerifier = getTokenVerifier()\n    // Must await here instead of returning the promise directly, so that errors can be caught in\n    // this function\n    return await tokenVerifier.verify(token)\n  } catch (e) {\n    // If the JWT has expired, aws-jwt-verify throws this error:\n    // https://github.com/awslabs/aws-jwt-verify/blob/8d8f714d7281913ecd660147f5c30311479601c1/src/jwt.ts#L197\n    // We can't check instanceof on that error class, since it's not exported, so this is the next\n    // best thing.\n    if (e instanceof Error && e.message?.includes(\"Token expired\")) {\n      return \"EXPIRED\"\n    } else {\n      return \"INVALID\"\n    }\n  }\n}\n\nexport type TokenVerifier = {\n  verify: (accessToken: string) => Promise<CognitoAccessTokenPayload>\n}\n\n/**\n * We cache the verifier in this global variable, so that subsequent invocations of a hot lambda\n * will re-use this.\n */\nlet cachedTokenVerifier: TokenVerifier | undefined = undefined\n\nfunction getTokenVerifier(): TokenVerifier {\n  if (cachedTokenVerifier === undefined) {\n    cachedTokenVerifier = dependencies.createTokenVerifier()\n  }\n  return cachedTokenVerifier\n}\n\n/** For overriding dependency creation in tests. */\nexport const dependencies = {\n  createTokenVerifier: (): TokenVerifier => {\n    const userPoolId = process.env[\"USER_POOL_ID\"]\n    if (!userPoolId) {\n      console.error(\"USER_POOL_ID env variable is not defined\")\n      throw new Error()\n    }\n\n    return CognitoJwtVerifier.create({\n      userPoolId,\n      tokenUse: \"access\",\n      clientId: null,\n      scope: process.env.REQUIRED_SCOPE || undefined, // `|| undefined` to discard empty string\n    })\n  },\n  createSecretsManager: () => new SecretsManager(),\n}\n\n/** Cache this value, so that subsequent lambda invocations don't have to refetch. */\nlet cachedInternalAuthorizationHeader: string | undefined = undefined\n\nasync function getInternalAuthorizationHeader(): Promise<string | undefined> {\n  if (cachedInternalAuthorizationHeader === undefined) {\n    const secretName: string | undefined =\n      process.env[\"CREDENTIALS_FOR_INTERNAL_AUTHORIZATION\"]\n    if (!secretName) {\n      return undefined\n    }\n\n    cachedInternalAuthorizationHeader =\n      await getSecretAsBasicAuthHeader(secretName)\n  }\n\n  return cachedInternalAuthorizationHeader\n}\n\nasync function getSecretAsBasicAuthHeader(secretName: string): Promise<string> {\n  const credentials = await getSecretValue(secretName)\n  if (!secretHasExpectedFormat(credentials)) {\n    console.error(\n      `Basic auth credentials secret did not follow expected format (secret name: '${secretName}')`,\n    )\n    throw new Error()\n  }\n\n  return (\n    \"Basic \" +\n    Buffer.from(`${credentials.username}:${credentials.password}`).toString(\n      \"base64\",\n    )\n  )\n}\n\nasync function getSecretValue(secretName: string): Promise<unknown> {\n  const client = dependencies.createSecretsManager()\n  const secret = await client.getSecretValue({ SecretId: secretName })\n\n  if (!secret.SecretString) {\n    console.error(`Secret value not found for '${secretName}'`)\n    throw new Error()\n  }\n\n  return JSON.parse(secret.SecretString)\n}\n\nfunction secretHasExpectedFormat(\n  value: unknown,\n): value is { username: string; password: string } {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"username\" in value &&\n    typeof value.username === \"string\" &&\n    \"password\" in value &&\n    typeof value.password === \"string\"\n  )\n}\n"]}

package/lib/api-gateway/authorizer-lambdas/cognito-user-pool-or-basic-auth-authorizer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * This lambda verifies credentials:
+ * - Against Cognito user pool if request uses Bearer token
+ * - Against credentials saved in Secret Manager if request uses basic auth (and if secret exists)
+ *
+ * Expects the following environment variables
+ * - USER_POOL_ID
+ * - BASIC_AUTH_CREDENTIALS_SECRET_NAME (optional)
+ *   - Secret value should follow this format: `{"username":"<username>","password":"<password>"}`
+ * - REQUIRED_SCOPE (optional)
+ *   - Set this to require that the bearer token payload contains the given scope
+ */
+import type { APIGatewayRequestAuthorizerEventV2, APIGatewaySimpleAuthorizerResult } from "aws-lambda";
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+import type { CognitoAccessTokenPayload } from "aws-jwt-verify/jwt-model";
+type AuthorizerResult = APIGatewaySimpleAuthorizerResult & {
+    /**
+     * Returning a context object from our authorizer allows our API Gateway to access these variables
+     * via `${context.authorizer.<property>}`.
+     * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging-variables.html
+     */
+    context?: {
+        /**
+         * If the token is verified, we return the auth client ID from the token's claims as a context
+         * variable (named `authorizer.clientId`). You can then use this for parameter mapping on the
+         * API Gateway (see `AlbIntegrationProps.mapParameters` on the `ApiGateway` construct), if for
+         * example you want to forward this to the backend integration.
+         */
+        clientId: string;
+        /**
+         * See `CognitoUserPoolAuthorizerProps.basicAuthForInternalAuthorization` in the `ApiGateway`
+         * construct (we provide the same context variable here as in the Cognito User Pool authorizer,
+         * using the credentials from BASIC_AUTH_CREDENTIALS_SECRET_NAME).
+         */
+        internalAuthorizationHeader?: string;
+    };
+};
+export declare const handler: (event: APIGatewayRequestAuthorizerEventV2) => Promise<AuthorizerResult>;
+export type TokenVerifier = {
+    verify: (accessToken: string) => Promise<CognitoAccessTokenPayload>;
+};
+/** For overriding dependency creation in tests. */
+export declare const dependencies: {
+    createTokenVerifier: () => TokenVerifier;
+    createSecretsManager: () => SecretsManager;
+};
+export {};

package/lib/api-gateway/authorizer-lambdas/cognito-user-pool-or-basic-auth-authorizer.js

@@ -0,0 +1,136 @@
+/**
+ * This lambda verifies credentials:
+ * - Against Cognito user pool if request uses Bearer token
+ * - Against credentials saved in Secret Manager if request uses basic auth (and if secret exists)
+ *
+ * Expects the following environment variables
+ * - USER_POOL_ID
+ * - BASIC_AUTH_CREDENTIALS_SECRET_NAME (optional)
+ *   - Secret value should follow this format: `{"username":"<username>","password":"<password>"}`
+ * - REQUIRED_SCOPE (optional)
+ *   - Set this to require that the bearer token payload contains the given scope
+ */
+import { SecretsManager } from "@aws-sdk/client-secrets-manager";
+import { CognitoJwtVerifier } from "aws-jwt-verify";
+export const handler = async (event) => {
+    const authHeader = event.headers?.authorization;
+    if (!authHeader) {
+        return { isAuthorized: false };
+    }
+    const expectedBasicAuthHeader = await getExpectedBasicAuthHeader();
+    if (authHeader.startsWith("Bearer ")) {
+        const result = await verifyAccessToken(authHeader.substring(7)); // substring(7) == after 'Bearer '
+        switch (result) {
+            case "INVALID":
+                return { isAuthorized: false };
+            case "EXPIRED":
+                // We want to return 401 Unauthorized for expired tokens, so the client knows to refresh
+                // their token when receiving this status code. API Gateway authorizer lambdas return
+                // 403 Forbidden for {isAuthorized: false}, but there is a way to return 401: throwing an
+                // error with this exact string. https://stackoverflow.com/a/71965890
+                throw new Error("Unauthorized");
+            default:
+                return {
+                    isAuthorized: true,
+                    context: {
+                        clientId: result.client_id,
+                        internalAuthorizationHeader: expectedBasicAuthHeader,
+                    },
+                };
+        }
+    }
+    else if (authHeader.startsWith("Basic ")) {
+        return { isAuthorized: authHeader === expectedBasicAuthHeader };
+    }
+    else {
+        return { isAuthorized: false };
+    }
+};
+/** Decodes and verifies the given token against Cognito. */
+async function verifyAccessToken(token) {
+    try {
+        const tokenVerifier = getTokenVerifier();
+        // Must await here instead of returning the promise directly, so that errors can be caught in
+        // this function
+        return await tokenVerifier.verify(token);
+    }
+    catch (e) {
+        // If the JWT has expired, aws-jwt-verify throws this error:
+        // https://github.com/awslabs/aws-jwt-verify/blob/8d8f714d7281913ecd660147f5c30311479601c1/src/jwt.ts#L197
+        // We can't check instanceof on that error class, since it's not exported, so this is the next
+        // best thing.
+        if (e instanceof Error && e.message?.includes("Token expired")) {
+            return "EXPIRED";
+        }
+        else {
+            return "INVALID";
+        }
+    }
+}
+/**
+ * We cache the verifier in this global variable, so that subsequent invocations of a hot lambda
+ * will re-use this.
+ */
+let cachedTokenVerifier = undefined;
+function getTokenVerifier() {
+    if (cachedTokenVerifier === undefined) {
+        cachedTokenVerifier = dependencies.createTokenVerifier();
+    }
+    return cachedTokenVerifier;
+}
+/** For overriding dependency creation in tests. */
+export const dependencies = {
+    createTokenVerifier: () => {
+        const userPoolId = process.env["USER_POOL_ID"];
+        if (!userPoolId) {
+            console.error("USER_POOL_ID env variable is not defined");
+            throw new Error();
+        }
+        return CognitoJwtVerifier.create({
+            userPoolId,
+            tokenUse: "access",
+            clientId: null,
+            scope: process.env.REQUIRED_SCOPE || undefined, // `|| undefined` to discard empty string
+        });
+    },
+    createSecretsManager: () => new SecretsManager(),
+};
+/** Cache this value, so that subsequent lambda invocations don't have to refetch. */
+let cachedBasicAuthHeader = undefined;
+async function getExpectedBasicAuthHeader() {
+    if (cachedBasicAuthHeader === undefined) {
+        const secretName = process.env["BASIC_AUTH_CREDENTIALS_SECRET_NAME"];
+        if (!secretName) {
+            return undefined;
+        }
+        cachedBasicAuthHeader = await getSecretAsBasicAuthHeader(secretName);
+    }
+    return cachedBasicAuthHeader;
+}
+async function getSecretAsBasicAuthHeader(secretName) {
+    const credentials = await getSecretValue(secretName);
+    if (!secretHasExpectedFormat(credentials)) {
+        console.error(`Basic auth credentials secret did not follow expected format (secret name: '${secretName}')`);
+        throw new Error();
+    }
+    return ("Basic " +
+        Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64"));
+}
+async function getSecretValue(secretName) {
+    const client = dependencies.createSecretsManager();
+    const secret = await client.getSecretValue({ SecretId: secretName });
+    if (!secret.SecretString) {
+        console.error(`Secret value not found for '${secretName}'`);
+        throw new Error();
+    }
+    return JSON.parse(secret.SecretString);
+}
+function secretHasExpectedFormat(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "username" in value &&
+        typeof value.username === "string" &&
+        "password" in value &&
+        typeof value.password === "string");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognito-user-pool-or-basic-auth-authorizer.js","sourceRoot":"","sources":["../../../src/api-gateway/authorizer-lambdas/cognito-user-pool-or-basic-auth-authorizer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This lambda verifies credentials:\n * - Against Cognito user pool if request uses Bearer token\n * - Against credentials saved in Secret Manager if request uses basic auth (and if secret exists)\n *\n * Expects the following environment variables\n * - USER_POOL_ID\n * - BASIC_AUTH_CREDENTIALS_SECRET_NAME (optional)\n *   - Secret value should follow this format: `{\"username\":\"<username>\",\"password\":\"<password>\"}`\n * - REQUIRED_SCOPE (optional)\n *   - Set this to require that the bearer token payload contains the given scope\n */\n\nimport type {\n  APIGatewayRequestAuthorizerEventV2,\n  APIGatewaySimpleAuthorizerResult,\n} from \"aws-lambda\"\nimport { SecretsManager } from \"@aws-sdk/client-secrets-manager\"\nimport { CognitoJwtVerifier } from \"aws-jwt-verify\"\nimport type { CognitoAccessTokenPayload } from \"aws-jwt-verify/jwt-model\"\n\ntype AuthorizerResult = APIGatewaySimpleAuthorizerResult & {\n  /**\n   * Returning a context object from our authorizer allows our API Gateway to access these variables\n   * via `${context.authorizer.<property>}`.\n   * https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging-variables.html\n   */\n  context?: {\n    /**\n     * If the token is verified, we return the auth client ID from the token's claims as a context\n     * variable (named `authorizer.clientId`). You can then use this for parameter mapping on the\n     * API Gateway (see `AlbIntegrationProps.mapParameters` on the `ApiGateway` construct), if for\n     * example you want to forward this to the backend integration.\n     */\n    clientId: string\n    /**\n     * See `CognitoUserPoolAuthorizerProps.basicAuthForInternalAuthorization` in the `ApiGateway`\n     * construct (we provide the same context variable here as in the Cognito User Pool authorizer,\n     * using the credentials from BASIC_AUTH_CREDENTIALS_SECRET_NAME).\n     */\n    internalAuthorizationHeader?: string\n  }\n}\n\nexport const handler = async (\n  event: APIGatewayRequestAuthorizerEventV2,\n): Promise<AuthorizerResult> => {\n  const authHeader = event.headers?.authorization\n  if (!authHeader) {\n    return { isAuthorized: false }\n  }\n\n  const expectedBasicAuthHeader = await getExpectedBasicAuthHeader()\n\n  if (authHeader.startsWith(\"Bearer \")) {\n    const result = await verifyAccessToken(authHeader.substring(7)) // substring(7) == after 'Bearer '\n    switch (result) {\n      case \"INVALID\":\n        return { isAuthorized: false }\n      case \"EXPIRED\":\n        // We want to return 401 Unauthorized for expired tokens, so the client knows to refresh\n        // their token when receiving this status code. API Gateway authorizer lambdas return\n        // 403 Forbidden for {isAuthorized: false}, but there is a way to return 401: throwing an\n        // error with this exact string. https://stackoverflow.com/a/71965890\n        throw new Error(\"Unauthorized\")\n      default:\n        return {\n          isAuthorized: true,\n          context: {\n            clientId: result.client_id,\n            internalAuthorizationHeader: expectedBasicAuthHeader,\n          },\n        }\n    }\n  } else if (authHeader.startsWith(\"Basic \")) {\n    return { isAuthorized: authHeader === expectedBasicAuthHeader }\n  } else {\n    return { isAuthorized: false }\n  }\n}\n\n/** Decodes and verifies the given token against Cognito. */\nasync function verifyAccessToken(\n  token: string,\n): Promise<CognitoAccessTokenPayload | \"EXPIRED\" | \"INVALID\"> {\n  try {\n    const tokenVerifier = getTokenVerifier()\n    // Must await here instead of returning the promise directly, so that errors can be caught in\n    // this function\n    return await tokenVerifier.verify(token)\n  } catch (e) {\n    // If the JWT has expired, aws-jwt-verify throws this error:\n    // https://github.com/awslabs/aws-jwt-verify/blob/8d8f714d7281913ecd660147f5c30311479601c1/src/jwt.ts#L197\n    // We can't check instanceof on that error class, since it's not exported, so this is the next\n    // best thing.\n    if (e instanceof Error && e.message?.includes(\"Token expired\")) {\n      return \"EXPIRED\"\n    } else {\n      return \"INVALID\"\n    }\n  }\n}\n\nexport type TokenVerifier = {\n  verify: (accessToken: string) => Promise<CognitoAccessTokenPayload>\n}\n\n/**\n * We cache the verifier in this global variable, so that subsequent invocations of a hot lambda\n * will re-use this.\n */\nlet cachedTokenVerifier: TokenVerifier | undefined = undefined\n\nfunction getTokenVerifier(): TokenVerifier {\n  if (cachedTokenVerifier === undefined) {\n    cachedTokenVerifier = dependencies.createTokenVerifier()\n  }\n  return cachedTokenVerifier\n}\n\n/** For overriding dependency creation in tests. */\nexport const dependencies = {\n  createTokenVerifier: (): TokenVerifier => {\n    const userPoolId = process.env[\"USER_POOL_ID\"]\n    if (!userPoolId) {\n      console.error(\"USER_POOL_ID env variable is not defined\")\n      throw new Error()\n    }\n\n    return CognitoJwtVerifier.create({\n      userPoolId,\n      tokenUse: \"access\",\n      clientId: null,\n      scope: process.env.REQUIRED_SCOPE || undefined, // `|| undefined` to discard empty string\n    })\n  },\n  createSecretsManager: () => new SecretsManager(),\n}\n\n/** Cache this value, so that subsequent lambda invocations don't have to refetch. */\nlet cachedBasicAuthHeader: string | undefined = undefined\n\nasync function getExpectedBasicAuthHeader(): Promise<string | undefined> {\n  if (cachedBasicAuthHeader === undefined) {\n    const secretName: string | undefined =\n      process.env[\"BASIC_AUTH_CREDENTIALS_SECRET_NAME\"]\n    if (!secretName) {\n      return undefined\n    }\n\n    cachedBasicAuthHeader = await getSecretAsBasicAuthHeader(secretName)\n  }\n\n  return cachedBasicAuthHeader\n}\n\nasync function getSecretAsBasicAuthHeader(secretName: string): Promise<string> {\n  const credentials = await getSecretValue(secretName)\n  if (!secretHasExpectedFormat(credentials)) {\n    console.error(\n      `Basic auth credentials secret did not follow expected format (secret name: '${secretName}')`,\n    )\n    throw new Error()\n  }\n\n  return (\n    \"Basic \" +\n    Buffer.from(`${credentials.username}:${credentials.password}`).toString(\n      \"base64\",\n    )\n  )\n}\n\nasync function getSecretValue(secretName: string): Promise<unknown> {\n  const client = dependencies.createSecretsManager()\n  const secret = await client.getSecretValue({ SecretId: secretName })\n\n  if (!secret.SecretString) {\n    console.error(`Secret value not found for '${secretName}'`)\n    throw new Error()\n  }\n\n  return JSON.parse(secret.SecretString)\n}\n\nfunction secretHasExpectedFormat(\n  value: unknown,\n): value is { username: string; password: string } {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"username\" in value &&\n    typeof value.username === \"string\" &&\n    \"password\" in value &&\n    typeof value.password === \"string\"\n  )\n}\n"]}