@catladder/pipeline 1.11.0 → 1.12.0

package/src/build/node/yarn.ts

@@ -1,8 +1,25 @@
 import { Context } from "../../types";
 
+export const getYarnInstallCommand = (
+  context: Context,
+  options?: {
+    prodOnly?: boolean;
+    noScripts?: boolean;
+  }
+) =>
+  context.packageManagerInfo?.isClassic
+    ? `yarn install --frozen-lockfile ${
+        options?.prodOnly ? "--production" : ""
+      } ${options?.noScripts ? "--ignore-scripts" : ""}`
+    : options?.prodOnly
+    ? `${
+        options?.noScripts ? "YARN_ENABLE_SCRIPTS=false " : ""
+      }yarn plugin import workspace-tools && yarn workspaces focus --production` // needs yarn plugin import workspace-tools
+    : `${
+        options?.noScripts ? "YARN_ENABLE_SCRIPTS=false " : ""
+      }yarn install --immutable`;
+
 export const getYarnInstall = (context: Context) => [
   "if [ -f ./.nvmrc ]; then source /root/.nvm/nvm.sh && nvm install <<< .nvmrc; fi",
-  context.yarnInfo?.isClassic
-    ? "yarn install --frozen-lockfile"
-    : "yarn install --immutable",
+  getYarnInstallCommand(context),
 ];

package/src/build/types.ts

@@ -46,6 +46,12 @@ export type BuildConfigBase = {
     | {
         command?: string | string[];
       };
+
+  /**
+   * additional paths for artifacts,
+   * by default "dist" and ".next" are allways included
+   */
+  artifactsPaths?: [];
 };
 
 export type BuildConfigNodeBase = BuildConfigBase;

package/src/context/index.ts

@@ -1,11 +1,15 @@
-import { merge, mergeWith } from "lodash";
 import slugify from "slugify";
 import { BUILD_TYPES } from "../build";
 import { BuildConfig } from "../build/types";
 import { DEPLOY_TYPES, getKubernetesNamespace } from "../deploy";
 import { DeployConfig } from "../deploy/types";
 import { Config, isKnowEnvType, DevLocalEnvConfig } from "../types/config";
-import { CommitInfo, Context, Environment, YarnInfo } from "../types/context";
+import {
+  CommitInfo,
+  Context,
+  Environment,
+  PackageManagerInfo,
+} from "../types/context";
 import { mergeWithMergingArrays } from "../utils";
 
 const sanitizeForEnVar = (s: string) => s.replace(/-/g, "_");
@@ -164,7 +168,7 @@ export const createContext = (
   componentName: string,
   env: string,
   commitInfo?: CommitInfo,
-  yarnInfo?: YarnInfo
+  packageManagerInfo?: PackageManagerInfo
 ): Context => {
   if (!/^[a-z0-9-]+$/.test(componentName)) {
     throw new Error(
@@ -208,6 +212,6 @@ export const createContext = (
     componentName,
     environment: getEnvironment(config, componentName, env, commitInfo),
     commitInfo,
-    yarnInfo,
+    packageManagerInfo,
   };
 };

package/src/pipeline/createJobs.ts

@@ -7,7 +7,7 @@ import { Config, PipelineTrigger } from "../types/config";
 import { Context, CommitInfo } from "../types/context";
 import { GitlabJob, GitlabJobDef, GitlabJobs } from "../types/gitlab-types";
 import { notNil } from "../utils";
-import { getYarnInfo } from "./yarnInfo";
+import { getPackageManagerInfo } from "./packageManager";
 
 const createRawJobs = (context: Context): GitlabJobs => {
   if (context.componentConfig.deploy === false) {
@@ -134,7 +134,7 @@ export const createJobs = async (
     trigger,
   };
 
-  const yarnInfo = await getYarnInfo(config, componentName);
+  const packageManagerInfo = await getPackageManagerInfo(config, componentName);
 
   return envs.reduce((acc, env) => {
     const context = createContext(
@@ -142,7 +142,7 @@ export const createJobs = async (
       componentName,
       env,
       commitInfo,
-      yarnInfo
+      packageManagerInfo
     );
     const jobs = addStageNeeds(createRawJobs(context));
 

package/src/pipeline/packageManager.ts

@@ -0,0 +1,99 @@
+import { exec } from "child-process-promise";
+import { Config, PackageManagerInfo } from "../types";
+import { pathEqual } from "path-equal";
+import memoizee from "memoizee";
+import { join } from "path";
+import { existsSync } from "fs";
+
+const execOrFail = async (cmd: string, onFail: string): Promise<string> => {
+  try {
+    return await exec(cmd).then((r) => r.stdout);
+  } catch (e) {
+    return onFail ?? null;
+  }
+};
+
+const getYarnVersion = memoizee(
+  async () => {
+    return await execOrFail("yarn --version", "");
+  },
+  { promise: true }
+);
+
+const getWorkspaces = memoizee(
+  async (isClassic: boolean): Promise<PackageManagerInfo["workspaces"]> => {
+    return isClassic
+      ? Object.values(
+          JSON.parse(
+            JSON.parse(await execOrFail("yarn workspaces --json info", "{}"))
+              ?.data ?? "{}"
+          )
+        )
+      : JSON.parse(
+          `[${(await execOrFail("yarn workspaces list --json --verbose", ""))
+            .trim()
+            .split("\n")
+            .join(",")}]`
+        );
+  },
+  { promise: true }
+);
+export const getPackageManagerInfo = async (
+  config: Config,
+  componentName: string
+): Promise<PackageManagerInfo> => {
+  // currently only supports yarn
+  const version = await getYarnVersion();
+  if (!version) throw new Error("could not get yarn version");
+  const isClassic = version.startsWith("1");
+
+  const component = config.components[componentName];
+  const workspaces = await getWorkspaces(isClassic);
+  const currentWorkspace = workspaces.find((w) =>
+    pathEqual(component.dir, w.location)
+  );
+  const componentIsInWorkspace = Boolean(currentWorkspace);
+  const workspaceRoot = "."; // currently we assume the root folder, later on we might support nested workspaces
+  const packageJson = join(component.dir, "package.json");
+  const workspacePackageJson = componentIsInWorkspace
+    ? join(workspaceRoot, "package.json")
+    : null;
+
+  const lockFile = componentIsInWorkspace
+    ? join(workspaceRoot, "yarn.lock")
+    : join(component.dir, "yarn.lock");
+  const configFiles = [".yarnrc", ".yarnrc.yml", ".npmrc", ".yarn"]; // ".yarn" is yarn 2 folder
+  const rcFiles = (
+    componentIsInWorkspace
+      ? configFiles
+      : configFiles.map((f) => join(component.dir, f))
+  ).filter((f) => existsSync(f));
+
+  // get all folders that this workspace depend on
+  // we will later copy them into the docker build
+  const workspaceDependencies = currentWorkspace
+    ? ([
+        ...currentWorkspace.workspaceDependencies,
+        ...currentWorkspace.mismatchedWorkspaceDependencies,
+      ]
+        .map((name) => workspaces.find((w) => w.name === name)?.location)
+        .filter(Boolean) as string[])
+    : [];
+
+  const pathsToCopyInDocker = [
+    packageJson,
+    ...(workspacePackageJson ? [workspacePackageJson] : []),
+    lockFile,
+    ...rcFiles,
+    ...workspaceDependencies,
+  ];
+  return {
+    type: "yarn",
+    workspaces,
+    version,
+    isClassic,
+    currentWorkspace,
+    componentIsInWorkspace,
+    pathsToCopyInDocker,
+  };
+};

package/src/types/context.ts

@@ -22,21 +22,28 @@ export type CommitInfo = {
   trigger: PipelineTrigger;
 };
 
-export type YarnInfo = {
+type Workspace = {
+  name: string;
+  location: string;
+  workspaceDependencies: string[];
+  mismatchedWorkspaceDependencies: string[];
+};
+export type YarnPackageManagerInfo = {
+  type: "yarn";
   version: string;
-  workspaces: { location: string }[];
+  workspaces: Workspace[];
+  currentWorkspace?: Workspace;
   isClassic: boolean;
   componentIsInWorkspace: boolean;
-  /**
-   * files relevant for the package manager
-   */
-  files: string[];
+  pathsToCopyInDocker: string[];
 };
+
+export type PackageManagerInfo = YarnPackageManagerInfo;
 export type Context = {
   componentName: string;
   componentConfig: ComponentConfig;
   fullConfig: Config;
   environment: Environment;
   commitInfo?: CommitInfo;
-  yarnInfo?: YarnInfo;
+  packageManagerInfo?: PackageManagerInfo;
 };

package/dist/pipeline/yarnInfo.d.ts

@@ -1,2 +0,0 @@
-import { Config, YarnInfo } from "../types";
-export declare const getYarnInfo: (config: Config, componentName: string) => Promise<YarnInfo>;

package/src/pipeline/yarnInfo.ts

@@ -1,73 +0,0 @@
-import { exec } from "child-process-promise";
-import { Config, YarnInfo } from "../types";
-import { pathEqual } from "path-equal";
-import memoizee from "memoizee";
-import { join } from "path";
-import { existsSync } from "fs";
-
-const execOrFail = async (cmd: string, onFail: string): Promise<string> => {
-  try {
-    return await exec(cmd).then((r) => r.stdout);
-  } catch (e) {
-    return onFail ?? null;
-  }
-};
-
-const getYarnVersion = memoizee(
-  async () => {
-    return await execOrFail("yarn --version", "");
-  },
-  { promise: true }
-);
-
-const getWorkspaces = memoizee(
-  async (isClassic: boolean): Promise<YarnInfo["workspaces"]> => {
-    return isClassic
-      ? Object.values(
-          JSON.parse(
-            JSON.parse(await execOrFail("yarn workspaces --json info", "{}"))
-              ?.data ?? "{}"
-          )
-        )
-      : JSON.parse(
-          `[${(await execOrFail("yarn workspaces list --json", ""))
-            .trim()
-            .split("\n")
-            .join(",")}]`
-        );
-  },
-  { promise: true }
-);
-export const getYarnInfo = async (
-  config: Config,
-  componentName: string
-): Promise<YarnInfo> => {
-  const version = await getYarnVersion();
-  if (!version) throw new Error("could not get yarn version");
-  const isClassic = version.startsWith("1");
-
-  const component = config.components[componentName];
-  const workspaces = await getWorkspaces(isClassic);
-  const componentIsInWorkspace = workspaces.some((w) =>
-    pathEqual(component.dir, w.location)
-  );
-  const packageJson = join(component.dir, "package.json");
-  const lockFile = componentIsInWorkspace
-    ? "yarn.lock"
-    : join(component.dir, "yarn.lock");
-  const RC_FILES = [".yarnrc", ".npmrc"];
-  const possibleRcFiles = componentIsInWorkspace
-    ? RC_FILES
-    : RC_FILES.map((f) => join(component.dir, f));
-  const files = [packageJson, lockFile, ...possibleRcFiles].filter((f) =>
-    existsSync(f)
-  );
-
-  return {
-    workspaces,
-    version,
-    isClassic,
-    componentIsInWorkspace,
-    files,
-  };
-};