@liflig/cdk-vy 1.0.0

package/lib/cognito-app-client/cognito-app-client.js

@@ -0,0 +1,183 @@
+/**
+ * CDK Construct for Cognito App Client
+ */
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as cdk from "aws-cdk-lib";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
+import * as cr from "aws-cdk-lib/custom-resources";
+import { Construct } from "constructs";
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Type of app client
+ */
+export var AppClientType;
+(function (AppClientType) {
+    /**
+     * Backend app client for machine-to-machine (M2M) authentication
+     * Uses OAuth 2.0 Client Credentials grant type
+     * Generates a client secret for authentication
+     */
+    AppClientType["BACKEND"] = "backend";
+    /**
+     * Frontend app client for user authentication
+     * Uses OAuth 2.0 Authorization Code or Implicit grant types
+     * Supports callback URLs and logout URLs for browser-based flows
+     */
+    AppClientType["FRONTEND"] = "frontend";
+})(AppClientType || (AppClientType = {}));
+/**
+ * A Cognito App Client managed through Vy's central Cognito service
+ *
+ * App clients are the user pool authentication resources attached to your app.
+ * Use an app client to configure the permitted authentication actions for an app.
+ *
+ * There are two types of app clients:
+ * - **Backend**: Machine-to-machine authentication using OAuth 2.0 Client Credentials
+ * - **Frontend**: User authentication using OAuth 2.0 Authorization Code or Implicit Grant
+ *
+ * @example
+ * // Backend app client for M2M authentication
+ * const backendClient = new CognitoAppClient(this, 'BackendClient', {
+ *   environment: VyEnvironment.TEST,
+ *   name: 'my-backend-service',
+ *   type: AppClientType.BACKEND,
+ *   scopes: ['https://api.vydev.io/read', 'https://api.vydev.io/write']
+ * });
+ *
+ * // Access credentials
+ * const clientId = backendClient.clientId;
+ * const clientSecret = backendClient.clientSecret; // Stored in Secrets Manager
+ *
+ * @example
+ * // Frontend app client for user authentication
+ * const frontendClient = new CognitoAppClient(this, 'FrontendClient', {
+ *   environment: VyEnvironment.PROD,
+ *   name: 'my-web-app',
+ *   type: AppClientType.FRONTEND,
+ *   scopes: ['email', 'openid', 'profile'],
+ *   callbackUrls: ['https://my-app.vydev.io/auth/callback'],
+ *   logoutUrls: ['https://my-app.vydev.io/logout']
+ * });
+ */
+export class CognitoAppClient extends Construct {
+    /**
+     * The name of the app client
+     */
+    name;
+    /**
+     * The underlying custom resource
+     */
+    resource;
+    /**
+     * The logGroup for the event handler lambda
+     */
+    lambdaLogGroup;
+    /**
+     * The logGroup for the custom resource provider
+     */
+    providerLogGroup;
+    /**
+     * The client ID for authentication
+     */
+    clientId;
+    /**
+     * The client secret (only for backend clients)
+     * If storeSecretInSecretsManager is true, this returns a reference to the secret value
+     */
+    clientSecret;
+    /**
+     * The Secrets Manager secret containing the client secret
+     * Only available if storeSecretInSecretsManager is true and type is backend
+     */
+    clientSecretSecret;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.name = props.name;
+        if (props.type === AppClientType.FRONTEND &&
+            props.callbackUrls &&
+            props.callbackUrls.length === 0) {
+            cdk.Annotations.of(this).addWarning("Frontend app clients typically require callbackUrls for OAuth flows");
+        }
+        this.lambdaLogGroup = new logs.LogGroup(this, "LambdaLogGroup", {
+            retention: props.logsRetention ?? logs.RetentionDays.ONE_WEEK,
+        });
+        const onEventHandler = new NodejsFunction(this, "OnEventHandler", {
+            runtime: lambda.Runtime.NODEJS_22_X,
+            handler: "handler",
+            entry: require.resolve(`${__dirname}/handler`),
+            timeout: cdk.Duration.minutes(2),
+            memorySize: 256,
+            logGroup: this.lambdaLogGroup,
+            environment: props.cognitoBaseDomain
+                ? {
+                    COGNITO_BASE_DOMAIN: props.cognitoBaseDomain,
+                }
+                : undefined,
+            bundling: {
+                minify: true,
+                sourceMap: true,
+                target: "es2020",
+                externalModules: ["aws-sdk"],
+            },
+        });
+        onEventHandler.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ["execute-api:Invoke"],
+            resources: ["*"], // Can be scoped down if API Gateway ARN is known
+        }));
+        this.providerLogGroup = new logs.LogGroup(this, "ProviderLogGroup", {
+            retention: props.logsRetention ?? logs.RetentionDays.ONE_WEEK,
+        });
+        const provider = new cr.Provider(this, "Provider", {
+            onEventHandler,
+            logGroup: this.providerLogGroup,
+        });
+        this.resource = new cdk.CustomResource(this, "Resource", {
+            serviceToken: provider.serviceToken,
+            properties: {
+                Environment: props.environment,
+                Name: props.name,
+                Type: props.type,
+                Scopes: props.scopes || [],
+                CallbackUrls: props.callbackUrls || [],
+                LogoutUrls: props.logoutUrls || [],
+                GenerateSecret: props.generateSecret,
+            },
+            // Force replacement if type changes
+            resourceType: "Custom::VyCognitoAppClient",
+        });
+        this.clientId = this.resource.getAttString("ClientId");
+        const shouldStoreSecret = props.storeSecretInSecretsManager !== false;
+        if (props.type === AppClientType.BACKEND && shouldStoreSecret) {
+            const secretValue = this.resource.getAttString("ClientSecret");
+            this.clientSecretSecret = new secretsmanager.Secret(this, "ClientSecret", {
+                secretName: props.secretName ??
+                    `vy/${props.environment}/cognito/app-client/${props.name}`,
+                description: `Client secret for Vy Cognito app client ${props.name}`,
+                secretStringValue: cdk.SecretValue.unsafePlainText(secretValue),
+            });
+            this.clientSecret = this.clientSecretSecret.secretValue.unsafeUnwrap();
+        }
+        else if (props.type === AppClientType.BACKEND) {
+            this.clientSecret = this.resource.getAttString("ClientSecret");
+        }
+    }
+    /**
+     * Grant read access to the client secret (if it exists in Secrets Manager)
+     */
+    grantReadSecret(grantee) {
+        if (!this.clientSecretSecret) {
+            throw new Error("Client secret is not stored in Secrets Manager");
+        }
+        return this.clientSecretSecret.grantRead(grantee);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognito-app-client.js","sourceRoot":"","sources":["../../src/cognito-app-client/cognito-app-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CDK Construct for Cognito App Client\n */\n\nimport { createRequire } from \"node:module\"\nimport * as path from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\nimport * as cdk from \"aws-cdk-lib\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport { NodejsFunction } from \"aws-cdk-lib/aws-lambda-nodejs\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as cr from \"aws-cdk-lib/custom-resources\"\nimport { Construct } from \"constructs\"\nimport type { VyEnvironment } from \"../shared/types\"\n\nconst require = createRequire(import.meta.url)\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\n\n/**\n * Type of app client\n */\nexport enum AppClientType {\n  /**\n   * Backend app client for machine-to-machine (M2M) authentication\n   * Uses OAuth 2.0 Client Credentials grant type\n   * Generates a client secret for authentication\n   */\n  BACKEND = \"backend\",\n\n  /**\n   * Frontend app client for user authentication\n   * Uses OAuth 2.0 Authorization Code or Implicit grant types\n   * Supports callback URLs and logout URLs for browser-based flows\n   */\n  FRONTEND = \"frontend\",\n}\n\nexport interface CognitoAppClientProps {\n  /**\n   * The Vy environment to provision in (e.g., VyEnvironment.PROD, VyEnvironment.STAGE, VyEnvironment.TEST)\n   */\n  readonly environment: VyEnvironment\n\n  /**\n   * The name of the app client\n   * Must be unique within the environment\n   */\n  readonly name: string\n\n  /**\n   * The type of app client\n   * - backend: Machine-to-machine authentication with client credentials\n   * - frontend: User authentication with authorization code or implicit grant\n   */\n  readonly type: AppClientType\n\n  /**\n   * OAuth scopes for this client\n   *\n   * For backend clients: Use resource server scopes (e.g., 'https://api.vydev.io/read')\n   * For frontend clients: Use OIDC scopes (e.g., 'email', 'openid', 'profile')\n   *\n   * @default - Empty array\n   */\n  readonly scopes?: string[]\n\n  /**\n   * Callback URLs for OAuth flows\n   * Only used with frontend clients\n   *\n   * @default - No callback URLs\n   */\n  readonly callbackUrls?: string[]\n\n  /**\n   * Logout URLs for OAuth flows\n   * Only used with frontend clients\n   *\n   * @default - No logout URLs\n   */\n  readonly logoutUrls?: string[]\n\n  /**\n   * Whether to generate a client secret\n   * Automatically set based on type, but can be overridden\n   *\n   * @default - true for backend, false for frontend\n   */\n  readonly generateSecret?: boolean\n\n  /**\n   * Whether to store the client secret in AWS Secrets Manager\n   * Only applicable if generateSecret is true\n   *\n   * @default true\n   */\n  readonly storeSecretInSecretsManager?: boolean\n\n  /**\n   * Name of the secret in AWS Secrets Manager\n   * Only applicable if generateSecret is true\n   */\n  readonly secretName?: string\n\n  /**\n   * Base domain for Cognito service\n   * @default 'cognito.vydev.io'\n   */\n  readonly cognitoBaseDomain?: string\n\n  /**\n   * @default logs.RetentionDays.ONE_WEEK\n   */\n  readonly logsRetention?: logs.RetentionDays\n}\n\n/**\n * A Cognito App Client managed through Vy's central Cognito service\n *\n * App clients are the user pool authentication resources attached to your app.\n * Use an app client to configure the permitted authentication actions for an app.\n *\n * There are two types of app clients:\n * - **Backend**: Machine-to-machine authentication using OAuth 2.0 Client Credentials\n * - **Frontend**: User authentication using OAuth 2.0 Authorization Code or Implicit Grant\n *\n * @example\n * // Backend app client for M2M authentication\n * const backendClient = new CognitoAppClient(this, 'BackendClient', {\n *   environment: VyEnvironment.TEST,\n *   name: 'my-backend-service',\n *   type: AppClientType.BACKEND,\n *   scopes: ['https://api.vydev.io/read', 'https://api.vydev.io/write']\n * });\n *\n * // Access credentials\n * const clientId = backendClient.clientId;\n * const clientSecret = backendClient.clientSecret; // Stored in Secrets Manager\n *\n * @example\n * // Frontend app client for user authentication\n * const frontendClient = new CognitoAppClient(this, 'FrontendClient', {\n *   environment: VyEnvironment.PROD,\n *   name: 'my-web-app',\n *   type: AppClientType.FRONTEND,\n *   scopes: ['email', 'openid', 'profile'],\n *   callbackUrls: ['https://my-app.vydev.io/auth/callback'],\n *   logoutUrls: ['https://my-app.vydev.io/logout']\n * });\n */\nexport class CognitoAppClient extends Construct {\n  /**\n   * The name of the app client\n   */\n  public readonly name: string\n\n  /**\n   * The underlying custom resource\n   */\n  public readonly resource: cdk.CustomResource\n\n  /**\n   * The logGroup for the event handler lambda\n   */\n  public readonly lambdaLogGroup: logs.LogGroup\n\n  /**\n   * The logGroup for the custom resource provider\n   */\n  public readonly providerLogGroup: logs.LogGroup\n\n  /**\n   * The client ID for authentication\n   */\n  public readonly clientId: string\n\n  /**\n   * The client secret (only for backend clients)\n   * If storeSecretInSecretsManager is true, this returns a reference to the secret value\n   */\n  public readonly clientSecret?: string\n\n  /**\n   * The Secrets Manager secret containing the client secret\n   * Only available if storeSecretInSecretsManager is true and type is backend\n   */\n  public readonly clientSecretSecret?: secretsmanager.ISecret\n\n  constructor(scope: Construct, id: string, props: CognitoAppClientProps) {\n    super(scope, id)\n\n    this.name = props.name\n\n    if (\n      props.type === AppClientType.FRONTEND &&\n      props.callbackUrls &&\n      props.callbackUrls.length === 0\n    ) {\n      cdk.Annotations.of(this).addWarning(\n        \"Frontend app clients typically require callbackUrls for OAuth flows\",\n      )\n    }\n\n    this.lambdaLogGroup = new logs.LogGroup(this, \"LambdaLogGroup\", {\n      retention: props.logsRetention ?? logs.RetentionDays.ONE_WEEK,\n    })\n\n    const onEventHandler = new NodejsFunction(this, \"OnEventHandler\", {\n      runtime: lambda.Runtime.NODEJS_22_X,\n      handler: \"handler\",\n      entry: require.resolve(`${__dirname}/handler`),\n      timeout: cdk.Duration.minutes(2),\n      memorySize: 256,\n      logGroup: this.lambdaLogGroup,\n      environment: props.cognitoBaseDomain\n        ? {\n            COGNITO_BASE_DOMAIN: props.cognitoBaseDomain,\n          }\n        : undefined,\n      bundling: {\n        minify: true,\n        sourceMap: true,\n        target: \"es2020\",\n        externalModules: [\"aws-sdk\"],\n      },\n    })\n\n    onEventHandler.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\"execute-api:Invoke\"],\n        resources: [\"*\"], // Can be scoped down if API Gateway ARN is known\n      }),\n    )\n\n    this.providerLogGroup = new logs.LogGroup(this, \"ProviderLogGroup\", {\n      retention: props.logsRetention ?? logs.RetentionDays.ONE_WEEK,\n    })\n\n    const provider = new cr.Provider(this, \"Provider\", {\n      onEventHandler,\n      logGroup: this.providerLogGroup,\n    })\n\n    this.resource = new cdk.CustomResource(this, \"Resource\", {\n      serviceToken: provider.serviceToken,\n      properties: {\n        Environment: props.environment,\n        Name: props.name,\n        Type: props.type,\n        Scopes: props.scopes || [],\n        CallbackUrls: props.callbackUrls || [],\n        LogoutUrls: props.logoutUrls || [],\n        GenerateSecret: props.generateSecret,\n      },\n      // Force replacement if type changes\n      resourceType: \"Custom::VyCognitoAppClient\",\n    })\n\n    this.clientId = this.resource.getAttString(\"ClientId\")\n\n    const shouldStoreSecret = props.storeSecretInSecretsManager !== false\n    if (props.type === AppClientType.BACKEND && shouldStoreSecret) {\n      const secretValue = this.resource.getAttString(\"ClientSecret\")\n\n      this.clientSecretSecret = new secretsmanager.Secret(\n        this,\n        \"ClientSecret\",\n        {\n          secretName:\n            props.secretName ??\n            `vy/${props.environment}/cognito/app-client/${props.name}`,\n          description: `Client secret for Vy Cognito app client ${props.name}`,\n          secretStringValue: cdk.SecretValue.unsafePlainText(secretValue),\n        },\n      )\n\n      this.clientSecret = this.clientSecretSecret.secretValue.unsafeUnwrap()\n    } else if (props.type === AppClientType.BACKEND) {\n      this.clientSecret = this.resource.getAttString(\"ClientSecret\")\n    }\n  }\n\n  /**\n   * Grant read access to the client secret (if it exists in Secrets Manager)\n   */\n  public grantReadSecret(grantee: iam.IGrantable): iam.Grant {\n    if (!this.clientSecretSecret) {\n      throw new Error(\"Client secret is not stored in Secrets Manager\")\n    }\n    return this.clientSecretSecret.grantRead(grantee)\n  }\n}\n"]}

package/lib/cognito-app-client/handler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Lambda handler for CognitoAppClient custom resource
+ */
+import type { CustomResourceRequest, CustomResourceResponse } from "../shared/types";
+export declare function handler(event: CustomResourceRequest): Promise<CustomResourceResponse>;

package/lib/cognito-app-client/handler.js

@@ -0,0 +1,114 @@
+/**
+ * Lambda handler for CognitoAppClient custom resource
+ */
+import { createFailureResponse, createSuccessResponse, handleError, } from "../shared/custom-resource-handler";
+import { createUrlFromEnvironment, signedRequest } from "../shared/sigv4-client";
+const COGNITO_BASE_DOMAIN = process.env.COGNITO_BASE_DOMAIN || "cognito.vydev.io";
+async function createAppClient(baseUrl, client) {
+    const response = await signedRequest({
+        method: "POST",
+        hostname: baseUrl,
+        path: "/app-clients",
+        body: JSON.stringify(client),
+    });
+    if (response.statusCode !== 201) {
+        throw new Error(`Could not create resource: ${response.statusCode} - ${response.body}`);
+    }
+    return JSON.parse(response.body);
+}
+async function readAppClient(baseUrl, name) {
+    const encodedName = encodeURIComponent(name);
+    const response = await signedRequest({
+        method: "GET",
+        hostname: baseUrl,
+        path: `/app-clients/${encodedName}`,
+    });
+    if (response.statusCode !== 200) {
+        throw new Error(`Could not read resource: ${response.statusCode} - ${response.body}`);
+    }
+    return JSON.parse(response.body);
+}
+async function updateAppClient(baseUrl, update) {
+    const encodedName = encodeURIComponent(update.name);
+    const response = await signedRequest({
+        method: "PUT",
+        hostname: baseUrl,
+        path: `/app-clients/${encodedName}`,
+        body: JSON.stringify(update),
+    });
+    if (response.statusCode !== 200) {
+        throw new Error(`Could not update resource: ${response.statusCode} - ${response.body}`);
+    }
+}
+async function deleteAppClient(baseUrl, name) {
+    const encodedName = encodeURIComponent(name);
+    const response = await signedRequest({
+        method: "DELETE",
+        hostname: baseUrl,
+        path: `/app-clients/${encodedName}`,
+    });
+    if (response.statusCode !== 200) {
+        throw new Error(`Could not delete resource: ${response.statusCode} - ${response.body}`);
+    }
+}
+export async function handler(event) {
+    const props = event.ResourceProperties;
+    const baseUrl = createUrlFromEnvironment(COGNITO_BASE_DOMAIN, "delegated", props.Environment);
+    try {
+        switch (event.RequestType) {
+            case "Create": {
+                // We receive a string value for GenerateSecret, but we need a boolean
+                // See https://github.com/aws-cloudformation/cloudformation-coverage-roadmap/issues/1037
+                const generate_secret = typeof props.GenerateSecret === "boolean"
+                    ? props.GenerateSecret
+                    : props.GenerateSecret === "true";
+                const client = {
+                    name: props.Name,
+                    type: props.Type,
+                    scopes: props.Scopes || [],
+                    callback_urls: props.CallbackUrls || [],
+                    logout_urls: props.LogoutUrls || [],
+                    generate_secret,
+                };
+                const created = await createAppClient(baseUrl, client);
+                return createSuccessResponse(event.PhysicalResourceId ?? created.name, {
+                    Name: created.name,
+                    ClientId: created.client_id || "",
+                    ClientSecret: created.client_secret || "",
+                    Type: created.type,
+                });
+            }
+            case "Update": {
+                // Check if Type changed (requires replacement)
+                const oldProps = event.OldResourceProperties;
+                if (oldProps && oldProps.Type !== props.Type) {
+                    throw new Error("Cannot change app client type. This requires resource replacement.");
+                }
+                const update = {
+                    name: props.Name,
+                    scopes: props.Scopes || [],
+                    callback_urls: props.CallbackUrls || [],
+                    logout_urls: props.LogoutUrls || [],
+                };
+                await updateAppClient(baseUrl, update);
+                const updated = await readAppClient(baseUrl, props.Name);
+                return createSuccessResponse(event.PhysicalResourceId ?? updated.name, {
+                    Name: updated.name,
+                    ClientId: updated.client_id || "",
+                    ClientSecret: updated.client_secret || "",
+                    Type: updated.type,
+                });
+            }
+            case "Delete": {
+                const name = event.PhysicalResourceId || props.Name;
+                await deleteAppClient(baseUrl, name);
+                return createSuccessResponse(name, {});
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error:", error);
+        return createFailureResponse(event.PhysicalResourceId || props.Name || "unknown", handleError(error));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/cognito-app-client/handler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lambda handler for CognitoAppClient custom resource\n */\n\nimport {\n  createFailureResponse,\n  createSuccessResponse,\n  handleError,\n} from \"../shared/custom-resource-handler\"\nimport { createUrlFromEnvironment, signedRequest } from \"../shared/sigv4-client\"\nimport type {\n  AppClient,\n  AppClientUpdateRequest,\n  CustomResourceRequest,\n  CustomResourceResponse,\n} from \"../shared/types\"\n\nconst COGNITO_BASE_DOMAIN =\n  process.env.COGNITO_BASE_DOMAIN || \"cognito.vydev.io\"\n\ninterface AppClientProperties {\n  Environment: string\n  Name: string\n  Type: \"frontend\" | \"backend\"\n  Scopes?: string[]\n  CallbackUrls?: string[]\n  LogoutUrls?: string[]\n  GenerateSecret?: boolean\n}\n\nasync function createAppClient(\n  baseUrl: string,\n  client: AppClient,\n): Promise<AppClient> {\n  const response = await signedRequest({\n    method: \"POST\",\n    hostname: baseUrl,\n    path: \"/app-clients\",\n    body: JSON.stringify(client),\n  })\n\n  if (response.statusCode !== 201) {\n    throw new Error(\n      `Could not create resource: ${response.statusCode} - ${response.body}`,\n    )\n  }\n\n  return JSON.parse(response.body)\n}\n\nasync function readAppClient(\n  baseUrl: string,\n  name: string,\n): Promise<AppClient> {\n  const encodedName = encodeURIComponent(name)\n  const response = await signedRequest({\n    method: \"GET\",\n    hostname: baseUrl,\n    path: `/app-clients/${encodedName}`,\n  })\n\n  if (response.statusCode !== 200) {\n    throw new Error(\n      `Could not read resource: ${response.statusCode} - ${response.body}`,\n    )\n  }\n\n  return JSON.parse(response.body)\n}\n\nasync function updateAppClient(\n  baseUrl: string,\n  update: AppClientUpdateRequest,\n): Promise<void> {\n  const encodedName = encodeURIComponent(update.name)\n  const response = await signedRequest({\n    method: \"PUT\",\n    hostname: baseUrl,\n    path: `/app-clients/${encodedName}`,\n    body: JSON.stringify(update),\n  })\n\n  if (response.statusCode !== 200) {\n    throw new Error(\n      `Could not update resource: ${response.statusCode} - ${response.body}`,\n    )\n  }\n}\n\nasync function deleteAppClient(baseUrl: string, name: string): Promise<void> {\n  const encodedName = encodeURIComponent(name)\n  const response = await signedRequest({\n    method: \"DELETE\",\n    hostname: baseUrl,\n    path: `/app-clients/${encodedName}`,\n  })\n\n  if (response.statusCode !== 200) {\n    throw new Error(\n      `Could not delete resource: ${response.statusCode} - ${response.body}`,\n    )\n  }\n}\n\nexport async function handler(\n  event: CustomResourceRequest,\n): Promise<CustomResourceResponse> {\n  const props = event.ResourceProperties as AppClientProperties\n  const baseUrl = createUrlFromEnvironment(\n    COGNITO_BASE_DOMAIN,\n    \"delegated\",\n    props.Environment,\n  )\n\n  try {\n    switch (event.RequestType) {\n      case \"Create\": {\n        // We receive a string value for GenerateSecret, but we need a boolean\n        // See https://github.com/aws-cloudformation/cloudformation-coverage-roadmap/issues/1037\n        const generate_secret: boolean =\n          typeof props.GenerateSecret === \"boolean\"\n            ? props.GenerateSecret\n            : props.GenerateSecret === \"true\"\n\n        const client: AppClient = {\n          name: props.Name,\n          type: props.Type,\n          scopes: props.Scopes || [],\n          callback_urls: props.CallbackUrls || [],\n          logout_urls: props.LogoutUrls || [],\n          generate_secret,\n        }\n\n        const created = await createAppClient(baseUrl, client)\n\n        return createSuccessResponse(event.PhysicalResourceId ?? created.name, {\n          Name: created.name,\n          ClientId: created.client_id || \"\",\n          ClientSecret: created.client_secret || \"\",\n          Type: created.type,\n        }) as CustomResourceResponse\n      }\n\n      case \"Update\": {\n        // Check if Type changed (requires replacement)\n        const oldProps = event.OldResourceProperties as AppClientProperties\n        if (oldProps && oldProps.Type !== props.Type) {\n          throw new Error(\n            \"Cannot change app client type. This requires resource replacement.\",\n          )\n        }\n\n        const update: AppClientUpdateRequest = {\n          name: props.Name,\n          scopes: props.Scopes || [],\n          callback_urls: props.CallbackUrls || [],\n          logout_urls: props.LogoutUrls || [],\n        }\n\n        await updateAppClient(baseUrl, update)\n        const updated = await readAppClient(baseUrl, props.Name)\n\n        return createSuccessResponse(event.PhysicalResourceId ?? updated.name, {\n          Name: updated.name,\n          ClientId: updated.client_id || \"\",\n          ClientSecret: updated.client_secret || \"\",\n          Type: updated.type,\n        }) as CustomResourceResponse\n      }\n\n      case \"Delete\": {\n        const name = event.PhysicalResourceId || props.Name\n        await deleteAppClient(baseUrl, name)\n\n        return createSuccessResponse(name, {}) as CustomResourceResponse\n      }\n    }\n  } catch (error) {\n    console.error(\"Error:\", error)\n    return createFailureResponse(\n      event.PhysicalResourceId || props.Name || \"unknown\",\n      handleError(error),\n    ) as CustomResourceResponse\n  }\n}\n"]}

package/lib/cognito-info.d.ts

@@ -0,0 +1,49 @@
+/**
+ * CDK Construct for Cognito Info data source
+ */
+import { Construct } from "constructs";
+import type { VyEnvironment } from "./shared/types";
+export interface CognitoInfoProps {
+    /**
+     * The environment to get Cognito info for (e.g., VyEnvironment.PROD, VyEnvironment.STAGE, VyEnvironment.TEST)
+     */
+    readonly environment: VyEnvironment;
+}
+/**
+ * Holds information about the centralized Cognito User Pool
+ *
+ * Use this to reference the shared Cognito User Pool in your CDK applications without
+ * hardcoding values.
+ *
+ * @example
+ * ```typescript
+ * const cognitoInfo = new CognitoInfo(this, 'CognitoInfo', {
+ *   environment: VyEnvironment.PROD
+ * });
+ *
+ * // Access authentication endpoints
+ * console.log('Auth URL:', cognitoInfo.authUrl);
+ * console.log('JWKS URL:', cognitoInfo.jwksUrl);
+ * console.log('OpenID URL:', cognitoInfo.openIdUrl);
+ * console.log('Issuer:', cognitoInfo.issuer);
+ * ```
+ */
+export declare class CognitoInfo extends Construct {
+    /**
+     * The URL where users can authenticate
+     */
+    readonly authUrl: string;
+    /**
+     * The URL for the /.well-known/jwks.json endpoint
+     */
+    readonly jwksUrl: string;
+    /**
+     * The URL for the /.well-known/openid-configuration endpoint
+     */
+    readonly openIdUrl: string;
+    /**
+     * The URI for the issuer
+     */
+    readonly issuer: string;
+    constructor(scope: Construct, id: string, props: CognitoInfoProps);
+}

package/lib/cognito-info.js

@@ -0,0 +1,76 @@
+/**
+ * CDK Construct for Cognito Info data source
+ */
+import { Construct } from "constructs";
+/**
+ * Holds information about the centralized Cognito User Pool
+ *
+ * Use this to reference the shared Cognito User Pool in your CDK applications without
+ * hardcoding values.
+ *
+ * @example
+ * ```typescript
+ * const cognitoInfo = new CognitoInfo(this, 'CognitoInfo', {
+ *   environment: VyEnvironment.PROD
+ * });
+ *
+ * // Access authentication endpoints
+ * console.log('Auth URL:', cognitoInfo.authUrl);
+ * console.log('JWKS URL:', cognitoInfo.jwksUrl);
+ * console.log('OpenID URL:', cognitoInfo.openIdUrl);
+ * console.log('Issuer:', cognitoInfo.issuer);
+ * ```
+ */
+export class CognitoInfo extends Construct {
+    /**
+     * The URL where users can authenticate
+     */
+    authUrl;
+    /**
+     * The URL for the /.well-known/jwks.json endpoint
+     */
+    jwksUrl;
+    /**
+     * The URL for the /.well-known/openid-configuration endpoint
+     */
+    openIdUrl;
+    /**
+     * The URI for the issuer
+     */
+    issuer;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.authUrl = getCognitoInfo(props.environment).authUrl;
+        this.jwksUrl = getCognitoInfo(props.environment).jwksUrl;
+        this.openIdUrl = getCognitoInfo(props.environment).openIdUrl;
+        this.issuer = getCognitoInfo(props.environment).issuer;
+    }
+}
+function getCognitoInfo(environment) {
+    const envConfigs = {
+        prod: {
+            authUrl: "https://auth.cognito.vydev.io",
+            jwksUrl: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_e6o46c1oE/.well-known/jwks.json",
+            openIdUrl: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_e6o46c1oE/.well-known/openid-configuration",
+            issuer: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_e6o46c1oE",
+        },
+        stage: {
+            authUrl: "https://auth.stage.cognito.vydev.io",
+            jwksUrl: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_AUYQ679zW/.well-known/jwks.json",
+            openIdUrl: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_AUYQ679zW/.well-known/openid-configuration",
+            issuer: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_AUYQ679zW",
+        },
+        test: {
+            authUrl: "https://auth.test.cognito.vydev.io",
+            jwksUrl: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_Z53b9AbeT/.well-known/jwks.json",
+            openIdUrl: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_Z53b9AbeT/.well-known/openid-configuration",
+            issuer: "https://cognito-idp.eu-west-1.amazonaws.com/eu-west-1_Z53b9AbeT",
+        },
+    };
+    const config = envConfigs[environment];
+    if (!config) {
+        throw new Error(`Unknown environment: ${environment}. Valid values are: prod, stage, test, dev`);
+    }
+    return config;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cognito-resource-server/__test__/index.test.d.ts

@@ -0,0 +1 @@
+import "jest-cdk-snapshot";

package/lib/cognito-resource-server/__test__/index.test.js

@@ -0,0 +1,23 @@
+import { App, Stack } from "aws-cdk-lib";
+import "jest-cdk-snapshot";
+import { VyEnvironment } from "../../shared/types";
+import { CognitoResourceServer } from "../cognito-resource-server";
+test("cognito resource server", () => {
+    const app = new App();
+    const stack = new Stack(app, "Stack");
+    new CognitoResourceServer(stack, "CognitoResourceServer", {
+        environment: VyEnvironment.TEST,
+        name: "testName",
+        identifier: "testIdentifier",
+        scopes: [
+            {
+                name: "testScopeName",
+                description: "testScopeDescription",
+            },
+        ],
+    });
+    expect(stack).toMatchCdkSnapshot({
+        ignoreAssets: true,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgudGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb2duaXRvLXJlc291cmNlLXNlcnZlci9fX3Rlc3RfXy9pbmRleC50ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFBO0FBQ3hDLE9BQU8sbUJBQW1CLENBQUE7QUFDMUIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBQ2xELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRCQUE0QixDQUFBO0FBRWxFLElBQUksQ0FBQyx5QkFBeUIsRUFBRSxHQUFHLEVBQUU7SUFDbkMsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQTtJQUNyQixNQUFNLEtBQUssR0FBRyxJQUFJLEtBQUssQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFFckMsSUFBSSxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsdUJBQXVCLEVBQUU7UUFDeEQsV0FBVyxFQUFFLGFBQWEsQ0FBQyxJQUFJO1FBQy9CLElBQUksRUFBRSxVQUFVO1FBQ2hCLFVBQVUsRUFBRSxnQkFBZ0I7UUFDNUIsTUFBTSxFQUFFO1lBQ047Z0JBQ0UsSUFBSSxFQUFFLGVBQWU7Z0JBQ3JCLFdBQVcsRUFBRSxzQkFBc0I7YUFDcEM7U0FDRjtLQUNGLENBQUMsQ0FBQTtJQUVGLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxrQkFBa0IsQ0FBQztRQUMvQixZQUFZLEVBQUUsSUFBSTtLQUNuQixDQUFDLENBQUE7QUFDSixDQUFDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFwcCwgU3RhY2sgfSBmcm9tIFwiYXdzLWNkay1saWJcIlxuaW1wb3J0IFwiamVzdC1jZGstc25hcHNob3RcIlxuaW1wb3J0IHsgVnlFbnZpcm9ubWVudCB9IGZyb20gXCIuLi8uLi9zaGFyZWQvdHlwZXNcIlxuaW1wb3J0IHsgQ29nbml0b1Jlc291cmNlU2VydmVyIH0gZnJvbSBcIi4uL2NvZ25pdG8tcmVzb3VyY2Utc2VydmVyXCJcblxudGVzdChcImNvZ25pdG8gcmVzb3VyY2Ugc2VydmVyXCIsICgpID0+IHtcbiAgY29uc3QgYXBwID0gbmV3IEFwcCgpXG4gIGNvbnN0IHN0YWNrID0gbmV3IFN0YWNrKGFwcCwgXCJTdGFja1wiKVxuXG4gIG5ldyBDb2duaXRvUmVzb3VyY2VTZXJ2ZXIoc3RhY2ssIFwiQ29nbml0b1Jlc291cmNlU2VydmVyXCIsIHtcbiAgICBlbnZpcm9ubWVudDogVnlFbnZpcm9ubWVudC5URVNULFxuICAgIG5hbWU6IFwidGVzdE5hbWVcIixcbiAgICBpZGVudGlmaWVyOiBcInRlc3RJZGVudGlmaWVyXCIsXG4gICAgc2NvcGVzOiBbXG4gICAgICB7XG4gICAgICAgIG5hbWU6IFwidGVzdFNjb3BlTmFtZVwiLFxuICAgICAgICBkZXNjcmlwdGlvbjogXCJ0ZXN0U2NvcGVEZXNjcmlwdGlvblwiLFxuICAgICAgfSxcbiAgICBdLFxuICB9KVxuXG4gIGV4cGVjdChzdGFjaykudG9NYXRjaENka1NuYXBzaG90KHtcbiAgICBpZ25vcmVBc3NldHM6IHRydWUsXG4gIH0pXG59KVxuIl19

package/lib/cognito-resource-server/cognito-resource-server.d.ts

@@ -0,0 +1,96 @@
+/**
+ * CDK Construct for Cognito Resource Server
+ */
+import * as cdk from "aws-cdk-lib";
+import * as logs from "aws-cdk-lib/aws-logs";
+import { Construct } from "constructs";
+import type { VyEnvironment } from "../shared/types";
+export interface Scope {
+    /**
+     * The name of the scope
+     */
+    readonly name: string;
+    /**
+     * A description of what this scope is for
+     */
+    readonly description: string;
+}
+export interface CognitoResourceServerProps {
+    /**
+     * The Vy environment to provision in (e.g., VyEnvironment.PROD, VyEnvironment.STAGE, VyEnvironment.TEST)
+     */
+    readonly environment: VyEnvironment;
+    /**
+     * The name of the resource server
+     */
+    readonly name: string;
+    /**
+     * The identifier for this resource server (usually a URL)
+     * @example 'https://api.vydev.io'
+     */
+    readonly identifier: string;
+    /**
+     * Custom scopes for this resource server
+     * @default - No scopes
+     */
+    readonly scopes?: Scope[];
+    /**
+     * Base domain for Cognito service
+     * @default 'cognito.vydev.io'
+     */
+    readonly cognitoBaseDomain?: string;
+    /**
+     * @default logs.RetentionDays.ONE_WEEK
+     */
+    readonly logsRetention?: logs.RetentionDays;
+}
+/**
+ * A Cognito Resource Server managed through Vy's central Cognito service
+ *
+ * A resource server is an integration between a user pool and an API.
+ * Each resource server has custom scopes that you must activate in your app client.
+ * When you configure a resource server, your app can generate access tokens with
+ * OAuth scopes that authorize read and write operations to an API server.
+ *
+ * @example
+ * ```typescript
+ * const resourceServer = new CognitoResourceServer(this, 'ApiResourceServer', {
+ *   environment: VyEnvironment.PROD,
+ *   name: 'my-api',
+ *   identifier: 'https://my-api.vydev.io',
+ *   scopes: [
+ *     { name: 'read', description: 'Read access to the API' },
+ *     { name: 'write', description: 'Write access to the API' }
+ *   ]
+ * });
+ * ```
+ */
+export declare class CognitoResourceServer extends Construct {
+    /**
+     * The identifier of the resource server
+     */
+    readonly identifier: string;
+    /**
+     * The name of the resource server
+     */
+    readonly name: string;
+    /**
+     * The underlying custom resource
+     */
+    readonly resource: cdk.CustomResource;
+    /**
+     * The logGroup for the event handler lambda
+     */
+    readonly lambdaLogGroup: logs.LogGroup;
+    /**
+     * The logGroup for the custom resource provider
+     */
+    readonly providerLogGroup: logs.LogGroup;
+    constructor(scope: Construct, id: string, props: CognitoResourceServerProps);
+    /**
+     * Get a reference to a scope in the format expected by app clients
+     * @param scopeName The name of the scope
+     * @returns The full scope identifier (e.g., 'https://api.vydev.io/read')
+     */
+    scopeIdentifier(scopeName: string): string;
+}