@liflig/cdk-cloudfront-auth 1.9.2 → 1.10.0

package/lib/cloudfront-auth.js

@@ -1,10 +1,10 @@
-import { LambdaConfig } from "@liflig/cdk-lambda-config";
 import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
 import { ViewerProtocolPolicy, } from "aws-cdk-lib/aws-cloudfront";
 import { Construct } from "constructs";
 import { RetrieveClientSecret } from "./client-secret";
 import { ClientUpdate } from "./client-update";
 import { GenerateSecret } from "./generate-secret";
+import { LambdaConfig } from "./lambda-config/lambda-config";
 /**
  * Configure previously deployed lambda functions, Cognito client
  * and CloudFront distribution.
@@ -250,4 +250,4 @@ export class CloudFrontAuth extends Construct {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-auth.js","sourceRoot":"","sources":["../src/cloudfront-auth.ts"],"names":[],"mappings":"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","sourcesContent":["import { LambdaConfig } from \"@liflig/cdk-lambda-config\"\nimport * as cloudfront from \"aws-cdk-lib/aws-cloudfront\"\nimport {\n  type AddBehaviorOptions,\n  type BehaviorOptions,\n  type IOrigin,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\"\nimport type * as cognito from \"aws-cdk-lib/aws-cognito\"\nimport type * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport type { IVersion } from \"aws-cdk-lib/aws-lambda\"\nimport { Construct } from \"constructs\"\nimport { RetrieveClientSecret } from \"./client-secret\"\nimport { ClientUpdate } from \"./client-update\"\nimport { GenerateSecret } from \"./generate-secret\"\nimport type { StoredConfig } from \"./handlers/util/config\"\nimport type { AuthLambdas } from \"./lambdas\"\n\nexport interface CloudFrontAuthProps {\n  /**\n   * Cognito Client that will be used to authenticate the user.\n   *\n   * If a custom client is provided, the updateClient method cannot\n   * be used since we cannot know which parameters was set.\n   *\n   * @default - a new client will be generated\n   */\n  client?: cognito.UserPoolClient\n  userPool: cognito.IUserPool\n  /**\n   * The domain that is used for Cognito Auth.\n   *\n   * If not using custom domains this will be a name under amazoncognito.com.\n   *\n   * @example `${domain.domainName}.auth.${region}.amazoncognito.com`\n   */\n  cognitoAuthDomain: string\n  authLambdas: AuthLambdas\n  /**\n   * @default /auth/callback\n   */\n  callbackPath?: string\n  /**\n   * @default /\n   */\n  signOutRedirectTo?: string\n  /**\n   * @default /auth/sign-out\n   */\n  signOutPath?: string\n  /**\n   * @default /auth/refresh\n   */\n  refreshAuthPath?: string\n  /**\n   * Log level.\n   *\n   * A log level of debug will log secrets and should only be used in\n   * a development environment.\n   *\n   * @default warn\n   */\n  logLevel?: \"none\" | \"error\" | \"warn\" | \"info\" | \"debug\"\n  /**\n   * Require the user to be part of a specific Cognito group to\n   * access any resource.\n   */\n  requireGroupAnyOf?: string[]\n}\n\nexport interface UpdateClientProps {\n  signOutUrl: string\n  callbackUrl: string\n  /**\n   * List of identity providers used for the client.\n   *\n   * @default - COGNITO and identity providers registered in the UserPool construct\n   */\n  identityProviders?: string[]\n}\n\n/**\n * Configure previously deployed lambda functions, Cognito client\n * and CloudFront distribution.\n */\nexport class CloudFrontAuth extends Construct {\n  public readonly callbackPath: string\n  public readonly signOutRedirectTo: string\n  public readonly signOutPath: string\n  public readonly refreshAuthPath: string\n\n  private readonly userPool: cognito.IUserPool\n  private readonly clientCreated: boolean\n  public readonly client: cognito.UserPoolClient\n\n  private readonly checkAuthFn: lambda.IVersion\n  private readonly httpHeadersFn: lambda.IVersion\n  private readonly parseAuthFn: lambda.IVersion\n  private readonly refreshAuthFn: lambda.IVersion\n  private readonly signOutFn: lambda.IVersion\n\n  private readonly oauthScopes: string[]\n\n  constructor(scope: Construct, id: string, props: CloudFrontAuthProps) {\n    super(scope, id)\n\n    this.callbackPath = props.callbackPath ?? \"/auth/callback\"\n    this.signOutRedirectTo = props.signOutRedirectTo ?? \"/\"\n    this.signOutPath = props.signOutPath ?? \"/auth/sign-out\"\n    this.refreshAuthPath = props.refreshAuthPath ?? \"/auth/refresh\"\n\n    this.oauthScopes = [\n      \"phone\",\n      \"email\",\n      \"profile\",\n      \"openid\",\n      \"aws.cognito.signin.user.admin\",\n    ]\n\n    this.userPool = props.userPool\n\n    this.clientCreated = !props.client\n    this.client =\n      props.client ??\n      props.userPool.addClient(\"UserPoolClient\", {\n        // Note: The following must be kept in sync with the API\n        // call performed in ClientUpdate.\n        authFlows: {\n          userPassword: true,\n          userSrp: true,\n        },\n        oAuth: {\n          flows: {\n            authorizationCodeGrant: true,\n          },\n        },\n        preventUserExistenceErrors: true,\n        generateSecret: true,\n      })\n\n    const nonceSigningSecret = new GenerateSecret(this, \"NonceSigningSecret\")\n      .value\n\n    const { clientSecretValue } = new RetrieveClientSecret(\n      this,\n      \"ClientSecret\",\n      {\n        client: this.client,\n        userPool: this.userPool,\n      },\n    )\n\n    const config: StoredConfig = {\n      httpHeaders: {\n        \"Content-Security-Policy\":\n          \"default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; object-src 'none'; connect-src 'self'\",\n        \"Strict-Transport-Security\":\n          \"max-age=31536000; includeSubdomains; preload\",\n        \"Referrer-Policy\": \"same-origin\",\n        \"X-XSS-Protection\": \"1; mode=block\",\n        \"X-Frame-Options\": \"DENY\",\n        \"X-Content-Type-Options\": \"nosniff\",\n        \"Cache-Control\": \"no-cache\",\n      },\n      logLevel: props.logLevel ?? \"warn\",\n      userPoolId: this.userPool.userPoolId,\n      clientId: this.client.userPoolClientId,\n      clientSecret: clientSecretValue,\n      oauthScopes: this.oauthScopes,\n      cognitoAuthDomain: props.cognitoAuthDomain,\n      callbackPath: this.callbackPath,\n      signOutRedirectTo: this.signOutRedirectTo,\n      signOutPath: this.signOutPath,\n      refreshAuthPath: this.refreshAuthPath,\n      requireGroupAnyOf: props.requireGroupAnyOf,\n      cookieSettings: {\n        /*\n        spaMode - consider if this should be supported\n        idToken: \"Path=/; Secure; SameSite=Lax\",\n        accessToken: \"Path=/; Secure; SameSite=Lax\",\n        refreshToken: \"Path=/; Secure; SameSite=Lax\",\n        nonce: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        */\n        idToken: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        accessToken: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        refreshToken: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        nonce: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n      },\n      nonceSigningSecret,\n    }\n\n    this.checkAuthFn = new LambdaConfig(this, \"CheckAuthFn\", {\n      function: props.authLambdas.checkAuthFn.get(this, \"CheckAuthFnImport\"),\n      config,\n    }).version\n\n    this.httpHeadersFn = new LambdaConfig(this, \"HttpHeadersFn\", {\n      function: props.authLambdas.httpHeadersFn.get(\n        this,\n        \"HttpHeadersFnImport\",\n      ),\n      config,\n    }).version\n\n    this.parseAuthFn = new LambdaConfig(this, \"ParseAuthFn\", {\n      function: props.authLambdas.parseAuthFn.get(this, \"ParseAuthFnImport\"),\n      config,\n    }).version\n\n    this.refreshAuthFn = new LambdaConfig(this, \"RefreshAuthFn\", {\n      function: props.authLambdas.refreshAuthFn.get(\n        this,\n        \"RefreshAuthFnImport\",\n      ),\n      config,\n    }).version\n\n    this.signOutFn = new LambdaConfig(this, \"SignOutFn\", {\n      function: props.authLambdas.signOutFn.get(this, \"SignOutFnImport\"),\n      config,\n    }).version\n  }\n\n  private createPathLambda(\n    path: string,\n    fn: lambda.IVersion,\n  ): cloudfront.Behavior {\n    return {\n      pathPattern: path,\n      forwardedValues: {\n        queryString: true,\n      },\n      lambdaFunctionAssociations: [\n        {\n          eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n          lambdaFunction: fn,\n        },\n      ],\n    }\n  }\n\n  /**\n   * Create behaviors for authentication pages:\n   *\n   * - callback page\n   * - refresh page\n   * - sign out page\n   *\n   * This is to be used with CloudFrontWebDistribution. See\n   * createAuthPagesBehaviors if using Distribution.\n   */\n  public get authPages(): cloudfront.Behavior[] {\n    return [\n      this.createPathLambda(this.callbackPath, this.parseAuthFn),\n      this.createPathLambda(this.refreshAuthPath, this.refreshAuthFn),\n      this.createPathLambda(this.signOutPath, this.signOutFn),\n    ]\n  }\n\n  /**\n   * Create behaviors for authentication pages.\n   *\n   * - callback page\n   * - refresh page\n   * - sign out page\n   *\n   * This is to be used with Distribution.\n   */\n  public createAuthPagesBehaviors(\n    origin: IOrigin,\n    options?: AddBehaviorOptions,\n  ): Record<string, BehaviorOptions> {\n    function path(path: string, fn: IVersion): Record<string, BehaviorOptions> {\n      return {\n        [path]: {\n          origin,\n          compress: true,\n          viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n          edgeLambdas: [\n            {\n              eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n              functionVersion: fn,\n            },\n          ],\n          ...options,\n        },\n      }\n    }\n\n    return {\n      ...path(this.callbackPath, this.parseAuthFn),\n      ...path(this.refreshAuthPath, this.refreshAuthFn),\n      ...path(this.signOutPath, this.signOutFn),\n    }\n  }\n\n  /**\n   * Create lambda function association for viewer request to check\n   * authentication and original response to add headers.\n   *\n   * This is to be used with CloudFrontWebDistribution. See\n   * createProtectedBehavior if using Distribution.\n   */\n  public get authFilters(): cloudfront.LambdaFunctionAssociation[] {\n    return [\n      {\n        eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n        lambdaFunction: this.checkAuthFn,\n      },\n      {\n        eventType: cloudfront.LambdaEdgeEventType.ORIGIN_RESPONSE,\n        lambdaFunction: this.httpHeadersFn,\n      },\n    ]\n  }\n\n  /**\n   * Create behavior that includes authorization check.\n   *\n   * This is to be used with Distribution.\n   */\n  public createProtectedBehavior(\n    origin: IOrigin,\n    options?: AddBehaviorOptions,\n  ): BehaviorOptions {\n    if (options?.edgeLambdas != null) {\n      throw Error(\"User-defined edgeLambdas is currently not supported\")\n    }\n\n    return {\n      origin,\n      compress: true,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      edgeLambdas: [\n        {\n          eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n          functionVersion: this.checkAuthFn,\n        },\n        {\n          eventType: cloudfront.LambdaEdgeEventType.ORIGIN_RESPONSE,\n          functionVersion: this.httpHeadersFn,\n        },\n      ],\n      ...options,\n    }\n  }\n\n  /**\n   * Update Cognito client to use the proper URLs and OAuth scopes.\n   *\n   * TODO: In case the client configuration changes and is updated\n   *  by CloudFormation, this will not be reapplied causing the client\n   *  to not be correctly configured.\n   *  How can we avoid this scenario?\n   */\n  public updateClient(id: string, props: UpdateClientProps): ClientUpdate {\n    if (!this.clientCreated) {\n      throw new Error(\n        \"You cannot use updateClient with a user-provided Cognito Client \" +\n          \"since it would override the user-provided settings\",\n      )\n    }\n\n    return new ClientUpdate(this, id, {\n      client: this.client,\n      userPool: this.userPool,\n      signOutUrl: props.signOutUrl,\n      callbackUrl: props.callbackUrl,\n      oauthScopes: this.oauthScopes,\n      identityProviders:\n        props.identityProviders ??\n        [\"COGNITO\"].concat(\n          this.userPool.identityProviders.map((it) => it.providerName),\n        ),\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudfront-auth.js","sourceRoot":"","sources":["../src/cloudfront-auth.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cloudfront from \"aws-cdk-lib/aws-cloudfront\"\nimport {\n  type AddBehaviorOptions,\n  type BehaviorOptions,\n  type IOrigin,\n  ViewerProtocolPolicy,\n} from \"aws-cdk-lib/aws-cloudfront\"\nimport type * as cognito from \"aws-cdk-lib/aws-cognito\"\nimport type * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport type { IVersion } from \"aws-cdk-lib/aws-lambda\"\nimport { Construct } from \"constructs\"\nimport { RetrieveClientSecret } from \"./client-secret\"\nimport { ClientUpdate } from \"./client-update\"\nimport { GenerateSecret } from \"./generate-secret\"\nimport type { StoredConfig } from \"./handlers/util/config\"\nimport { LambdaConfig } from \"./lambda-config/lambda-config\"\nimport type { AuthLambdas } from \"./lambdas\"\n\nexport interface CloudFrontAuthProps {\n  /**\n   * Cognito Client that will be used to authenticate the user.\n   *\n   * If a custom client is provided, the updateClient method cannot\n   * be used since we cannot know which parameters was set.\n   *\n   * @default - a new client will be generated\n   */\n  client?: cognito.UserPoolClient\n  userPool: cognito.IUserPool\n  /**\n   * The domain that is used for Cognito Auth.\n   *\n   * If not using custom domains this will be a name under amazoncognito.com.\n   *\n   * @example `${domain.domainName}.auth.${region}.amazoncognito.com`\n   */\n  cognitoAuthDomain: string\n  authLambdas: AuthLambdas\n  /**\n   * @default /auth/callback\n   */\n  callbackPath?: string\n  /**\n   * @default /\n   */\n  signOutRedirectTo?: string\n  /**\n   * @default /auth/sign-out\n   */\n  signOutPath?: string\n  /**\n   * @default /auth/refresh\n   */\n  refreshAuthPath?: string\n  /**\n   * Log level.\n   *\n   * A log level of debug will log secrets and should only be used in\n   * a development environment.\n   *\n   * @default warn\n   */\n  logLevel?: \"none\" | \"error\" | \"warn\" | \"info\" | \"debug\"\n  /**\n   * Require the user to be part of a specific Cognito group to\n   * access any resource.\n   */\n  requireGroupAnyOf?: string[]\n}\n\nexport interface UpdateClientProps {\n  signOutUrl: string\n  callbackUrl: string\n  /**\n   * List of identity providers used for the client.\n   *\n   * @default - COGNITO and identity providers registered in the UserPool construct\n   */\n  identityProviders?: string[]\n}\n\n/**\n * Configure previously deployed lambda functions, Cognito client\n * and CloudFront distribution.\n */\nexport class CloudFrontAuth extends Construct {\n  public readonly callbackPath: string\n  public readonly signOutRedirectTo: string\n  public readonly signOutPath: string\n  public readonly refreshAuthPath: string\n\n  private readonly userPool: cognito.IUserPool\n  private readonly clientCreated: boolean\n  public readonly client: cognito.UserPoolClient\n\n  private readonly checkAuthFn: lambda.IVersion\n  private readonly httpHeadersFn: lambda.IVersion\n  private readonly parseAuthFn: lambda.IVersion\n  private readonly refreshAuthFn: lambda.IVersion\n  private readonly signOutFn: lambda.IVersion\n\n  private readonly oauthScopes: string[]\n\n  constructor(scope: Construct, id: string, props: CloudFrontAuthProps) {\n    super(scope, id)\n\n    this.callbackPath = props.callbackPath ?? \"/auth/callback\"\n    this.signOutRedirectTo = props.signOutRedirectTo ?? \"/\"\n    this.signOutPath = props.signOutPath ?? \"/auth/sign-out\"\n    this.refreshAuthPath = props.refreshAuthPath ?? \"/auth/refresh\"\n\n    this.oauthScopes = [\n      \"phone\",\n      \"email\",\n      \"profile\",\n      \"openid\",\n      \"aws.cognito.signin.user.admin\",\n    ]\n\n    this.userPool = props.userPool\n\n    this.clientCreated = !props.client\n    this.client =\n      props.client ??\n      props.userPool.addClient(\"UserPoolClient\", {\n        // Note: The following must be kept in sync with the API\n        // call performed in ClientUpdate.\n        authFlows: {\n          userPassword: true,\n          userSrp: true,\n        },\n        oAuth: {\n          flows: {\n            authorizationCodeGrant: true,\n          },\n        },\n        preventUserExistenceErrors: true,\n        generateSecret: true,\n      })\n\n    const nonceSigningSecret = new GenerateSecret(this, \"NonceSigningSecret\")\n      .value\n\n    const { clientSecretValue } = new RetrieveClientSecret(\n      this,\n      \"ClientSecret\",\n      {\n        client: this.client,\n        userPool: this.userPool,\n      },\n    )\n\n    const config: StoredConfig = {\n      httpHeaders: {\n        \"Content-Security-Policy\":\n          \"default-src 'none'; img-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; object-src 'none'; connect-src 'self'\",\n        \"Strict-Transport-Security\":\n          \"max-age=31536000; includeSubdomains; preload\",\n        \"Referrer-Policy\": \"same-origin\",\n        \"X-XSS-Protection\": \"1; mode=block\",\n        \"X-Frame-Options\": \"DENY\",\n        \"X-Content-Type-Options\": \"nosniff\",\n        \"Cache-Control\": \"no-cache\",\n      },\n      logLevel: props.logLevel ?? \"warn\",\n      userPoolId: this.userPool.userPoolId,\n      clientId: this.client.userPoolClientId,\n      clientSecret: clientSecretValue,\n      oauthScopes: this.oauthScopes,\n      cognitoAuthDomain: props.cognitoAuthDomain,\n      callbackPath: this.callbackPath,\n      signOutRedirectTo: this.signOutRedirectTo,\n      signOutPath: this.signOutPath,\n      refreshAuthPath: this.refreshAuthPath,\n      requireGroupAnyOf: props.requireGroupAnyOf,\n      cookieSettings: {\n        /*\n        spaMode - consider if this should be supported\n        idToken: \"Path=/; Secure; SameSite=Lax\",\n        accessToken: \"Path=/; Secure; SameSite=Lax\",\n        refreshToken: \"Path=/; Secure; SameSite=Lax\",\n        nonce: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        */\n        idToken: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        accessToken: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        refreshToken: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n        nonce: \"Path=/; Secure; HttpOnly; SameSite=Lax\",\n      },\n      nonceSigningSecret,\n    }\n\n    this.checkAuthFn = new LambdaConfig(this, \"CheckAuthFn\", {\n      function: props.authLambdas.checkAuthFn.get(this, \"CheckAuthFnImport\"),\n      config,\n    }).version\n\n    this.httpHeadersFn = new LambdaConfig(this, \"HttpHeadersFn\", {\n      function: props.authLambdas.httpHeadersFn.get(\n        this,\n        \"HttpHeadersFnImport\",\n      ),\n      config,\n    }).version\n\n    this.parseAuthFn = new LambdaConfig(this, \"ParseAuthFn\", {\n      function: props.authLambdas.parseAuthFn.get(this, \"ParseAuthFnImport\"),\n      config,\n    }).version\n\n    this.refreshAuthFn = new LambdaConfig(this, \"RefreshAuthFn\", {\n      function: props.authLambdas.refreshAuthFn.get(\n        this,\n        \"RefreshAuthFnImport\",\n      ),\n      config,\n    }).version\n\n    this.signOutFn = new LambdaConfig(this, \"SignOutFn\", {\n      function: props.authLambdas.signOutFn.get(this, \"SignOutFnImport\"),\n      config,\n    }).version\n  }\n\n  private createPathLambda(\n    path: string,\n    fn: lambda.IVersion,\n  ): cloudfront.Behavior {\n    return {\n      pathPattern: path,\n      forwardedValues: {\n        queryString: true,\n      },\n      lambdaFunctionAssociations: [\n        {\n          eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n          lambdaFunction: fn,\n        },\n      ],\n    }\n  }\n\n  /**\n   * Create behaviors for authentication pages:\n   *\n   * - callback page\n   * - refresh page\n   * - sign out page\n   *\n   * This is to be used with CloudFrontWebDistribution. See\n   * createAuthPagesBehaviors if using Distribution.\n   */\n  public get authPages(): cloudfront.Behavior[] {\n    return [\n      this.createPathLambda(this.callbackPath, this.parseAuthFn),\n      this.createPathLambda(this.refreshAuthPath, this.refreshAuthFn),\n      this.createPathLambda(this.signOutPath, this.signOutFn),\n    ]\n  }\n\n  /**\n   * Create behaviors for authentication pages.\n   *\n   * - callback page\n   * - refresh page\n   * - sign out page\n   *\n   * This is to be used with Distribution.\n   */\n  public createAuthPagesBehaviors(\n    origin: IOrigin,\n    options?: AddBehaviorOptions,\n  ): Record<string, BehaviorOptions> {\n    function path(path: string, fn: IVersion): Record<string, BehaviorOptions> {\n      return {\n        [path]: {\n          origin,\n          compress: true,\n          viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n          edgeLambdas: [\n            {\n              eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n              functionVersion: fn,\n            },\n          ],\n          ...options,\n        },\n      }\n    }\n\n    return {\n      ...path(this.callbackPath, this.parseAuthFn),\n      ...path(this.refreshAuthPath, this.refreshAuthFn),\n      ...path(this.signOutPath, this.signOutFn),\n    }\n  }\n\n  /**\n   * Create lambda function association for viewer request to check\n   * authentication and original response to add headers.\n   *\n   * This is to be used with CloudFrontWebDistribution. See\n   * createProtectedBehavior if using Distribution.\n   */\n  public get authFilters(): cloudfront.LambdaFunctionAssociation[] {\n    return [\n      {\n        eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n        lambdaFunction: this.checkAuthFn,\n      },\n      {\n        eventType: cloudfront.LambdaEdgeEventType.ORIGIN_RESPONSE,\n        lambdaFunction: this.httpHeadersFn,\n      },\n    ]\n  }\n\n  /**\n   * Create behavior that includes authorization check.\n   *\n   * This is to be used with Distribution.\n   */\n  public createProtectedBehavior(\n    origin: IOrigin,\n    options?: AddBehaviorOptions,\n  ): BehaviorOptions {\n    if (options?.edgeLambdas != null) {\n      throw Error(\"User-defined edgeLambdas is currently not supported\")\n    }\n\n    return {\n      origin,\n      compress: true,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      edgeLambdas: [\n        {\n          eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,\n          functionVersion: this.checkAuthFn,\n        },\n        {\n          eventType: cloudfront.LambdaEdgeEventType.ORIGIN_RESPONSE,\n          functionVersion: this.httpHeadersFn,\n        },\n      ],\n      ...options,\n    }\n  }\n\n  /**\n   * Update Cognito client to use the proper URLs and OAuth scopes.\n   *\n   * TODO: In case the client configuration changes and is updated\n   *  by CloudFormation, this will not be reapplied causing the client\n   *  to not be correctly configured.\n   *  How can we avoid this scenario?\n   */\n  public updateClient(id: string, props: UpdateClientProps): ClientUpdate {\n    if (!this.clientCreated) {\n      throw new Error(\n        \"You cannot use updateClient with a user-provided Cognito Client \" +\n          \"since it would override the user-provided settings\",\n      )\n    }\n\n    return new ClientUpdate(this, id, {\n      client: this.client,\n      userPool: this.userPool,\n      signOutUrl: props.signOutUrl,\n      callbackUrl: props.callbackUrl,\n      oauthScopes: this.oauthScopes,\n      identityProviders:\n        props.identityProviders ??\n        [\"COGNITO\"].concat(\n          this.userPool.identityProviders.map((it) => it.providerName),\n        ),\n    })\n  }\n}\n"]}

package/lib/cross-region-params.d.ts

@@ -0,0 +1,57 @@
+import { Construct } from "constructs";
+export interface CrossRegionParamProps<T> {
+    /**
+     * Nonce to force the stack to re-check for updated values.
+     *
+     * @default Date.now().toString()
+     */
+    nonce?: string;
+    /**
+     * SSM Parameter name used to store the reference.
+     */
+    parameterName: string;
+    /**
+     * The resource to make available cross-region.
+     */
+    resource: T;
+    /**
+     * Convert the resource to a string representation for storage in SSM.
+     */
+    resourceToReference(resource: T): string;
+    /**
+     * Reconstruct the resource from its stored string representation.
+     */
+    referenceToResource(scope: Construct, id: string, reference: string): T;
+    /**
+     * Regions where this reference should be available.
+     */
+    regions: string[];
+}
+/**
+ * Makes a CDK resource available in other AWS regions by storing a
+ * string reference in SSM Parameter Store.
+ *
+ * On the producer side (constructor), the resource's string representation
+ * is written to SSM in each target region via custom resources.
+ *
+ * On the consumer side (get), the reference is read back from SSM and
+ * used to reconstruct the resource. If producer and consumer are in the
+ * same region, the resource is returned directly without SSM.
+ */
+export declare class CrossRegionParam<T> extends Construct {
+    private readonly nonce;
+    private readonly parameterName;
+    private readonly resource;
+    private readonly referenceToResource;
+    private readonly regions;
+    constructor(scope: Construct, id: string, props: CrossRegionParamProps<T>);
+    /**
+     * Retrieve the resource. Returns it directly when in the same region
+     * as the producer, otherwise resolves it from SSM Parameter Store.
+     */
+    get(scope: Construct, id: string): T;
+    /**
+     * Write an SSM Parameter to a specific region using a custom resource.
+     */
+    private putParameterInRegion;
+}

package/lib/cross-region-params.js

@@ -0,0 +1,96 @@
+import { CfnParameter, Stack } from "aws-cdk-lib";
+import * as ssm from "aws-cdk-lib/aws-ssm";
+import * as cr from "aws-cdk-lib/custom-resources";
+import { Construct } from "constructs";
+/**
+ * Makes a CDK resource available in other AWS regions by storing a
+ * string reference in SSM Parameter Store.
+ *
+ * On the producer side (constructor), the resource's string representation
+ * is written to SSM in each target region via custom resources.
+ *
+ * On the consumer side (get), the reference is read back from SSM and
+ * used to reconstruct the resource. If producer and consumer are in the
+ * same region, the resource is returned directly without SSM.
+ */
+export class CrossRegionParam extends Construct {
+    nonce;
+    parameterName;
+    resource;
+    referenceToResource;
+    regions;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.nonce = props.nonce ?? Date.now().toString();
+        this.parameterName = props.parameterName;
+        this.resource = props.resource;
+        this.referenceToResource = props.referenceToResource;
+        this.regions = props.regions;
+        const value = props.resourceToReference(props.resource);
+        for (const region of props.regions) {
+            this.putParameterInRegion(`Param${region}`, {
+                name: this.parameterName,
+                region,
+                value,
+            });
+        }
+    }
+    /**
+     * Retrieve the resource. Returns it directly when in the same region
+     * as the producer, otherwise resolves it from SSM Parameter Store.
+     */
+    get(scope, id) {
+        const producerRegion = Stack.of(this).region;
+        const consumerRegion = Stack.of(scope).region;
+        if (producerRegion === consumerRegion) {
+            return this.resource;
+        }
+        if (!this.regions.includes(consumerRegion)) {
+            throw new Error(`Region ${consumerRegion} is not registered for parameter ${this.parameterName}`);
+        }
+        scope.node.addDependency(this);
+        new CfnParameter(scope, `${id}Nonce`, {
+            default: this.nonce,
+        });
+        const reference = ssm.StringParameter.valueForStringParameter(scope, this.parameterName);
+        return this.referenceToResource(scope, id, reference);
+    }
+    /**
+     * Write an SSM Parameter to a specific region using a custom resource.
+     */
+    putParameterInRegion(id, props) {
+        const physicalResourceId = cr.PhysicalResourceId.of(props.name);
+        // "Resoure" is an intentional typo preserved for backward compatibility.
+        // Changing it would alter CloudFormation logical IDs and cause resource
+        // replacement in existing deployments.
+        const paramScope = new Construct(this, id);
+        new cr.AwsCustomResource(paramScope, "Resoure", {
+            onUpdate: {
+                service: "SSM",
+                action: "putParameter",
+                parameters: {
+                    Name: props.name,
+                    Value: props.value,
+                    Type: "String",
+                    Overwrite: true,
+                },
+                region: props.region,
+                physicalResourceId,
+            },
+            onDelete: {
+                service: "SSM",
+                action: "deleteParameter",
+                parameters: {
+                    Name: props.name,
+                },
+                region: props.region,
+                physicalResourceId,
+            },
+            policy: cr.AwsCustomResourcePolicy.fromSdkCalls({
+                resources: cr.AwsCustomResourcePolicy.ANY_RESOURCE,
+            }),
+            installLatestAwsSdk: false,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cross-region-params.js","sourceRoot":"","sources":["../src/cross-region-params.ts"],"names":[],"mappings":"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","sourcesContent":["import { CfnParameter, Stack } from \"aws-cdk-lib\"\nimport * as ssm from \"aws-cdk-lib/aws-ssm\"\nimport * as cr from \"aws-cdk-lib/custom-resources\"\nimport { Construct } from \"constructs\"\n\nexport interface CrossRegionParamProps<T> {\n  /**\n   * Nonce to force the stack to re-check for updated values.\n   *\n   * @default Date.now().toString()\n   */\n  nonce?: string\n  /**\n   * SSM Parameter name used to store the reference.\n   */\n  parameterName: string\n  /**\n   * The resource to make available cross-region.\n   */\n  resource: T\n  /**\n   * Convert the resource to a string representation for storage in SSM.\n   */\n  resourceToReference(resource: T): string\n  /**\n   * Reconstruct the resource from its stored string representation.\n   */\n  referenceToResource(scope: Construct, id: string, reference: string): T\n  /**\n   * Regions where this reference should be available.\n   */\n  regions: string[]\n}\n\n/**\n * Makes a CDK resource available in other AWS regions by storing a\n * string reference in SSM Parameter Store.\n *\n * On the producer side (constructor), the resource's string representation\n * is written to SSM in each target region via custom resources.\n *\n * On the consumer side (get), the reference is read back from SSM and\n * used to reconstruct the resource. If producer and consumer are in the\n * same region, the resource is returned directly without SSM.\n */\nexport class CrossRegionParam<T> extends Construct {\n  private readonly nonce: string\n  private readonly parameterName: string\n  private readonly resource: T\n  private readonly referenceToResource: CrossRegionParamProps<T>[\"referenceToResource\"]\n  private readonly regions: string[]\n\n  constructor(scope: Construct, id: string, props: CrossRegionParamProps<T>) {\n    super(scope, id)\n    this.nonce = props.nonce ?? Date.now().toString()\n    this.parameterName = props.parameterName\n    this.resource = props.resource\n    this.referenceToResource = props.referenceToResource\n    this.regions = props.regions\n\n    const value = props.resourceToReference(props.resource)\n\n    for (const region of props.regions) {\n      this.putParameterInRegion(`Param${region}`, {\n        name: this.parameterName,\n        region,\n        value,\n      })\n    }\n  }\n\n  /**\n   * Retrieve the resource. Returns it directly when in the same region\n   * as the producer, otherwise resolves it from SSM Parameter Store.\n   */\n  public get(scope: Construct, id: string): T {\n    const producerRegion = Stack.of(this).region\n    const consumerRegion = Stack.of(scope).region\n\n    if (producerRegion === consumerRegion) {\n      return this.resource\n    }\n\n    if (!this.regions.includes(consumerRegion)) {\n      throw new Error(\n        `Region ${consumerRegion} is not registered for parameter ${this.parameterName}`,\n      )\n    }\n\n    scope.node.addDependency(this)\n\n    new CfnParameter(scope, `${id}Nonce`, {\n      default: this.nonce,\n    })\n\n    const reference = ssm.StringParameter.valueForStringParameter(\n      scope,\n      this.parameterName,\n    )\n    return this.referenceToResource(scope, id, reference)\n  }\n\n  /**\n   * Write an SSM Parameter to a specific region using a custom resource.\n   */\n  private putParameterInRegion(\n    id: string,\n    props: { name: string; region: string; value: string },\n  ) {\n    const physicalResourceId = cr.PhysicalResourceId.of(props.name)\n\n    // \"Resoure\" is an intentional typo preserved for backward compatibility.\n    // Changing it would alter CloudFormation logical IDs and cause resource\n    // replacement in existing deployments.\n    const paramScope = new Construct(this, id)\n    new cr.AwsCustomResource(paramScope, \"Resoure\", {\n      onUpdate: {\n        service: \"SSM\",\n        action: \"putParameter\",\n        parameters: {\n          Name: props.name,\n          Value: props.value,\n          Type: \"String\",\n          Overwrite: true,\n        },\n        region: props.region,\n        physicalResourceId,\n      },\n      onDelete: {\n        service: \"SSM\",\n        action: \"deleteParameter\",\n        parameters: {\n          Name: props.name,\n        },\n        region: props.region,\n        physicalResourceId,\n      },\n      policy: cr.AwsCustomResourcePolicy.fromSdkCalls({\n        resources: cr.AwsCustomResourcePolicy.ANY_RESOURCE,\n      }),\n      installLatestAwsSdk: false,\n    })\n  }\n}\n"]}

package/lib/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./cloudfront-auth";
+export * from "./cross-region-params";
+export * from "./lambda-config/lambda-config";
 export * from "./lambdas";

package/lib/index.js

@@ -1,3 +1,5 @@
 export * from "./cloudfront-auth";
+export * from "./cross-region-params";
+export * from "./lambda-config/lambda-config";
 export * from "./lambdas";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLFdBQVcsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2Nsb3VkZnJvbnQtYXV0aFwiXG5leHBvcnQgKiBmcm9tIFwiLi9sYW1iZGFzXCJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLHVCQUF1QixDQUFBO0FBQ3JDLGNBQWMsK0JBQStCLENBQUE7QUFDN0MsY0FBYyxXQUFXLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jbG91ZGZyb250LWF1dGhcIlxuZXhwb3J0ICogZnJvbSBcIi4vY3Jvc3MtcmVnaW9uLXBhcmFtc1wiXG5leHBvcnQgKiBmcm9tIFwiLi9sYW1iZGEtY29uZmlnL2xhbWJkYS1jb25maWdcIlxuZXhwb3J0ICogZnJvbSBcIi4vbGFtYmRhc1wiXG4iXX0=

package/lib/lambda-config/lambda-config.d.ts

@@ -0,0 +1,38 @@
+import { aws_lambda as lambda } from "aws-cdk-lib";
+import { Construct } from "constructs";
+export interface LambdaConfigProps {
+    /**
+     * The Lambda Function to be updated.
+     *
+     * If this points to a specific version, the version qualifier
+     * will be ignored, but will be used for invalidation instead
+     * of providing a separate nonce value.
+     *
+     * A Lambda Function can only receive a new version based on
+     * the latest version.
+     */
+    function: lambda.IFunction;
+    /**
+     * The configuration to be added to the Lambda Function. Must be
+     * a valid JSON structure and cannot contain null values since it
+     * is not supported by CloudFormation custom resource properties.
+     */
+    config: Record<string, any>;
+    /**
+     * Nonce to force new version.
+     *
+     * If the function provided does not point to a specific
+     * version, specify nonce to ensure the function is updated
+     * after every change.
+     */
+    nonce?: string;
+}
+/**
+ * Modify a Lambda Function by adding a config.json file using
+ * the provided object, and provide a new version for the
+ * Lambda Function.
+ */
+export declare class LambdaConfig extends Construct {
+    readonly version: lambda.IVersion;
+    constructor(scope: Construct, id: string, props: LambdaConfigProps);
+}

package/lib/lambda-config/lambda-config.js

@@ -0,0 +1,59 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CustomResource, custom_resources as cr, Duration, aws_iam as iam, aws_lambda as lambda, Stack, } from "aws-cdk-lib";
+import { Construct } from "constructs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Modify a Lambda Function by adding a config.json file using
+ * the provided object, and provide a new version for the
+ * Lambda Function.
+ */
+export class LambdaConfig extends Construct {
+    version;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const updateCodeResource = new CustomResource(this, "Resource", {
+            serviceToken: LambdaConfigProvider.getOrCreate(this).serviceToken,
+            properties: {
+                FunctionArn: props.function.functionArn,
+                Config: props.config,
+                Nonce: props.nonce ?? "",
+            },
+        });
+        this.version = lambda.Version.fromVersionArn(this, "Version", updateCodeResource.getAttString("FunctionArn"));
+    }
+}
+class LambdaConfigProvider extends Construct {
+    static getOrCreate(scope) {
+        const stack = Stack.of(scope);
+        const id = "liflig-infra.lambda-config.provider";
+        return (stack.node.tryFindChild(id) ||
+            new LambdaConfigProvider(stack, id));
+    }
+    provider;
+    serviceToken;
+    constructor(scope, id) {
+        super(scope, id);
+        this.provider = new cr.Provider(this, "Provider", {
+            onEventHandler: new lambda.Function(this, "UpdateCodeFn", {
+                code: lambda.Code.fromAsset(path.join(__dirname, "../../dist/lambda-config-handler")),
+                handler: "index.handler",
+                runtime: lambda.Runtime.NODEJS_24_X,
+                timeout: Duration.minutes(2),
+                initialPolicy: [
+                    new iam.PolicyStatement({
+                        actions: [
+                            "lambda:GetFunction",
+                            "lambda:GetFunctionConfiguration",
+                            "lambda:UpdateFunctionCode",
+                        ],
+                        resources: ["*"],
+                    }),
+                ],
+            }),
+        });
+        this.serviceToken = this.provider.serviceToken;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambdas.d.ts

@@ -1,6 +1,6 @@
-import { ParameterResource } from "@henrist/cdk-cross-region-params";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import { Construct } from "constructs";
+import { CrossRegionParam } from "./cross-region-params";
 interface AuthLambdasProps {
     /**
      * List of regions this can be used in. This should contain the region
@@ -20,11 +20,11 @@ interface AuthLambdasProps {
  * distribution is deployed from, so that it can be used cross-region.
  */
 export declare class AuthLambdas extends Construct {
-    readonly checkAuthFn: ParameterResource<lambda.IVersion>;
-    readonly httpHeadersFn: ParameterResource<lambda.IVersion>;
-    readonly parseAuthFn: ParameterResource<lambda.IVersion>;
-    readonly refreshAuthFn: ParameterResource<lambda.IVersion>;
-    readonly signOutFn: ParameterResource<lambda.IVersion>;
+    readonly checkAuthFn: CrossRegionParam<lambda.IVersion>;
+    readonly httpHeadersFn: CrossRegionParam<lambda.IVersion>;
+    readonly parseAuthFn: CrossRegionParam<lambda.IVersion>;
+    readonly refreshAuthFn: CrossRegionParam<lambda.IVersion>;
+    readonly signOutFn: CrossRegionParam<lambda.IVersion>;
     private readonly regions;
     private readonly nonce;
     constructor(scope: Construct, id: string, props: AuthLambdasProps);

package/lib/lambdas.js

@@ -1,10 +1,10 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ParameterResource } from "@henrist/cdk-cross-region-params";
 import { Duration, Stack } from "aws-cdk-lib";
 import * as iam from "aws-cdk-lib/aws-iam";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import { Construct } from "constructs";
+import { CrossRegionParam } from "./cross-region-params";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const isSnapshot = process.env.IS_SNAPSHOT === "true";
@@ -58,7 +58,7 @@ export class AuthLambdas extends Construct {
         if (this.node.addr === undefined) {
             throw new Error("node.addr not found - ensure aws-cdk is up-to-update");
         }
-        return new ParameterResource(this, `${id}VersionParam`, {
+        return new CrossRegionParam(this, `${id}VersionParam`, {
             nonce: isSnapshot ? "snapshot" : undefined,
             parameterName: `/cf/region/${region}/stack/${stackName}/${this.node.addr}-${id}-function-arn`,
             referenceToResource: (scope, id, reference) => lambda.Version.fromVersionArn(scope, id, reference),
@@ -68,4 +68,4 @@ export class AuthLambdas extends Construct {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambdas.js","sourceRoot":"","sources":["../src/lambdas.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\nimport { ParameterResource } from \"@henrist/cdk-cross-region-params\"\nimport { Duration, Stack } from \"aws-cdk-lib\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport { Construct } from \"constructs\"\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\nconst isSnapshot = process.env.IS_SNAPSHOT === \"true\"\n\ninterface AuthLambdasProps {\n  /**\n   * List of regions this can be used in. This should contain the region\n   * where the CloudFront distribution is deployed (the CloudFormation stack).\n   */\n  regions: string[]\n  /**\n   * A nonce value that can be used to force new lambda functions\n   * to allow new versions to be created.\n   */\n  nonce?: string\n}\n\n/**\n * Lambdas used for CloudFront. Must be deployed in us-east-1.\n *\n * This will provision SSM Parameters the region where the CloudFront\n * distribution is deployed from, so that it can be used cross-region.\n */\nexport class AuthLambdas extends Construct {\n  public readonly checkAuthFn: ParameterResource<lambda.IVersion>\n  public readonly httpHeadersFn: ParameterResource<lambda.IVersion>\n  public readonly parseAuthFn: ParameterResource<lambda.IVersion>\n  public readonly refreshAuthFn: ParameterResource<lambda.IVersion>\n  public readonly signOutFn: ParameterResource<lambda.IVersion>\n\n  private readonly regions: string[]\n  private readonly nonce: string | undefined\n\n  constructor(scope: Construct, id: string, props: AuthLambdasProps) {\n    super(scope, id)\n\n    const region = Stack.of(this).region\n    this.regions = props.regions\n\n    this.nonce = props.nonce\n\n    if (region !== \"us-east-1\") {\n      throw new Error(\"Region must be us-east-1 due to Lambda@edge\")\n    }\n\n    const role = new iam.Role(this, \"ServiceRole\", {\n      assumedBy: new iam.CompositePrincipal(\n        new iam.ServicePrincipal(\"lambda.amazonaws.com\"),\n        new iam.ServicePrincipal(\"edgelambda.amazonaws.com\"),\n      ),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          \"service-role/AWSLambdaBasicExecutionRole\",\n        ),\n      ],\n    })\n\n    this.checkAuthFn = this.addFunction(\"CheckAuthFunction\", \"check-auth\", role)\n    this.httpHeadersFn = this.addFunction(\n      \"HttpHeadersFunction\",\n      \"http-headers\",\n      role,\n    )\n    this.parseAuthFn = this.addFunction(\"ParseAuthFunction\", \"parse-auth\", role)\n    this.refreshAuthFn = this.addFunction(\n      \"RefreshAuthFunction\",\n      \"refresh-auth\",\n      role,\n    )\n    this.signOutFn = this.addFunction(\"SignOutFunction\", \"sign-out\", role)\n  }\n\n  private addFunction(id: string, assetName: string, role: iam.IRole) {\n    const region = Stack.of(this).region\n    const stackName = Stack.of(this).stackName\n\n    const fn = new lambda.Function(this, id, {\n      code:\n        process.env.NODE_ENV === \"test\"\n          ? lambda.Code.fromInline(\"snapshot-value\")\n          : lambda.Code.fromAsset(path.join(__dirname, `../dist/${assetName}`)),\n      handler: \"index.handler\",\n      runtime: lambda.Runtime.NODEJS_24_X,\n      timeout: Duration.seconds(5),\n      role,\n      description:\n        this.nonce == null ? undefined : `Nonce value: ${this.nonce}`,\n    })\n\n    if (this.node.addr === undefined) {\n      throw new Error(\"node.addr not found - ensure aws-cdk is up-to-update\")\n    }\n\n    return new ParameterResource<lambda.IVersion>(this, `${id}VersionParam`, {\n      nonce: isSnapshot ? \"snapshot\" : undefined,\n      parameterName: `/cf/region/${region}/stack/${stackName}/${this.node.addr}-${id}-function-arn`,\n      referenceToResource: (scope, id, reference) =>\n        lambda.Version.fromVersionArn(scope, id, reference),\n      regions: this.regions,\n      resource: fn.currentVersion,\n      resourceToReference: (resource) => resource.functionArn,\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambdas.js","sourceRoot":"","sources":["../src/lambdas.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\nimport { Duration, Stack } from \"aws-cdk-lib\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport { Construct } from \"constructs\"\nimport { CrossRegionParam } from \"./cross-region-params\"\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\nconst isSnapshot = process.env.IS_SNAPSHOT === \"true\"\n\ninterface AuthLambdasProps {\n  /**\n   * List of regions this can be used in. This should contain the region\n   * where the CloudFront distribution is deployed (the CloudFormation stack).\n   */\n  regions: string[]\n  /**\n   * A nonce value that can be used to force new lambda functions\n   * to allow new versions to be created.\n   */\n  nonce?: string\n}\n\n/**\n * Lambdas used for CloudFront. Must be deployed in us-east-1.\n *\n * This will provision SSM Parameters the region where the CloudFront\n * distribution is deployed from, so that it can be used cross-region.\n */\nexport class AuthLambdas extends Construct {\n  public readonly checkAuthFn: CrossRegionParam<lambda.IVersion>\n  public readonly httpHeadersFn: CrossRegionParam<lambda.IVersion>\n  public readonly parseAuthFn: CrossRegionParam<lambda.IVersion>\n  public readonly refreshAuthFn: CrossRegionParam<lambda.IVersion>\n  public readonly signOutFn: CrossRegionParam<lambda.IVersion>\n\n  private readonly regions: string[]\n  private readonly nonce: string | undefined\n\n  constructor(scope: Construct, id: string, props: AuthLambdasProps) {\n    super(scope, id)\n\n    const region = Stack.of(this).region\n    this.regions = props.regions\n\n    this.nonce = props.nonce\n\n    if (region !== \"us-east-1\") {\n      throw new Error(\"Region must be us-east-1 due to Lambda@edge\")\n    }\n\n    const role = new iam.Role(this, \"ServiceRole\", {\n      assumedBy: new iam.CompositePrincipal(\n        new iam.ServicePrincipal(\"lambda.amazonaws.com\"),\n        new iam.ServicePrincipal(\"edgelambda.amazonaws.com\"),\n      ),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          \"service-role/AWSLambdaBasicExecutionRole\",\n        ),\n      ],\n    })\n\n    this.checkAuthFn = this.addFunction(\"CheckAuthFunction\", \"check-auth\", role)\n    this.httpHeadersFn = this.addFunction(\n      \"HttpHeadersFunction\",\n      \"http-headers\",\n      role,\n    )\n    this.parseAuthFn = this.addFunction(\"ParseAuthFunction\", \"parse-auth\", role)\n    this.refreshAuthFn = this.addFunction(\n      \"RefreshAuthFunction\",\n      \"refresh-auth\",\n      role,\n    )\n    this.signOutFn = this.addFunction(\"SignOutFunction\", \"sign-out\", role)\n  }\n\n  private addFunction(id: string, assetName: string, role: iam.IRole) {\n    const region = Stack.of(this).region\n    const stackName = Stack.of(this).stackName\n\n    const fn = new lambda.Function(this, id, {\n      code:\n        process.env.NODE_ENV === \"test\"\n          ? lambda.Code.fromInline(\"snapshot-value\")\n          : lambda.Code.fromAsset(path.join(__dirname, `../dist/${assetName}`)),\n      handler: \"index.handler\",\n      runtime: lambda.Runtime.NODEJS_24_X,\n      timeout: Duration.seconds(5),\n      role,\n      description:\n        this.nonce == null ? undefined : `Nonce value: ${this.nonce}`,\n    })\n\n    if (this.node.addr === undefined) {\n      throw new Error(\"node.addr not found - ensure aws-cdk is up-to-update\")\n    }\n\n    return new CrossRegionParam<lambda.IVersion>(this, `${id}VersionParam`, {\n      nonce: isSnapshot ? \"snapshot\" : undefined,\n      parameterName: `/cf/region/${region}/stack/${stackName}/${this.node.addr}-${id}-function-arn`,\n      referenceToResource: (scope, id, reference) =>\n        lambda.Version.fromVersionArn(scope, id, reference),\n      regions: this.regions,\n      resource: fn.currentVersion,\n      resourceToReference: (resource) => resource.functionArn,\n    })\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk-cloudfront-auth",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "description": "CDK Constructs for adding authentication for a CloudFront Distribution",
   "type": "module",
   "repository": {
@@ -16,7 +16,7 @@
     "prepare": "bun run build && bunx husky",
     "semantic-release": "semantic-release",
     "clean": "rm -rf dist lib",
-    "upgrade-deps": "ncu --upgrade --install=always --format group --reject @types/node"
+    "upgrade-deps": "bun update"
   },
   "keywords": [
     "cdk",
@@ -35,31 +35,30 @@
     "provenance": true
   },
   "devDependencies": {
+    "@aws-sdk/client-lambda": "^3.1005.0",
     "@biomejs/biome": "2.4.6",
-    "@commitlint/cli": "20.4.3",
-    "@commitlint/config-conventional": "20.4.3",
+    "@commitlint/cli": "20.4.4",
+    "@commitlint/config-conventional": "20.4.4",
+    "@types/adm-zip": "^0.5.7",
     "@types/aws-lambda": "8.10.161",
     "@types/jest": "30.0.0",
     "@types/jsonwebtoken": "9.0.10",
     "@types/node": "24.12.0",
-    "aws-cdk-lib": "2.241.0",
+    "adm-zip": "^0.5.16",
+    "aws-cdk-lib": "2.243.0",
     "axios": "1.13.6",
     "constructs": "10.5.1",
     "cookie": "1.1.1",
     "husky": "9.1.7",
-    "jest": "30.2.0",
+    "jest": "30.3.0",
     "jest-cdk-snapshot": "2.3.6",
     "jsonwebtoken": "9.0.3",
     "jwks-rsa": "3.2.2",
-    "npm-check-updates": "19.6.3",
     "semantic-release": "25.0.3",
     "ts-jest": "29.4.6",
     "typescript": "5.9.3"
   },
-  "dependencies": {
-    "@henrist/cdk-cross-region-params": "^2.0.1",
-    "@liflig/cdk-lambda-config": "1.7.36"
-  },
+  "dependencies": {},
   "peerDependencies": {
     "aws-cdk-lib": "^2.0.0"
   },