@diquattro/cfnassets 0.6.1

package/src/template/DeploymentBundle.ts

@@ -0,0 +1,20 @@
+import { Readable } from 'stream';
+
+export interface AddAssetOpts {
+  keepName?: boolean;
+}
+
+export interface DeploymentBundleAsset {
+  name: string;
+  size: number;
+  createReadStream(encoding?: BufferEncoding): Readable;
+}
+
+export interface DeploymentBundle {
+  addAsset(
+    fileName: string,
+    stream: Readable,
+    opts?: AddAssetOpts,
+  ): PromiseLike<string>;
+  assets: DeploymentBundleAsset[];
+}

package/src/template/FileSystemDeploymentBundle.ts

@@ -0,0 +1,112 @@
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir, rename, stat } from 'fs/promises';
+import { basename, dirname, extname, join } from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { temporaryDirectory } from 'tempy';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { hash } from '../internal/hash.js';
+import { HashStream } from '../internal/HashStream.js';
+import { ProgressStream } from '../internal/ProgressStream.js';
+import {
+  AddAssetOpts,
+  DeploymentBundle,
+  DeploymentBundleAsset,
+} from './DeploymentBundle.js';
+import { ProgressStats } from './ProgressStats.js';
+
+export interface FileSystemBundleOptions {
+  stagingDirectory?: string;
+}
+
+export interface FileSystemDeploymentBundleEvents {
+  assetProgress(name: string, stats: ProgressStats): void;
+  assetRename(oldName: string, rename: string): void;
+}
+
+export class FileSystemDeploymentBundle
+  extends TypedEmitter<FileSystemDeploymentBundleEvents>
+  implements DeploymentBundle
+{
+  private readonly outputDir: string;
+  public readonly assets: DeploymentBundleAsset[] = [];
+
+  constructor(options: FileSystemBundleOptions) {
+    super();
+    this.outputDir = options.stagingDirectory ?? temporaryDirectory();
+  }
+
+  public async addAsset(
+    fileName: string,
+    content: Readable,
+    opts: AddAssetOpts = {},
+  ): Promise<string> {
+    if (dirname(fileName) !== '.') {
+      throw new Error(`the fileName must not be within a directory`);
+    }
+
+    this.emit('assetProgress', fileName, {});
+
+    const outDir = await this.getOutputDir();
+    const originalExt = extname(fileName);
+    const originalBasename = basename(fileName, originalExt);
+    const stagingExt = `.stagingprogress_${hash([
+      `${Date.now()}`,
+      fileName,
+      `${Math.random()}`,
+    ])}`;
+
+    const outPath = join(outDir, fileName + stagingExt);
+    const outStream = createWriteStream(outPath);
+
+    const progress = new ProgressStream((total) =>
+      this.emit('assetProgress', fileName, { total }),
+    );
+    progress.on('finish', () =>
+      this.emit('assetProgress', fileName, { complete: true }),
+    );
+
+    if (opts.keepName) {
+      await pipeline(content, progress, outStream);
+
+      const finalPath = join(outDir, originalBasename + originalExt);
+      await rename(outPath, finalPath);
+
+      this.assets.push({
+        name: fileName,
+        size: (await stat(finalPath)).size,
+        createReadStream: (encoding) => createReadStream(finalPath, encoding),
+      });
+      return fileName;
+    } else {
+      const hashStream = new HashStream();
+
+      await pipeline(content, progress, hashStream, outStream);
+      const sha = hashStream.digest('hex');
+
+      const finalBasename = originalBasename + `.${sha}` + originalExt;
+      const finalPath = join(outDir, finalBasename);
+
+      await rename(outPath, finalPath);
+      this.emit('assetRename', fileName, finalBasename);
+
+      this.assets.push({
+        name: finalBasename,
+        size: (await stat(finalPath)).size,
+        createReadStream: (encoding) => createReadStream(finalPath, encoding),
+      });
+      return finalBasename;
+    }
+  }
+
+  private getOutputDir = (() => {
+    let created = false;
+    return async () => {
+      if (!created) {
+        await mkdir(this.outputDir, { recursive: true });
+        created = true;
+      }
+      return this.outputDir;
+    };
+  })();
+}

package/src/template/ProgressStats.ts

@@ -0,0 +1,5 @@
+export interface ProgressStats {
+  complete?: boolean;
+  progress?: number;
+  total?: number;
+}

package/src/template/makeAsset.ts

@@ -0,0 +1,12 @@
+import { TemplateBuilder } from '@awboost/cfntemplate';
+import { AssetAttributes } from './AssetAttributes.js';
+import { AssetGenerator } from './AssetGenerator.js';
+import { CustomAsset } from './CustomAsset.js';
+
+export function makeAsset(
+  name: string,
+  generate: AssetGenerator,
+): [TemplateBuilder, AssetAttributes] {
+  const asset = new CustomAsset(name, generate);
+  return [asset, asset];
+}

package/src/template/makeAssetFromPackage.ts

@@ -0,0 +1,42 @@
+import { TemplateBuilder } from '@awboost/cfntemplate';
+import { createReadStream } from 'fs';
+import { readFile } from 'fs/promises';
+import { basename, dirname, join } from 'path';
+import { AssetAttributes } from './AssetAttributes.js';
+import { AssetBase } from './AssetBase.js';
+import { AssetOutput } from './AssetOutput.js';
+
+export class PackageAsset extends AssetBase {
+  constructor(
+    name: string,
+    private readonly packagePath: string,
+    private readonly assetName: string,
+  ) {
+    super(name);
+  }
+
+  public override async generate(): Promise<AssetOutput> {
+    const pkg = JSON.parse(await readFile(this.packagePath, 'utf8'));
+
+    if (!pkg.bundles || !pkg.bundles[this.assetName]?.path) {
+      throw new Error(
+        `expected package.json to have a bundles entry for '${this.assetName}'`,
+      );
+    }
+    const assetPath = pkg.bundles[this.assetName].path;
+
+    return {
+      content: createReadStream(join(dirname(this.packagePath), assetPath)),
+      fileName: basename(assetPath),
+    };
+  }
+}
+
+export function makeAssetFromPackage(
+  name: string,
+  packagePath: string,
+  assetName: string,
+): [TemplateBuilder, AssetAttributes] {
+  const asset = new PackageAsset(name, packagePath, assetName);
+  return [asset, asset];
+}

package/src/template/processAssets.ts

@@ -0,0 +1,40 @@
+import {
+  BuilderContext,
+  Template,
+  TemplateFragment,
+} from '@awboost/cfntemplate';
+import { AssetContext } from './AssetContext.js';
+import { AssetManifest, AssetManifestMetadataKey } from './AssetManifest.js';
+import { DeploymentBundle } from './DeploymentBundle.js';
+
+export async function processAssets(
+  template: Template,
+  ctx: BuilderContext,
+  bundle: DeploymentBundle,
+): Promise<Template> {
+  const assets = ctx.get(AssetContext).assets;
+  if (!assets?.length) {
+    return template;
+  }
+
+  const manifest: AssetManifest = {
+    assets: [],
+  };
+
+  for (const asset of assets) {
+    const output = await asset.generate();
+    const key = await bundle.addAsset(output.fileName, output.content);
+
+    manifest.assets.push({
+      bucketParam: asset.parameters.S3Bucket,
+      key,
+      keyParam: asset.parameters.S3Key,
+      name: asset.name,
+    });
+  }
+
+  return TemplateFragment.metadata(AssetManifestMetadataKey, manifest).build(
+    template,
+    ctx,
+  );
+}

package/src/types/loadConfigFile.d.ts

@@ -0,0 +1,20 @@
+import { MergedRollupOptions, RollupWarning } from 'rollup';
+
+declare module 'rollup/loadConfigFile' {
+  export interface BatchWarnings {
+    add: (warning: RollupWarning) => void;
+    readonly count: number;
+    flush: () => void;
+    readonly warningOccurred: boolean;
+  }
+
+  export interface LoadConfigFileResult {
+    options: MergedRollupOptions[];
+    warnings: BatchWarnings;
+  }
+
+  export default function loadAndParseConfigFile(
+    fileName: string,
+    commandOptions?: any,
+  ): Promise<LoadConfigFileResult>;
+}