@liflig/cdk-vy 1.0.0

package/lib/cognito-resource-server/cognito-resource-server.js

@@ -0,0 +1,120 @@
+/**
+ * CDK Construct for Cognito Resource Server
+ */
+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 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);
+/**
+ * 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 class CognitoResourceServer extends Construct {
+    /**
+     * The identifier of the resource server
+     */
+    identifier;
+    /**
+     * The name of the resource server
+     */
+    name;
+    /**
+     * The underlying custom resource
+     */
+    resource;
+    /**
+     * The logGroup for the event handler lambda
+     */
+    lambdaLogGroup;
+    /**
+     * The logGroup for the custom resource provider
+     */
+    providerLogGroup;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.identifier = props.identifier;
+        this.name = props.name;
+        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,
+                Identifier: props.identifier,
+                Scopes: props.scopes?.map((s) => ({
+                    Name: s.name,
+                    Description: s.description,
+                })),
+            },
+            resourceType: "Custom::VyCognitoResourceServer",
+        });
+    }
+    /**
+     * 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) {
+        return `${this.identifier}/${scopeName}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognito-resource-server.js","sourceRoot":"","sources":["../../src/cognito-resource-server/cognito-resource-server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CDK Construct for Cognito Resource Server\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 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\nexport interface Scope {\n  /**\n   * The name of the scope\n   */\n  readonly name: string\n\n  /**\n   * A description of what this scope is for\n   */\n  readonly description: string\n}\n\nexport interface CognitoResourceServerProps {\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 resource server\n   */\n  readonly name: string\n\n  /**\n   * The identifier for this resource server (usually a URL)\n   * @example 'https://api.vydev.io'\n   */\n  readonly identifier: string\n\n  /**\n   * Custom scopes for this resource server\n   * @default - No scopes\n   */\n  readonly scopes?: Scope[]\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 Resource Server managed through Vy's central Cognito service\n *\n * A resource server is an integration between a user pool and an API.\n * Each resource server has custom scopes that you must activate in your app client.\n * When you configure a resource server, your app can generate access tokens with\n * OAuth scopes that authorize read and write operations to an API server.\n *\n * @example\n * ```typescript\n * const resourceServer = new CognitoResourceServer(this, 'ApiResourceServer', {\n *   environment: VyEnvironment.PROD,\n *   name: 'my-api',\n *   identifier: 'https://my-api.vydev.io',\n *   scopes: [\n *     { name: 'read', description: 'Read access to the API' },\n *     { name: 'write', description: 'Write access to the API' }\n *   ]\n * });\n * ```\n */\nexport class CognitoResourceServer extends Construct {\n  /**\n   * The identifier of the resource server\n   */\n  public readonly identifier: string\n\n  /**\n   * The name of the resource server\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  constructor(scope: Construct, id: string, props: CognitoResourceServerProps) {\n    super(scope, id)\n\n    this.identifier = props.identifier\n    this.name = props.name\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        Identifier: props.identifier,\n        Scopes: props.scopes?.map((s) => ({\n          Name: s.name,\n          Description: s.description,\n        })),\n      },\n      resourceType: \"Custom::VyCognitoResourceServer\",\n    })\n  }\n\n  /**\n   * Get a reference to a scope in the format expected by app clients\n   * @param scopeName The name of the scope\n   * @returns The full scope identifier (e.g., 'https://api.vydev.io/read')\n   */\n  public scopeIdentifier(scopeName: string): string {\n    return `${this.identifier}/${scopeName}`\n  }\n}\n"]}

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

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

package/lib/cognito-resource-server/handler.js

@@ -0,0 +1,104 @@
+/**
+ * Lambda handler for CognitoResourceServer 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 createResourceServer(baseUrl, server) {
+    const response = await signedRequest({
+        method: "POST",
+        hostname: baseUrl,
+        path: "/resource-servers",
+        body: JSON.stringify(server),
+    });
+    if (response.statusCode !== 201) {
+        throw new Error(`Could not create resource: ${response.statusCode} - ${response.body}`);
+    }
+    return JSON.parse(response.body);
+}
+async function readResourceServer(baseUrl, identifier) {
+    const encodedIdentifier = encodeURIComponent(identifier);
+    const response = await signedRequest({
+        method: "GET",
+        hostname: baseUrl,
+        path: `/resource-servers/${encodedIdentifier}`,
+    });
+    if (response.statusCode !== 200) {
+        throw new Error(`Could not read resource: ${response.statusCode} - ${response.body}`);
+    }
+    return JSON.parse(response.body);
+}
+async function updateResourceServer(baseUrl, update) {
+    const encodedIdentifier = encodeURIComponent(update.identifier);
+    const response = await signedRequest({
+        method: "PUT",
+        hostname: baseUrl,
+        path: `/resource-servers/${encodedIdentifier}`,
+        body: JSON.stringify(update),
+    });
+    if (response.statusCode !== 200) {
+        throw new Error(`Could not update resource: ${response.statusCode} - ${response.body}`);
+    }
+}
+async function deleteResourceServer(baseUrl, identifier) {
+    const encodedIdentifier = encodeURIComponent(identifier);
+    const response = await signedRequest({
+        method: "DELETE",
+        hostname: baseUrl,
+        path: `/resource-servers/${encodedIdentifier}`,
+    });
+    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": {
+                const server = {
+                    identifier: props.Identifier,
+                    name: props.Name,
+                    scopes: props.Scopes?.map((s) => ({
+                        name: s.Name,
+                        description: s.Description,
+                    })),
+                };
+                const created = await createResourceServer(baseUrl, server);
+                return createSuccessResponse(event.PhysicalResourceId ?? created.identifier, {
+                    Identifier: created.identifier,
+                    Name: created.name,
+                    Scopes: created.scopes,
+                });
+            }
+            case "Update": {
+                const update = {
+                    identifier: props.Identifier,
+                    name: props.Name,
+                    scopes: props.Scopes?.map((s) => ({
+                        name: s.Name,
+                        description: s.Description,
+                    })),
+                };
+                await updateResourceServer(baseUrl, update);
+                const updated = await readResourceServer(baseUrl, props.Identifier);
+                return createSuccessResponse(event.PhysicalResourceId ?? updated.identifier, {
+                    Identifier: updated.identifier,
+                    Name: updated.name,
+                    Scopes: updated.scopes,
+                });
+            }
+            case "Delete": {
+                const identifier = event.PhysicalResourceId || props.Identifier;
+                await deleteResourceServer(baseUrl, identifier);
+                return createSuccessResponse(identifier, {});
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error:", error);
+        return createFailureResponse(event.PhysicalResourceId || props.Identifier || "unknown", handleError(error));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/cognito-resource-server/handler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lambda handler for CognitoResourceServer 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  CustomResourceRequest,\n  CustomResourceResponse,\n  ResourceServer,\n  ResourceServerUpdateRequest,\n} from \"../shared/types\"\n\nconst COGNITO_BASE_DOMAIN =\n  process.env.COGNITO_BASE_DOMAIN || \"cognito.vydev.io\"\n\ninterface ResourceServerProperties {\n  Environment: string\n  Name: string\n  Identifier: string\n  Scopes?: Array<{ Name: string; Description: string }>\n}\n\nasync function createResourceServer(\n  baseUrl: string,\n  server: ResourceServer,\n): Promise<ResourceServer> {\n  const response = await signedRequest({\n    method: \"POST\",\n    hostname: baseUrl,\n    path: \"/resource-servers\",\n    body: JSON.stringify(server),\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 readResourceServer(\n  baseUrl: string,\n  identifier: string,\n): Promise<ResourceServer> {\n  const encodedIdentifier = encodeURIComponent(identifier)\n  const response = await signedRequest({\n    method: \"GET\",\n    hostname: baseUrl,\n    path: `/resource-servers/${encodedIdentifier}`,\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 updateResourceServer(\n  baseUrl: string,\n  update: ResourceServerUpdateRequest,\n): Promise<void> {\n  const encodedIdentifier = encodeURIComponent(update.identifier)\n  const response = await signedRequest({\n    method: \"PUT\",\n    hostname: baseUrl,\n    path: `/resource-servers/${encodedIdentifier}`,\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 deleteResourceServer(\n  baseUrl: string,\n  identifier: string,\n): Promise<void> {\n  const encodedIdentifier = encodeURIComponent(identifier)\n  const response = await signedRequest({\n    method: \"DELETE\",\n    hostname: baseUrl,\n    path: `/resource-servers/${encodedIdentifier}`,\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 ResourceServerProperties\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        const server: ResourceServer = {\n          identifier: props.Identifier,\n          name: props.Name,\n          scopes: props.Scopes?.map((s) => ({\n            name: s.Name,\n            description: s.Description,\n          })),\n        }\n\n        const created = await createResourceServer(baseUrl, server)\n\n        return createSuccessResponse(\n          event.PhysicalResourceId ?? created.identifier,\n          {\n            Identifier: created.identifier,\n            Name: created.name,\n            Scopes: created.scopes,\n          },\n        ) as CustomResourceResponse\n      }\n\n      case \"Update\": {\n        const update: ResourceServerUpdateRequest = {\n          identifier: props.Identifier,\n          name: props.Name,\n          scopes: props.Scopes?.map((s) => ({\n            name: s.Name,\n            description: s.Description,\n          })),\n        }\n\n        await updateResourceServer(baseUrl, update)\n        const updated = await readResourceServer(baseUrl, props.Identifier)\n\n        return createSuccessResponse(\n          event.PhysicalResourceId ?? updated.identifier,\n          {\n            Identifier: updated.identifier,\n            Name: updated.name,\n            Scopes: updated.scopes,\n          },\n        ) as CustomResourceResponse\n      }\n\n      case \"Delete\": {\n        const identifier = event.PhysicalResourceId || props.Identifier\n        await deleteResourceServer(baseUrl, identifier)\n\n        return createSuccessResponse(identifier, {}) as CustomResourceResponse\n      }\n    }\n  } catch (error) {\n    console.error(\"Error:\", error)\n    return createFailureResponse(\n      event.PhysicalResourceId || props.Identifier || \"unknown\",\n      handleError(error),\n    ) as CustomResourceResponse\n  }\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @vy/cdk-resources
+ * CDK constructs for Vy internal services
+ *
+ * This library provides CDK equivalents to the Terraform provider `terraform-provider-vy`.
+ */
+export * from "./cognito-app-client/cognito-app-client";
+export * from "./cognito-info";
+export * from "./cognito-resource-server/cognito-resource-server";

package/lib/index.js

@@ -0,0 +1,12 @@
+/**
+ * @vy/cdk-resources
+ * CDK constructs for Vy internal services
+ *
+ * This library provides CDK equivalents to the Terraform provider `terraform-provider-vy`.
+ */
+// Resources
+export * from "./cognito-app-client/cognito-app-client";
+// Data Sources
+export * from "./cognito-info";
+export * from "./cognito-resource-server/cognito-resource-server";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFFSCxZQUFZO0FBQ1osY0FBYyx5Q0FBeUMsQ0FBQTtBQUN2RCxlQUFlO0FBQ2YsY0FBYyxnQkFBZ0IsQ0FBQTtBQUM5QixjQUFjLG1EQUFtRCxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAdnkvY2RrLXJlc291cmNlc1xuICogQ0RLIGNvbnN0cnVjdHMgZm9yIFZ5IGludGVybmFsIHNlcnZpY2VzXG4gKlxuICogVGhpcyBsaWJyYXJ5IHByb3ZpZGVzIENESyBlcXVpdmFsZW50cyB0byB0aGUgVGVycmFmb3JtIHByb3ZpZGVyIGB0ZXJyYWZvcm0tcHJvdmlkZXItdnlgLlxuICovXG5cbi8vIFJlc291cmNlc1xuZXhwb3J0ICogZnJvbSBcIi4vY29nbml0by1hcHAtY2xpZW50L2NvZ25pdG8tYXBwLWNsaWVudFwiXG4vLyBEYXRhIFNvdXJjZXNcbmV4cG9ydCAqIGZyb20gXCIuL2NvZ25pdG8taW5mb1wiXG5leHBvcnQgKiBmcm9tIFwiLi9jb2duaXRvLXJlc291cmNlLXNlcnZlci9jb2duaXRvLXJlc291cmNlLXNlcnZlclwiXG4iXX0=

package/lib/shared/custom-resource-handler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Base handler for Custom Resources
+ * Handles the CloudFormation response protocol
+ */
+import type { CustomResourceResponse } from "./types";
+export declare function createSuccessResponse(physicalResourceId: string, data?: Record<string, any>): Pick<CustomResourceResponse, "Status" | "PhysicalResourceId" | "Data">;
+export declare function createFailureResponse(physicalResourceId: string, reason: string): Pick<CustomResourceResponse, "Status" | "PhysicalResourceId" | "Reason">;
+/**
+ * Base error handler for custom resource operations
+ */
+export declare function handleError(error: unknown): string;

package/lib/shared/custom-resource-handler.js

@@ -0,0 +1,28 @@
+/**
+ * Base handler for Custom Resources
+ * Handles the CloudFormation response protocol
+ */
+export function createSuccessResponse(physicalResourceId, data) {
+    return {
+        Status: "SUCCESS",
+        PhysicalResourceId: physicalResourceId,
+        Data: data,
+    };
+}
+export function createFailureResponse(physicalResourceId, reason) {
+    return {
+        Status: "FAILED",
+        PhysicalResourceId: physicalResourceId,
+        Reason: reason,
+    };
+}
+/**
+ * Base error handler for custom resource operations
+ */
+export function handleError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shared/sigv4-client.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared utility for making AWS SigV4 signed HTTP requests
+ */
+export interface SignedRequestOptions {
+    method: string;
+    hostname: string;
+    path: string;
+    body?: string;
+    headers?: Record<string, string>;
+    region?: string;
+}
+export interface SignedResponse {
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+}
+export declare function signedRequest(options: SignedRequestOptions): Promise<SignedResponse>;
+/**
+ * Helper to create base URL from environment
+ */
+export declare function createUrlFromEnvironment(baseUrl: string, urlPrefix: string, environment: string): string;

package/lib/shared/sigv4-client.js

@@ -0,0 +1,53 @@
+/**
+ * Shared utility for making AWS SigV4 signed HTTP requests
+ */
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { HttpRequest } from "@smithy/protocol-http";
+import { SignatureV4 } from "@smithy/signature-v4";
+export async function signedRequest(options) {
+    const { method, hostname, path, body, headers = {}, region } = options;
+    const request = new HttpRequest({
+        method,
+        protocol: "https:",
+        hostname,
+        path,
+        headers: {
+            "Content-Type": "application/json",
+            Host: hostname,
+            ...headers,
+        },
+        body,
+    });
+    const credentialsProvider = defaultProvider();
+    const credentials = await credentialsProvider();
+    const signer = new SignatureV4({
+        credentials,
+        region: region ?? "eu-west-1",
+        service: "execute-api",
+        sha256: Sha256,
+    });
+    const signedRequest = await signer.sign(request);
+    const url = `https://${signedRequest.hostname}${signedRequest.path}`;
+    const response = await fetch(url, {
+        method: signedRequest.method,
+        headers: signedRequest.headers,
+        body: signedRequest.body,
+    });
+    const responseBody = await response.text();
+    return {
+        statusCode: response.status,
+        body: responseBody,
+        headers: Object.fromEntries(response.headers.entries()),
+    };
+}
+/**
+ * Helper to create base URL from environment
+ */
+export function createUrlFromEnvironment(baseUrl, urlPrefix, environment) {
+    if (environment === "prod") {
+        return `${urlPrefix}.${baseUrl}`;
+    }
+    return `${urlPrefix}.${environment}.${baseUrl}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shared/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Shared type definitions for Vy custom resources
+ */
+/**
+ * The different Vy environments
+ */
+export declare enum VyEnvironment {
+    /**
+     * Development environment
+     */
+    TEST = "test",
+    /**
+     * Production-like environment
+     */
+    STAGE = "stage",
+    /**
+     * Production environment
+     */
+    PROD = "prod"
+}
+export interface Scope {
+    name: string;
+    description: string;
+}
+export interface ResourceServer {
+    identifier: string;
+    name: string;
+    scopes?: Scope[];
+}
+export interface ResourceServerUpdateRequest {
+    identifier: string;
+    name: string;
+    scopes?: Scope[];
+}
+export interface AppClient {
+    name: string;
+    scopes: string[];
+    type: "frontend" | "backend";
+    callback_urls: string[];
+    logout_urls: string[];
+    generate_secret?: boolean;
+    client_id?: string;
+    client_secret?: string;
+}
+export interface AppClientUpdateRequest {
+    name: string;
+    scopes: string[];
+    callback_urls: string[];
+    logout_urls: string[];
+}
+export interface DeploymentAccount {
+    accountId: string;
+    slackChannel: string;
+}
+export interface EnvironmentAccount {
+    accountId: string;
+    ownerAccountId: string;
+}
+export interface ArtifactVersion {
+    uri: string;
+    store: string;
+    path: string;
+    version: string;
+}
+export interface CognitoDetails {
+    authUrl: string;
+    jwksUrl: string;
+    openIdUrl: string;
+    issuer: string;
+}
+/**
+ * Custom Resource event types
+ */
+export interface CustomResourceRequest {
+    RequestType: "Create" | "Update" | "Delete";
+    RequestId: string;
+    ResponseURL: string;
+    ResourceType: string;
+    LogicalResourceId: string;
+    StackId: string;
+    PhysicalResourceId?: string;
+    ResourceProperties: Record<string, any>;
+    OldResourceProperties?: Record<string, any>;
+}
+export interface CustomResourceResponse {
+    Status: "SUCCESS" | "FAILED";
+    Reason?: string;
+    PhysicalResourceId: string;
+    StackId: string;
+    RequestId: string;
+    LogicalResourceId: string;
+    Data?: Record<string, any>;
+}

package/lib/shared/types.js

@@ -0,0 +1,22 @@
+/**
+ * Shared type definitions for Vy custom resources
+ */
+/**
+ * The different Vy environments
+ */
+export var VyEnvironment;
+(function (VyEnvironment) {
+    /**
+     * Development environment
+     */
+    VyEnvironment["TEST"] = "test";
+    /**
+     * Production-like environment
+     */
+    VyEnvironment["STAGE"] = "stage";
+    /**
+     * Production environment
+     */
+    VyEnvironment["PROD"] = "prod";
+})(VyEnvironment || (VyEnvironment = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@liflig/cdk-vy",
+  "version": "1.0.0",
+  "description": "CDK constructs for the Vy internal services, based on nsbno/terraform-provider-vy",
+  "keywords": [
+    "aws-cdk",
+    "cdk",
+    "vy",
+    "cognito",
+    "custom-resource"
+  ],
+  "homepage": "https://github.com/capralifecycle/vy-cdk-lib#readme",
+  "bugs": {
+    "url": "https://github.com/capralifecycle/vy-cdk-lib/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/capralifecycle/liflig-cdk-vy.git"
+  },
+  "license": "MPL-2.0",
+  "author": "Liflig",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --runInBand",
+    "lint": "biome check",
+    "lint:fix": "biome check --fix",
+    "format": "biome format --write",
+    "semantic-release": "semantic-release",
+    "package": "jsii-pacmak",
+    "upgrade-dependencies": "ncu --upgrade --install always --format group"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.2",
+    "@commitlint/cli": "20.1.0",
+    "@commitlint/config-conventional": "20.0.0",
+    "@types/aws-lambda": "8.10.157",
+    "@types/jest": "30.0.0",
+    "@types/node": "24.9.2",
+    "aws-cdk-lib": "2.221.0",
+    "constructs": "10.4.2",
+    "jest": "30.2.0",
+    "jest-cdk-snapshot": "2.3.6",
+    "semantic-release": "25.0.1",
+    "ts-jest": "29.4.5",
+    "ts-node": "10.9.2",
+    "tsx": "4.20.6",
+    "typescript": "5.9.3",
+    "npm-check-updates": "19.1.2"
+  },
+  "dependencies": {
+    "@aws-crypto/sha256-js": "5.2.0",
+    "@aws-sdk/client-sts": "3.919.0",
+    "@smithy/protocol-http": "5.3.3",
+    "@smithy/signature-v4": "5.3.3"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.0.0",
+    "constructs": "^10.0.0"
+  }
+}