@teambit/builder 0.0.551 → 0.0.556

package/build-pipeline-order.ts

@@ -1,197 +0,0 @@
-import { Graph } from 'cleargraph';
-import TesterAspect from '@teambit/tester';
-import { EnvDefinition, Environment } from '@teambit/envs';
-import { BuildTask, BuildTaskHelper } from './build-task';
-import type { TaskSlot } from './builder.main.runtime';
-import { TasksQueue } from './tasks-queue';
-
-type TaskDependenciesGraph = Graph<string, string>;
-type Location = 'start' | 'middle' | 'end';
-type TasksLocationGraph = { location: Location; graph: TaskDependenciesGraph };
-type PipelineEnv = { env: EnvDefinition; pipeline: BuildTask[] };
-type DataPerLocation = { location: Location; graph: TaskDependenciesGraph; pipelineEnvs: PipelineEnv[] };
-
-/**
- * there are two ways how to add tasks to build pipeline.
- * 1. `getBuildPipe()` method of the env.
- * 2. registering to the `builder.registerBuildTask()`.
- *
- * in the option #1, it's possible to determine the order. e.g. `getBuildPipe() { return [taskA, taskB, taskC]; }`
- * in the option #2, the register happens once the extension is loaded, so there is no way to put
- * one task before/after another task.
- *
- * To be able to determine the order, you can do the following
- * 1. "task.location", it has two options "start" and "end". the rest are "middle".
- * 2. "task.dependencies", the dependencies must be completed for all envs before this task starts.
- * the dependencies are applicable inside a location and not across locations. see getLocation()
- * or/and continue reading for more info about this.
- *
- * to determine the final order of the tasks, the following is done:
- * 1. split all tasks to three groups: start, middle and end.
- * 2. for each group define a dependencies graph for the tasks with "dependencies" prop and the pipeline.
- * 3. start with the first group "start", toposort the dependencies graph and push the found tasks
- * to a queue. once completed, iterate the pipeline and add all tasks to the queue.
- * 4. do the same for the "middle" and "end" groups.
- *
- * the reason for splitting the tasks to the three groups and not using the "dependencies" field
- * alone to determine the order is that the "start" and "end" groups are mostly core and "middle"
- * is mostly the user entering tasks to the pipeline and we as the core don't know about the users
- * tasks. For example, a core task "PublishComponent" must happen after the compiler, however, a
- * user might have an env without a compiler. if we determine the order only by the dependencies
- * field, the "PublishComponent" would have a dependency "compiler" and because in this case there
- * is no compiler task, it would throw an error about missing dependencies.
- */
-export function calculatePipelineOrder(
-  taskSlot: TaskSlot,
-  envs: EnvDefinition[],
-  pipeNameOnEnv = 'getBuildPipe',
-  tasks: string[] = [],
-  skipTests = false
-): TasksQueue {
-  const graphs: TasksLocationGraph[] = [];
-  const locations: Location[] = ['start', 'middle', 'end']; // the order is important here!
-  locations.forEach((location) => {
-    graphs.push({ location, graph: new Graph<string, string>() });
-  });
-  const pipelineEnvs: PipelineEnv[] = [];
-  envs.forEach((envDefinition) => {
-    if (envDefinition.env.getPipe) {
-      // @todo: remove once this confusion is over
-      throw new Error(
-        `Fatal: a breaking API has introduced. Please change "getPipe()" method on "${envDefinition.id}" to "getBuildPipe()"`
-      );
-    }
-    const pipeline = getPipelineForEnv(taskSlot, envDefinition.env, pipeNameOnEnv);
-    pipelineEnvs.push({ env: envDefinition, pipeline });
-  });
-
-  const flattenedPipeline: BuildTask[] = pipelineEnvs.map((pipelineEnv) => pipelineEnv.pipeline).flat();
-  flattenedPipeline.forEach((task) => addDependenciesToGraph(graphs, flattenedPipeline, task));
-
-  const dataPerLocation: DataPerLocation[] = graphs.map(({ location, graph }) => {
-    const pipelineEnvsPerLocation: PipelineEnv[] = pipelineEnvs.map(({ env, pipeline }) => {
-      return { env, pipeline: pipeline.filter((task) => (task.location || 'middle') === location) };
-    });
-    return { location, graph, pipelineEnvs: pipelineEnvsPerLocation };
-  });
-
-  const tasksQueue = new TasksQueue();
-  locations.forEach((location) => addTasksToGraph(tasksQueue, dataPerLocation, location));
-  if (tasks.length) {
-    return new TasksQueue(
-      ...tasksQueue.filter(({ task }) => tasks.includes(task.name) || tasks.includes(task.aspectId))
-    );
-  }
-  if (skipTests) {
-    return new TasksQueue(...tasksQueue.filter(({ task }) => task.aspectId !== TesterAspect.id));
-  }
-  return tasksQueue;
-}
-
-function addTasksToGraph(tasksQueue: TasksQueue, dataPerLocation: DataPerLocation[], location: Location) {
-  const data = dataPerLocation.find((d) => d.location === location);
-  if (!data) return;
-  const sorted = data.graph.toposort();
-  sorted.forEach((taskNode) => {
-    const { aspectId, name } = BuildTaskHelper.deserializeId(taskNode.attr);
-    data.pipelineEnvs.forEach(({ env, pipeline }) => {
-      const taskIndex = pipeline.findIndex(
-        (pipelineTask) => pipelineTask.aspectId === aspectId && pipelineTask.name === name
-      );
-      if (taskIndex < 0) return;
-      const task = pipeline[taskIndex];
-      tasksQueue.push({ env, task });
-      pipeline.splice(taskIndex, 1); // delete the task from the pipeline
-    });
-  });
-  data.pipelineEnvs.forEach(({ env, pipeline }) => {
-    pipeline.forEach((task) => tasksQueue.push({ env, task }));
-  });
-}
-
-function addDependenciesToGraph(graphs: TasksLocationGraph[], pipeline: BuildTask[], task: BuildTask) {
-  if (!task.dependencies || !task.dependencies.length) return;
-  const taskId = BuildTaskHelper.serializeId(task);
-  task.dependencies.forEach((dependency) => {
-    const { aspectId, name } = BuildTaskHelper.deserializeId(dependency);
-    const dependencyTasks = pipeline.filter((pipelineTask) => {
-      if (pipelineTask.aspectId !== aspectId) return false;
-      return name ? name === pipelineTask.name : true;
-    });
-    if (dependencyTasks.length === 0) {
-      throw new Error(
-        `unable to find dependency "${dependency}" of "${BuildTaskHelper.serializeId(task)}" in the pipeline`
-      );
-    }
-    dependencyTasks.forEach((dependencyTask) => {
-      const location = getLocation(task, dependencyTask);
-      if (!location) {
-        // the dependency is behind and will be in the correct order regardless the graph.
-        return;
-      }
-      const graphLocation = graphs.find((g) => g.location === location);
-      if (!graphLocation) throw new Error(`unable to find graph for location ${location}`);
-      const dependencyId = BuildTaskHelper.serializeId(dependencyTask);
-      const graph = graphLocation.graph;
-      graph.setNode(taskId, taskId);
-      graph.setNode(dependencyId, dependencyId);
-      graph.setEdge(dependencyId, taskId, 'dependency');
-    });
-  });
-}
-
-/**
- * since the task execution is happening per group: "start", "middle" and "end", the dependencies
- * need to be inside the same group.
- * e.g. if a dependency located at "end" group and the task located at "start", it's impossible to
- * complete the dependency before the task, there it throws an error.
- * it's ok to have the dependency located earlier, e.g. "start" and the task at "end", and in this
- * case, it will not be part of the graph because there is no need to do any special calculation.
- */
-function getLocation(task: BuildTask, dependencyTask: BuildTask): Location | null {
-  const taskLocation = task.location || 'middle';
-  const dependencyLocation = dependencyTask.location || 'middle';
-
-  const isDependencyAhead =
-    (taskLocation === 'start' && dependencyLocation !== 'start') ||
-    (taskLocation === 'middle' && dependencyLocation === 'end');
-
-  const isDependencyEqual = taskLocation === dependencyLocation;
-
-  if (isDependencyAhead) {
-    throw new Error(`a task "${BuildTaskHelper.serializeId(task)}" located at ${taskLocation}
-has a dependency "${BuildTaskHelper.serializeId(dependencyTask)} located at ${dependencyLocation},
-which is invalid. the dependency must be located earlier or in the same location as the task"`);
-  }
-
-  if (isDependencyEqual) {
-    return taskLocation;
-  }
-
-  // dependency is behind. e.g. task is "end" and dependency is "start". no need to enter to the
-  // graph as it's going to be executed in the right order regardless the graph.
-  return null;
-}
-
-function getPipelineForEnv(taskSlot: TaskSlot, env: Environment, pipeNameOnEnv: string): BuildTask[] {
-  const buildTasks: BuildTask[] = env[pipeNameOnEnv] ? env[pipeNameOnEnv]() : [];
-  const slotsTasks = taskSlot.values().flat();
-  const tasksAtStart: BuildTask[] = [];
-  const tasksAtEnd: BuildTask[] = [];
-  slotsTasks.forEach((task) => {
-    if (task.location === 'start') {
-      tasksAtStart.push(task);
-      return;
-    }
-    if (task.location === 'end') {
-      tasksAtEnd.push(task);
-      return;
-    }
-    tasksAtStart.push(task);
-  });
-
-  // merge with extension registered tasks.
-  const mergedTasks = [...tasksAtStart, ...buildTasks, ...tasksAtEnd];
-
-  return mergedTasks;
-}

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 { Serializable, TaskMetadata } from './types';
-
-export type PipelineReport = {
-  taskId: string;
-  taskName?: string;
-  taskDescription?: string;
-  startTime?: number;
-  endTime?: number;
-  errors?: Array<Error | string>;
-  warnings?: string[];
-};
-
-export type AspectData = {
-  aspectId: string;
-  data: Serializable;
-};
-
-/**
- * Helper to get the data and artifacts from the TasksResultsList before saving during the tag
- */
-export class BuildPipelineResultList {
-  private artifactListsMap: ComponentMap<ArtifactList>;
-  constructor(private tasksResults: TaskResults[], private components: Component[]) {
-    this.artifactListsMap = this.getFlattenedArtifactListsMapFromAllTasks();
-  }
-
-  private getFlattenedArtifactListsMapFromAllTasks(): ComponentMap<ArtifactList> {
-    const artifactListsMaps = this.tasksResults.flatMap((t) => (t.artifacts ? [t.artifacts] : []));
-    return ComponentMap.as<ArtifactList>(this.components, (component) => {
-      const artifacts: Artifact[] = [];
-      artifactListsMaps.forEach((artifactListMap) => {
-        const artifactList = artifactListMap.getValueByComponentId(component.id);
-        if (artifactList) artifacts.push(...artifactList.toArray());
-      });
-      return new ArtifactList(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: Serializable, existingData: Serializable | 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,114 +0,0 @@
-import type { Component } from '@teambit/component';
-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';
-
-export type TaskLocation = 'start' | 'end';
-
-/**
- * delimiter between task.aspectId and task.name
- */
-export const TaskIdDelimiter = ':';
-
-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[];
-}
-
-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 }: BuildTask): 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) return { aspectId: split[0] };
-    if (split.length === 2) return { aspectId: split[0], name: split[1] };
-    throw new Error(`deserializeId, id ${id} has more than one ${TaskIdDelimiter}`);
-  }
-}

package/build.cmd.ts

@@ -1,91 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import { Logger } from '@teambit/logger';
-import { Workspace } from '@teambit/workspace';
-import { ConsumerNotFound } from '@teambit/legacy/dist/consumer/exceptions';
-import chalk from 'chalk';
-import { BuilderMain } from './builder.main.runtime';
-
-type BuildOpts = {
-  rebuild: boolean;
-  install: boolean;
-  cachePackagesOnCapsulesRoot: boolean;
-  reuseCapsules: boolean;
-  tasks: string;
-  listTasks?: string;
-};
-
-export class BuilderCmd implements Command {
-  name = 'build [pattern]';
-  description = 'run set of tasks for build';
-  alias = '';
-  group = 'development';
-  options = [
-    ['', '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',
-    ],
-  ] as CommandOptions;
-
-  constructor(private builder: BuilderMain, private workspace: Workspace, private logger: Logger) {}
-
-  async report(
-    [userPattern]: [string],
-    { install = false, cachePackagesOnCapsulesRoot = false, reuseCapsules = false, tasks, listTasks }: BuildOpts
-  ): Promise<string> {
-    if (!this.workspace) throw new ConsumerNotFound();
-    if (listTasks) {
-      return this.getListTasks(listTasks);
-    }
-    const longProcessLogger = this.logger.createLongProcessLogger('build');
-    const pattern = userPattern && userPattern.toString();
-    const components = pattern ? await this.workspace.byPattern(pattern) : await this.workspace.list();
-
-    const envsExecutionResults = await this.builder.build(
-      components,
-      {
-        installOptions: {
-          installTeambitBit: install,
-        },
-        linkingOptions: { linkTeambitBit: !install },
-        emptyRootDir: !reuseCapsules,
-        getExistingAsIs: reuseCapsules,
-        cachePackagesOnCapsulesRoot,
-      },
-      {
-        tasks: tasks ? tasks.split(',').map((task) => task.trim()) : [],
-      }
-    );
-    longProcessLogger.end();
-    envsExecutionResults.throwErrorsIfExist();
-    this.logger.consoleSuccess();
-    return chalk.green(`the build has been completed. total: ${envsExecutionResults.tasksQueue.length} tasks`);
-  }
-
-  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('Tasks 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.aspect.ts

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

package/builder.docs.mdx

@@ -1,8 +0,0 @@
----
-description: build components on isolated directories
-labels: ['docs', 'aspect', 'extensions']
----
-
-import { Builder } from '@teambit/pipelines.aspect-docs.builder';
-
-<Builder />

package/builder.graphql.ts

@@ -1,38 +0,0 @@
-import { Component } from '@teambit/component';
-import gql from 'graphql-tag';
-
-import { BuilderMain } from './builder.main.runtime';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export function builderSchema(builder: BuilderMain) {
-  return {
-    typeDefs: gql`
-      type ExtensionDescriptor {
-        # extension ID.
-        id: String
-
-        # icon of the extension.
-        icon: String
-      }
-
-      type ExtensionArtifact {
-        # descriptor of the artifact's extension
-        extensionDescriptor: ExtensionDescriptor
-      }
-
-      extend type Component {
-        # list of extension artifacts.
-        getArtifacts(hash: String!): [ExtensionArtifact]
-      }
-    `,
-    resolvers: {
-      Component: {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        getArtifacts: async (component: Component, { hash }: { hash: string }) => {
-          // const artifacts = await builder.getArtifacts(component.id, hash);
-          // return artifacts.map((artifact) => artifact.toObject());
-        },
-      },
-    },
-  };
-}