@nikovirtala/projen-constructs 0.3.79 → 0.3.80

package/lib/components/bundle-lambda-function-code.d.ts

@@ -1,60 +1,303 @@
 import { Component, cdk, type Project, type Task } from "projen";
+/**
+ * Renders the bundle name of an entrypoint: its path without the extension and without a leading `src` directory.
+ *
+ * @example renderBundleName("src/handlers/foo.lambda.ts") // "handlers/foo.lambda"
+ */
 export declare function renderBundleName(entrypoint: string): string;
+/**
+ * Converts the given path string to posix if it wasn't already.
+ */
 export declare function convertToPosixPath(p: string): string;
+/**
+ * Options for `Bundler`.
+ */
 export interface BundlerOptions {
+    /**
+     * The semantic version requirement for `esbuild`.
+     *
+     * @default - no specific version (implies latest)
+     */
     readonly esbuildVersion?: string;
+    /**
+     * Output directory for all bundles.
+     *
+     * @default "assets"
+     */
     readonly assetsDir?: string;
+    /**
+     * Install the `bundle` command as a pre-compile phase.
+     *
+     * @default true
+     */
     readonly addToPreCompile?: boolean;
+    /**
+     * Map of file extensions (without dot) and loaders to use for this file type.
+     * Loaders are appended to the esbuild command by `--loader:.extension=loader`
+     *
+     * @default - no loaders
+     */
     readonly loaders?: {
         [key: string]: string;
     };
 }
+/**
+ * Adds support for bundling JavaScript applications and dependencies into a
+ * single file.
+ */
 export declare class Bundler extends Component {
+    /**
+     * Returns the `Bundler` instance associated with a project or `undefined` if
+     * there is no Bundler.
+     *
+     * @param project The project
+     * @returns A bundler
+     */
     static of(project: Project): Bundler | undefined;
+    /**
+     * The semantic version requirement for `esbuild` (if defined).
+     */
     readonly esbuildVersion: string | undefined;
+    /**
+     * Root bundle directory.
+     */
     readonly bundledir: string;
     private _task;
     private readonly addToPreCompile;
     private readonly loaders?;
+    /**
+     * Creates a `Bundler`.
+     */
     constructor(project: Project, options?: BundlerOptions);
+    /**
+     * Gets or creates the singleton "bundle" task of the project.
+     *
+     * If the project doesn't have a "bundle" task, it will be created and spawned
+     * during the pre-compile phase (unless `addToPreCompile` is `false`).
+     */
     get bundleTask(): Task;
+    /**
+     * Adds a task to the project which bundles a specific entrypoint and all of
+     * its dependencies into a single javascript output file.
+     *
+     * @param entrypoint The relative path of the artifact within the project
+     * @param options Bundling options
+     */
     addBundle(entrypoint: string, options: BundlingOptions): Bundle;
+    /**
+     * Add bundling support to a project. This is called implicitly when
+     * `bundleTask` is referenced first. It adds the dependency on `esbuild`,
+     * gitignore/npmignore, etc.
+     */
     private addBundlingSupport;
 }
+/**
+ * A bundle created by `Bundler.addBundle`.
+ */
 export interface Bundle {
+    /**
+     * The task that produces this bundle.
+     */
     readonly bundleTask: Task;
+    /**
+     * Location of the output file (relative to project root).
+     */
     readonly outfile: string;
+    /**
+     * Base directory containing the output file (relative to project root).
+     */
     readonly outdir: string;
 }
+/**
+ * Options for bundling.
+ */
 export interface BundlingOptions {
+    /**
+     * You can mark a file or a package as external to exclude it from your build.
+     * Instead of being bundled, the import will be preserved (using require for
+     * the iife and cjs formats and using import for the esm format) and will be
+     * evaluated at run time instead.
+     *
+     * This has several uses. First of all, it can be used to trim unnecessary
+     * code from your bundle for a code path that you know will never be executed.
+     * For example, a package may contain code that only runs in node but you will
+     * only be using that package in the browser. It can also be used to import
+     * code in node at run time from a package that cannot be bundled. For
+     * example, the fsevents package contains a native extension, which esbuild
+     * doesn't support.
+     *
+     * @default []
+     */
     readonly externals?: string[];
+    /**
+     * Include a source map in the bundle.
+     *
+     * @default true
+     */
     readonly sourcemap?: boolean;
+    /**
+     * esbuild target.
+     *
+     * @default "esnext"
+     */
     readonly target?: string;
+    /**
+     * esbuild platform.
+     *
+     * @default "node"
+     */
     readonly platform?: string;
+    /**
+     * Bundler output path relative to the asset's output directory.
+     *
+     * @default "index.mjs"
+     */
     readonly outfile?: string;
+    /**
+     * The path of the tsconfig.json file to use for bundling.
+     *
+     * `LambdaFunctionCodeBundle` always sets this to the project's development tsconfig.
+     *
+     * @default - no tsconfig is passed to esbuild
+     */
     readonly tsconfigPath?: string;
+    /**
+     * Map of file extensions (without dot) and loaders to use for this file type.
+     * Loaders are appended to the esbuild command by `--loader:.extension=loader`
+     *
+     * @default - the loaders of the `Bundler`
+     */
     readonly loaders?: {
         [key: string]: string;
     };
+    /**
+     * Output format for the generated JavaScript files: `"iife"`, `"cjs"` or `"esm"`.
+     *
+     * @default "esm"
+     * @see https://esbuild.github.io/api/#format
+     */
     readonly format?: string;
+    /**
+     * Minify the bundle.
+     *
+     * @default true
+     * @see https://esbuild.github.io/api/#minify
+     */
     readonly minify?: boolean;
+    /**
+     * Include the original source code in the source map.
+     *
+     * @default false
+     * @see https://esbuild.github.io/api/#sources-content
+     */
     readonly sourcesContent?: boolean;
+    /**
+     * Comma-separated list of `package.json` fields esbuild tries when resolving a package.
+     *
+     * @default "module,main"
+     * @see https://esbuild.github.io/api/#main-fields
+     */
     readonly mainFields?: string;
+    /**
+     * esbuild `--banner` argument, appended as is (so it starts with the file type, e.g. `:js=`).
+     *
+     * The default defines `require` so that CommonJS dependencies work in an ES module bundle.
+     *
+     * @default ":js=import { createRequire as topLevelCreateRequire } from 'module';const require = topLevelCreateRequire(import.meta.url)"
+     * @see https://esbuild.github.io/api/#banner
+     */
     readonly banner?: string;
 }
+/**
+ * Options for `LambdaFunctionCodeBundle`.
+ */
 export interface LambdaFunctionCodeBundleOptions {
+    /**
+     * A path from the project root directory to a TypeScript file which contains
+     * the AWS Lambda handler entrypoint (exports a `handler` function).
+     *
+     * This is relative to the root directory of the project.
+     *
+     * @example "src/subdir/foo.lambda.ts"
+     */
     readonly entrypoint: string;
+    /**
+     * Suffix for AWS Lambda handlers.
+     *
+     * @example ".lambda.ts"
+     */
     readonly extension: string;
+    /**
+     * The name of the generated TypeScript source file. This file should also be
+     * under the source tree.
+     *
+     * @default - The path of the entrypoint file, with the `-code.ts` suffix
+     * instead of the extension (e.g. `src/foo-code.ts`).
+     */
     readonly constructFile?: string;
+    /**
+     * The name of the generated `aws_lambda.Code` constant.
+     *
+     * @default - A pascal cased version of the name of the entrypoint file, with
+     * the suffix `FunctionCode` (e.g. `ResizeImageFunctionCode`).
+     */
     readonly constructName?: string;
+    /**
+     * Bundling options for this AWS Lambda Function.
+     *
+     * @default - the defaults of `BundlingOptions`
+     */
     readonly bundlingOptions?: BundlingOptions;
 }
+/**
+ * Generates a pre-bundled AWS Lambda Function code asset from handler code.
+ *
+ * Adds a task to the project's `Bundler` that uses `esbuild` to bundle the
+ * handler into the assets directory, and generates a file (e.g. `src/foo-code.ts`)
+ * exporting an `aws_lambda.Code` constant (e.g. `FooFunctionCode`) that points to
+ * the bundle. Pass it as the `code` of an `aws_lambda.Function`.
+ *
+ * Requires a `Bundler` component in the project.
+ *
+ * @example
+ *
+ * new Bundler(myProject);
+ * new LambdaFunctionCodeBundle(myProject, {
+ *   entrypoint: "src/foo.lambda.ts",
+ *   extension: ".lambda.ts",
+ * });
+ */
 export declare class LambdaFunctionCodeBundle extends Component {
+    /**
+     * Defines a pre-bundled AWS Lambda Function code asset from handler code.
+     *
+     * @param project The project to use
+     * @param options Options
+     */
     constructor(project: Project, options: LambdaFunctionCodeBundleOptions);
 }
+/**
+ * Options for `LambdaFunctionCodeBundler`
+ */
 export interface LambdaFunctionCodeBundlerOptions {
+    /**
+     * Locate files with the given extension.
+     *
+     * @example ".lambda.ts"
+     */
     readonly extension: string;
+    /**
+     * Project source tree (relative to project output directory).
+     */
     readonly srcdir: string;
+    /**
+     * Options for AWS Lambda Function bundling, applied to every discovered entrypoint.
+     *
+     * The `entrypoint` and `extension` given here are ignored: each bundle uses its
+     * discovered entrypoint and the `extension` of the bundler.
+     *
+     * @default - the defaults of `LambdaFunctionCodeBundleOptions`
+     */
     readonly bundleOptions?: LambdaFunctionCodeBundleOptions;
 }
 /**

package/lib/components/bundle-lambda-function-code.js

@@ -41,30 +41,58 @@ const path = __importStar(require("node:path"));
 const node_path_1 = require("node:path");
 const case_1 = require("case");
 const projen_1 = require("projen");
+/**
+ * Renders the bundle name of an entrypoint: its path without the extension and without a leading `src` directory.
+ *
+ * @example renderBundleName("src/handlers/foo.lambda.ts") // "handlers/foo.lambda"
+ */
 function renderBundleName(entrypoint) {
     const parts = (0, node_path_1.join)(entrypoint).split(node_path_1.sep);
     if (parts[0] === "src") {
-        parts.shift();
+        parts.shift(); // just remove 'src' if its the first element for ergonomics
     }
     const p = parts.join(node_path_1.sep);
     const dir = (0, node_path_1.dirname)(p);
     const base = (0, node_path_1.basename)(p, (0, node_path_1.extname)(p));
     return (0, node_path_1.join)(dir, base);
 }
+/**
+ * Converts the given path string to posix if it wasn't already.
+ */
 function convertToPosixPath(p) {
     return p.split(node_path_1.sep).join(node_path_1.posix.sep);
 }
+/**
+ * Adds support for bundling JavaScript applications and dependencies into a
+ * single file.
+ */
 class Bundler extends projen_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.Bundler", version: "0.3.79" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.Bundler", version: "0.3.80" };
+    /**
+     * Returns the `Bundler` instance associated with a project or `undefined` if
+     * there is no Bundler.
+     *
+     * @param project The project
+     * @returns A bundler
+     */
     static of(project) {
         const isBundler = (o) => o instanceof Bundler;
         return project.components.find(isBundler);
     }
+    /**
+     * The semantic version requirement for `esbuild` (if defined).
+     */
     esbuildVersion;
+    /**
+     * Root bundle directory.
+     */
     bundledir;
     _task;
     addToPreCompile;
     loaders;
+    /**
+     * Creates a `Bundler`.
+     */
     constructor(project, options = {}) {
         super(project);
         this.esbuildVersion = options.esbuildVersion;
@@ -72,6 +100,12 @@ class Bundler extends projen_1.Component {
         this.addToPreCompile = options.addToPreCompile ?? true;
         this.loaders = options.loaders;
     }
+    /**
+     * Gets or creates the singleton "bundle" task of the project.
+     *
+     * If the project doesn't have a "bundle" task, it will be created and spawned
+     * during the pre-compile phase (unless `addToPreCompile` is `false`).
+     */
     get bundleTask() {
         if (!this._task) {
             this.addBundlingSupport();
@@ -84,6 +118,13 @@ class Bundler extends projen_1.Component {
         }
         return this._task;
     }
+    /**
+     * Adds a task to the project which bundles a specific entrypoint and all of
+     * its dependencies into a single javascript output file.
+     *
+     * @param entrypoint The relative path of the artifact within the project
+     * @param options Bundling options
+     */
     addBundle(entrypoint, options) {
         const name = renderBundleName(entrypoint);
         const outdir = path.posix.join(this.bundledir, name);
@@ -147,6 +188,11 @@ class Bundler extends projen_1.Component {
             outfile: outfile,
         };
     }
+    /**
+     * Add bundling support to a project. This is called implicitly when
+     * `bundleTask` is referenced first. It adds the dependency on `esbuild`,
+     * gitignore/npmignore, etc.
+     */
     addBundlingSupport() {
         const ignoreEntry = `/${this.bundledir}/`;
         this.project.addGitIgnore(ignoreEntry);
@@ -156,8 +202,32 @@ class Bundler extends projen_1.Component {
     }
 }
 exports.Bundler = Bundler;
+/**
+ * Generates a pre-bundled AWS Lambda Function code asset from handler code.
+ *
+ * Adds a task to the project's `Bundler` that uses `esbuild` to bundle the
+ * handler into the assets directory, and generates a file (e.g. `src/foo-code.ts`)
+ * exporting an `aws_lambda.Code` constant (e.g. `FooFunctionCode`) that points to
+ * the bundle. Pass it as the `code` of an `aws_lambda.Function`.
+ *
+ * Requires a `Bundler` component in the project.
+ *
+ * @example
+ *
+ * new Bundler(myProject);
+ * new LambdaFunctionCodeBundle(myProject, {
+ *   entrypoint: "src/foo.lambda.ts",
+ *   extension: ".lambda.ts",
+ * });
+ */
 class LambdaFunctionCodeBundle extends projen_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.LambdaFunctionCodeBundle", version: "0.3.79" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.LambdaFunctionCodeBundle", version: "0.3.80" };
+    /**
+     * Defines a pre-bundled AWS Lambda Function code asset from handler code.
+     *
+     * @param project The project to use
+     * @param options Options
+     */
     constructor(project, options) {
         super(project);
         const bundler = Bundler.of(project);
@@ -203,7 +273,7 @@ exports.LambdaFunctionCodeBundle = LambdaFunctionCodeBundle;
  * Creates Lambda Function code bundles from entrypoints discovered in the project's source tree.
  */
 class LambdaFunctionCodeBundler extends projen_1.cdk.AutoDiscoverBase {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.LambdaFunctionCodeBundler", version: "0.3.79" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.LambdaFunctionCodeBundler", version: "0.3.80" };
     constructor(project, options) {
         super(project, {
             projectdir: options.srcdir,
@@ -219,4 +289,4 @@ class LambdaFunctionCodeBundler extends projen_1.cdk.AutoDiscoverBase {
     }
 }
 exports.LambdaFunctionCodeBundler = LambdaFunctionCodeBundler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundle-lambda-function-code.js","sourceRoot":"","sources":["../../src/components/bundle-lambda-function-code.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"node:path\";\nimport { basename, dirname, extname, join, posix, sep } from \"node:path\";\nimport { pascal } from \"case\";\nimport {\n    Component,\n    cdk,\n    DependencyType,\n    javascript,\n    type Project,\n    SourceCode,\n    type Task,\n    type typescript,\n} from \"projen\";\n\nexport function renderBundleName(entrypoint: string) {\n    const parts = join(entrypoint).split(sep);\n    if (parts[0] === \"src\") {\n        parts.shift();\n    }\n    const p = parts.join(sep);\n    const dir = dirname(p);\n    const base = basename(p, extname(p));\n    return join(dir, base);\n}\n\nexport function convertToPosixPath(p: string) {\n    return p.split(sep).join(posix.sep);\n}\n\nexport interface BundlerOptions {\n    readonly esbuildVersion?: string;\n    readonly assetsDir?: string;\n    readonly addToPreCompile?: boolean;\n    readonly loaders?: { [key: string]: string };\n}\n\nexport class Bundler extends Component {\n    public static of(project: Project): Bundler | undefined {\n        const isBundler = (o: Component): o is Bundler => o instanceof Bundler;\n        return project.components.find(isBundler);\n    }\n\n    public readonly esbuildVersion: string | undefined;\n    public readonly bundledir: string;\n\n    private _task: Task | undefined;\n    private readonly addToPreCompile: boolean;\n    private readonly loaders?: { [key: string]: string };\n\n    constructor(project: Project, options: BundlerOptions = {}) {\n        super(project);\n        this.esbuildVersion = options.esbuildVersion;\n        this.bundledir = options.assetsDir ?? \"assets\";\n        this.addToPreCompile = options.addToPreCompile ?? true;\n        this.loaders = options.loaders;\n    }\n\n    public get bundleTask(): Task {\n        if (!this._task) {\n            this.addBundlingSupport();\n            this._task = this.project.tasks.addTask(\"bundle\", {\n                description: \"Prepare assets\",\n            });\n            if (this.addToPreCompile) {\n                this.project.preCompileTask.spawn(this._task);\n            }\n        }\n        return this._task;\n    }\n\n    public addBundle(entrypoint: string, options: BundlingOptions): Bundle {\n        const name = renderBundleName(entrypoint);\n        const outdir = path.posix.join(this.bundledir, name);\n        const outfile = path.posix.join(outdir, options.outfile ?? \"index.mjs\");\n        const target = options.target ?? \"esnext\";\n        const platform = options.platform ?? \"node\";\n        const format = options.format ?? \"esm\";\n        const sourcemap = options.sourcemap ?? true;\n        const sourcesContent = options.sourcesContent ?? false;\n        const minify = options.minify ?? true;\n        const mainFields = options.mainFields ?? \"module,main\";\n        const banner =\n            options.banner ??\n            \":js=import { createRequire as topLevelCreateRequire } from 'module';const require = topLevelCreateRequire(import.meta.url)\";\n\n        const args = [\n            \"esbuild\",\n            \"--bundle\",\n            entrypoint,\n            `--target=\"${target}\"`,\n            `--platform=\"${platform}\"`,\n            `--outfile=\"${outfile}\"`,\n        ];\n\n        const tsconfig = options.tsconfigPath ?? false;\n        if (tsconfig) {\n            args.push(`--tsconfig=\"${tsconfig}\"`);\n        }\n\n        for (const x of options.externals ?? []) {\n            args.push(`--external:${x}`);\n        }\n\n        if (sourcemap) {\n            args.push(\"--sourcemap\");\n        }\n\n        if (sourcesContent) {\n            args.push(`--sources-content=${sourcesContent}`);\n        }\n\n        if (minify) {\n            args.push(\"--minify\");\n        }\n\n        if (format) {\n            args.push(`--format=${format}`);\n        }\n\n        if (mainFields) {\n            args.push(`--main-fields=${mainFields}`);\n        }\n\n        if (banner) {\n            args.push(`--banner${banner}`);\n        }\n\n        const loaders = (options.loaders ?? false) ? options.loaders : (this.loaders ?? false);\n        if (loaders) {\n            for (const [extension, loader] of Object.entries(loaders)) {\n                args.push(`--loader:.${extension}=${loader}`);\n            }\n        }\n\n        const bundleTask = this.project.addTask(`bundle:${name}`, {\n            description: `Create a JavaScript bundle from ${entrypoint}`,\n            exec: args.join(\" \"),\n        });\n\n        this.bundleTask.spawn(bundleTask);\n\n        return {\n            bundleTask: bundleTask,\n            outdir: outdir,\n            outfile: outfile,\n        };\n    }\n\n    private addBundlingSupport() {\n        const ignoreEntry = `/${this.bundledir}/`;\n        this.project.addGitIgnore(ignoreEntry);\n        this.project.addPackageIgnore(`!${ignoreEntry}`);\n        const dep = this.esbuildVersion ? `esbuild@${this.esbuildVersion}` : \"esbuild\";\n        this.project.deps.addDependency(dep, DependencyType.BUILD);\n    }\n}\n\nexport interface Bundle {\n    readonly bundleTask: Task;\n    readonly outfile: string;\n    readonly outdir: string;\n}\n\nexport interface BundlingOptions {\n    readonly externals?: string[];\n    readonly sourcemap?: boolean;\n    readonly target?: string;\n    readonly platform?: string;\n    readonly outfile?: string;\n    readonly tsconfigPath?: string;\n    readonly loaders?: { [key: string]: string };\n    readonly format?: string;\n    readonly minify?: boolean;\n    readonly sourcesContent?: boolean;\n    readonly mainFields?: string;\n    readonly banner?: string;\n}\n\nexport interface LambdaFunctionCodeBundleOptions {\n    readonly entrypoint: string;\n    readonly extension: string;\n    readonly constructFile?: string;\n    readonly constructName?: string;\n    readonly bundlingOptions?: BundlingOptions;\n}\n\nexport class LambdaFunctionCodeBundle extends Component {\n    constructor(project: Project, options: LambdaFunctionCodeBundleOptions) {\n        super(project);\n\n        const bundler = Bundler.of(project);\n        if (!bundler) {\n            throw new Error(\"No bundler found. Please add a Bundler component to your project.\");\n        }\n\n        const eslint = javascript.Eslint.of(project);\n        eslint?.allowDevDeps(options.entrypoint);\n\n        const entrypoint = options.entrypoint;\n        const extension = options.extension ?? \".lambda.ts\";\n\n        if (!entrypoint.endsWith(extension)) {\n            throw new Error(`${entrypoint} must have a ${extension} extension`);\n        }\n\n        const basePath = path.posix.join(path.dirname(entrypoint), path.basename(entrypoint, extension));\n        const constructFile = options.constructFile ?? `${basePath}-code.ts`;\n\n        if (path.extname(constructFile) !== \".ts\") {\n            throw new Error(`Construct file name \"${constructFile}\" must have a .ts extension`);\n        }\n\n        const constructName = options.constructName ?? `${pascal(path.basename(basePath))}FunctionCode`;\n\n        const bundle = bundler.addBundle(entrypoint, {\n            ...options.bundlingOptions,\n            tsconfigPath: (project as typescript.TypeScriptProject)?.tsconfigDev?.fileName,\n        });\n\n        const outfileAbs = path.join(project.outdir, bundle.outfile);\n        const constructAbs = path.join(project.outdir, constructFile);\n        const relativeOutfile = path.relative(path.dirname(constructAbs), path.dirname(outfileAbs));\n\n        const src = new SourceCode(project, constructFile);\n        if (src.marker) {\n            src.line(`// ${src.marker}`);\n        }\n        src.line(\"import * as path from 'path';\");\n        src.line(\"import { aws_lambda } from 'aws-cdk-lib';\");\n        src.line();\n        src.open(`export const ${constructName} = aws_lambda.Code.fromAsset(`);\n        src.line(`path.join(__dirname, '${convertToPosixPath(relativeOutfile)}'),`);\n        src.close(\");\");\n\n        this.project.logger.verbose(`${basePath}: construct \"${constructName}\" generated under \"${constructFile}\"`);\n        this.project.logger.verbose(`${basePath}: bundle task \"${bundle.bundleTask.name}\"`);\n    }\n}\n\nexport interface LambdaFunctionCodeBundlerOptions {\n    readonly extension: string;\n    readonly srcdir: string;\n    readonly bundleOptions?: LambdaFunctionCodeBundleOptions;\n}\n\n/**\n * Creates Lambda Function code bundles from entrypoints discovered in the project's source tree.\n */\nexport class LambdaFunctionCodeBundler extends cdk.AutoDiscoverBase {\n    constructor(project: Project, options: LambdaFunctionCodeBundlerOptions) {\n        super(project, {\n            projectdir: options.srcdir,\n            extension: options.extension,\n        });\n\n        for (const entrypoint of this.entrypoints) {\n            new LambdaFunctionCodeBundle(this.project, {\n                ...options.bundleOptions,\n                entrypoint: entrypoint,\n                extension: options.extension,\n            });\n        }\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundle-lambda-function-code.js","sourceRoot":"","sources":["../../src/components/bundle-lambda-function-code.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"node:path\";\nimport { basename, dirname, extname, join, posix, sep } from \"node:path\";\nimport { pascal } from \"case\";\nimport {\n    Component,\n    cdk,\n    DependencyType,\n    javascript,\n    type Project,\n    SourceCode,\n    type Task,\n    type typescript,\n} from \"projen\";\n\n/**\n * Renders the bundle name of an entrypoint: its path without the extension and without a leading `src` directory.\n *\n * @example renderBundleName(\"src/handlers/foo.lambda.ts\") // \"handlers/foo.lambda\"\n */\nexport function renderBundleName(entrypoint: string) {\n    const parts = join(entrypoint).split(sep);\n    if (parts[0] === \"src\") {\n        parts.shift(); // just remove 'src' if its the first element for ergonomics\n    }\n    const p = parts.join(sep);\n    const dir = dirname(p);\n    const base = basename(p, extname(p));\n    return join(dir, base);\n}\n\n/**\n * Converts the given path string to posix if it wasn't already.\n */\nexport function convertToPosixPath(p: string) {\n    return p.split(sep).join(posix.sep);\n}\n\n/**\n * Options for `Bundler`.\n */\nexport interface BundlerOptions {\n    /**\n     * The semantic version requirement for `esbuild`.\n     *\n     * @default - no specific version (implies latest)\n     */\n    readonly esbuildVersion?: string;\n\n    /**\n     * Output directory for all bundles.\n     *\n     * @default \"assets\"\n     */\n    readonly assetsDir?: string;\n\n    /**\n     * Install the `bundle` command as a pre-compile phase.\n     *\n     * @default true\n     */\n    readonly addToPreCompile?: boolean;\n\n    /**\n     * Map of file extensions (without dot) and loaders to use for this file type.\n     * Loaders are appended to the esbuild command by `--loader:.extension=loader`\n     *\n     * @default - no loaders\n     */\n    readonly loaders?: { [key: string]: string };\n}\n\n/**\n * Adds support for bundling JavaScript applications and dependencies into a\n * single file.\n */\nexport class Bundler extends Component {\n    /**\n     * Returns the `Bundler` instance associated with a project or `undefined` if\n     * there is no Bundler.\n     *\n     * @param project The project\n     * @returns A bundler\n     */\n    public static of(project: Project): Bundler | undefined {\n        const isBundler = (o: Component): o is Bundler => o instanceof Bundler;\n        return project.components.find(isBundler);\n    }\n\n    /**\n     * The semantic version requirement for `esbuild` (if defined).\n     */\n    public readonly esbuildVersion: string | undefined;\n\n    /**\n     * Root bundle directory.\n     */\n    public readonly bundledir: string;\n\n    private _task: Task | undefined;\n    private readonly addToPreCompile: boolean;\n    private readonly loaders?: { [key: string]: string };\n\n    /**\n     * Creates a `Bundler`.\n     */\n    constructor(project: Project, options: BundlerOptions = {}) {\n        super(project);\n        this.esbuildVersion = options.esbuildVersion;\n        this.bundledir = options.assetsDir ?? \"assets\";\n        this.addToPreCompile = options.addToPreCompile ?? true;\n        this.loaders = options.loaders;\n    }\n\n    /**\n     * Gets or creates the singleton \"bundle\" task of the project.\n     *\n     * If the project doesn't have a \"bundle\" task, it will be created and spawned\n     * during the pre-compile phase (unless `addToPreCompile` is `false`).\n     */\n    public get bundleTask(): Task {\n        if (!this._task) {\n            this.addBundlingSupport();\n            this._task = this.project.tasks.addTask(\"bundle\", {\n                description: \"Prepare assets\",\n            });\n            if (this.addToPreCompile) {\n                this.project.preCompileTask.spawn(this._task);\n            }\n        }\n        return this._task;\n    }\n\n    /**\n     * Adds a task to the project which bundles a specific entrypoint and all of\n     * its dependencies into a single javascript output file.\n     *\n     * @param entrypoint The relative path of the artifact within the project\n     * @param options Bundling options\n     */\n    public addBundle(entrypoint: string, options: BundlingOptions): Bundle {\n        const name = renderBundleName(entrypoint);\n        const outdir = path.posix.join(this.bundledir, name);\n        const outfile = path.posix.join(outdir, options.outfile ?? \"index.mjs\");\n        const target = options.target ?? \"esnext\";\n        const platform = options.platform ?? \"node\";\n        const format = options.format ?? \"esm\";\n        const sourcemap = options.sourcemap ?? true;\n        const sourcesContent = options.sourcesContent ?? false;\n        const minify = options.minify ?? true;\n        const mainFields = options.mainFields ?? \"module,main\";\n        const banner =\n            options.banner ??\n            \":js=import { createRequire as topLevelCreateRequire } from 'module';const require = topLevelCreateRequire(import.meta.url)\";\n\n        const args = [\n            \"esbuild\",\n            \"--bundle\",\n            entrypoint,\n            `--target=\"${target}\"`,\n            `--platform=\"${platform}\"`,\n            `--outfile=\"${outfile}\"`,\n        ];\n\n        const tsconfig = options.tsconfigPath ?? false;\n        if (tsconfig) {\n            args.push(`--tsconfig=\"${tsconfig}\"`);\n        }\n\n        for (const x of options.externals ?? []) {\n            args.push(`--external:${x}`);\n        }\n\n        if (sourcemap) {\n            args.push(\"--sourcemap\");\n        }\n\n        if (sourcesContent) {\n            args.push(`--sources-content=${sourcesContent}`);\n        }\n\n        if (minify) {\n            args.push(\"--minify\");\n        }\n\n        if (format) {\n            args.push(`--format=${format}`);\n        }\n\n        if (mainFields) {\n            args.push(`--main-fields=${mainFields}`);\n        }\n\n        if (banner) {\n            args.push(`--banner${banner}`);\n        }\n\n        const loaders = (options.loaders ?? false) ? options.loaders : (this.loaders ?? false);\n        if (loaders) {\n            for (const [extension, loader] of Object.entries(loaders)) {\n                args.push(`--loader:.${extension}=${loader}`);\n            }\n        }\n\n        const bundleTask = this.project.addTask(`bundle:${name}`, {\n            description: `Create a JavaScript bundle from ${entrypoint}`,\n            exec: args.join(\" \"),\n        });\n\n        this.bundleTask.spawn(bundleTask);\n\n        return {\n            bundleTask: bundleTask,\n            outdir: outdir,\n            outfile: outfile,\n        };\n    }\n\n    /**\n     * Add bundling support to a project. This is called implicitly when\n     * `bundleTask` is referenced first. It adds the dependency on `esbuild`,\n     * gitignore/npmignore, etc.\n     */\n    private addBundlingSupport() {\n        const ignoreEntry = `/${this.bundledir}/`;\n        this.project.addGitIgnore(ignoreEntry);\n        this.project.addPackageIgnore(`!${ignoreEntry}`);\n        const dep = this.esbuildVersion ? `esbuild@${this.esbuildVersion}` : \"esbuild\";\n        this.project.deps.addDependency(dep, DependencyType.BUILD);\n    }\n}\n\n/**\n * A bundle created by `Bundler.addBundle`.\n */\nexport interface Bundle {\n    /**\n     * The task that produces this bundle.\n     */\n    readonly bundleTask: Task;\n\n    /**\n     * Location of the output file (relative to project root).\n     */\n    readonly outfile: string;\n\n    /**\n     * Base directory containing the output file (relative to project root).\n     */\n    readonly outdir: string;\n}\n\n/**\n * Options for bundling.\n */\nexport interface BundlingOptions {\n    /**\n     * You can mark a file or a package as external to exclude it from your build.\n     * Instead of being bundled, the import will be preserved (using require for\n     * the iife and cjs formats and using import for the esm format) and will be\n     * evaluated at run time instead.\n     *\n     * This has several uses. First of all, it can be used to trim unnecessary\n     * code from your bundle for a code path that you know will never be executed.\n     * For example, a package may contain code that only runs in node but you will\n     * only be using that package in the browser. It can also be used to import\n     * code in node at run time from a package that cannot be bundled. For\n     * example, the fsevents package contains a native extension, which esbuild\n     * doesn't support.\n     *\n     * @default []\n     */\n    readonly externals?: string[];\n\n    /**\n     * Include a source map in the bundle.\n     *\n     * @default true\n     */\n    readonly sourcemap?: boolean;\n\n    /**\n     * esbuild target.\n     *\n     * @default \"esnext\"\n     */\n    readonly target?: string;\n\n    /**\n     * esbuild platform.\n     *\n     * @default \"node\"\n     */\n    readonly platform?: string;\n\n    /**\n     * Bundler output path relative to the asset's output directory.\n     *\n     * @default \"index.mjs\"\n     */\n    readonly outfile?: string;\n\n    /**\n     * The path of the tsconfig.json file to use for bundling.\n     *\n     * `LambdaFunctionCodeBundle` always sets this to the project's development tsconfig.\n     *\n     * @default - no tsconfig is passed to esbuild\n     */\n    readonly tsconfigPath?: string;\n\n    /**\n     * Map of file extensions (without dot) and loaders to use for this file type.\n     * Loaders are appended to the esbuild command by `--loader:.extension=loader`\n     *\n     * @default - the loaders of the `Bundler`\n     */\n    readonly loaders?: { [key: string]: string };\n\n    /**\n     * Output format for the generated JavaScript files: `\"iife\"`, `\"cjs\"` or `\"esm\"`.\n     *\n     * @default \"esm\"\n     * @see https://esbuild.github.io/api/#format\n     */\n    readonly format?: string;\n\n    /**\n     * Minify the bundle.\n     *\n     * @default true\n     * @see https://esbuild.github.io/api/#minify\n     */\n    readonly minify?: boolean;\n\n    /**\n     * Include the original source code in the source map.\n     *\n     * @default false\n     * @see https://esbuild.github.io/api/#sources-content\n     */\n    readonly sourcesContent?: boolean;\n\n    /**\n     * Comma-separated list of `package.json` fields esbuild tries when resolving a package.\n     *\n     * @default \"module,main\"\n     * @see https://esbuild.github.io/api/#main-fields\n     */\n    readonly mainFields?: string;\n\n    /**\n     * esbuild `--banner` argument, appended as is (so it starts with the file type, e.g. `:js=`).\n     *\n     * The default defines `require` so that CommonJS dependencies work in an ES module bundle.\n     *\n     * @default \":js=import { createRequire as topLevelCreateRequire } from 'module';const require = topLevelCreateRequire(import.meta.url)\"\n     * @see https://esbuild.github.io/api/#banner\n     */\n    readonly banner?: string;\n}\n\n/**\n * Options for `LambdaFunctionCodeBundle`.\n */\nexport interface LambdaFunctionCodeBundleOptions {\n    /**\n     * A path from the project root directory to a TypeScript file which contains\n     * the AWS Lambda handler entrypoint (exports a `handler` function).\n     *\n     * This is relative to the root directory of the project.\n     *\n     * @example \"src/subdir/foo.lambda.ts\"\n     */\n    readonly entrypoint: string;\n\n    /**\n     * Suffix for AWS Lambda handlers.\n     *\n     * @example \".lambda.ts\"\n     */\n    readonly extension: string;\n\n    /**\n     * The name of the generated TypeScript source file. This file should also be\n     * under the source tree.\n     *\n     * @default - The path of the entrypoint file, with the `-code.ts` suffix\n     * instead of the extension (e.g. `src/foo-code.ts`).\n     */\n    readonly constructFile?: string;\n\n    /**\n     * The name of the generated `aws_lambda.Code` constant.\n     *\n     * @default - A pascal cased version of the name of the entrypoint file, with\n     * the suffix `FunctionCode` (e.g. `ResizeImageFunctionCode`).\n     */\n    readonly constructName?: string;\n\n    /**\n     * Bundling options for this AWS Lambda Function.\n     *\n     * @default - the defaults of `BundlingOptions`\n     */\n    readonly bundlingOptions?: BundlingOptions;\n}\n\n/**\n * Generates a pre-bundled AWS Lambda Function code asset from handler code.\n *\n * Adds a task to the project's `Bundler` that uses `esbuild` to bundle the\n * handler into the assets directory, and generates a file (e.g. `src/foo-code.ts`)\n * exporting an `aws_lambda.Code` constant (e.g. `FooFunctionCode`) that points to\n * the bundle. Pass it as the `code` of an `aws_lambda.Function`.\n *\n * Requires a `Bundler` component in the project.\n *\n * @example\n *\n * new Bundler(myProject);\n * new LambdaFunctionCodeBundle(myProject, {\n *   entrypoint: \"src/foo.lambda.ts\",\n *   extension: \".lambda.ts\",\n * });\n */\nexport class LambdaFunctionCodeBundle extends Component {\n    /**\n     * Defines a pre-bundled AWS Lambda Function code asset from handler code.\n     *\n     * @param project The project to use\n     * @param options Options\n     */\n    constructor(project: Project, options: LambdaFunctionCodeBundleOptions) {\n        super(project);\n\n        const bundler = Bundler.of(project);\n        if (!bundler) {\n            throw new Error(\"No bundler found. Please add a Bundler component to your project.\");\n        }\n\n        const eslint = javascript.Eslint.of(project);\n        eslint?.allowDevDeps(options.entrypoint);\n\n        const entrypoint = options.entrypoint;\n        const extension = options.extension ?? \".lambda.ts\";\n\n        if (!entrypoint.endsWith(extension)) {\n            throw new Error(`${entrypoint} must have a ${extension} extension`);\n        }\n\n        const basePath = path.posix.join(path.dirname(entrypoint), path.basename(entrypoint, extension));\n        const constructFile = options.constructFile ?? `${basePath}-code.ts`;\n\n        if (path.extname(constructFile) !== \".ts\") {\n            throw new Error(`Construct file name \"${constructFile}\" must have a .ts extension`);\n        }\n\n        const constructName = options.constructName ?? `${pascal(path.basename(basePath))}FunctionCode`;\n\n        const bundle = bundler.addBundle(entrypoint, {\n            ...options.bundlingOptions,\n            tsconfigPath: (project as typescript.TypeScriptProject)?.tsconfigDev?.fileName,\n        });\n\n        const outfileAbs = path.join(project.outdir, bundle.outfile);\n        const constructAbs = path.join(project.outdir, constructFile);\n        const relativeOutfile = path.relative(path.dirname(constructAbs), path.dirname(outfileAbs));\n\n        const src = new SourceCode(project, constructFile);\n        if (src.marker) {\n            src.line(`// ${src.marker}`);\n        }\n        src.line(\"import * as path from 'path';\");\n        src.line(\"import { aws_lambda } from 'aws-cdk-lib';\");\n        src.line();\n        src.open(`export const ${constructName} = aws_lambda.Code.fromAsset(`);\n        src.line(`path.join(__dirname, '${convertToPosixPath(relativeOutfile)}'),`);\n        src.close(\");\");\n\n        this.project.logger.verbose(`${basePath}: construct \"${constructName}\" generated under \"${constructFile}\"`);\n        this.project.logger.verbose(`${basePath}: bundle task \"${bundle.bundleTask.name}\"`);\n    }\n}\n\n/**\n * Options for `LambdaFunctionCodeBundler`\n */\nexport interface LambdaFunctionCodeBundlerOptions {\n    /**\n     * Locate files with the given extension.\n     *\n     * @example \".lambda.ts\"\n     */\n    readonly extension: string;\n\n    /**\n     * Project source tree (relative to project output directory).\n     */\n    readonly srcdir: string;\n\n    /**\n     * Options for AWS Lambda Function bundling, applied to every discovered entrypoint.\n     *\n     * The `entrypoint` and `extension` given here are ignored: each bundle uses its\n     * discovered entrypoint and the `extension` of the bundler.\n     *\n     * @default - the defaults of `LambdaFunctionCodeBundleOptions`\n     */\n    readonly bundleOptions?: LambdaFunctionCodeBundleOptions;\n}\n\n/**\n * Creates Lambda Function code bundles from entrypoints discovered in the project's source tree.\n */\nexport class LambdaFunctionCodeBundler extends cdk.AutoDiscoverBase {\n    constructor(project: Project, options: LambdaFunctionCodeBundlerOptions) {\n        super(project, {\n            projectdir: options.srcdir,\n            extension: options.extension,\n        });\n\n        for (const entrypoint of this.entrypoints) {\n            new LambdaFunctionCodeBundle(this.project, {\n                ...options.bundleOptions,\n                entrypoint: entrypoint,\n                extension: options.extension,\n            });\n        }\n    }\n}\n"]}

package/lib/components/colima.d.ts

@@ -1,5 +1,10 @@
 import type { IConstruct } from "constructs";
 import { Component } from "projen/lib/component";
+/**
+ * Colima component for projen projects.
+ *
+ * Adds Colima support to your project with automatic installation and startup.
+ */
 export declare class Colima extends Component {
     constructor(scope: IConstruct);
 }

package/lib/components/colima.js

@@ -5,8 +5,13 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const component_1 = require("projen/lib/component");
 const task_shell_1 = require("projen/lib/task-shell");
 const homebrew_1 = require("./homebrew");
+/**
+ * Colima component for projen projects.
+ *
+ * Adds Colima support to your project with automatic installation and startup.
+ */
 class Colima extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.Colima", version: "0.3.79" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.Colima", version: "0.3.80" };
     constructor(scope) {
         super(scope);
         const project = this.project;
@@ -25,4 +30,4 @@ class Colima extends component_1.Component {
     }
 }
 exports.Colima = Colima;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/homebrew.js

@@ -6,7 +6,7 @@ const component_1 = require("projen/lib/component");
 const task_shell_1 = require("projen/lib/task-shell");
 const textfile_1 = require("projen/lib/textfile");
 class Homebrew extends component_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.Homebrew", version: "0.3.79" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@nikovirtala/projen-constructs.Homebrew", version: "0.3.80" };
     static of(project) {
         const isHomebrew = (c) => c instanceof Homebrew;
         return project.components.find(isHomebrew);