@teambit/builder 1.0.107 → 1.0.108

package/build.cmd.ts

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

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

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

package/builder.graphql.ts

@@ -0,0 +1,185 @@
+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),
+          };
+        },
+      },
+    },
+  };
+}