@teambit/builder 1.0.107 → 1.0.108

package/builder.main.runtime.ts

@@ -0,0 +1,493 @@
+import { cloneDeep } from 'lodash';
+import { ArtifactVinyl } from '@teambit/legacy/dist/consumer/component/sources/artifact';
+import { ArtifactFiles, ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
+import { AspectLoaderAspect, AspectLoaderMain } from '@teambit/aspect-loader';
+import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
+import { Component, ComponentMap, IComponent, ComponentAspect, ComponentMain, ComponentID } from '@teambit/component';
+import { EnvsAspect, EnvsMain } from '@teambit/envs';
+import { GraphqlAspect, GraphqlMain } from '@teambit/graphql';
+import { Slot, SlotRegistry } from '@teambit/harmony';
+import GlobalConfigAspect, { GlobalConfigMain } from '@teambit/global-config';
+import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
+import AspectAspect from '@teambit/aspect';
+import { ScopeAspect, ScopeMain } from '@teambit/scope';
+import { Workspace, WorkspaceAspect } from '@teambit/workspace';
+import { IsolateComponentsOptions, IsolatorAspect, IsolatorMain } from '@teambit/isolator';
+import { getHarmonyVersion } from '@teambit/legacy/dist/bootstrap';
+import findDuplications from '@teambit/legacy/dist/utils/array/find-duplications';
+import { GeneratorAspect, GeneratorMain } from '@teambit/generator';
+import { UIAspect, UiMain, BundleUiTask } from '@teambit/ui';
+import { Artifact, ArtifactList, FsArtifact } from './artifact';
+import { ArtifactFactory } from './artifact/artifact-factory'; // it gets undefined when importing it from './artifact'
+import { BuilderAspect } from './builder.aspect';
+import { builderSchema } from './builder.graphql';
+import { BuilderService, BuilderServiceOptions } from './builder.service';
+import { BuilderCmd } from './build.cmd';
+import { BuildTask, BuildTaskHelper } from './build-task';
+import { TaskResults } from './build-pipe';
+import { TaskResultsList } from './task-results-list';
+import { ArtifactStorageError } from './exceptions';
+import { BuildPipelineResultList, AspectData, PipelineReport } from './build-pipeline-result-list';
+import { TaskMetadata } from './types';
+import { ArtifactsCmd } from './artifact/artifacts.cmd';
+import { buildTaskTemplate } from './templates/build-task';
+import { BuilderRoute } from './builder.route';
+
+export type TaskSlot = SlotRegistry<BuildTask[]>;
+export type OnTagResults = { builderDataMap: ComponentMap<RawBuilderData>; pipeResults: TaskResultsList[] };
+export type OnTagOpts = {
+  disableTagAndSnapPipelines?: boolean;
+  throwOnError?: boolean; // on the CI it helps to save the results on failure so this is set to false
+  forceDeploy?: boolean; // whether run the deploy-pipeline although the build-pipeline has failed
+  populateArtifactsFrom?: ComponentID[]; // helpful for tagging from scope where we want to use the build-artifacts of previous snap.
+  isSnap?: boolean;
+};
+export const FILE_PATH_PARAM_DELIM = '~';
+
+/**
+ * builder data format for the bit object store
+ */
+export type RawBuilderData = {
+  pipeline: PipelineReport[];
+  artifacts?: ArtifactObject[];
+  aspectsData: AspectData[];
+  bitVersion?: string;
+};
+/**
+ * builder data mapped to an ArtifactList instance
+ */
+export type BuilderData = Omit<RawBuilderData, 'artifacts'> & {
+  artifacts: ArtifactList<Artifact>;
+};
+
+export class BuilderMain {
+  constructor(
+    private envs: EnvsMain,
+    private workspace: Workspace,
+    private buildService: BuilderService,
+    private tagService: BuilderService,
+    private snapService: BuilderService,
+    private scope: ScopeMain,
+    private isolator: IsolatorMain,
+    private aspectLoader: AspectLoaderMain,
+    private componentAspect: ComponentMain,
+    private globalConfig: GlobalConfigMain,
+    private buildTaskSlot: TaskSlot,
+    private tagTaskSlot: TaskSlot,
+    private snapTaskSlot: TaskSlot,
+    private logger: Logger
+  ) {}
+
+  private async storeArtifacts(tasksResults: TaskResults[]) {
+    const artifacts = tasksResults.flatMap((t) => (t.artifacts ? [t.artifacts] : []));
+    const storeP = artifacts.map(async (artifactMap: ComponentMap<ArtifactList<FsArtifact>>) => {
+      return Promise.all(
+        artifactMap.toArray().map(async ([component, artifactList]) => {
+          try {
+            return await artifactList.store(component);
+          } catch (err: any) {
+            throw new ArtifactStorageError(err, component);
+          }
+        })
+      );
+    });
+    await Promise.all(storeP);
+  }
+
+  private pipelineResultsToBuilderData(
+    components: Component[],
+    buildPipelineResults: TaskResults[]
+  ): ComponentMap<RawBuilderData> {
+    const buildPipelineResultList = new BuildPipelineResultList(buildPipelineResults, components);
+    return ComponentMap.as<RawBuilderData>(components, (component) => {
+      const aspectsData = buildPipelineResultList.getDataOfComponent(component.id);
+      const pipelineReport = buildPipelineResultList.getPipelineReportOfComponent(component.id);
+      const artifacts = buildPipelineResultList.getArtifactsDataOfComponent(component.id);
+      return { pipeline: pipelineReport, artifacts, aspectsData, bitVersion: getHarmonyVersion(true) };
+    });
+  }
+
+  async tagListener(
+    components: Component[],
+    options: OnTagOpts = {},
+    isolateOptions: IsolateComponentsOptions = {},
+    builderOptions: BuilderServiceOptions = {}
+  ): Promise<OnTagResults> {
+    const pipeResults: TaskResultsList[] = [];
+    const allTasksResults: TaskResults[] = [];
+    const { throwOnError, forceDeploy, disableTagAndSnapPipelines, isSnap, populateArtifactsFrom } = options;
+    if (populateArtifactsFrom) isolateOptions.populateArtifactsFrom = populateArtifactsFrom;
+    const buildEnvsExecutionResults = await this.build(
+      components,
+      { emptyRootDir: true, ...isolateOptions },
+      {
+        ...builderOptions,
+        // even when build is skipped (in case of tag-from-scope), the pre-build/post-build and teambit.harmony/aspect tasks are needed
+        tasks: populateArtifactsFrom ? [AspectAspect.id] : undefined,
+      }
+    );
+    if (throwOnError && !forceDeploy) buildEnvsExecutionResults.throwErrorsIfExist();
+    allTasksResults.push(...buildEnvsExecutionResults.tasksResults);
+    pipeResults.push(buildEnvsExecutionResults);
+
+    if (forceDeploy || (!disableTagAndSnapPipelines && !buildEnvsExecutionResults?.hasErrors())) {
+      const builderOptionsForTagSnap: BuilderServiceOptions = {
+        ...builderOptions,
+        seedersOnly: isolateOptions.seedersOnly,
+        previousTasksResults: buildEnvsExecutionResults?.tasksResults,
+      };
+      const deployEnvsExecutionResults = isSnap
+        ? await this.runSnapTasks(components, builderOptionsForTagSnap)
+        : await this.runTagTasks(components, builderOptionsForTagSnap);
+      if (throwOnError && !forceDeploy) deployEnvsExecutionResults.throwErrorsIfExist();
+      allTasksResults.push(...deployEnvsExecutionResults.tasksResults);
+      pipeResults.push(deployEnvsExecutionResults);
+    }
+    await this.storeArtifacts(allTasksResults);
+    const builderDataMap = this.pipelineResultsToBuilderData(components, allTasksResults);
+    if (populateArtifactsFrom) await this.combineBuildDataFrom(builderDataMap, populateArtifactsFrom);
+    this.validateBuilderDataMap(builderDataMap);
+
+    return { builderDataMap, pipeResults };
+  }
+
+  private validateBuilderDataMap(builderDataMap: ComponentMap<RawBuilderData>) {
+    builderDataMap.forEach((buildData: RawBuilderData, component) => {
+      const taskSerializedIds = buildData.pipeline.map((t) =>
+        BuildTaskHelper.serializeId({ aspectId: t.taskId, name: t.taskName })
+      );
+      const duplications = findDuplications(taskSerializedIds);
+      if (duplications.length) {
+        throw new Error(
+          `build-task-results validation has failed. the following task(s) of "${component.id.toString()}" are duplicated: ${duplications.join(
+            ', '
+          )}`
+        );
+      }
+    });
+  }
+
+  private async combineBuildDataFrom(
+    builderDataMap: ComponentMap<RawBuilderData>,
+    populateArtifactsFrom: ComponentID[]
+  ) {
+    const promises = builderDataMap.map(async (builderData, component) => {
+      const populateFrom = populateArtifactsFrom.find((id) => id.isEqual(component.id, { ignoreVersion: true }));
+      const idStr = component.id.toString();
+      if (!populateFrom) {
+        throw new Error(`combineBuildDataFromParent: unable to find where to populate the artifacts from for ${idStr}`);
+      }
+      const populateFromComp = await this.componentAspect.getHost().get(populateFrom);
+      if (!populateFromComp)
+        throw new Error(
+          `combineBuildDataFromParent, unable to load parent component of ${idStr}. hash: ${populateFrom.version}`
+        );
+      const populateFromBuilderData = this.getBuilderData(populateFromComp);
+      if (!populateFromBuilderData) throw new Error(`parent of ${idStr} was not built yet. unable to continue`);
+      populateFromBuilderData.artifacts.forEach((artifact) => {
+        const artifactObj = artifact.toObject();
+        if (!builderData.artifacts) builderData.artifacts = [];
+        if (
+          builderData.artifacts.find((a) => a.task.id === artifactObj.task.id && a.task.name === artifactObj.task.name)
+        ) {
+          return;
+        }
+        builderData.artifacts.push(artifactObj);
+      });
+      populateFromBuilderData.aspectsData.forEach((aspectData) => {
+        if (builderData.aspectsData.find((a) => a.aspectId === aspectData.aspectId)) return;
+        builderData.aspectsData.push(aspectData);
+      });
+      populateFromBuilderData.pipeline.forEach((pipeline) => {
+        if (builderData.pipeline.find((p) => p.taskId === pipeline.taskId && p.taskName === pipeline.taskName)) return;
+        builderData.pipeline.push(pipeline);
+      });
+    });
+
+    await Promise.all(promises.flattenValue());
+  }
+
+  // TODO: merge with getArtifactsVinylByExtensionAndName by getting aspect name and name as object with optional props
+  async getArtifactsVinylByAspect(component: Component, aspectName: string): Promise<ArtifactVinyl[]> {
+    const artifacts = this.getArtifactsByAspect(component, aspectName);
+    const vinyls = await artifacts.getVinylsAndImportIfMissing(component.id, this.scope.legacyScope);
+    return vinyls;
+  }
+
+  async getArtifactsVinylByAspectAndName(
+    component: Component,
+    aspectName: string,
+    name: string
+  ): Promise<ArtifactVinyl[]> {
+    const artifacts = this.getArtifactsByAspectAndName(component, aspectName, name);
+    const vinyls = await artifacts.getVinylsAndImportIfMissing(component.id, this.scope.legacyScope);
+    return vinyls;
+  }
+
+  async getArtifactsVinylByAspectAndTaskName(
+    component: Component,
+    aspectName: string,
+    name: string
+  ): Promise<ArtifactVinyl[]> {
+    const artifacts = this.getArtifactsbyAspectAndTaskName(component, aspectName, name);
+    const vinyls = await artifacts.getVinylsAndImportIfMissing(component.id, this.scope.legacyScope);
+    return vinyls;
+  }
+
+  getArtifactsByName(component: Component, name: string): ArtifactList<Artifact> {
+    const artifacts = this.getArtifacts(component).byAspectNameAndName(undefined, name);
+    return artifacts;
+  }
+
+  getArtifactsByAspect(component: Component, aspectName: string): ArtifactList<Artifact> {
+    const artifacts = this.getArtifacts(component).byAspectNameAndName(aspectName);
+    return artifacts;
+  }
+
+  getArtifactsByAspectAndName(component: Component, aspectName: string, name: string): ArtifactList<Artifact> {
+    const artifacts = this.getArtifacts(component).byAspectNameAndName(aspectName, name);
+    return artifacts;
+  }
+
+  getArtifactsbyAspectAndTaskName(component: IComponent, aspectName: string, taskName: string): ArtifactList<Artifact> {
+    const artifacts = this.getArtifacts(component).byAspectNameAndTaskName(aspectName, taskName);
+    return artifacts;
+  }
+
+  /**
+   * this is the aspect's data that was generated as "metadata" of the task component-result during the build process
+   * and saved by the builder aspect in the "aspectsData" property.
+   * (not to be confused with the data saved in the aspect itself, which is saved in the "data" property of the aspect).
+   */
+  getDataByAspect(component: IComponent, aspectName: string): TaskMetadata | undefined {
+    const aspectsData = this.getBuilderData(component)?.aspectsData;
+    const data = aspectsData?.find((aspectData) => aspectData.aspectId === aspectName);
+    return data?.data;
+  }
+
+  getArtifacts(component: IComponent): ArtifactList<Artifact> {
+    const artifacts = this.getBuilderData(component)?.artifacts || ArtifactList.fromArray([]);
+    return artifacts;
+  }
+
+  getBuilderData(component: IComponent): BuilderData | undefined {
+    const data = component.get(BuilderAspect.id)?.data;
+    if (!data) return undefined;
+    const clonedData = cloneDeep(data) as BuilderData;
+    let artifactFiles: ArtifactFiles;
+    const artifacts = clonedData.artifacts?.map((artifact) => {
+      if (!(artifact.files instanceof ArtifactFiles)) {
+        artifactFiles = ArtifactFiles.fromObject(artifact.files);
+      } else {
+        artifactFiles = artifact.files;
+      }
+      if (artifact instanceof Artifact) {
+        return artifact;
+      }
+      Object.assign(artifact, { files: artifactFiles });
+      return Artifact.fromArtifactObject(artifact);
+    });
+    clonedData.artifacts = ArtifactList.fromArray(artifacts || []);
+    return clonedData;
+  }
+
+  async build(
+    components: Component[],
+    isolateOptions?: IsolateComponentsOptions,
+    builderOptions?: BuilderServiceOptions,
+    extraOptions?: { includeTag?: boolean; includeSnap?: boolean }
+  ): Promise<TaskResultsList> {
+    const ids = components.map((c) => c.id);
+    const capsulesBaseDir = this.buildService.getComponentsCapsulesBaseDir();
+    const baseIsolateOpts = {
+      baseDir: capsulesBaseDir,
+      useHash: !capsulesBaseDir,
+    };
+    const mergedIsolateOpts = {
+      ...baseIsolateOpts,
+      ...isolateOptions,
+    };
+
+    const network = await this.isolator.isolateComponents(ids, mergedIsolateOpts, this.scope.legacyScope);
+    const envs = await this.envs.createEnvironment(network.graphCapsules.getAllComponents());
+    const builderServiceOptions = {
+      seedersOnly: isolateOptions?.seedersOnly,
+      originalSeeders: ids,
+      capsulesBaseDir,
+      ...(builderOptions || {}),
+    };
+    this.logger.consoleTitle(`Total ${components.length} components to build`);
+    const buildResult: TaskResultsList = await envs.runOnce(this.buildService, builderServiceOptions);
+
+    if (extraOptions?.includeSnap || extraOptions?.includeTag) {
+      const builderOptionsForTagSnap: BuilderServiceOptions = {
+        ...builderServiceOptions,
+        previousTasksResults: buildResult.tasksResults,
+      };
+      const deployEnvsExecutionResults = extraOptions?.includeSnap
+        ? await this.runSnapTasks(components, builderOptionsForTagSnap)
+        : await this.runTagTasks(components, builderOptionsForTagSnap);
+      buildResult.tasksResults.push(...deployEnvsExecutionResults.tasksResults);
+    }
+
+    return buildResult;
+  }
+
+  async runTagTasks(components: Component[], builderOptions: BuilderServiceOptions): Promise<TaskResultsList> {
+    const envs = await this.envs.createEnvironment(components);
+    const buildResult = await envs.runOnce(this.tagService, builderOptions);
+
+    return buildResult;
+  }
+
+  async runSnapTasks(components: Component[], builderOptions: BuilderServiceOptions): Promise<TaskResultsList> {
+    const envs = await this.envs.createEnvironment(components);
+    const buildResult = await envs.runOnce(this.snapService, builderOptions);
+
+    return buildResult;
+  }
+
+  listTasks(component: Component) {
+    const compEnv = this.envs.getEnv(component);
+    const buildTasks = this.buildService.getCurrentPipeTasks(compEnv);
+    const tagTasks = this.tagService.getCurrentPipeTasks(compEnv);
+    const snapTasks = this.snapService.getCurrentPipeTasks(compEnv);
+    return { id: component.id, envId: compEnv.id, buildTasks, tagTasks, snapTasks };
+  }
+
+  /**
+   * register a build task to apply on all component build pipelines.
+   * build happens on `bit build` and as part of `bit tag --persist`.
+   */
+  registerBuildTasks(tasks: BuildTask[]) {
+    this.buildTaskSlot.register(tasks);
+    return this;
+  }
+
+  /**
+   * @deprecated use registerTagTasks or registerSnapTasks
+   */
+  registerDeployTasks(tasks: BuildTask[]) {
+    this.tagTaskSlot.register(tasks);
+    return this;
+  }
+
+  /**
+   * tag tasks that don't get executed on `bit build`, only on `bit tag'.
+   * this pipeline is running once the build-pipeline has completed.
+   */
+  registerTagTasks(tasks: BuildTask[]) {
+    this.tagTaskSlot.register(tasks);
+    return this;
+  }
+
+  /**
+   * tag tasks that don't get executed on `bit build`, only on `bit snap'.
+   * this pipeline is running once the build-pipeline has completed.
+   */
+  registerSnapTasks(tasks: BuildTask[]) {
+    this.snapTaskSlot.register(tasks);
+    return this;
+  }
+
+  getDownloadUrlForArtifact(componentId: ComponentID, taskId: string, path?: string) {
+    return `/api/${componentId}/~aspect/builder/${taskId}/${path ? `${FILE_PATH_PARAM_DELIM}${path}` : ''}`;
+  }
+
+  static slots = [Slot.withType<BuildTask>(), Slot.withType<BuildTask>(), Slot.withType<BuildTask>()];
+
+  static runtime = MainRuntime;
+  static dependencies = [
+    CLIAspect,
+    EnvsAspect,
+    WorkspaceAspect,
+    ScopeAspect,
+    IsolatorAspect,
+    LoggerAspect,
+    AspectLoaderAspect,
+    GraphqlAspect,
+    GeneratorAspect,
+    ComponentAspect,
+    UIAspect,
+    GlobalConfigAspect,
+  ];
+
+  static async provider(
+    [cli, envs, workspace, scope, isolator, loggerExt, aspectLoader, graphql, generator, component, ui, globalConfig]: [
+      CLIMain,
+      EnvsMain,
+      Workspace,
+      ScopeMain,
+      IsolatorMain,
+      LoggerMain,
+      AspectLoaderMain,
+      GraphqlMain,
+      GeneratorMain,
+      ComponentMain,
+      UiMain,
+      GlobalConfigMain
+    ],
+    config,
+    [buildTaskSlot, tagTaskSlot, snapTaskSlot]: [TaskSlot, TaskSlot, TaskSlot]
+  ) {
+    const artifactFactory = new ArtifactFactory();
+    const logger = loggerExt.createLogger(BuilderAspect.id);
+    const buildService = new BuilderService(
+      isolator,
+      logger,
+      buildTaskSlot,
+      'getBuildPipe',
+      'build',
+      artifactFactory,
+      scope,
+      globalConfig
+    );
+    envs.registerService(buildService);
+    const tagService = new BuilderService(
+      isolator,
+      logger,
+      tagTaskSlot,
+      'getTagPipe',
+      'tag',
+      artifactFactory,
+      scope,
+      globalConfig
+    );
+    const snapService = new BuilderService(
+      isolator,
+      logger,
+      snapTaskSlot,
+      'getSnapPipe',
+      'snap',
+      artifactFactory,
+      scope,
+      globalConfig
+    );
+    const builder = new BuilderMain(
+      envs,
+      workspace,
+      buildService,
+      tagService,
+      snapService,
+      scope,
+      isolator,
+      aspectLoader,
+      component,
+      globalConfig,
+      buildTaskSlot,
+      tagTaskSlot,
+      snapTaskSlot,
+      logger
+    );
+    builder.registerBuildTasks([new BundleUiTask(ui, logger)]);
+    component.registerRoute([new BuilderRoute(builder, scope, logger)]);
+    graphql.register(builderSchema(builder, logger));
+    if (generator) generator.registerComponentTemplate([buildTaskTemplate]);
+    const commands = [new BuilderCmd(builder, workspace, logger), new ArtifactsCmd(builder, component)];
+    cli.register(...commands);
+
+    return builder;
+  }
+}
+
+BuilderAspect.addRuntime(BuilderMain);

package/builder.route.ts

@@ -0,0 +1,95 @@
+import { Request, Response, Route } from '@teambit/express';
+import { Component } from '@teambit/component';
+import archiver from 'archiver';
+import { Logger } from '@teambit/logger';
+import { ScopeMain } from '@teambit/scope';
+import mime from 'mime';
+import { BuilderMain } from './builder.main.runtime';
+
+export const routePath = `builder`;
+
+export type BuilderUrlParams = {
+  aspectId?: string;
+  filePath?: string;
+};
+export const defaultExtension = '.tgz';
+export class BuilderRoute implements Route {
+  constructor(private builder: BuilderMain, private scope: ScopeMain, private logger: Logger) {}
+  route = `/${routePath}/*`;
+  method = 'get';
+
+  middlewares = [
+    async (req: Request<BuilderUrlParams>, res: Response) => {
+      // @ts-ignore TODO: @guy please fix.
+      const component = req.component as Component;
+      const { params } = req;
+      const [aspectIdStr, filePath] = params[1].split('~');
+      // remove trailing slash
+      const aspectId = aspectIdStr.replace(/\/$/, '');
+      const artifacts = aspectId
+        ? this.builder.getArtifactsByAspect(component, aspectId)
+        : this.builder.getArtifacts(component);
+      if (!artifacts)
+        return res
+          .status(404)
+          .jsonp({ error: `no artifacts found for component ${component.id} by aspect ${aspectId}` });
+      const extensionsWithArtifacts = await Promise.all(
+        artifacts.map(async (artifact) => {
+          const files = await artifact.files.getVinylsAndImportIfMissing(component.id, this.scope.legacyScope);
+          if (!filePath) return { extensionId: artifact.task.aspectId, files };
+          return { extensionId: artifact.task.aspectId, files: files.filter((file) => file.path === filePath) };
+        })
+      );
+
+      const artifactFilesCount = extensionsWithArtifacts.reduce((accum, next) => accum + next.files.length, 0);
+
+      if (artifactFilesCount === 0)
+        return res
+          .status(404)
+          .jsonp({ error: `no artifacts found for component ${component.id} by aspect ${aspectId}` });
+
+      if (artifactFilesCount === 1) {
+        const extensionWithArtifact = extensionsWithArtifacts.find((e) => e.files.length > 0);
+        const fileName = `${extensionWithArtifact?.extensionId}_${extensionWithArtifact?.files[0].path}`;
+        const fileContent = extensionWithArtifact?.files[0].contents;
+        const fileExt = extensionWithArtifact?.files[0].extname || defaultExtension;
+        const contentType = mime.getType(fileExt);
+        res.set('Content-disposition', `attachment; filename=${fileName}`);
+        if (contentType) res.set('Content-Type', contentType);
+        return res.send(fileContent);
+      }
+
+      /**
+       * if more than 1 file requested, zip them before sending
+       */
+      const archive = archiver('tar', { gzip: true });
+
+      archive.on('warning', (warn) => {
+        this.logger.warn(warn.message);
+      });
+
+      archive.on('error', (err) => {
+        this.logger.error(err.message);
+      });
+
+      extensionsWithArtifacts.forEach((extensionWithArtifacts) => {
+        extensionWithArtifacts.files.forEach((artifact) => {
+          archive.append(artifact.contents, { name: `${extensionWithArtifacts.extensionId}_${artifact.path}` });
+        });
+      });
+
+      try {
+        archive.pipe(res);
+        /**
+         *  promise that is returned from the await zip.finalize(); is resolved before the archive is actually finalized
+         *  resolving it results in setting the headers before the stream is finished
+         */
+        // eslint-disable-next-line no-void
+        void archive.finalize();
+        return res.attachment(`${aspectId.replace('/', '_')}.tar`);
+      } catch (e: any) {
+        return res.send({ error: e.toString() });
+      }
+    },
+  ];
+}

package/dist/artifact/artifact-definition.d.ts

@@ -1,5 +1,5 @@
 import { ArtifactStorageResolver } from '..';
-export declare type ArtifactDefinition = {
+export type ArtifactDefinition = {
     /**
      * name of the artifact.
      * e.g. a project might utilize two different artifacts for the same typescript compiler, one
@@ -60,6 +60,6 @@ export declare type ArtifactDefinition = {
      */
     storageResolver?: ArtifactStorageResolver;
 };
-export declare type ArtifactModelDefinition = Omit<ArtifactDefinition, 'storageResolver'> & {
+export type ArtifactModelDefinition = Omit<ArtifactDefinition, 'storageResolver'> & {
     storageResolver?: string;
 };

package/dist/artifact/artifact-extractor.d.ts

@@ -2,17 +2,17 @@ import { ComponentMain } from '@teambit/component';
 import { ComponentID } from '@teambit/component-id';
 import { BuilderMain } from '../builder.main.runtime';
 import { ArtifactsOpts } from './artifacts.cmd';
-export declare type ExtractorResult = {
+export type ExtractorResult = {
     id: ComponentID;
     artifacts: ExtractorArtifactResult[];
 };
-export declare type ExtractorArtifactResult = {
+export type ExtractorArtifactResult = {
     artifactName: string;
     aspectId: string;
     taskName: string;
     files: string[];
 };
-export declare type ExtractorResultGrouped = {
+export type ExtractorResultGrouped = {
     id: ComponentID;
     artifacts: {
         [aspectId: string]: ExtractorArtifactResult[];

package/dist/artifact/artifact-factory.d.ts

@@ -4,7 +4,7 @@ import { ArtifactList } from './artifact-list';
 import type { BuildContext, BuildTask } from '../build-task';
 import { FsArtifact } from './fs-artifact';
 export declare const DEFAULT_CONTEXT = "component";
-export declare type ArtifactMap = ComponentMap<ArtifactList<FsArtifact>>;
+export type ArtifactMap = ComponentMap<ArtifactList<FsArtifact>>;
 export declare class ArtifactFactory {
     resolvePaths(root: string, def: ArtifactDefinition): string[];
     private getArtifactContextPath;

package/dist/artifact/artifact-factory.js

@@ -80,8 +80,7 @@ class ArtifactFactory {
   getArtifactContextPath(context, component, def) {
     const artifactContext = this.getArtifactContext(def);
     if (artifactContext === 'component') {
-      var _context$capsuleNetwo;
-      const capsulePath = (_context$capsuleNetwo = context.capsuleNetwork.graphCapsules.getCapsule(component.id)) === null || _context$capsuleNetwo === void 0 ? void 0 : _context$capsuleNetwo.path;
+      const capsulePath = context.capsuleNetwork.graphCapsules.getCapsule(component.id)?.path;
       if (!capsulePath) throw new (_exceptions().CapsuleNotFound)(component.id);
       return capsulePath;
     }