@teambit/builder 0.0.565 → 0.0.569

package/artifact/artifact-definition.ts

@@ -0,0 +1,52 @@
+export type ArtifactDefinition = {
+  /**
+   * name of the artifact.
+   * e.g. a project might utilize two different artifacts for the same typescript compiler, one
+   * that generates ES5 files and another for ES6, this prop helps to distinguish between the two.
+   */
+  name: string;
+
+  /**
+   * aspect id that created the artifact. sometimes it's not the same as the task.id.
+   * e.g. teambit.compilation/compiler executes teambit.typescript/typescript code that generates dists artifacts
+   * the generatedBy in this case is the teambit.typescript/typescript while the task.id is
+   * teambit.compilation/compiler
+   */
+  generatedBy?: string;
+
+  /**
+   * description of the artifact.
+   */
+  description?: string;
+
+  /**
+   * glob patterns of files to include upon artifact creation. minimatch is used to match the patterns.
+   * e.g. ['*.ts', '!foo.ts'] matches all ts files but ignores foo.ts.
+   */
+  globPatterns: string[];
+
+  /**
+   * define the root directory for reading the artifacts from the capsule file system.
+   * the rootDir must be unique per artifacts, otherwise we risk overriding data between artifacts.
+   */
+  rootDir?: string;
+
+  /**
+   * adds a directory prefix for all artifact files.
+   */
+  dirPrefix?: string;
+
+  /**
+   * determine the context of the artifact.
+   * default artifact context is `component`.
+   * "env" is useful when the same file is generated for all components, for example, "preview"
+   * task may create the same webpack file for all components of that env.
+   */
+  context?: 'component' | 'env';
+
+  /**
+   * storage resolver. can be used to replace where artifacts are stored.
+   * default resolver persists artifacts on scope. (not recommended for large files!)
+   */
+  storageResolver?: string;
+};

package/artifact/artifact-extractor.ts

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,5 @@
+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/builder.service.tsx

@@ -0,0 +1,163 @@
+import { EnvDefinition, EnvService, ExecutionContext } from '@teambit/envs';
+import React from 'react';
+import { ScopeMain } from '@teambit/scope';
+import { Text, Newline } from 'ink';
+import { Logger } from '@teambit/logger';
+import { IsolatorMain } from '@teambit/isolator';
+import { Component } from '@teambit/component';
+import { BuildPipe } from './build-pipe';
+import { TaskResultsList } from './task-results-list';
+import { TaskSlot } from './builder.main.runtime';
+import { BuildContext, BuildTaskHelper } from './build-task';
+import { ArtifactFactory } from './artifact';
+import { calculatePipelineOrder } from './build-pipeline-order';
+import { BuilderAspect } from './builder.aspect';
+
+export type BuildServiceResults = {
+  id: string;
+  buildResults: TaskResultsList;
+  components: Component[];
+  errors?: [];
+};
+
+export type BuilderServiceOptions = { seedersOnly?: boolean; tasks?: string[]; skipTests?: boolean };
+
+export type EnvsBuildContext = { [envId: string]: BuildContext };
+
+const pipeNames = {
+  getBuildPipe: 'build',
+  getTagPipe: 'tag',
+  getSnapPipe: 'snap',
+};
+
+type PipeName = 'build' | 'tag' | 'snap';
+
+export type BuilderDescriptor = Array<{ pipeName: PipeName; tasks: string[] }>;
+
+type PipeFunctionNames = keyof typeof pipeNames;
+export class BuilderService implements EnvService<BuildServiceResults, BuilderDescriptor> {
+  name = 'builder';
+
+  constructor(
+    /**
+     * isolator extension.
+     */
+    private isolator: IsolatorMain,
+
+    /**
+     * logger extension.
+     */
+    private logger: Logger,
+
+    /**
+     * task slot (e.g tasks registered by other extensions.).
+     */
+    private taskSlot: TaskSlot,
+
+    /**
+     * a method with such name should be implemented on the env in order to run the pipe tasks.
+     */
+    private pipeNameOnEnv: PipeFunctionNames,
+
+    /**
+     * pipe name to display on the console during the execution
+     */
+    private displayPipeName: string,
+    private artifactFactory: ArtifactFactory,
+    private scope: ScopeMain
+  ) {}
+
+  /**
+   * runs all tasks for all envs
+   */
+  async runOnce(envsExecutionContext: ExecutionContext[], options: BuilderServiceOptions): Promise<TaskResultsList> {
+    const envs = envsExecutionContext.map((executionContext) => executionContext.envDefinition);
+    const tasksQueue = calculatePipelineOrder(
+      this.taskSlot,
+      envs,
+      this.pipeNameOnEnv,
+      options.tasks,
+      options.skipTests
+    );
+    tasksQueue.validate();
+    this.logger.info(`going to run tasks in the following order:\n${tasksQueue.toString()}`);
+    const title = `running ${this.displayPipeName} pipe for ${envs.length} environments, total ${tasksQueue.length} tasks`;
+    const longProcessLogger = this.logger.createLongProcessLogger(title);
+    this.logger.consoleTitle(title);
+    const envsBuildContext: EnvsBuildContext = {};
+    await Promise.all(
+      envsExecutionContext.map(async (executionContext) => {
+        const componentIds = executionContext.components.map((component) => component.id);
+        const capsuleNetwork = await this.isolator.isolateComponents(componentIds, {
+          getExistingAsIs: true,
+          seedersOnly: options.seedersOnly,
+        });
+        this.logger.console(
+          `generated graph for env "${executionContext.id}", seeders total: ${capsuleNetwork.seedersCapsules.length}, graph total: ${capsuleNetwork.graphCapsules.length}`
+        );
+        const buildContext = Object.assign(executionContext, {
+          capsuleNetwork,
+          previousTasksResults: [],
+        });
+        envsBuildContext[executionContext.id] = buildContext;
+      })
+    );
+    const buildPipe = BuildPipe.from(tasksQueue, envsBuildContext, this.logger, this.artifactFactory);
+    const buildResults = await buildPipe.execute();
+    longProcessLogger.end();
+    buildResults.hasErrors() ? this.logger.consoleFailure() : this.logger.consoleSuccess();
+
+    return buildResults;
+  }
+
+  render(env: EnvDefinition) {
+    const pipes = this.getDescriptor(env);
+
+    return (
+      <Text key={BuilderAspect.id}>{pipes.map(({ pipeName, tasks }) => this.renderOnePipe(pipeName, tasks))}</Text>
+    );
+  }
+
+  private renderOnePipe(pipeName, tasks) {
+    if (!tasks || !tasks.length) return null;
+    return (
+      <Text key={pipeName}>
+        <Text underline color="green">
+          {pipeName} pipe
+        </Text>
+        <Newline />
+        <Text color="cyan">total {tasks.length} tasks are configured to be executed in the following order</Text>
+        <Newline />
+        {tasks.map((task, index) => (
+          <Text key={index}>
+            <Text>
+              {index + 1}. {task}
+            </Text>
+            <Newline />
+          </Text>
+        ))}
+        <Newline />
+      </Text>
+    );
+  }
+
+  getDescriptor(env: EnvDefinition) {
+    // @ts-ignore
+    const tasks = Object.keys(pipeNames).map((pipeFuncName: PipeFunctionNames) => {
+      const tasksQueue = this.getTasksNamesByPipeFunc(env, pipeFuncName);
+      return { pipeName: pipeNames[pipeFuncName], tasks: tasksQueue };
+    });
+    return tasks as BuilderDescriptor;
+  }
+
+  private getTasksNamesByPipeFunc(env: EnvDefinition, pipeFuncName: PipeFunctionNames): string[] {
+    const tasksQueue = calculatePipelineOrder(this.taskSlot, [env], pipeFuncName).map(({ task }) =>
+      BuildTaskHelper.serializeId(task)
+    );
+    return tasksQueue;
+  }
+
+  getCurrentPipeTasks(env: EnvDefinition) {
+    return this.getTasksNamesByPipeFunc(env, this.pipeNameOnEnv);
+  }
+}

package/exceptions/artifact-storage-error.ts

@@ -0,0 +1,7 @@
+import { Component } from '@teambit/component';
+
+export class ArtifactStorageError extends Error {
+  constructor(private originalError: Error, private component: Component) {
+    super(`failed to store artifacts for component ${component.id.toString()}`);
+  }
+}

package/exceptions/capsule-not-found.ts

@@ -0,0 +1,7 @@
+import { ComponentID } from '@teambit/component';
+
+export class CapsuleNotFound extends Error {
+  constructor(private id: ComponentID) {
+    super(`unable to find capsule for component ${id.toString()}`);
+  }
+}

package/exceptions/index.ts

@@ -0,0 +1,3 @@
+export { InvalidTask } from './invalid-task';
+export { CapsuleNotFound } from './capsule-not-found';
+export { ArtifactStorageError } from './artifact-storage-error';

package/exceptions/invalid-task.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+
+export class InvalidTask extends BitError {
+  constructor(readonly taskAspectId: string, reason: string) {
+    super(`task of ${taskAspectId} is invalid, ${reason}`);
+  }
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/builder",
-  "version": "0.0.565",
+  "version": "0.0.569",
   "homepage": "https://bit.dev/teambit/pipelines/builder",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.pipelines",
     "name": "builder",
-    "version": "0.0.565"
+    "version": "0.0.569"
   },
   "dependencies": {
     "p-map-series": "2.1.0",
@@ -22,18 +22,18 @@
     "globby": "11.0.1",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/component": "0.0.565",
-    "@teambit/envs": "0.0.565",
-    "@teambit/logger": "0.0.477",
-    "@teambit/tester": "0.0.565",
-    "@teambit/isolator": "0.0.565",
-    "@teambit/cli": "0.0.392",
-    "@teambit/workspace": "0.0.565",
-    "@teambit/aspect-loader": "0.0.565",
-    "@teambit/graphql": "0.0.565",
-    "@teambit/scope": "0.0.565",
-    "@teambit/bit-error": "0.0.378",
-    "@teambit/component-id": "0.0.382"
+    "@teambit/component": "0.0.569",
+    "@teambit/envs": "0.0.569",
+    "@teambit/logger": "0.0.481",
+    "@teambit/tester": "0.0.569",
+    "@teambit/isolator": "0.0.569",
+    "@teambit/cli": "0.0.395",
+    "@teambit/workspace": "0.0.569",
+    "@teambit/aspect-loader": "0.0.569",
+    "@teambit/graphql": "0.0.569",
+    "@teambit/scope": "0.0.569",
+    "@teambit/bit-error": "0.0.381",
+    "@teambit/component-id": "0.0.385"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
@@ -45,10 +45,10 @@
     "@types/jest": "^26.0.0",
     "@types/react-dom": "^17.0.5",
     "@types/node": "12.20.4",
-    "@teambit/pipelines.aspect-docs.builder": "0.0.111"
+    "@teambit/pipelines.aspect-docs.builder": "0.0.115"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.178",
+    "@teambit/legacy": "1.0.181",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -76,27 +76,12 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.178",
+        "@teambit/legacy": "1.0.181",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
-  "files": [
-    "dist",
-    "!dist/tsconfig.tsbuildinfo",
-    "**/*.md",
-    "**/*.mdx",
-    "**/*.js",
-    "**/*.json",
-    "**/*.sass",
-    "**/*.scss",
-    "**/*.less",
-    "**/*.css",
-    "**/*.css",
-    "**/*.jpeg",
-    "**/*.gif"
-  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/pipeline/index.ts

@@ -0,0 +1 @@
+export { PipelineResults } from './pipeline-results';

package/pipeline/pipeline-results.ts

@@ -0,0 +1 @@
+export class PipelineResults {}

package/storage/default-resolver.ts

@@ -0,0 +1,13 @@
+import { Component } from '@teambit/component';
+import { StorageResolver } from './storage-resolver';
+import type { ArtifactList } from '../artifact';
+
+export class DefaultResolver implements StorageResolver {
+  name = 'default';
+
+  async store(component: Component, artifactList: ArtifactList) {
+    artifactList.artifacts.forEach((artifact) => {
+      artifact.files.populateVinylsFromPaths(artifact.rootDir);
+    });
+  }
+}

package/storage/index.ts

@@ -0,0 +1,2 @@
+export { StorageResolver } from './storage-resolver';
+export { DefaultResolver } from './default-resolver';

package/storage/s3-resolver.ts

@@ -0,0 +1,40 @@
+// import { S3 } from 'aws-sdk';
+// import { Component, ComponentID } from '@teambit/component';
+// import { StorageResolver } from './storage-resolver';
+// import type { ArtifactList } from '../artifact';
+
+// export class S3Resolver implements StorageResolver {
+//   name = 's3';
+//   // todo artifact map
+//   async store(component: Component, artifacts: ArtifactList) {
+//     // https://staoge.com/{compId}/aspectId/${path}
+//     const artifactsByTaskId = artifacts.groupByTaskId();
+//     const files = Object.entries(artifactsByTaskId).map(([taskId, artifact]) => {
+//       return artifact.paths.map((path) => this.buildKey(component.id, taskId, path));
+//     });
+//     // files file to upload
+//   }
+
+//   private buildKey(id: ComponentID, taskId: string, path: string) {
+//     return id.fullName;
+//   }
+
+//   private upload(key: string, body: string) {
+//     const s3 = this.getS3Client();
+//     s3.upload({
+//       Bucket: 'storage',
+//       Key: key,
+//       Body: body,
+//     });
+//   }
+
+//   private getS3Client() {
+//     //TODO: need to pass bithub token
+//     const s3 = new S3({
+//       accessKeyId: 'bit',
+//       secretAccessKey: process.env.BIT_DEV_TOKEN,
+//       endpoint: 'http://bit.test:5003',
+//     });
+//     return s3;
+//   }
+// }

package/storage/storage-resolver.ts

@@ -0,0 +1,18 @@
+import { Component } from '@teambit/component';
+import { ArtifactList } from '../artifact';
+
+export type StoreResult = {
+  [path: string]: string;
+};
+
+export interface StorageResolver {
+  /**
+   * name of the storage resolver.
+   */
+  name: string;
+
+  /**
+   * store artifacts in the storage.
+   */
+  store(component: Component, artifacts: ArtifactList): Promise<void>;
+}

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  const src: string;
+  export default src;
+}
+
+// @TODO Gilad
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}