@xpertss/projen-types 0.0.0

package/lib/cdk/cdk-typescript-base.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkTypescriptProject = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const constants_1 = require("../common/constants");
+const manual_deploy_workflow_1 = require("../common/manual-deploy-workflow");
+/**
+ * Shared CDK + TypeScript foundation for `CdkInfraProject` and
+ * `CdkAppProject`: standard app structure (via `AwsCdkTypeScriptApp`,
+ * `cdk.json`, `cdk synth`/`cdk diff` tasks), a PR-check build that hard-fails
+ * on projen drift (rather than self-mutating), and an optional
+ * `ManualDeployWorkflow` when `environments` is provided.
+ */
+class CdkTypescriptProject extends projen_1.awscdk.AwsCdkTypeScriptApp {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.CdkTypescriptProject", version: "0.0.0" };
+    constructor(options) {
+        super({
+            name: options.name,
+            cdkVersion: options.cdkVersion ?? '2.189.1',
+            defaultReleaseBranch: 'main',
+            sampleCode: true,
+            // Fail PR checks on drift instead of auto-committing projen's output.
+            buildWorkflowOptions: { mutableBuild: false },
+            projenCredentials: projen_1.github.GithubCredentials.fromPersonalAccessToken({
+                secret: options.gheTokenSecret ?? constants_1.DEFAULT_GHE_TOKEN_SECRET,
+            }),
+        });
+        this.addDevDeps('esbuild');
+        if (options.environments && options.environments.length > 0) {
+            new manual_deploy_workflow_1.ManualDeployWorkflow(this, {
+                environments: options.environments,
+                slackWebhookSecret: options.slackWebhookSecret,
+                deploySteps: (env) => [
+                    {
+                        name: 'Install',
+                        run: 'npm ci',
+                    },
+                    {
+                        name: `cdk deploy (${env.name})`,
+                        run: `npx cdk deploy --all --require-approval never --context environment=${env.name}`,
+                        env: {
+                            ...(env.accountId ? { CDK_DEFAULT_ACCOUNT: env.accountId } : {}),
+                            ...(env.region ? { CDK_DEFAULT_REGION: env.region } : {}),
+                        },
+                    },
+                ],
+            });
+        }
+    }
+}
+exports.CdkTypescriptProject = CdkTypescriptProject;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cdk/components/ecr-ecs-constructs.d.ts

@@ -0,0 +1,12 @@
+import { Component } from 'projen';
+import type { Project } from 'projen';
+import { EcrEcsOptions } from '../options';
+/**
+ * Reusable construct helper for an ECR repo + Fargate ECS cluster/service
+ * standing up a container image. `externalImageSource` controls whether the
+ * service pulls an externally-published image (infra-only projects) or one
+ * built from this project's own source (app projects).
+ */
+export declare class EcrEcsConstructs extends Component {
+    constructor(project: Project, options?: EcrEcsOptions);
+}

package/lib/cdk/components/ecr-ecs-constructs.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcrEcsConstructs = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/**
+ * Reusable construct helper for an ECR repo + Fargate ECS cluster/service
+ * standing up a container image. `externalImageSource` controls whether the
+ * service pulls an externally-published image (infra-only projects) or one
+ * built from this project's own source (app projects).
+ */
+class EcrEcsConstructs extends projen_1.Component {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.EcrEcsConstructs", version: "0.0.0" };
+    constructor(project, options = {}) {
+        super(project, 'EcrEcsConstructs');
+        const externalImageSource = options.externalImageSource ?? true;
+        const src = new projen_1.SourceCode(project, 'src/constructs/ecr-ecs.ts');
+        src.line('import { Construct } from "constructs";');
+        src.line('import * as ecr from "aws-cdk-lib/aws-ecr";');
+        src.line('import * as ecs from "aws-cdk-lib/aws-ecs";');
+        src.line();
+        src.open('export interface EcrEcsServiceProps {');
+        src.line('readonly vpcId?: string;');
+        src.line(externalImageSource
+            ? 'readonly imageTag?: string; // externally-built image tag to deploy'
+            : "readonly imageDirectory: string; // path to a Dockerfile built from this project's source");
+        src.close('}');
+        src.line();
+        src.open('export class EcrEcsService extends Construct {');
+        src.line('public readonly repository: ecr.IRepository;');
+        src.line('public readonly cluster: ecs.Cluster;');
+        src.line();
+        src.open('constructor(scope: Construct, id: string, props: EcrEcsServiceProps) {');
+        src.line('super(scope, id);');
+        src.line();
+        src.line(externalImageSource
+            ? 'this.repository = ecr.Repository.fromRepositoryName(this, "Repository", id);'
+            : 'this.repository = new ecr.Repository(this, "Repository");');
+        src.line('this.cluster = new ecs.Cluster(this, "Cluster");');
+        src.line('// TODO: wire up a FargateTaskDefinition/FargateService using this.repository');
+        src.close('}');
+        src.close('}');
+    }
+}
+exports.EcrEcsConstructs = EcrEcsConstructs;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cdk/components/edge-networking-constructs.d.ts

@@ -0,0 +1,10 @@
+import { Component } from 'projen';
+import type { Project } from 'projen';
+import { EdgeResource } from '../options';
+/**
+ * Construct helpers for CloudFront/Route53/API Gateway/Cognito/SQS, scoped
+ * to whichever `edgeResources` the consuming project type opts into.
+ */
+export declare class EdgeNetworkingConstructs extends Component {
+    constructor(project: Project, resources: EdgeResource[]);
+}

package/lib/cdk/components/edge-networking-constructs.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeNetworkingConstructs = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const IMPORTS = {
+    cloudfront: 'import * as cloudfront from "aws-cdk-lib/aws-cloudfront";',
+    route53: 'import * as route53 from "aws-cdk-lib/aws-route53";',
+    apigateway: 'import * as apigateway from "aws-cdk-lib/aws-apigateway";',
+    cognito: 'import * as cognito from "aws-cdk-lib/aws-cognito";',
+    sqs: 'import * as sqs from "aws-cdk-lib/aws-sqs";',
+};
+const HELPERS = {
+    cloudfront: [
+        'export function addDistribution(scope: Construct, id: string, props: cloudfront.DistributionProps) {',
+        '  return new cloudfront.Distribution(scope, id, props);',
+        '}',
+    ],
+    route53: [
+        'export function importHostedZone(scope: Construct, id: string, zoneName: string) {',
+        '  return route53.HostedZone.fromLookup(scope, id, { domainName: zoneName });',
+        '}',
+    ],
+    apigateway: [
+        'export function addRestApi(scope: Construct, id: string, props?: apigateway.RestApiProps) {',
+        '  return new apigateway.RestApi(scope, id, props);',
+        '}',
+    ],
+    cognito: [
+        'export function addUserPool(scope: Construct, id: string, props?: cognito.UserPoolProps) {',
+        '  return new cognito.UserPool(scope, id, props);',
+        '}',
+    ],
+    sqs: [
+        'export function addQueue(scope: Construct, id: string, props?: sqs.QueueProps) {',
+        '  return new sqs.Queue(scope, id, props);',
+        '}',
+    ],
+};
+/**
+ * Construct helpers for CloudFront/Route53/API Gateway/Cognito/SQS, scoped
+ * to whichever `edgeResources` the consuming project type opts into.
+ */
+class EdgeNetworkingConstructs extends projen_1.Component {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.EdgeNetworkingConstructs", version: "0.0.0" };
+    constructor(project, resources) {
+        super(project, 'EdgeNetworkingConstructs');
+        if (resources.length === 0) {
+            return;
+        }
+        const src = new projen_1.SourceCode(project, 'src/constructs/edge-networking.ts');
+        src.line('import { Construct } from "constructs";');
+        for (const resource of resources) {
+            src.line(IMPORTS[resource]);
+        }
+        src.line();
+        for (const resource of resources) {
+            for (const line of HELPERS[resource]) {
+                src.line(line);
+            }
+            src.line();
+        }
+    }
+}
+exports.EdgeNetworkingConstructs = EdgeNetworkingConstructs;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cdk/database-component.d.ts

@@ -0,0 +1,11 @@
+import { Component, javascript } from 'projen';
+import { DatabaseOptions } from './options';
+/**
+ * DB provisioning construct + migration tooling wiring. The migration tool
+ * itself is left fully pluggable per the spec's open question - if
+ * `migrationTool` is provided it's added as a dev dependency and left for
+ * the consuming team to wire up; no opinionated default is imposed.
+ */
+export declare class DatabaseComponent extends Component {
+    constructor(project: javascript.NodeProject, options?: DatabaseOptions);
+}

package/lib/cdk/database-component.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseComponent = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/**
+ * DB provisioning construct + migration tooling wiring. The migration tool
+ * itself is left fully pluggable per the spec's open question - if
+ * `migrationTool` is provided it's added as a dev dependency and left for
+ * the consuming team to wire up; no opinionated default is imposed.
+ */
+class DatabaseComponent extends projen_1.Component {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@xpertss/projen-types.DatabaseComponent", version: "0.0.0" };
+    constructor(project, options = {}) {
+        super(project, 'DatabaseComponent');
+        const engine = options.engine ?? 'postgres';
+        if (options.migrationTool) {
+            project.addDevDeps(options.migrationTool);
+        }
+        const src = new projen_1.SourceCode(project, 'src/constructs/database.ts');
+        src.line('import { Construct } from "constructs";');
+        if (engine === 'dynamodb') {
+            src.line('import * as dynamodb from "aws-cdk-lib/aws-dynamodb";');
+        }
+        else {
+            src.line('import * as rds from "aws-cdk-lib/aws-rds";');
+        }
+        src.line();
+        src.open('export class Database extends Construct {');
+        src.line(engine === 'dynamodb'
+            ? 'public readonly table!: dynamodb.Table;'
+            : 'public readonly instance!: rds.DatabaseInstance;');
+        src.line();
+        src.open('constructor(scope: Construct, id: string) {');
+        src.line('super(scope, id);');
+        src.line(`// TODO: provision a ${engine} ${engine === 'dynamodb' ? 'table' : 'instance'}${options.migrationTool
+            ? ` and wire up migrations via ${options.migrationTool}`
+            : ''}`);
+        src.close('}');
+        src.close('}');
+    }
+}
+exports.DatabaseComponent = DatabaseComponent;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cdk/options.d.ts

@@ -0,0 +1,39 @@
+import { EnvironmentOptions } from '../common/environment-options';
+export type EdgeResource = 'cloudfront' | 'route53' | 'apigateway' | 'cognito' | 'sqs';
+export interface EcrEcsOptions {
+    /** @default false */
+    readonly enabled?: boolean;
+    /**
+     * Whether the ECS service stands up an externally-built image (infra-only)
+     * rather than one built from this project's own source.
+     *
+     * @default true
+     */
+    readonly externalImageSource?: boolean;
+}
+export interface CommonCdkOptions {
+    readonly name: string;
+    /** @default "2.189.1" */
+    readonly cdkVersion?: string;
+    /** @default "PROJEN_GITHUB_TOKEN" */
+    readonly gheTokenSecret?: string;
+    /** GitHub secret holding a Slack webhook URL for deploy notifications. */
+    readonly slackWebhookSecret?: string;
+}
+export interface CdkInfraProjectOptions extends CommonCdkOptions {
+    /** Deploy targets for the manual-dispatch deploy workflow, e.g. ["dev", "stage", "prod"]. */
+    readonly environments: (string | EnvironmentOptions)[];
+    readonly ecrEcs?: EcrEcsOptions;
+    readonly edgeResources?: EdgeResource[];
+}
+export interface DatabaseOptions {
+    /** @default "postgres" */
+    readonly engine?: 'postgres' | 'mysql' | 'dynamodb';
+    /** Migration tool to wire up, e.g. "flyway", "liquibase", "prisma". Left pluggable - no default. */
+    readonly migrationTool?: string;
+}
+export interface CdkAppProjectOptions extends CdkInfraProjectOptions {
+    readonly database?: DatabaseOptions;
+    /** @default "src/app.ts" */
+    readonly appEntryPoint?: string;
+}

package/lib/cdk/options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/common/constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default GitHub secret name used for projen's self-mutation/automation token,
+ * unless a project overrides it via `gheTokenSecret`.
+ */
+export declare const DEFAULT_GHE_TOKEN_SECRET = "PROJEN_GITHUB_TOKEN";
+/** Cron schedule used by nightly dependency-upgrade workflows (03:00 UTC). */
+export declare const NIGHTLY_UPGRADE_SCHEDULE = "0 3 * * *";

package/lib/common/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NIGHTLY_UPGRADE_SCHEDULE = exports.DEFAULT_GHE_TOKEN_SECRET = void 0;
+/**
+ * Default GitHub secret name used for projen's self-mutation/automation token,
+ * unless a project overrides it via `gheTokenSecret`.
+ */
+exports.DEFAULT_GHE_TOKEN_SECRET = 'PROJEN_GITHUB_TOKEN';
+/** Cron schedule used by nightly dependency-upgrade workflows (03:00 UTC). */
+exports.NIGHTLY_UPGRADE_SCHEDULE = '0 3 * * *';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbW1vbi9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7OztHQUdHO0FBQ1UsUUFBQSx3QkFBd0IsR0FBRyxxQkFBcUIsQ0FBQztBQUU5RCw4RUFBOEU7QUFDakUsUUFBQSx3QkFBd0IsR0FBRyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERlZmF1bHQgR2l0SHViIHNlY3JldCBuYW1lIHVzZWQgZm9yIHByb2plbidzIHNlbGYtbXV0YXRpb24vYXV0b21hdGlvbiB0b2tlbixcbiAqIHVubGVzcyBhIHByb2plY3Qgb3ZlcnJpZGVzIGl0IHZpYSBgZ2hlVG9rZW5TZWNyZXRgLlxuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9HSEVfVE9LRU5fU0VDUkVUID0gJ1BST0pFTl9HSVRIVUJfVE9LRU4nO1xuXG4vKiogQ3JvbiBzY2hlZHVsZSB1c2VkIGJ5IG5pZ2h0bHkgZGVwZW5kZW5jeS11cGdyYWRlIHdvcmtmbG93cyAoMDM6MDAgVVRDKS4gKi9cbmV4cG9ydCBjb25zdCBOSUdIVExZX1VQR1JBREVfU0NIRURVTEUgPSAnMCAzICogKiAqJztcbiJdfQ==

package/lib/common/drift-check.d.ts

@@ -0,0 +1,8 @@
+import { github } from 'projen';
+/**
+ * Steps that re-run projen and fail the job if the generated output no
+ * longer matches what's committed - i.e. someone hand-edited a projen
+ * managed file (package.json/pom.xml/.github/workflows/*.yml/...) without
+ * going through .projenrc.
+ */
+export declare function driftCheckSteps(projenCommand?: string): github.workflows.JobStep[];

package/lib/common/drift-check.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driftCheckSteps = driftCheckSteps;
+/**
+ * Steps that re-run projen and fail the job if the generated output no
+ * longer matches what's committed - i.e. someone hand-edited a projen
+ * managed file (package.json/pom.xml/.github/workflows/*.yml/...) without
+ * going through .projenrc.
+ */
+function driftCheckSteps(projenCommand = 'npx projen') {
+    return [
+        {
+            name: 'Check for projen drift',
+            run: `${projenCommand}\ngit diff --exit-code`,
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJpZnQtY2hlY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tbW9uL2RyaWZ0LWNoZWNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsMENBU0M7QUFmRDs7Ozs7R0FLRztBQUNILFNBQWdCLGVBQWUsQ0FDN0IsYUFBYSxHQUFHLFlBQVk7SUFFNUIsT0FBTztRQUNMO1lBQ0UsSUFBSSxFQUFFLHdCQUF3QjtZQUM5QixHQUFHLEVBQUUsR0FBRyxhQUFhLHdCQUF3QjtTQUM5QztLQUNGLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2l0aHViIH0gZnJvbSAncHJvamVuJztcblxuLyoqXG4gKiBTdGVwcyB0aGF0IHJlLXJ1biBwcm9qZW4gYW5kIGZhaWwgdGhlIGpvYiBpZiB0aGUgZ2VuZXJhdGVkIG91dHB1dCBub1xuICogbG9uZ2VyIG1hdGNoZXMgd2hhdCdzIGNvbW1pdHRlZCAtIGkuZS4gc29tZW9uZSBoYW5kLWVkaXRlZCBhIHByb2plblxuICogbWFuYWdlZCBmaWxlIChwYWNrYWdlLmpzb24vcG9tLnhtbC8uZ2l0aHViL3dvcmtmbG93cy8qLnltbC8uLi4pIHdpdGhvdXRcbiAqIGdvaW5nIHRocm91Z2ggLnByb2plbnJjLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZHJpZnRDaGVja1N0ZXBzKFxuICBwcm9qZW5Db21tYW5kID0gJ25weCBwcm9qZW4nLFxuKTogZ2l0aHViLndvcmtmbG93cy5Kb2JTdGVwW10ge1xuICByZXR1cm4gW1xuICAgIHtcbiAgICAgIG5hbWU6ICdDaGVjayBmb3IgcHJvamVuIGRyaWZ0JyxcbiAgICAgIHJ1bjogYCR7cHJvamVuQ29tbWFuZH1cXG5naXQgZGlmZiAtLWV4aXQtY29kZWAsXG4gICAgfSxcbiAgXTtcbn1cbiJdfQ==

package/lib/common/environment-options.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A single named deployment target used by manual-dispatch deploy workflows.
+ */
+export interface EnvironmentOptions {
+    /** Environment name, e.g. "dev", "stage", "prod". */
+    readonly name: string;
+    /** AWS account id to deploy into, if relevant to the deploy steps used. */
+    readonly accountId?: string;
+    /** AWS region to deploy into, if relevant to the deploy steps used. */
+    readonly region?: string;
+    /**
+     * Whether this environment requires a GitHub Environment approval gate
+     * before the deploy job is allowed to run.
+     *
+     * @default false
+     */
+    readonly requiresApproval?: boolean;
+}
+export declare function normalizeEnvironments(environments: (string | EnvironmentOptions)[]): EnvironmentOptions[];

package/lib/common/environment-options.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEnvironments = normalizeEnvironments;
+function normalizeEnvironments(environments) {
+    return environments.map((env) => typeof env === 'string' ? { name: env } : env);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQtb3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21tb24vZW52aXJvbm1lbnQtb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQXNCQSxzREFNQztBQU5ELFNBQWdCLHFCQUFxQixDQUNuQyxZQUE2QztJQUU3QyxPQUFPLFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUM5QixPQUFPLEdBQUcsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQzlDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBIHNpbmdsZSBuYW1lZCBkZXBsb3ltZW50IHRhcmdldCB1c2VkIGJ5IG1hbnVhbC1kaXNwYXRjaCBkZXBsb3kgd29ya2Zsb3dzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEVudmlyb25tZW50T3B0aW9ucyB7XG4gIC8qKiBFbnZpcm9ubWVudCBuYW1lLCBlLmcuIFwiZGV2XCIsIFwic3RhZ2VcIiwgXCJwcm9kXCIuICovXG4gIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcblxuICAvKiogQVdTIGFjY291bnQgaWQgdG8gZGVwbG95IGludG8sIGlmIHJlbGV2YW50IHRvIHRoZSBkZXBsb3kgc3RlcHMgdXNlZC4gKi9cbiAgcmVhZG9ubHkgYWNjb3VudElkPzogc3RyaW5nO1xuXG4gIC8qKiBBV1MgcmVnaW9uIHRvIGRlcGxveSBpbnRvLCBpZiByZWxldmFudCB0byB0aGUgZGVwbG95IHN0ZXBzIHVzZWQuICovXG4gIHJlYWRvbmx5IHJlZ2lvbj86IHN0cmluZztcblxuICAvKipcbiAgICogV2hldGhlciB0aGlzIGVudmlyb25tZW50IHJlcXVpcmVzIGEgR2l0SHViIEVudmlyb25tZW50IGFwcHJvdmFsIGdhdGVcbiAgICogYmVmb3JlIHRoZSBkZXBsb3kgam9iIGlzIGFsbG93ZWQgdG8gcnVuLlxuICAgKlxuICAgKiBAZGVmYXVsdCBmYWxzZVxuICAgKi9cbiAgcmVhZG9ubHkgcmVxdWlyZXNBcHByb3ZhbD86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBub3JtYWxpemVFbnZpcm9ubWVudHMoXG4gIGVudmlyb25tZW50czogKHN0cmluZyB8IEVudmlyb25tZW50T3B0aW9ucylbXSxcbik6IEVudmlyb25tZW50T3B0aW9uc1tdIHtcbiAgcmV0dXJuIGVudmlyb25tZW50cy5tYXAoKGVudikgPT5cbiAgICB0eXBlb2YgZW52ID09PSAnc3RyaW5nJyA/IHsgbmFtZTogZW52IH0gOiBlbnYsXG4gICk7XG59XG4iXX0=

package/lib/common/manual-deploy-workflow.d.ts

@@ -0,0 +1,34 @@
+import { Component, github } from 'projen';
+import { EnvironmentOptions } from './environment-options';
+/**
+ * Shared, environment-parameterized manual-dispatch deploy workflow.
+ *
+ * This is the one "trigger a deploy" contract used by both the CDK project
+ * types (deploying their own stacks) and the Java `CdkDeployHook` component
+ * (dispatching a deploy in a companion CDK repo) - see the "Open Questions"
+ * sections of the two specs.
+ *
+ * @internal - not part of the jsii-exported API (its `deploySteps` callback
+ * isn't representable across jsii languages); consumed directly by other
+ * TypeScript source in this package.
+ */
+export interface ManualDeployWorkflowOptions {
+    /** Deploy targets exposed as the `environment` workflow_dispatch choice. */
+    readonly environments: (string | EnvironmentOptions)[];
+    /** @default "deploy" */
+    readonly workflowName?: string;
+    /**
+     * The steps that actually perform the deploy for a given environment.
+     * Defaults to a placeholder `echo` step - project types are expected to
+     * override this with something real (e.g. `cdk deploy`, or a
+     * `repository_dispatch` to a companion infra repo).
+     */
+    readonly deploySteps?: (env: EnvironmentOptions) => github.workflows.JobStep[];
+    /** GitHub secret holding a Slack webhook URL used to notify on deploy. */
+    readonly slackWebhookSecret?: string;
+}
+/** @internal */
+export declare class ManualDeployWorkflow extends Component {
+    readonly workflow: github.GithubWorkflow;
+    constructor(scope: github.GitHubProject, options: ManualDeployWorkflowOptions);
+}

package/lib/common/manual-deploy-workflow.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualDeployWorkflow = void 0;
+const projen_1 = require("projen");
+const environment_options_1 = require("./environment-options");
+/** @internal */
+class ManualDeployWorkflow extends projen_1.Component {
+    workflow;
+    constructor(scope, options) {
+        super(scope, 'ManualDeployWorkflow');
+        const environments = (0, environment_options_1.normalizeEnvironments)(options.environments);
+        const gh = scope.github;
+        if (!gh) {
+            throw new Error('ManualDeployWorkflow requires GitHub integration to be enabled');
+        }
+        const workflowName = options.workflowName ?? 'deploy';
+        const deploySteps = options.deploySteps ??
+            ((env) => [
+                {
+                    name: `Deploy ${env.name}`,
+                    run: `echo "TODO: implement deploy steps for environment '${env.name}'"`,
+                },
+            ]);
+        this.workflow = new projen_1.github.GithubWorkflow(gh, workflowName);
+        this.workflow.on({
+            workflowDispatch: {
+                inputs: {
+                    environment: {
+                        description: 'Environment to deploy',
+                        required: true,
+                        type: 'choice',
+                        options: environments.map((e) => e.name),
+                    },
+                    git_sha: {
+                        description: 'Optional commit SHA to deploy (defaults to the default branch)',
+                        required: false,
+                    },
+                },
+            },
+        });
+        for (const env of environments) {
+            const steps = [
+                {
+                    name: 'Checkout',
+                    uses: 'actions/checkout@v4',
+                    with: {
+                        ref: '${{ github.event.inputs.git_sha || github.sha }}',
+                    },
+                },
+                ...deploySteps(env),
+            ];
+            if (options.slackWebhookSecret) {
+                steps.push({
+                    name: 'Notify Slack',
+                    if: 'always()',
+                    uses: 'slackapi/slack-github-action@v2',
+                    with: { 'webhook-type': 'incoming-webhook' },
+                    env: {
+                        SLACK_WEBHOOK_URL: `\${{ secrets.${options.slackWebhookSecret} }}`,
+                    },
+                });
+            }
+            this.workflow.addJob(`deploy-${env.name}`, {
+                name: `Deploy (${env.name})`,
+                if: `github.event.inputs.environment == '${env.name}'`,
+                runsOn: ['ubuntu-latest'],
+                environment: env.requiresApproval ? env.name : undefined,
+                permissions: {
+                    idToken: projen_1.github.workflows.JobPermission.WRITE,
+                    contents: projen_1.github.workflows.JobPermission.READ,
+                },
+                steps,
+            });
+        }
+    }
+}
+exports.ManualDeployWorkflow = ManualDeployWorkflow;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manual-deploy-workflow.js","sourceRoot":"","sources":["../../src/common/manual-deploy-workflow.ts"],"names":[],"mappings":";;;AAAA,mCAA2C;AAC3C,+DAG+B;AAmC/B,gBAAgB;AAChB,MAAa,oBAAqB,SAAQ,kBAAS;IACjC,QAAQ,CAAwB;IAEhD,YACE,KAA2B,EAC3B,OAAoC;QAEpC,KAAK,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC;QAErC,MAAM,YAAY,GAAG,IAAA,2CAAqB,EAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QACjE,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC;QACxB,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;QACJ,CAAC;QAED,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,QAAQ,CAAC;QACtD,MAAM,WAAW,GACf,OAAO,CAAC,WAAW;YACnB,CAAC,CAAC,GAAuB,EAA8B,EAAE,CAAC;gBACxD;oBACE,IAAI,EAAE,UAAU,GAAG,CAAC,IAAI,EAAE;oBAC1B,GAAG,EAAE,uDAAuD,GAAG,CAAC,IAAI,IAAI;iBACzE;aACF,CAAC,CAAC;QAEL,IAAI,CAAC,QAAQ,GAAG,IAAI,eAAM,CAAC,cAAc,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACf,gBAAgB,EAAE;gBAChB,MAAM,EAAE;oBACN,WAAW,EAAE;wBACX,WAAW,EAAE,uBAAuB;wBACpC,QAAQ,EAAE,IAAI;wBACd,IAAI,EAAE,QAAQ;wBACd,OAAO,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;qBACzC;oBACD,OAAO,EAAE;wBACP,WAAW,EACT,gEAAgE;wBAClE,QAAQ,EAAE,KAAK;qBAChB;iBACF;aACF;SACF,CAAC,CAAC;QAEH,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAC/B,MAAM,KAAK,GAA+B;gBACxC;oBACE,IAAI,EAAE,UAAU;oBAChB,IAAI,EAAE,qBAAqB;oBAC3B,IAAI,EAAE;wBACJ,GAAG,EAAE,kDAAkD;qBACxD;iBACF;gBACD,GAAG,WAAW,CAAC,GAAG,CAAC;aACpB,CAAC;YAEF,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;gBAC/B,KAAK,CAAC,IAAI,CAAC;oBACT,IAAI,EAAE,cAAc;oBACpB,EAAE,EAAE,UAAU;oBACd,IAAI,EAAE,iCAAiC;oBACvC,IAAI,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;oBAC5C,GAAG,EAAE;wBACH,iBAAiB,EAAE,gBAAgB,OAAO,CAAC,kBAAkB,KAAK;qBACnE;iBACF,CAAC,CAAC;YACL,CAAC;YAED,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,GAAG,CAAC,IAAI,EAAE,EAAE;gBACzC,IAAI,EAAE,WAAW,GAAG,CAAC,IAAI,GAAG;gBAC5B,EAAE,EAAE,uCAAuC,GAAG,CAAC,IAAI,GAAG;gBACtD,MAAM,EAAE,CAAC,eAAe,CAAC;gBACzB,WAAW,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;gBACxD,WAAW,EAAE;oBACX,OAAO,EAAE,eAAM,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK;oBAC7C,QAAQ,EAAE,eAAM,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI;iBAC9C;gBACD,KAAK;aACN,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF;AAnFD,oDAmFC","sourcesContent":["import { Component, github } from 'projen';\nimport {\n  EnvironmentOptions,\n  normalizeEnvironments,\n} from './environment-options';\n\n/**\n * Shared, environment-parameterized manual-dispatch deploy workflow.\n *\n * This is the one \"trigger a deploy\" contract used by both the CDK project\n * types (deploying their own stacks) and the Java `CdkDeployHook` component\n * (dispatching a deploy in a companion CDK repo) - see the \"Open Questions\"\n * sections of the two specs.\n *\n * @internal - not part of the jsii-exported API (its `deploySteps` callback\n * isn't representable across jsii languages); consumed directly by other\n * TypeScript source in this package.\n */\nexport interface ManualDeployWorkflowOptions {\n  /** Deploy targets exposed as the `environment` workflow_dispatch choice. */\n  readonly environments: (string | EnvironmentOptions)[];\n\n  /** @default \"deploy\" */\n  readonly workflowName?: string;\n\n  /**\n   * The steps that actually perform the deploy for a given environment.\n   * Defaults to a placeholder `echo` step - project types are expected to\n   * override this with something real (e.g. `cdk deploy`, or a\n   * `repository_dispatch` to a companion infra repo).\n   */\n  readonly deploySteps?: (\n    env: EnvironmentOptions,\n  ) => github.workflows.JobStep[];\n\n  /** GitHub secret holding a Slack webhook URL used to notify on deploy. */\n  readonly slackWebhookSecret?: string;\n}\n\n/** @internal */\nexport class ManualDeployWorkflow extends Component {\n  public readonly workflow: github.GithubWorkflow;\n\n  constructor(\n    scope: github.GitHubProject,\n    options: ManualDeployWorkflowOptions,\n  ) {\n    super(scope, 'ManualDeployWorkflow');\n\n    const environments = normalizeEnvironments(options.environments);\n    const gh = scope.github;\n    if (!gh) {\n      throw new Error(\n        'ManualDeployWorkflow requires GitHub integration to be enabled',\n      );\n    }\n\n    const workflowName = options.workflowName ?? 'deploy';\n    const deploySteps =\n      options.deploySteps ??\n      ((env: EnvironmentOptions): github.workflows.JobStep[] => [\n        {\n          name: `Deploy ${env.name}`,\n          run: `echo \"TODO: implement deploy steps for environment '${env.name}'\"`,\n        },\n      ]);\n\n    this.workflow = new github.GithubWorkflow(gh, workflowName);\n    this.workflow.on({\n      workflowDispatch: {\n        inputs: {\n          environment: {\n            description: 'Environment to deploy',\n            required: true,\n            type: 'choice',\n            options: environments.map((e) => e.name),\n          },\n          git_sha: {\n            description:\n              'Optional commit SHA to deploy (defaults to the default branch)',\n            required: false,\n          },\n        },\n      },\n    });\n\n    for (const env of environments) {\n      const steps: github.workflows.JobStep[] = [\n        {\n          name: 'Checkout',\n          uses: 'actions/checkout@v4',\n          with: {\n            ref: '${{ github.event.inputs.git_sha || github.sha }}',\n          },\n        },\n        ...deploySteps(env),\n      ];\n\n      if (options.slackWebhookSecret) {\n        steps.push({\n          name: 'Notify Slack',\n          if: 'always()',\n          uses: 'slackapi/slack-github-action@v2',\n          with: { 'webhook-type': 'incoming-webhook' },\n          env: {\n            SLACK_WEBHOOK_URL: `\\${{ secrets.${options.slackWebhookSecret} }}`,\n          },\n        });\n      }\n\n      this.workflow.addJob(`deploy-${env.name}`, {\n        name: `Deploy (${env.name})`,\n        if: `github.event.inputs.environment == '${env.name}'`,\n        runsOn: ['ubuntu-latest'],\n        environment: env.requiresApproval ? env.name : undefined,\n        permissions: {\n          idToken: github.workflows.JobPermission.WRITE,\n          contents: github.workflows.JobPermission.READ,\n        },\n        steps,\n      });\n    }\n  }\n}\n"]}

package/lib/common/upgrade-workflow.d.ts

@@ -0,0 +1,18 @@
+import { Component, Task, github } from 'projen';
+/**
+ * Nightly cron workflow that opens a PR with dependency upgrades. Used by
+ * non-Node project types (Java); TypeScript/CDK project types instead get
+ * this for free from projen's built-in `depsUpgrade`.
+ */
+export interface UpgradeWorkflowOptions {
+    /** The task that performs the upgrade (e.g. `mvn versions:use-latest-releases`). */
+    readonly task: Task;
+    /** @default "upgrade" */
+    readonly workflowName?: string;
+    /** @default NIGHTLY_UPGRADE_SCHEDULE (03:00 UTC) */
+    readonly schedule?: string;
+}
+export declare class UpgradeWorkflow extends Component {
+    readonly workflow: github.TaskWorkflow;
+    constructor(scope: github.GitHubProject, options: UpgradeWorkflowOptions);
+}

package/lib/common/upgrade-workflow.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpgradeWorkflow = void 0;
+const projen_1 = require("projen");
+const constants_1 = require("./constants");
+class UpgradeWorkflow extends projen_1.Component {
+    workflow;
+    constructor(scope, options) {
+        super(scope, 'UpgradeWorkflow');
+        const gh = scope.github;
+        if (!gh) {
+            throw new Error('UpgradeWorkflow requires GitHub integration to be enabled');
+        }
+        this.workflow = new projen_1.github.TaskWorkflow(gh, {
+            name: options.workflowName ?? 'upgrade',
+            jobId: 'upgrade',
+            task: options.task,
+            triggers: {
+                schedule: [{ cron: options.schedule ?? constants_1.NIGHTLY_UPGRADE_SCHEDULE }],
+                workflowDispatch: {},
+            },
+            permissions: { contents: projen_1.github.workflows.JobPermission.READ },
+            postBuildSteps: [
+                {
+                    name: 'Create Pull Request',
+                    uses: 'peter-evans/create-pull-request@v7',
+                    with: {
+                        'commit-message': 'chore: upgrade dependencies',
+                        'branch': 'auto/upgrade-dependencies',
+                        'title': 'chore: upgrade dependencies',
+                        'labels': 'auto-approve,auto-merge',
+                    },
+                },
+            ],
+        });
+    }
+}
+exports.UpgradeWorkflow = UpgradeWorkflow;
+//# sourceMappingURL=data:application/json;base64,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