@nikovirtala/projen-lambda-function-construct-generator 0.0.0

package/lib/index.d.ts

@@ -0,0 +1,99 @@
+import { BuildOptions } from "@mrgrain/cdk-esbuild";
+import { Component } from "projen";
+import { NodeProject } from "projen/lib/javascript";
+/**
+ * Options for the LambdaFunctionConstructGenerator
+ */
+export interface LambdaFunctionConstructGeneratorOptions {
+    /**
+     * Source directory where Lambda Function handlers are located
+     *
+     * @default "src/handlers"
+     */
+    readonly sourceDir?: string;
+    /**
+     * Output directory where Lambda Function constructs will be generated
+     *
+     * @default "src/constructs/lambda"
+     */
+    readonly outputDir?: string;
+    /**
+     * File pattern to identify Lambda Function handlers
+     *
+     * @default "*.lambda.ts"
+     */
+    readonly filePattern?: string;
+    /**
+     * esbuild options to customize the bundling process
+     *
+     * @default {}
+     */
+    readonly esbuildOptions?: BuildOptions;
+    /**
+     * Whether to automatically add the required dependencies
+     *
+     * @default true
+     */
+    readonly addDependencies?: boolean;
+    /**
+     * Import statement for the base construct
+     *
+     * @example "import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';"
+     *
+     * @default "import { aws_lambda } from 'aws-cdk-lib';"
+     */
+    readonly baseConstructImport?: string;
+    /**
+     * Name of the construct class to extend
+     *
+     * @example "NodejsFunction"
+     *
+     * @default "aws_lambda.Function"
+     */
+    readonly baseConstructClass?: string;
+    /**
+     * Package name to add as dependency for the base construct
+     *
+     * @example "aws-cdk-lib"
+     *
+     * @default "aws-cdk-lib"
+     */
+    readonly baseConstructPackage?: string;
+}
+/**
+ * A projen component that generates AWS CDK Lambda Function constructs and bundles their code assets using esbuild.
+ *
+ * The bundling happens during projen execution, not during CDK synth, enabling a "build once, deploy many" pattern.
+ */
+export declare class LambdaFunctionConstructGenerator extends Component {
+    readonly sourceDir: string;
+    readonly outputDir: string;
+    readonly filePattern: string;
+    readonly esbuildOptions: BuildOptions;
+    readonly baseConstructImport?: string;
+    readonly baseConstructClass?: string;
+    readonly baseConstructPackage?: string;
+    private readonly nodeProject;
+    private readonly bundlerScriptPath;
+    constructor(project: NodeProject, options?: LambdaFunctionConstructGeneratorOptions);
+    /**
+     * Add required dependencies for the component
+     */
+    private addDependencies;
+    /**
+     * Create a unique ID based on sourceDir and filePattern
+     */
+    private createUniqueId;
+    /**
+     * Create the bundle task that will be executed during projen build
+     */
+    private createBundleTask;
+    /**
+     * Create the bundler script that will be executed by the bundle task
+     */
+    private createBundlerScript;
+    /**
+     * Add the bundle task to the build workflow
+     */
+    private addBundleTaskToWorkflow;
+}

package/lib/index.js

@@ -0,0 +1,245 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaFunctionConstructGenerator = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const projen_1 = require("projen");
+/**
+ * A projen component that generates AWS CDK Lambda Function constructs and bundles their code assets using esbuild.
+ *
+ * The bundling happens during projen execution, not during CDK synth, enabling a "build once, deploy many" pattern.
+ */
+class LambdaFunctionConstructGenerator extends projen_1.Component {
+    constructor(project, options) {
+        super(project);
+        this.nodeProject = project;
+        this.sourceDir = options?.sourceDir ?? "src/handlers";
+        this.outputDir = options?.outputDir ?? "src/constructs/lambda";
+        this.filePattern = options?.filePattern ?? "*.lambda.ts";
+        this.esbuildOptions = options?.esbuildOptions ?? {};
+        this.baseConstructImport = options?.baseConstructImport;
+        this.baseConstructClass = options?.baseConstructClass;
+        this.baseConstructPackage = options?.baseConstructPackage;
+        // Create unique script name based on sourceDir and filePattern
+        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);
+        this.bundlerScriptPath = path.join(".projen", `generate-and-bundle-${uniqueId}.ts`);
+        // Add required dependencies
+        if (options?.addDependencies ?? true) {
+            this.addDependencies(options?.baseConstructPackage);
+        }
+        // Create the bundle task
+        this.createBundleTask();
+        // Add the bundle task to the build workflow
+        this.addBundleTaskToWorkflow();
+    }
+    /**
+     * Add required dependencies for the component
+     */
+    addDependencies(additionalPackage) {
+        this.nodeProject.addDeps("aws-cdk-lib", "constructs");
+        if (additionalPackage && additionalPackage !== "aws-cdk-lib" && additionalPackage !== "constructs") {
+            this.nodeProject.addDeps(additionalPackage);
+        }
+    }
+    /**
+     * Create a unique ID based on sourceDir and filePattern
+     */
+    createUniqueId(sourceDir, filePattern) {
+        // Remove special characters and convert to kebab case
+        const dirPart = sourceDir.replace(/\//g, "-").replace(/[^\w-]/g, "");
+        const patternPart = filePattern
+            .replace(/\*/g, "")
+            .replace(/\./g, "-")
+            .replace(/[^\w-]/g, "");
+        return `${dirPart}-${patternPart}`.replace(/--+/g, "-").replace(/^-|-$/g, "");
+    }
+    /**
+     * Create the bundle task that will be executed during projen build
+     */
+    createBundleTask() {
+        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);
+        const taskName = `generate-and-bundle-${uniqueId}`;
+        let baseConstructArgs = "";
+        if (this.baseConstructImport) {
+            baseConstructArgs += ` --base-construct-import '${this.baseConstructImport}'`;
+        }
+        if (this.baseConstructClass) {
+            baseConstructArgs += ` --base-construct-class '${this.baseConstructClass}'`;
+        }
+        const bundleTask = this.nodeProject.addTask(taskName, {
+            description: `Generate Lambda Function Constructs from ${this.sourceDir}/${this.filePattern} and bundle their handlers`,
+            exec: `tsx --tsconfig tsconfig.dev.json ${this.bundlerScriptPath} --source-dir ${this.sourceDir} --output-dir ${this.outputDir} --file-pattern "${this.filePattern}" --esbuild-options '${JSON.stringify(this.esbuildOptions)}'${baseConstructArgs}`,
+        });
+        // Create the bundler script
+        this.createBundlerScript();
+        return bundleTask;
+    }
+    /**
+     * Create the bundler script that will be executed by the bundle task
+     */
+    createBundlerScript() {
+        const bundlerScript = `// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as esbuild from 'esbuild';
+import * as glob from 'glob';
+import { pascalCase } from 'change-case';
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+
+async function main() {
+  const argv = await yargs(hideBin(process.argv))
+    .option('source-dir', { type: 'string', default: 'src/handlers', description: 'Source directory where Lambda Function handlers are located' })
+    .option('output-dir', { type: 'string', default: 'src/constructs/lambda', description: 'Output directory where Lambda Function constructs will be generated' })
+    .option('file-pattern', { type: 'string', default: '*.lambda.ts', description: 'File pattern to identify Lambda Function handlers' })
+    .option('esbuild-options', { type: 'string', default: '{}', description: 'esbuild options as JSON string' })
+    .option('base-construct-import', { type: 'string', description: 'Import statement for the base construct' })
+    .option('base-construct-class', { type: 'string', description: 'Name of the construct class to extend' })
+    .help()
+    .parse();
+
+  const sourceDir = argv['source-dir'];
+  const outputDir = argv['output-dir'];
+  const filePattern = argv['file-pattern'];
+  const esbuildOptions = JSON.parse(argv['esbuild-options'] as string);
+  const baseConstructImport = argv['base-construct-import'] as string | undefined;
+  const baseConstructClass = argv['base-construct-class'] as string | undefined;
+
+  // Ensure output directory exists
+  fs.mkdirSync(path.join(process.cwd(), outputDir), { recursive: true });
+
+  // Ensure assets directory exists
+  const assetsDir = path.join(process.cwd(), 'assets', 'handlers');
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  // Find all Lambda Function handler files
+  const handlerFiles = glob.sync(path.join(process.cwd(), sourceDir, filePattern));
+
+  console.log(\`Found \${handlerFiles.length} Lambda Function handler files\`);
+
+  // Process each handler file
+  for (const handlerFile of handlerFiles) {
+    const relativePath = path.relative(path.join(process.cwd(), sourceDir), handlerFile);
+    const fileName = path.basename(relativePath, path.extname(relativePath));
+    const functionName = fileName.replace('.lambda', '');
+
+    console.log(\`Processing Lambda Function handler: \${functionName}\`);
+
+    // Create function-specific directory
+    const functionDir = path.join(assetsDir, functionName);
+    fs.mkdirSync(functionDir, { recursive: true });
+
+    // Bundle the handler code to index.js in the function directory
+    const outfile = path.join(functionDir, 'index.js');
+
+    try {
+      await esbuild.build({
+        entryPoints: [handlerFile],
+        bundle: true,
+        minify: true,
+        platform: 'node',
+        target: 'node18',
+        outfile,
+        ...esbuildOptions,
+      });
+
+      console.log(\`Successfully bundled \${functionName} to \${outfile}\`);
+
+      // Generate the CDK construct
+      const constructFilePath = path.join(process.cwd(), outputDir, \`\${functionName}.ts\`);
+      const constructCode = generateConstructCode(functionName, relativePath, baseConstructImport, baseConstructClass);
+
+      fs.writeFileSync(constructFilePath, constructCode);
+      console.log(\`Generated construct at \${constructFilePath}\`);
+    } catch (error) {
+      console.error(\`Error processing \${functionName}:\`, error);
+    }
+  }
+}
+
+function generateConstructCode(functionName: string, handlerPath: string, baseConstructImport?: string, baseConstructClass?: string) {
+  const constructName = \`\${pascalCase(functionName)}Function\`;
+
+  // Default values if no baseConstruct is provided
+  const importStatement = baseConstructImport ?? "";
+  const baseClassName = baseConstructClass ?? "aws_lambda.Function";
+
+  // Determine if we need to use aws_lambda.Runtime or not based on the base class
+  const useAwsLambdaRuntime = !baseConstructClass || baseClassName.includes("Function");
+
+  return \`// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+\${importStatement}
+import { aws_lambda } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+
+// ES Module compatibility
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Properties for \${constructName}
+ */
+export interface \${constructName}Props extends Omit<\${baseClassName === "aws_lambda.Function" ? "aws_lambda.FunctionProps" : \`\${baseClassName}Props\`}, 'code'\${useAwsLambdaRuntime ? " | 'runtime'" : ""} | 'handler'> {
+  \${useAwsLambdaRuntime ? \`/**
+   * Override the default runtime
+   * @default nodejs22.x
+   */
+  readonly runtime?: aws_lambda.Runtime;\` : ""}
+}
+
+/**
+ * \${constructName} - Lambda Function Construct for \${handlerPath}
+ */
+export class \${constructName} extends \${baseClassName} {
+  constructor(scope: Construct, id: string, props: \${constructName}Props = {}) {
+    super(scope, id, {
+      ...props,
+      \${useAwsLambdaRuntime ? "runtime: props.runtime ?? aws_lambda.Runtime.NODEJS_22_X," : ""}
+      handler: 'index.handler',
+      code: aws_lambda.Code.fromAsset(path.join(__dirname, '../../../assets/handlers/\${functionName}')),
+    });
+  }
+}
+\`;
+}
+
+main().catch(error => {
+  console.error('Error:', error);
+  process.exit(1);
+});
+`;
+        // Create source code file and add code lines to it
+        const src = new projen_1.SourceCode(this.project, this.bundlerScriptPath);
+        const lines = bundlerScript.split("\n");
+        for (const line of lines) {
+            src.line(line);
+        }
+        // Add the dependencies needed for the bundler script
+        this.nodeProject.addDevDeps("esbuild", "glob", "yargs", "@types/glob", "@types/yargs", "tsx", "change-case");
+    }
+    /**
+     * Add the bundle task to the build workflow
+     */
+    addBundleTaskToWorkflow() {
+        // Get the compile task
+        const compileTask = this.nodeProject.tasks.tryFind("compile");
+        if (compileTask) {
+            // Add the bundle task as a dependency of the compile task
+            const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);
+            const taskName = `generate-and-bundle-${uniqueId}`;
+            const bundleTask = this.nodeProject.tasks.tryFind(taskName);
+            if (bundleTask) {
+                compileTask.prependSpawn(bundleTask);
+            }
+        }
+    }
+}
+exports.LambdaFunctionConstructGenerator = LambdaFunctionConstructGenerator;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaFunctionConstructGenerator[_a] = { fqn: "@nikovirtala/projen-lambda-function-construct-generator.LambdaFunctionConstructGenerator", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"path\";\nimport { BuildOptions } from \"@mrgrain/cdk-esbuild\";\nimport { Component, SourceCode } from \"projen\";\nimport { NodeProject } from \"projen/lib/javascript\";\n\n/**\n * Options for the LambdaFunctionConstructGenerator\n */\nexport interface LambdaFunctionConstructGeneratorOptions {\n    /**\n     * Source directory where Lambda Function handlers are located\n     *\n     * @default \"src/handlers\"\n     */\n    readonly sourceDir?: string;\n\n    /**\n     * Output directory where Lambda Function constructs will be generated\n     *\n     * @default \"src/constructs/lambda\"\n     */\n    readonly outputDir?: string;\n\n    /**\n     * File pattern to identify Lambda Function handlers\n     *\n     * @default \"*.lambda.ts\"\n     */\n    readonly filePattern?: string;\n\n    /**\n     * esbuild options to customize the bundling process\n     *\n     * @default {}\n     */\n    readonly esbuildOptions?: BuildOptions;\n\n    /**\n     * Whether to automatically add the required dependencies\n     *\n     * @default true\n     */\n    readonly addDependencies?: boolean;\n\n    /**\n     * Import statement for the base construct\n     *\n     * @example \"import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';\"\n     *\n     * @default \"import { aws_lambda } from 'aws-cdk-lib';\"\n     */\n    readonly baseConstructImport?: string;\n\n    /**\n     * Name of the construct class to extend\n     *\n     * @example \"NodejsFunction\"\n     *\n     * @default \"aws_lambda.Function\"\n     */\n    readonly baseConstructClass?: string;\n\n    /**\n     * Package name to add as dependency for the base construct\n     *\n     * @example \"aws-cdk-lib\"\n     *\n     * @default \"aws-cdk-lib\"\n     */\n    readonly baseConstructPackage?: string;\n}\n\n/**\n * A projen component that generates AWS CDK Lambda Function constructs and bundles their code assets using esbuild.\n *\n * The bundling happens during projen execution, not during CDK synth, enabling a \"build once, deploy many\" pattern.\n */\nexport class LambdaFunctionConstructGenerator extends Component {\n    public readonly sourceDir: string;\n    public readonly outputDir: string;\n    public readonly filePattern: string;\n    public readonly esbuildOptions: BuildOptions;\n    public readonly baseConstructImport?: string;\n    public readonly baseConstructClass?: string;\n    public readonly baseConstructPackage?: string;\n    private readonly nodeProject: NodeProject;\n    private readonly bundlerScriptPath: string;\n\n    constructor(project: NodeProject, options?: LambdaFunctionConstructGeneratorOptions) {\n        super(project);\n        this.nodeProject = project;\n        this.sourceDir = options?.sourceDir ?? \"src/handlers\";\n        this.outputDir = options?.outputDir ?? \"src/constructs/lambda\";\n        this.filePattern = options?.filePattern ?? \"*.lambda.ts\";\n        this.esbuildOptions = options?.esbuildOptions ?? {};\n        this.baseConstructImport = options?.baseConstructImport;\n        this.baseConstructClass = options?.baseConstructClass;\n        this.baseConstructPackage = options?.baseConstructPackage;\n\n        // Create unique script name based on sourceDir and filePattern\n        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);\n        this.bundlerScriptPath = path.join(\".projen\", `generate-and-bundle-${uniqueId}.ts`);\n\n        // Add required dependencies\n        if (options?.addDependencies ?? true) {\n            this.addDependencies(options?.baseConstructPackage);\n        }\n\n        // Create the bundle task\n        this.createBundleTask();\n\n        // Add the bundle task to the build workflow\n        this.addBundleTaskToWorkflow();\n    }\n\n    /**\n     * Add required dependencies for the component\n     */\n    private addDependencies(additionalPackage?: string) {\n        this.nodeProject.addDeps(\"aws-cdk-lib\", \"constructs\");\n\n        if (additionalPackage && additionalPackage !== \"aws-cdk-lib\" && additionalPackage !== \"constructs\") {\n            this.nodeProject.addDeps(additionalPackage);\n        }\n    }\n\n    /**\n     * Create a unique ID based on sourceDir and filePattern\n     */\n    private createUniqueId(sourceDir: string, filePattern: string): string {\n        // Remove special characters and convert to kebab case\n        const dirPart = sourceDir.replace(/\\//g, \"-\").replace(/[^\\w-]/g, \"\");\n        const patternPart = filePattern\n            .replace(/\\*/g, \"\")\n            .replace(/\\./g, \"-\")\n            .replace(/[^\\w-]/g, \"\");\n        return `${dirPart}-${patternPart}`.replace(/--+/g, \"-\").replace(/^-|-$/g, \"\");\n    }\n\n    /**\n     * Create the bundle task that will be executed during projen build\n     */\n    private createBundleTask() {\n        const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);\n        const taskName = `generate-and-bundle-${uniqueId}`;\n\n        let baseConstructArgs = \"\";\n        if (this.baseConstructImport) {\n            baseConstructArgs += ` --base-construct-import '${this.baseConstructImport}'`;\n        }\n        if (this.baseConstructClass) {\n            baseConstructArgs += ` --base-construct-class '${this.baseConstructClass}'`;\n        }\n\n        const bundleTask = this.nodeProject.addTask(taskName, {\n            description: `Generate Lambda Function Constructs from ${this.sourceDir}/${this.filePattern} and bundle their handlers`,\n            exec: `tsx --tsconfig tsconfig.dev.json ${this.bundlerScriptPath} --source-dir ${this.sourceDir} --output-dir ${this.outputDir} --file-pattern \"${this.filePattern}\" --esbuild-options '${JSON.stringify(this.esbuildOptions)}'${baseConstructArgs}`,\n        });\n\n        // Create the bundler script\n        this.createBundlerScript();\n\n        return bundleTask;\n    }\n\n    /**\n     * Create the bundler script that will be executed by the bundle task\n     */\n    private createBundlerScript() {\n        const bundlerScript = `// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\n\nimport * as path from 'path';\nimport * as fs from 'fs';\nimport * as esbuild from 'esbuild';\nimport * as glob from 'glob';\nimport { pascalCase } from 'change-case';\nimport yargs from 'yargs/yargs';\nimport { hideBin } from 'yargs/helpers';\n\nasync function main() {\n  const argv = await yargs(hideBin(process.argv))\n    .option('source-dir', { type: 'string', default: 'src/handlers', description: 'Source directory where Lambda Function handlers are located' })\n    .option('output-dir', { type: 'string', default: 'src/constructs/lambda', description: 'Output directory where Lambda Function constructs will be generated' })\n    .option('file-pattern', { type: 'string', default: '*.lambda.ts', description: 'File pattern to identify Lambda Function handlers' })\n    .option('esbuild-options', { type: 'string', default: '{}', description: 'esbuild options as JSON string' })\n    .option('base-construct-import', { type: 'string', description: 'Import statement for the base construct' })\n    .option('base-construct-class', { type: 'string', description: 'Name of the construct class to extend' })\n    .help()\n    .parse();\n\n  const sourceDir = argv['source-dir'];\n  const outputDir = argv['output-dir'];\n  const filePattern = argv['file-pattern'];\n  const esbuildOptions = JSON.parse(argv['esbuild-options'] as string);\n  const baseConstructImport = argv['base-construct-import'] as string | undefined;\n  const baseConstructClass = argv['base-construct-class'] as string | undefined;\n\n  // Ensure output directory exists\n  fs.mkdirSync(path.join(process.cwd(), outputDir), { recursive: true });\n\n  // Ensure assets directory exists\n  const assetsDir = path.join(process.cwd(), 'assets', 'handlers');\n  fs.mkdirSync(assetsDir, { recursive: true });\n\n  // Find all Lambda Function handler files\n  const handlerFiles = glob.sync(path.join(process.cwd(), sourceDir, filePattern));\n\n  console.log(\\`Found \\${handlerFiles.length} Lambda Function handler files\\`);\n\n  // Process each handler file\n  for (const handlerFile of handlerFiles) {\n    const relativePath = path.relative(path.join(process.cwd(), sourceDir), handlerFile);\n    const fileName = path.basename(relativePath, path.extname(relativePath));\n    const functionName = fileName.replace('.lambda', '');\n\n    console.log(\\`Processing Lambda Function handler: \\${functionName}\\`);\n\n    // Create function-specific directory\n    const functionDir = path.join(assetsDir, functionName);\n    fs.mkdirSync(functionDir, { recursive: true });\n\n    // Bundle the handler code to index.js in the function directory\n    const outfile = path.join(functionDir, 'index.js');\n\n    try {\n      await esbuild.build({\n        entryPoints: [handlerFile],\n        bundle: true,\n        minify: true,\n        platform: 'node',\n        target: 'node18',\n        outfile,\n        ...esbuildOptions,\n      });\n\n      console.log(\\`Successfully bundled \\${functionName} to \\${outfile}\\`);\n\n      // Generate the CDK construct\n      const constructFilePath = path.join(process.cwd(), outputDir, \\`\\${functionName}.ts\\`);\n      const constructCode = generateConstructCode(functionName, relativePath, baseConstructImport, baseConstructClass);\n\n      fs.writeFileSync(constructFilePath, constructCode);\n      console.log(\\`Generated construct at \\${constructFilePath}\\`);\n    } catch (error) {\n      console.error(\\`Error processing \\${functionName}:\\`, error);\n    }\n  }\n}\n\nfunction generateConstructCode(functionName: string, handlerPath: string, baseConstructImport?: string, baseConstructClass?: string) {\n  const constructName = \\`\\${pascalCase(functionName)}Function\\`;\n\n  // Default values if no baseConstruct is provided\n  const importStatement = baseConstructImport ?? \"\";\n  const baseClassName = baseConstructClass ?? \"aws_lambda.Function\";\n\n  // Determine if we need to use aws_lambda.Runtime or not based on the base class\n  const useAwsLambdaRuntime = !baseConstructClass || baseClassName.includes(\"Function\");\n\n  return \\`// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\n\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\n\\${importStatement}\nimport { aws_lambda } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\n\n// ES Module compatibility\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\n\n/**\n * Properties for \\${constructName}\n */\nexport interface \\${constructName}Props extends Omit<\\${baseClassName === \"aws_lambda.Function\" ? \"aws_lambda.FunctionProps\" : \\`\\${baseClassName}Props\\`}, 'code'\\${useAwsLambdaRuntime ? \" | 'runtime'\" : \"\"} | 'handler'> {\n  \\${useAwsLambdaRuntime ? \\`/**\n   * Override the default runtime\n   * @default nodejs22.x\n   */\n  readonly runtime?: aws_lambda.Runtime;\\` : \"\"}\n}\n\n/**\n * \\${constructName} - Lambda Function Construct for \\${handlerPath}\n */\nexport class \\${constructName} extends \\${baseClassName} {\n  constructor(scope: Construct, id: string, props: \\${constructName}Props = {}) {\n    super(scope, id, {\n      ...props,\n      \\${useAwsLambdaRuntime ? \"runtime: props.runtime ?? aws_lambda.Runtime.NODEJS_22_X,\" : \"\"}\n      handler: 'index.handler',\n      code: aws_lambda.Code.fromAsset(path.join(__dirname, '../../../assets/handlers/\\${functionName}')),\n    });\n  }\n}\n\\`;\n}\n\nmain().catch(error => {\n  console.error('Error:', error);\n  process.exit(1);\n});\n`;\n\n        // Create source code file and add code lines to it\n        const src = new SourceCode(this.project, this.bundlerScriptPath);\n        const lines = bundlerScript.split(\"\\n\");\n        for (const line of lines) {\n            src.line(line);\n        }\n\n        // Add the dependencies needed for the bundler script\n        this.nodeProject.addDevDeps(\"esbuild\", \"glob\", \"yargs\", \"@types/glob\", \"@types/yargs\", \"tsx\", \"change-case\");\n    }\n\n    /**\n     * Add the bundle task to the build workflow\n     */\n    private addBundleTaskToWorkflow() {\n        // Get the compile task\n        const compileTask = this.nodeProject.tasks.tryFind(\"compile\");\n\n        if (compileTask) {\n            // Add the bundle task as a dependency of the compile task\n            const uniqueId = this.createUniqueId(this.sourceDir, this.filePattern);\n            const taskName = `generate-and-bundle-${uniqueId}`;\n            const bundleTask = this.nodeProject.tasks.tryFind(taskName);\n            if (bundleTask) {\n                compileTask.prependSpawn(bundleTask);\n            }\n        }\n    }\n}\n"]}

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@nikovirtala/projen-lambda-function-construct-generator",
+  "description": "Projen component to generate AWS CDK Lambda Function Constructs and bundle their Code Assets",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nikovirtala/projen-lambda-function-construct-generator.git"
+  },
+  "author": {
+    "name": "Niko Virtala",
+    "email": "niko.virtala@hey.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@mrgrain/cdk-esbuild": "^5.7.3",
+    "@nikovirtala/projen-vitest": "^2.1.1",
+    "@types/glob": "^8.1.0",
+    "@types/node": "ts5.9",
+    "@types/yargs": "^17.0.34",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "@vitest/coverage-v8": "^4",
+    "change-case": "^5.4.4",
+    "commit-and-tag-version": "^12",
+    "constructs": "^10.4.3",
+    "esbuild": "^0.27.0",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "glob": "^10.4.5",
+    "jsii": "~5.9.3",
+    "jsii-diff": "^1.118.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.118.0",
+    "jsii-rosetta": "~5.9.3",
+    "prettier": "^3.6.2",
+    "projen": "^0.98.10",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.6",
+    "typescript": "5.9.3",
+    "vitest": "^4",
+    "yargs": "^17.7.2"
+  },
+  "peerDependencies": {
+    "@mrgrain/cdk-esbuild": "^5.7.3",
+    "aws-cdk-lib": "^2.222.0",
+    "constructs": "^10.4.3",
+    "projen": "^0.98.10"
+  },
+  "dependencies": {
+    "@mrgrain/cdk-esbuild": "^5.7.3",
+    "aws-cdk-lib": "^2.222.0",
+    "constructs": "^10.4.3",
+    "projen": "^0.98.10"
+  },
+  "main": "lib/index.js",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".",
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:update": "npx projen test:update",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  }
+}