@teambit/builder 0.0.551 → 0.0.556

package/artifact/artifact-extractor.ts

@@ -1,116 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { ScopeMain } from '@teambit/scope';
-import { ComponentID } from '@teambit/component-id';
-import pMapSeries from 'p-map-series';
-import minimatch from 'minimatch';
-import { ArtifactFiles, ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import { BuilderMain } from '../builder.main.runtime';
-import { ArtifactsOpts } from './artifacts.cmd';
-
-export type ExtractorResult = {
-  id: ComponentID;
-  artifacts: ExtractorArtifactResult[];
-};
-
-export type ExtractorArtifactResult = {
-  aspectId: string;
-  taskName: string;
-  files: string[];
-};
-
-export type ExtractorResultGrouped = {
-  id: ComponentID;
-  artifacts: { [aspectId: string]: ExtractorArtifactResult[] };
-};
-
-type ArtifactObjectsPerId = {
-  id: ComponentID;
-  artifacts: ArtifactObject[];
-};
-
-export class ArtifactExtractor {
-  constructor(
-    private scope: ScopeMain,
-    private builder: BuilderMain,
-    private patterns: string[],
-    private options: ArtifactsOpts
-  ) {}
-
-  async list(): Promise<ExtractorResult[]> {
-    const components = await this.scope.byPattern(this.patterns);
-    const artifactObjectsPerId: ArtifactObjectsPerId[] = components.map((component) => {
-      return {
-        id: component.id,
-        artifacts: this.builder.getArtifacts(component) || [],
-      };
-    });
-    this.filterByOptions(artifactObjectsPerId);
-    await this.saveFilesInFileSystemIfAsked(artifactObjectsPerId);
-
-    return this.artifactsObjectsToExtractorResults(artifactObjectsPerId);
-  }
-
-  groupResultsByAspect(extractorResult: ExtractorResult[]) {
-    return extractorResult.map((result) => {
-      const artifacts = result.artifacts.reduce((acc, current) => {
-        (acc[current.aspectId] ||= []).push(current);
-        return acc;
-      }, {});
-      return { id: result.id, artifacts };
-    });
-  }
-
-  private async saveFilesInFileSystemIfAsked(artifactObjectsPerId: ArtifactObjectsPerId[]) {
-    const outDir = this.options.outDir;
-    if (!outDir) {
-      return;
-    }
-    // @todo: optimize this to first import all missing hashes.
-    await pMapSeries(artifactObjectsPerId, async ({ id, artifacts }) => {
-      const vinyls = await Promise.all(
-        artifacts.map((artifactObject) =>
-          artifactObject.files.getVinylsAndImportIfMissing(id.scope as string, this.scope.legacyScope)
-        )
-      );
-      const flattenedVinyls = vinyls.flat();
-      const compPath = path.join(outDir, id.toStringWithoutVersion());
-      await Promise.all(flattenedVinyls.map((vinyl) => fs.outputFile(path.join(compPath, vinyl.path), vinyl.contents)));
-    });
-  }
-
-  private artifactsObjectsToExtractorResults(artifactObjectsPerId: ArtifactObjectsPerId[]): ExtractorResult[] {
-    return artifactObjectsPerId.map(({ id, artifacts }) => {
-      const results: ExtractorArtifactResult[] = artifacts.map((artifact) => {
-        return {
-          aspectId: artifact.task.id,
-          taskName: artifact.task.name || artifact.generatedBy,
-          files: artifact.files.refs.map((ref) => ref.relativePath),
-        };
-      });
-      return {
-        id,
-        artifacts: results,
-      };
-    });
-  }
-
-  private filterByOptions(artifactObjectsPerId: ArtifactObjectsPerId[]) {
-    const { aspect, task, files } = this.options;
-    artifactObjectsPerId.forEach((item) => {
-      item.artifacts = item.artifacts.filter((artifact) => {
-        if (aspect && aspect !== artifact.task.id) return false;
-        if (task && task !== artifact.task.name) return false;
-        return true;
-      });
-      if (files) {
-        item.artifacts.forEach((artifact) => {
-          const refs = artifact.files.refs.filter((ref) => minimatch(ref.relativePath, files));
-          artifact.files = new ArtifactFiles([], [], refs);
-        });
-        // remove artifacts with no files
-        item.artifacts = item.artifacts.filter((artifact) => artifact.files.refs.length);
-      }
-    });
-  }
-}

package/artifact/artifact-factory.ts

@@ -1,119 +0,0 @@
-import { join } from 'path';
-import globby from 'globby';
-import { flatten } from 'lodash';
-import { ArtifactFiles } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import { Component, ComponentMap } from '@teambit/component';
-import type { StorageResolverSlot } from '../builder.main.runtime';
-import { ArtifactDefinition } from './artifact-definition';
-import { DefaultResolver, StorageResolver } from '../storage';
-import { ArtifactList } from './artifact-list';
-import { Artifact } from './artifact';
-import type { BuildContext, BuildTask } from '../build-task';
-import { CapsuleNotFound } from '../exceptions';
-
-export const DEFAULT_CONTEXT = 'component';
-
-export type ArtifactMap = ComponentMap<ArtifactList>;
-
-export class ArtifactFactory {
-  constructor(private storageResolverSlot: StorageResolverSlot) {}
-
-  private getResolver(resolvers: StorageResolver[], name?: string) {
-    const defaultResolver = new DefaultResolver();
-    const userResolver = resolvers.find((resolver) => resolver.name === name);
-    return userResolver || defaultResolver;
-  }
-
-  private resolvePaths(root: string, def: ArtifactDefinition): string[] {
-    const patternsFlattened = flatten(def.globPatterns);
-    const paths = globby.sync(patternsFlattened, { cwd: root });
-    return paths;
-  }
-
-  private getArtifactContextPath(context: BuildContext, component: Component, def: ArtifactDefinition) {
-    const artifactContext = this.getArtifactContext(def);
-    if (artifactContext === 'component') {
-      const capsulePath = context.capsuleNetwork.graphCapsules.getCapsule(component.id)?.path;
-      if (!capsulePath) throw new CapsuleNotFound(component.id);
-      return capsulePath;
-    }
-
-    return context.capsuleNetwork.capsulesRootDir;
-  }
-
-  private getArtifactContext(def: ArtifactDefinition) {
-    return def.context || DEFAULT_CONTEXT;
-  }
-
-  createFromComponent(
-    context: BuildContext,
-    component: Component,
-    def: ArtifactDefinition,
-    task: BuildTask
-  ): Artifact | undefined {
-    const storageResolver = this.getStorageResolver(def);
-    const rootDir = this.getArtifactContextPath(context, component, def);
-    const paths = this.resolvePaths(this.getRootDir(rootDir, def), def);
-    if (!paths || !paths.length) {
-      return undefined;
-    }
-    return new Artifact(def, storageResolver, new ArtifactFiles(paths), rootDir, task);
-  }
-
-  private getStorageResolver(def: ArtifactDefinition) {
-    const storageResolvers = this.storageResolverSlot.values();
-    return this.getResolver(storageResolvers, def.storageResolver);
-  }
-
-  private toComponentMap(context: BuildContext, artifactMap: [string, Artifact][]) {
-    return ComponentMap.as<ArtifactList>(context.components, (component) => {
-      const id = component.id.toString();
-      const artifacts = artifactMap.filter(([targetId]) => targetId === id).map(([, artifact]) => artifact);
-
-      return new ArtifactList(artifacts);
-    });
-  }
-
-  private getRootDir(rootDir: string, def: ArtifactDefinition) {
-    if (!def.rootDir) return rootDir;
-    return join(rootDir, def.rootDir);
-  }
-
-  /**
-   * generate artifacts from a build context according to the spec defined in the artifact definitions.
-   */
-  generate(context: BuildContext, defs: ArtifactDefinition[], task: BuildTask): ComponentMap<ArtifactList> {
-    const tupleArr: [string, Artifact][] = [];
-
-    defs.forEach((def) => {
-      const artifactContext = this.getArtifactContext(def);
-      if (artifactContext === 'env') {
-        const capsuleDir = context.capsuleNetwork.capsulesRootDir;
-        const rootDir = this.getRootDir(capsuleDir, def);
-        const paths = this.resolvePaths(rootDir, def);
-        if (paths && paths.length) {
-          const artifact = new Artifact(
-            def,
-            this.getStorageResolver(def),
-            new ArtifactFiles(this.resolvePaths(rootDir, def)),
-            rootDir,
-            task
-          );
-
-          return context.components.forEach((component) => {
-            tupleArr.push([component.id.toString(), artifact]);
-          });
-        }
-      }
-
-      return context.components.forEach((component) => {
-        const artifact = this.createFromComponent(context, component, def, task);
-        if (artifact) {
-          tupleArr.push([component.id.toString(), artifact]);
-        }
-      });
-    });
-
-    return this.toComponentMap(context, tupleArr);
-  }
-}

package/artifact/artifact-list.ts

@@ -1,64 +0,0 @@
-import { Component } from '@teambit/component';
-import type { ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import type { Artifact } from './artifact';
-
-export type ResolverMap = { [key: string]: Artifact[] };
-
-export class ArtifactList {
-  constructor(readonly artifacts: Artifact[]) {}
-
-  /**
-   * return an array of artifact objects.
-   */
-  toArray() {
-    return this.artifacts;
-  }
-
-  /**
-   * group artifacts by the storage resolver.
-   */
-  groupByResolver(): ResolverMap {
-    const resolverMap: ResolverMap = {};
-    this.artifacts.forEach((artifact) => {
-      const storageResolver = artifact.storageResolver;
-      const resolverArray = resolverMap[storageResolver.name];
-      if (!resolverArray) {
-        resolverMap[storageResolver.name] = [artifact];
-        return;
-      }
-      if (resolverArray.length) {
-        resolverMap[storageResolver.name].push(artifact);
-      }
-    });
-
-    return resolverMap;
-  }
-
-  toObject(): ArtifactObject[] {
-    return this.artifacts.map((artifact) => artifact.toObject());
-  }
-
-  groupByTaskId() {
-    return this.artifacts.reduce((acc: { [key: string]: Artifact }, artifact) => {
-      const taskId = artifact.task.aspectId;
-      acc[taskId] = artifact;
-      return acc;
-    }, {});
-  }
-
-  /**
-   * store all artifacts using the configured storage resolvers.
-   */
-  async store(component: Component) {
-    const byResolvers = this.groupByResolver();
-    const promises = Object.keys(byResolvers).map(async (key) => {
-      const artifacts = byResolvers[key];
-      if (!artifacts.length) return;
-      const storageResolver = artifacts[0].storageResolver;
-      const artifactList = new ArtifactList(artifacts);
-      await storageResolver.store(component, artifactList);
-    });
-
-    return Promise.all(promises);
-  }
-}

package/artifact/artifact.ts

@@ -1,81 +0,0 @@
-import type { ArtifactFiles, ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import type { BuildTask } from '../build-task';
-import type { StorageResolver } from '../storage';
-import type { ArtifactDefinition } from './artifact-definition';
-
-export class Artifact {
-  constructor(
-    /**
-     * definition of the artifact.
-     */
-    readonly def: ArtifactDefinition,
-
-    /**
-     * storage resolver. can be used to replace where artifacts are stored.
-     */
-    readonly storageResolver: StorageResolver,
-
-    readonly files: ArtifactFiles,
-
-    /**
-     * join this with `this.paths` to get the absolute paths
-     */
-    readonly rootDir: string,
-
-    /**
-     * the declaring task.
-     * todo: change this to taskDescriptor that has only the metadata of the task, so it could be
-     * saved into the model.
-     */
-    readonly task: BuildTask,
-
-    /**
-     * timestamp of the artifact creation.
-     */
-    readonly timestamp: number = Date.now()
-  ) {}
-
-  get storage() {
-    return this.storageResolver;
-  }
-
-  /**
-   * name of the artifact.
-   */
-  get name(): string {
-    return this.def.name;
-  }
-
-  /**
-   * description of the artifact.
-   */
-  get description() {
-    return this.def.description;
-  }
-
-  /**
-   * aspect id (string) that generated the artifact
-   */
-  get generatedBy(): string {
-    return this.def.generatedBy || this.task.aspectId;
-  }
-
-  /**
-   * archive all artifact files into a tar.
-   */
-  tar() {}
-
-  toObject(): ArtifactObject {
-    return {
-      name: this.name,
-      description: this.description,
-      generatedBy: this.generatedBy,
-      storage: this.storageResolver.name,
-      task: {
-        id: this.task.aspectId,
-        name: this.task.name,
-      },
-      files: this.files,
-    };
-  }
-}

package/artifact/artifacts.cmd.ts

@@ -1,68 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { ScopeMain } from '@teambit/scope';
-import { BuilderMain } from '../builder.main.runtime';
-import { ArtifactExtractor, ExtractorArtifactResult, ExtractorResultGrouped } from './artifact-extractor';
-
-const INDENT_TITLE = ' '.repeat(2);
-const INDENT_SUB_TITLE = ' '.repeat(4);
-const INDENT_FILES = ' '.repeat(6);
-
-export type ArtifactsOpts = {
-  aspect?: string;
-  task?: string;
-  files?: string;
-  outDir?: string;
-};
-
-export class ArtifactsCmd implements Command {
-  name = 'artifacts <pattern...>';
-  shortDescription = 'EXPERIMENTAL. list and download components artifacts';
-  description = `EXPERIMENTAL. list and download components artifacts.
-artifacts are created on isolated capsules during tag or snap commands.
-example of artifacts are dists files generated by a compiler, a JUnit.xml file generated by a tester
-and a package.tgz file generated by pkg aspect.
-`;
-  alias = '';
-  group = 'development';
-  options = [
-    ['', 'aspect <aspect-id>', 'show/download only artifacts generated by this aspect-id'],
-    ['', 'task <task-id>', 'show/download only artifacts generated by this task-id'],
-    [
-      '',
-      'files <glob>',
-      'show/download only artifacts matching the given files or the glob pattern (wrap glob patterns in quotes)',
-    ],
-    ['', 'out-dir <string>', 'download the files to the specified dir'],
-  ] as CommandOptions;
-
-  constructor(private builder: BuilderMain, private scope: ScopeMain) {}
-
-  async report([userPattern]: [string[]], artifactsOpts: ArtifactsOpts): Promise<string> {
-    const artifactExtractor = new ArtifactExtractor(this.scope, this.builder, userPattern, artifactsOpts);
-    const list = await artifactExtractor.list();
-    const grouped = artifactExtractor.groupResultsByAspect(list);
-    const outputArtifacts = (aspectId: string, artifactData: ExtractorArtifactResult[]) => {
-      const title = chalk.green(aspectId);
-      const artifactDataStr = artifactData
-        .map((artifact) => {
-          const subTitle = chalk.white(artifact.taskName);
-          const files = artifact.files.map((f) => INDENT_FILES + chalk.dim(f)).join('\n');
-          return `${INDENT_SUB_TITLE}${subTitle}\n${files}`;
-        })
-        .join('\n');
-      return `${INDENT_TITLE}${title}\n${artifactDataStr}`;
-    };
-    const outputResult = (result: ExtractorResultGrouped) => {
-      const idStr = chalk.cyan(result.id.toString());
-      const artifacts = Object.keys(result.artifacts)
-        .map((aspectId) => outputArtifacts(aspectId, result.artifacts[aspectId]))
-        .join('\n\n');
-      return `${idStr}\n${artifacts}`;
-    };
-    const footer = artifactsOpts.outDir
-      ? chalk.green('\n\nThe above files were saved successfully to the file system')
-      : '';
-    return grouped.map(outputResult).join('\n\n') + footer;
-  }
-}

package/artifact/extension-artifact.ts

@@ -1,12 +0,0 @@
-import type { AspectDescriptor } from '@teambit/aspect-loader';
-import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
-
-export class ExtensionArtifact {
-  constructor(readonly files: AbstractVinyl[], readonly extensionDescriptor: AspectDescriptor) {}
-
-  toObject() {
-    return {
-      extensionDescriptor: this.extensionDescriptor,
-    };
-  }
-}

package/artifact/index.ts

@@ -1,5 +0,0 @@
-export { ArtifactDefinition } from './artifact-definition';
-export { ExtensionArtifact } from './extension-artifact';
-export { Artifact } from './artifact';
-export { ArtifactList } from './artifact-list';
-export { ArtifactFactory, ArtifactMap } from './artifact-factory';

package/build-pipe.ts

@@ -1,167 +0,0 @@
-import { EnvDefinition } from '@teambit/envs';
-import { ComponentMap } from '@teambit/component';
-import { Logger, LongProcessLogger } from '@teambit/logger';
-import mapSeries from 'p-map-series';
-import prettyTime from 'pretty-time';
-import { ArtifactFactory, ArtifactList } from './artifact';
-import { BuildTask, BuildTaskHelper } from './build-task';
-import { ComponentResult } from './types';
-import { TasksQueue } from './tasks-queue';
-import { EnvsBuildContext } from './builder.service';
-import { TaskResultsList } from './task-results-list';
-
-export type TaskResults = {
-  /**
-   * task itself. useful for getting its id/description later on.
-   */
-  task: BuildTask;
-
-  /**
-   * environment were the task was running
-   */
-  env: EnvDefinition;
-
-  /**
-   * component build results.
-   */
-  componentsResults: ComponentResult[];
-
-  /**
-   * artifacts generated by the build pipeline.
-   * in case the task finished with errors, this prop is undefined.
-   */
-  artifacts: ComponentMap<ArtifactList> | undefined;
-
-  /**
-   * timestamp of start initiation.
-   */
-  startTime: number;
-
-  /**
-   * timestamp of task completion.
-   */
-  endTime: number;
-};
-
-export class BuildPipe {
-  private failedTasks: BuildTask[] = [];
-  private failedDependencyTask: BuildTask | undefined;
-  private longProcessLogger: LongProcessLogger;
-  private taskResults: TaskResults[] = [];
-  constructor(
-    /**
-     * array of services to apply on the components.
-     */
-    readonly tasksQueue: TasksQueue,
-    readonly envsBuildContext: EnvsBuildContext,
-    readonly logger: Logger,
-    readonly artifactFactory: ArtifactFactory
-  ) {}
-
-  /**
-   * execute a pipeline of build tasks.
-   */
-  async execute(): Promise<TaskResultsList> {
-    await this.executePreBuild();
-    this.longProcessLogger = this.logger.createLongProcessLogger('running tasks', this.tasksQueue.length);
-    await mapSeries(this.tasksQueue, async ({ task, env }) => this.executeTask(task, env));
-    this.longProcessLogger.end();
-    const tasksResultsList = new TaskResultsList(this.tasksQueue, this.taskResults);
-    await this.executePostBuild(tasksResultsList);
-
-    return tasksResultsList;
-  }
-
-  private async executePreBuild() {
-    this.logger.setStatusLine('executing pre-build for all tasks');
-    await mapSeries(this.tasksQueue, async ({ task, env }) => {
-      if (!task.preBuild) return;
-      await task.preBuild(this.getBuildContext(env.id));
-    });
-    this.logger.consoleSuccess();
-  }
-
-  private async executeTask(task: BuildTask, env: EnvDefinition): Promise<void> {
-    const taskId = BuildTaskHelper.serializeId(task);
-    const taskName = `${taskId}${task.description ? ` (${task.description})` : ''}`;
-    this.longProcessLogger.logProgress(`env "${env.id}", task "${taskName}"`);
-    this.updateFailedDependencyTask(task);
-    if (this.shouldSkipTask(taskId, env.id)) {
-      return;
-    }
-    const startTask = process.hrtime();
-    const taskStartTime = Date.now();
-    const buildContext = this.getBuildContext(env.id);
-    const buildTaskResult = await task.execute(buildContext);
-    const endTime = Date.now();
-    const compsWithErrors = buildTaskResult.componentsResults.filter((c) => c.errors?.length);
-    let artifacts;
-    if (compsWithErrors.length) {
-      this.logger.consoleFailure(`env: ${env.id}, task "${taskId}" has failed`);
-      this.failedTasks.push(task);
-    } else {
-      const duration = prettyTime(process.hrtime(startTask));
-      this.logger.consoleSuccess(`env "${env.id}", task "${taskName}" has completed successfully in ${duration}`);
-      const defs = buildTaskResult.artifacts || [];
-      artifacts = this.artifactFactory.generate(buildContext, defs, task);
-    }
-
-    const taskResults: TaskResults = {
-      task,
-      env,
-      componentsResults: buildTaskResult.componentsResults,
-      artifacts,
-      startTime: taskStartTime,
-      endTime,
-    };
-
-    this.taskResults.push(taskResults);
-  }
-
-  private async executePostBuild(tasksResults: TaskResultsList) {
-    this.logger.setStatusLine('executing post-build for all tasks');
-    await mapSeries(this.tasksQueue, async ({ task, env }) => {
-      if (!task.postBuild) return;
-      await task.postBuild(this.getBuildContext(env.id), tasksResults);
-    });
-    this.logger.consoleSuccess();
-  }
-
-  private updateFailedDependencyTask(task: BuildTask) {
-    if (!this.failedDependencyTask && this.failedTasks.length && task.dependencies) {
-      task.dependencies.forEach((dependency) => {
-        const { aspectId, name } = BuildTaskHelper.deserializeId(dependency);
-        this.failedDependencyTask = this.failedTasks.find((failedTask) => {
-          if (name && name !== failedTask.name) return false;
-          return aspectId === failedTask.aspectId;
-        });
-      });
-    }
-  }
-
-  private shouldSkipTask(taskId: string, envId: string): boolean {
-    if (!this.failedDependencyTask) return false;
-    const failedTaskId = BuildTaskHelper.serializeId(this.failedDependencyTask);
-    this.logger.consoleWarning(`env: ${envId}, task "${taskId}" has skipped due to "${failedTaskId}" failure`);
-    return true;
-  }
-
-  private getBuildContext(envId: string) {
-    const buildContext = this.envsBuildContext[envId];
-    if (!buildContext) throw new Error(`unable to find buildContext for ${envId}`);
-    buildContext.previousTasksResults = this.taskResults;
-    return buildContext;
-  }
-
-  /**
-   * create a build pipe from an array of tasks.
-   */
-  static from(
-    tasksQueue: TasksQueue,
-    envsBuildContext: EnvsBuildContext,
-    logger: Logger,
-    artifactFactory: ArtifactFactory
-  ) {
-    return new BuildPipe(tasksQueue, envsBuildContext, logger, artifactFactory);
-  }
-}