@teambit/builder 1.0.108 → 1.0.110

package/build-pipeline-result-list.ts

@@ -1,97 +0,0 @@
-import { ComponentID, ComponentMap, Component } from '@teambit/component';
-import { isEmpty, compact } from 'lodash';
-import type { ArtifactObject } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import { Artifact, ArtifactList } from './artifact';
-import { TaskResults } from './build-pipe';
-import { TaskMetadata } from './types';
-
-export type PipelineReport = {
-  taskId: string; // task aspect-id
-  taskName: string;
-  taskDescription?: string;
-  startTime?: number;
-  endTime?: number;
-  errors?: Array<Error | string>;
-  warnings?: string[];
-};
-
-export type AspectData = {
-  aspectId: string;
-  data: TaskMetadata;
-};
-
-/**
- * Helper to get the data and artifacts from the TasksResultsList before saving during the tag
- */
-export class BuildPipelineResultList {
-  private artifactListsMap: ComponentMap<ArtifactList<Artifact>>;
-  constructor(private tasksResults: TaskResults[], private components: Component[]) {
-    this.artifactListsMap = this.getFlattenedArtifactListsMapFromAllTasks();
-  }
-
-  private getFlattenedArtifactListsMapFromAllTasks(): ComponentMap<ArtifactList<Artifact>> {
-    const artifactListsMaps = this.tasksResults.flatMap((t) => (t.artifacts ? [t.artifacts] : []));
-    return ComponentMap.as<ArtifactList<Artifact>>(this.components, (component) => {
-      const artifacts: Artifact[] = [];
-      artifactListsMaps.forEach((artifactListMap) => {
-        const artifactList = artifactListMap.getValueByComponentId(component.id);
-        if (artifactList) artifacts.push(...artifactList);
-      });
-      return ArtifactList.fromArray(artifacts);
-    });
-  }
-
-  public getMetadataFromTaskResults(componentId: ComponentID): { [taskId: string]: TaskMetadata } {
-    const compResults = this.tasksResults.reduce((acc, current: TaskResults) => {
-      const foundComponent = current.componentsResults.find((c) => c.component.id.isEqual(componentId));
-      const taskId = current.task.aspectId;
-      if (foundComponent && foundComponent.metadata) {
-        acc[taskId] = this.mergeDataIfPossible(foundComponent.metadata, acc[taskId], taskId);
-      }
-      return acc;
-    }, {});
-    return compResults;
-  }
-
-  public getPipelineReportOfComponent(componentId: ComponentID): PipelineReport[] {
-    const compResults = this.tasksResults.map((taskResults: TaskResults) => {
-      const foundComponent = taskResults.componentsResults.find((c) => c.component.id.isEqual(componentId));
-      if (!foundComponent) return null;
-      const pipelineReport: PipelineReport = {
-        taskId: taskResults.task.aspectId,
-        taskName: taskResults.task.name,
-        taskDescription: taskResults.task.description,
-        errors: foundComponent.errors,
-        warnings: foundComponent.warnings,
-        startTime: foundComponent.startTime,
-        endTime: foundComponent.endTime,
-      };
-      return pipelineReport;
-    });
-    return compact(compResults);
-  }
-
-  public getDataOfComponent(componentId: ComponentID): AspectData[] {
-    const tasksData = this.getMetadataFromTaskResults(componentId);
-    return Object.keys(tasksData).map((taskId) => ({
-      aspectId: taskId,
-      data: tasksData[taskId],
-    }));
-  }
-
-  public getArtifactsDataOfComponent(componentId: ComponentID): ArtifactObject[] | undefined {
-    return this.artifactListsMap.getValueByComponentId(componentId)?.toObject();
-  }
-
-  private mergeDataIfPossible(currentData: TaskMetadata, existingData: TaskMetadata | undefined, taskId: string) {
-    if (!existingData || isEmpty(existingData)) return currentData;
-    // both exist
-    if (typeof currentData !== 'object') {
-      throw new Error(`task data must be "object", get ${typeof currentData} for ${taskId}`);
-    }
-    if (Array.isArray(currentData)) {
-      throw new Error(`task data must be "object", get Array for ${taskId}`);
-    }
-    return { ...currentData, ...existingData };
-  }
-}

package/build-task.ts

@@ -1,151 +0,0 @@
-import type { Component } from '@teambit/component';
-import { LaneId } from '@teambit/lane-id';
-import { ExecutionContext } from '@teambit/envs';
-import type { Network } from '@teambit/isolator';
-import type { ComponentResult } from './types';
-import type { ArtifactDefinition } from './artifact';
-import { TaskResultsList } from './task-results-list';
-import { TaskResults } from './build-pipe';
-import { PipeName } from './builder.service';
-
-export type TaskLocation = 'start' | 'end';
-
-/**
- * delimiter between task.aspectId and task.name
- */
-export const TaskIdDelimiter = ':';
-
-/**
- * A folder to write artifacts generated during a build task
- * This folder is used in the core envs and excluded by default from the package tar file (the core envs is writing this into the npmignore file)
- */
-export const CAPSULE_ARTIFACTS_DIR = 'artifacts';
-
-export interface BuildContext extends ExecutionContext {
-  /**
-   * all components about to be built/tagged.
-   */
-  components: Component[];
-
-  /**
-   * network of capsules ready to be built.
-   */
-  capsuleNetwork: Network;
-
-  /**
-   * data generated by tasks that were running before this task
-   */
-  previousTasksResults: TaskResults[];
-
-  /**
-   * Run the build pipeline in dev mode
-   */
-  dev?: boolean;
-
-  /**
-   * pipe name such as "build", "tas", "snap".
-   * an example usage is "deploy" task which is running in snap and tag pipeline and has different needs in each one.
-   */
-  pipeName: PipeName;
-
-  /**
-   * current lane-id if exists. empty when on main.
-   */
-  laneId?: LaneId;
-}
-
-export interface TaskDescriptor {
-  aspectId: string;
-  name?: string;
-  description?: string;
-}
-
-export interface BuildTask {
-  /**
-   * aspect id serialized of the creator of the task.
-   * todo: automate this so then it won't be needed to pass manually.
-   */
-  aspectId: string;
-
-  /**
-   * name of the task. function as an identifier among other tasks of the same aspectId.
-   * spaces and special characters are not allowed. as a convention, use UpperCamelCase style.
-   * (e.g. TypescriptCompiler).
-   */
-  name: string;
-
-  /**
-   * description of what the task does.
-   * if available, the logger will log it show it in the status-line.
-   */
-  description?: string;
-
-  /**
-   * where to put the task, before the env pipeline or after
-   */
-  location?: TaskLocation;
-
-  /**
-   * execute a task in a build context
-   */
-  execute(context: BuildContext): Promise<BuiltTaskResult>;
-
-  /**
-   * run before the build pipeline has started. this is useful when some preparation are needed to
-   * be done on all envs before the build starts.
-   * e.g. typescript compiler needs to write the tsconfig file. doing it during the task, will
-   * cause dependencies from other envs to get this tsconfig written.
-   */
-  preBuild?(context: BuildContext): Promise<void>;
-
-  /**
-   * run after the build pipeline completed for all envs. useful for doing some cleanup on the
-   * capsules before the deployment starts.
-   */
-  postBuild?(context: BuildContext, tasksResults: TaskResultsList): Promise<void>;
-
-  /**
-   * needed if you want the task to be running only after the dependencies were completed
-   * for *all* envs.
-   * normally this is not needed because the build-pipeline runs the tasks in the same order
-   * they're located in the `getBuildPipe()` array and according to the task.location.
-   * the case where this is useful is when a task not only needs to be after another task, but also
-   * after all environments were running that task.
-   * a dependency is task.aspectId. if an aspect has multiple tasks, to be more specific, use
-   * "aspectId:name", e.g. "teambit.compilation/compiler:TypescriptCompiler".
-   */
-  dependencies?: string[];
-}
-
-// TODO: rename to BuildTaskResults
-export interface BuiltTaskResult {
-  /**
-   * build results for each of the components in the build context.
-   */
-  componentsResults: ComponentResult[];
-
-  /**
-   * array of artifact definitions to generate after a successful build.
-   */
-  artifacts?: ArtifactDefinition[];
-}
-
-export class BuildTaskHelper {
-  static serializeId({ aspectId, name }: { aspectId: string; name: string }): string {
-    return aspectId + TaskIdDelimiter + name;
-  }
-  static deserializeId(id: string): { aspectId: string; name: string } {
-    const split = id.split(TaskIdDelimiter);
-    if (split.length === 0) throw new Error(`deserializeId, ${id} is empty`);
-    if (split.length === 1) throw new Error(`deserializeId, ${id} has only aspect-id without name`);
-    if (split.length === 2) return { aspectId: split[0], name: split[1] };
-    throw new Error(`deserializeId, id ${id} has more than one ${TaskIdDelimiter}`);
-  }
-  /**
-   * don't throw an error when the id includes only the aspect-id without the task name.
-   * useful for task dependencies, when it's allowed to specify the aspect-id only.
-   */
-  static deserializeIdAllowEmptyName(id: string): { aspectId: string; name?: string } {
-    return id.includes(TaskIdDelimiter) ? BuildTaskHelper.deserializeId(id) : { aspectId: id, name: undefined };
-  }
-}

package/build.cmd.ts

@@ -1,157 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import { Logger } from '@teambit/logger';
-import prettyTime from 'pretty-time';
-import { OutsideWorkspaceError, Workspace } from '@teambit/workspace';
-import { COMPONENT_PATTERN_HELP } from '@teambit/legacy/dist/constants';
-import chalk from 'chalk';
-import { BuilderMain } from './builder.main.runtime';
-
-type BuildOpts = {
-  all: boolean; // deprecated. use unmodified
-  unmodified?: boolean;
-  dev: boolean;
-  rebuild: boolean;
-  install: boolean;
-  cachePackagesOnCapsulesRoot: boolean;
-  reuseCapsules: boolean;
-  tasks: string;
-  listTasks?: string;
-  skipTests?: boolean;
-  failFast?: boolean;
-  includeSnap?: boolean;
-  includeTag?: boolean;
-};
-
-export class BuilderCmd implements Command {
-  name = 'build [component-pattern]';
-  description = 'run set of tasks for build.';
-  extendedDescription = 'by default, only new and modified components are built';
-  arguments = [{ name: 'component-pattern', description: COMPONENT_PATTERN_HELP }];
-  helpUrl = 'reference/build-pipeline/builder-overview';
-  alias = '';
-  group = 'development';
-  options = [
-    ['a', 'all', 'DEPRECATED. use --unmodified'],
-    ['u', 'unmodified', 'include unmodified components (by default, only new and modified components are built)'],
-    ['d', 'dev', 'run the pipeline in dev mode'],
-    ['', 'install', 'install core aspects in capsules'],
-    ['', 'reuse-capsules', 'avoid deleting the capsules root-dir before starting the build'],
-    [
-      '',
-      'tasks <string>',
-      `build the specified task(s) only. for multiple tasks, separate by a comma and wrap with quotes.
-specify the task-name (e.g. "TypescriptCompiler") or the task-aspect-id (e.g. teambit.compilation/compiler)`,
-    ],
-    ['', 'cache-packages-on-capsule-root', 'set the package-manager cache on the capsule root'],
-    [
-      '',
-      'list-tasks <string>',
-      'list tasks of an env or a component-id for each one of the pipelines: build, tag and snap',
-    ],
-    ['', 'skip-tests', 'skip running component tests during build process'],
-    [
-      '',
-      'fail-fast',
-      'stop pipeline execution on the first failed task (by default a task is skipped only when its dependency failed)',
-    ],
-    [
-      '',
-      'include-snap',
-      'EXPERIMENTAL. include snap pipeline tasks. Warning: this may deploy/publish if you have such tasks',
-    ],
-    [
-      '',
-      'include-tag',
-      'EXPERIMENTAL. include tag pipeline tasks. Warning: this may deploy/publish if you have such tasks',
-    ],
-  ] as CommandOptions;
-
-  constructor(private builder: BuilderMain, private workspace: Workspace, private logger: Logger) {}
-
-  async report(
-    [pattern]: [string],
-    {
-      all = false,
-      unmodified = false,
-      dev = false,
-      install = false,
-      cachePackagesOnCapsulesRoot = false,
-      reuseCapsules = false,
-      tasks,
-      listTasks,
-      skipTests,
-      failFast,
-      includeSnap,
-      includeTag,
-    }: BuildOpts
-  ): Promise<string> {
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    if (all) {
-      this.logger.consoleWarning(`--all is deprecated, please use --unmodified instead`);
-      unmodified = true;
-    }
-    if (listTasks) {
-      return this.getListTasks(listTasks);
-    }
-
-    this.logger.setStatusLine('build');
-    const start = process.hrtime();
-    const components = await this.workspace.getComponentsByUserInput(unmodified, pattern, true);
-    if (!components.length) {
-      return chalk.bold(
-        `no components found to build. use "--unmodified" flag to build all components or specify the ids to build, otherwise, only new and modified components will be built`
-      );
-    }
-
-    const envsExecutionResults = await this.builder.build(
-      components,
-      {
-        installOptions: {
-          installTeambitBit: install,
-          packageManagerConfigRootDir: this.workspace.path,
-        },
-        linkingOptions: { linkTeambitBit: !install },
-        emptyRootDir: !reuseCapsules,
-        getExistingAsIs: reuseCapsules,
-        cachePackagesOnCapsulesRoot,
-      },
-      {
-        dev,
-        tasks: tasks ? tasks.split(',').map((task) => task.trim()) : [],
-        skipTests,
-        exitOnFirstFailedTask: failFast,
-      },
-      {
-        includeSnap,
-        includeTag,
-      }
-    );
-    this.logger.console(`build output can be found in path: ${envsExecutionResults.capsuleRootDir}`);
-    const duration = prettyTime(process.hrtime(start));
-    const succeedOrFailed = envsExecutionResults.hasErrors() ? 'failed' : 'succeeded';
-    const msg = `build ${succeedOrFailed}. completed in ${duration}.`;
-    if (envsExecutionResults.hasErrors()) {
-      this.logger.consoleFailure(msg);
-    }
-    envsExecutionResults.throwErrorsIfExist();
-    return chalk.green(msg);
-  }
-
-  private async getListTasks(componentIdStr: string): Promise<string> {
-    const compId = await this.workspace.resolveComponentId(componentIdStr);
-    const component = await this.workspace.get(compId);
-    const results = this.builder.listTasks(component);
-    return `${chalk.green('Task List')}
-id:    ${results.id.toString()}
-envId: ${results.envId}
-
-${chalk.bold('Build Pipeline Tasks:')}
-${results.buildTasks.join('\n')}
-
-${chalk.bold('Tag Pipeline Tasks:')}
-${results.tagTasks.join('\n')}
-
-${chalk.bold('Snap Pipeline Tasks:')}
-${results.snapTasks.join('\n') || '<N/A>'}`;
-  }
-}

package/builder-env-type.ts

@@ -1,16 +0,0 @@
-import { Pipeline } from './pipeline';
-
-export interface BuilderEnv {
-  /**
-   * return a build pipeline instance.
-   */
-  build(): Pipeline;
-  /**
-   * return a snap pipeline instance.
-   */
-  snap(): Pipeline;
-  /**
-   * return a tag pipeline instance.
-   */
-  tag(): Pipeline;
-}

package/builder.aspect.ts

@@ -1,5 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const BuilderAspect = Aspect.create({
-  id: 'teambit.pipelines/builder',
-});

package/builder.graphql.ts

@@ -1,185 +0,0 @@
-import { Component, ComponentID } from '@teambit/component';
-import gql from 'graphql-tag';
-import { Logger } from '@teambit/logger';
-import isBinaryPath from 'is-binary-path';
-import { BuilderMain } from './builder.main.runtime';
-import { PipelineReport } from './build-pipeline-result-list';
-
-type ArtifactGQLFile = {
-  /**
-   * same as the path - used for GQL caching
-   */
-  id: string;
-  /**
-   * name of the artifact file
-   */
-  name: string;
-  /**
-   * path of the artifact file
-   */
-  path: string;
-  /**
-   * artifact file content (only for text files). Use /api/<component-id>/~aspect/builder/<extension-id>/~<path> to fetch binary file data
-   */
-  content?: string;
-  /**
-   * REST endpoint to fetch artifact data from. /api/<component-id>/~aspect/builder/<extension-id>/~<pat
-   */
-  downloadUrl?: string;
-  /**
-   * Remote storage url to resolve artifact file from
-   */
-  externalUrl?: string;
-  /**
-   * Size in bytes
-   */
-  size: number;
-};
-
-type ArtifactGQLData = {
-  name: string;
-  description?: string;
-  storage?: string;
-  generatedBy: string;
-  files: ArtifactGQLFile[];
-};
-type TaskReport = PipelineReport & {
-  artifact?: ArtifactGQLData;
-  componentId: ComponentID;
-};
-
-export function builderSchema(builder: BuilderMain, logger: Logger) {
-  return {
-    typeDefs: gql`
-      type TaskReport {
-        # for GQL caching - taskId + taskName
-        id: String!
-        taskId: String!
-        taskName: String!
-        description: String
-        startTime: String
-        endTime: String
-        errors: [String!]
-        warnings: [String!]
-        artifact(path: String): Artifact
-      }
-
-      type ArtifactFile {
-        # for GQL caching - same as the path
-        id: String!
-        # name of the artifact file
-        name: String
-        # path of the artifact file
-        path: String!
-        # artifact file content (only for text files). Use /api/<component-id>/~aspect/builder/<extension-id>/~<path> to fetch binary file data
-        content: String
-        # REST endpoint to fetch artifact data from. /api/<component-id>/~aspect/builder/<extension-id>/~<path>
-        downloadUrl: String
-        # Remote storage url to resolve artifact file from
-        externalUrl: String
-        # size in bytes
-        size: Int!
-      }
-
-      type Artifact {
-        # for GQL caching -  PipelineId + Artifact Name
-        id: String!
-        # artifact name
-        name: String!
-        description: String
-        storage: String
-        generatedBy: String
-        files: [ArtifactFile!]!
-      }
-
-      extend type Component {
-        pipelineReport(taskId: String): [TaskReport!]!
-      }
-    `,
-
-    resolvers: {
-      Component: {
-        pipelineReport: async (component: Component, { taskId }: { taskId?: string }) => {
-          try {
-            const builderData = builder.getBuilderData(component);
-            const pipeline = builderData?.pipeline || [];
-            const artifacts = taskId
-              ? builder.getArtifactsByAspect(component, taskId)
-              : builder.getArtifacts(component);
-            const artifactsWithVinyl = await Promise.all(
-              artifacts.map(async (artifact) => {
-                const id = artifact.task.aspectId;
-                const name = artifact.task.name as string;
-                try {
-                  const artifactFiles = (await builder.getArtifactsVinylByAspectAndTaskName(component, id, name)).map(
-                    (vinyl) => {
-                      const { basename, path, contents } = vinyl || {};
-                      const isBinary = path && isBinaryPath(path);
-                      const content = !isBinary ? contents?.toString('utf-8') : undefined;
-                      const size = contents.byteLength;
-                      const downloadUrl = encodeURI(
-                        builder.getDownloadUrlForArtifact(component.id, artifact.task.aspectId, path)
-                      );
-                      const externalUrl = vinyl.url;
-                      return { id: path, name: basename, path, content, downloadUrl, externalUrl, size };
-                    }
-                  );
-                  return {
-                    id: `${id}-${name}-${artifact.name}`,
-                    name: artifact.name,
-                    description: artifact.description,
-                    task: artifact.task,
-                    storage: artifact.storage,
-                    generatedBy: artifact.generatedBy,
-                    files: artifactFiles,
-                  };
-                } catch (e: any) {
-                  logger.error(e.toString());
-                  return {
-                    id: `${id}-${name}-${artifact.name}`,
-                    name: artifact.name,
-                    description: artifact.description,
-                    task: artifact.task,
-                    storage: artifact.storage,
-                    generatedBy: artifact.generatedBy,
-                    files: [],
-                  };
-                }
-              })
-            );
-
-            const result = pipeline
-              .filter((task) => !taskId || task.taskId === taskId)
-              .map((task) => ({
-                ...task,
-                id: `filter-${taskId || ''}`,
-                artifact: artifactsWithVinyl.find(
-                  (data) => data.task.aspectId === task.taskId && data.task.name === task.taskName
-                ),
-              }));
-
-            return result;
-          } catch (e: any) {
-            logger.error(e.toString());
-            return [];
-          }
-        },
-      },
-      TaskReport: {
-        id: (taskReport: TaskReport & { id?: string }) =>
-          `${(taskReport.id && `${taskReport.id}-`) || ''}${taskReport.taskId}-${taskReport.taskName}`,
-        description: (taskReport: TaskReport) => taskReport.taskDescription,
-        errors: (taskReport: TaskReport) => taskReport.errors?.map((e) => e.toString()) || [],
-        warnings: (taskReport: TaskReport) => taskReport.warnings || [],
-        artifact: async (taskReport: TaskReport, { path: pathFilter }: { path?: string }) => {
-          if (!taskReport.artifact) return undefined;
-          return {
-            id: `${taskReport.taskId}-${taskReport.taskName}-${taskReport.artifact?.name}-${pathFilter || ''}`,
-            ...taskReport.artifact,
-            files: taskReport.artifact.files.filter((file) => !pathFilter || file.path === pathFilter),
-          };
-        },
-      },
-    },
-  };
-}