eoas 1.0.1

package/src/lib/vcs/git.ts

@@ -0,0 +1,68 @@
+import spawnAsync from '@expo/spawn-async';
+
+export async function isGitInstalledAsync(): Promise<boolean> {
+  try {
+    await spawnAsync('git', ['--help']);
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+  return true;
+}
+
+export async function doesGitRepoExistAsync(cwd: string | undefined): Promise<boolean> {
+  try {
+    await spawnAsync('git', ['rev-parse', '--git-dir'], {
+      cwd,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+interface GitStatusOptions {
+  showUntracked: boolean;
+  cwd: string | undefined;
+}
+
+export async function gitStatusAsync({ showUntracked, cwd }: GitStatusOptions): Promise<string> {
+  return (
+    await spawnAsync('git', ['status', '-s', showUntracked ? '-uall' : '-uno'], {
+      cwd,
+    })
+  ).stdout;
+}
+
+export async function getGitDiffOutputAsync(cwd: string | undefined): Promise<string> {
+  return (
+    await spawnAsync('git', ['--no-pager', 'diff'], {
+      cwd,
+    })
+  ).stdout;
+}
+
+export async function gitDiffAsync({
+  withPager = false,
+  cwd,
+}: {
+  withPager?: boolean;
+  cwd: string | undefined;
+}): Promise<void> {
+  const options = withPager ? [] : ['--no-pager'];
+  try {
+    await spawnAsync('git', [...options, 'diff'], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+      cwd,
+    });
+  } catch (error: any) {
+    if (typeof error.message === 'string' && error.message.includes('SIGPIPE')) {
+      // This error is thrown when the user exits the pager with `q`.
+      // do nothing
+      return;
+    }
+    throw error;
+  }
+}

package/src/lib/vcs/index.ts

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+
+import GitClient from './clients/git';
+import GitNoCommitClient from './clients/gitNoCommit';
+import NoVcsClient from './clients/noVcs';
+import { Client } from './vcs';
+
+const NO_VCS_WARNING = `Using EAS CLI without version control system is not recommended, use this mode only if you know what you are doing.`;
+
+export function resolveVcsClient(requireCommit: boolean = false): Client {
+  if (process.env.EAS_NO_VCS) {
+    if (process.env.NODE_ENV !== 'test') {
+      // This log might be printed before cli arguments are evaluated,
+      // so it needs to go to stderr in case command is run in JSON
+      // only mode.
+      // eslint-disable-next-line no-console
+      console.error(chalk.yellow(NO_VCS_WARNING));
+    }
+    return new NoVcsClient();
+  }
+  if (requireCommit) {
+    return new GitClient();
+  }
+  return new GitNoCommitClient();
+}

package/src/lib/vcs/local.ts

@@ -0,0 +1,88 @@
+import fg from 'fast-glob';
+import fs from 'fs-extra';
+import createIgnore, { Ignore as SingleFileIgnore } from 'ignore';
+import path from 'path';
+
+const EASIGNORE_FILENAME = '.easignore';
+const GITIGNORE_FILENAME = '.gitignore';
+
+const DEFAULT_IGNORE = `
+.git
+node_modules
+`;
+
+export function getRootPath(): string {
+  const rootPath = process.env.EAS_PROJECT_ROOT ?? process.cwd();
+  if (!path.isAbsolute(rootPath)) {
+    return path.resolve(process.cwd(), rootPath);
+  }
+  return rootPath;
+}
+
+/**
+ * Ignore wraps the 'ignore' package to support multiple .gitignore files
+ * in subdirectories.
+ *
+ * Inconsistencies with git behavior:
+ * - if parent .gitignore has ignore rule and child has exception to that rule,
+ *   file will still be ignored,
+ * - node_modules is always ignored,
+ * - if .easignore exists, .gitignore files are not used.
+ */
+export class Ignore {
+  private ignoreMapping: (readonly [string, SingleFileIgnore])[] = [];
+
+  constructor(private readonly rootDir: string) {}
+
+  public async initIgnoreAsync(): Promise<void> {
+    const easIgnorePath = path.join(this.rootDir, EASIGNORE_FILENAME);
+    if (await fs.pathExists(easIgnorePath)) {
+      this.ignoreMapping = [
+        ['', createIgnore().add(DEFAULT_IGNORE)],
+        ['', createIgnore().add(await fs.readFile(easIgnorePath, 'utf-8'))],
+      ];
+      return;
+    }
+    const ignoreFilePaths = (
+      await fg(`**/${GITIGNORE_FILENAME}`, {
+        cwd: this.rootDir,
+        ignore: ['node_modules'],
+        followSymbolicLinks: false,
+      })
+    )
+      // ensure that parent dir is before child directories
+      .sort((a, b) => a.length - b.length && a.localeCompare(b));
+
+    const ignoreMapping = await Promise.all(
+      ignoreFilePaths.map(async filePath => {
+        return [
+          filePath.slice(0, filePath.length - GITIGNORE_FILENAME.length),
+          createIgnore().add(await fs.readFile(path.join(this.rootDir, filePath), 'utf-8')),
+        ] as const;
+      })
+    );
+    this.ignoreMapping = [['', createIgnore().add(DEFAULT_IGNORE)], ...ignoreMapping];
+  }
+
+  public ignores(relativePath: string): boolean {
+    for (const [prefix, ignore] of this.ignoreMapping) {
+      if (relativePath.startsWith(prefix) && ignore.ignores(relativePath.slice(prefix.length))) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+export async function makeShallowCopyAsync(src: string, dst: string): Promise<void> {
+  const ignore = new Ignore(src);
+  await ignore.initIgnoreAsync();
+  await fs.copy(src, dst, {
+    filter: (srcFilePath: string) => {
+      if (srcFilePath === src) {
+        return true;
+      }
+      return !ignore.ignores(path.relative(src, srcFilePath));
+    },
+  });
+}

package/src/lib/vcs/vcs.ts

@@ -0,0 +1,90 @@
+export abstract class Client {
+  // makeShallowCopyAsync should copy current project (result of getRootPathAsync()) to the specified
+  // destination, folder created this way will be uploaded "as is", so implementation should skip
+  // anything that is not committed to the repository. Most optimal solution is to create shallow clone
+  // using tooling provided by specific VCS, that respects all ignore rules
+  public abstract makeShallowCopyAsync(destinationPath: string): Promise<void>;
+
+  // Find root of the repository.
+  //
+  // On windows path might look different depending on implementation
+  // - git based clients will return "C:/path/to/repo"
+  // - non-git clients will return "C:\path\to\repo"
+  public abstract getRootPathAsync(): Promise<string>;
+
+  // (optional) ensureRepoExistsAsync should verify whether repository exists and tooling is installed
+  // it's not required for minimal support, but lack of validation might cause the failure at a later stage.
+  public async ensureRepoExistsAsync(): Promise<void> {}
+
+  // (optional) checks whether commit is necessary before calling makeShallowCopyAsync
+  //
+  // If it's not implemented method `makeShallowCopyAsync` needs to be able to include uncommitted changes
+  // when creating copy
+  public async isCommitRequiredAsync(): Promise<boolean> {
+    return false;
+  }
+
+  // (optional) hasUncommittedChangesAsync should check whether there are changes in local repository
+  public async hasUncommittedChangesAsync(): Promise<boolean | undefined> {
+    return undefined;
+  }
+
+  // (optional) commitAsync commits changes
+  //
+  // - Should be implemented if hasUncommittedChangesAsync is implemented
+  // - If it's not implemented method `makeShallowCopyAsync` needs to be able to include uncommitted changes
+  // in project copy
+  public async commitAsync(_arg: {
+    commitMessage: string;
+    commitAllFiles?: boolean;
+    nonInteractive: boolean;
+  }): Promise<void> {
+    // it should not be called unless hasUncommittedChangesAsync is implemented
+    throw new Error('commitAsync is not implemented');
+  }
+
+  // (optional) mark file as tracked, if this method is called on file, the next call to
+  // `commitAsync({ commitAllFiles: false })` should commit that file
+  public async trackFileAsync(_file: string): Promise<void> {}
+
+  // (optional) print diff of the changes that will be commited in the next call to
+  // `commitAsync({ commitAllFiles: false })`
+  public async showDiffAsync(): Promise<void> {}
+
+  /** (optional) print list of changed files */
+  public async showChangedFilesAsync(): Promise<void> {}
+
+  // (optional) returns hash of the last commit
+  // used for metadata - implementation can be safely skipped
+  public async getCommitHashAsync(): Promise<string | undefined> {
+    return undefined;
+  }
+
+  // (optional) returns name of the current branch
+  // used for EAS Update - implementation can be safely skipped
+  public async getBranchNameAsync(): Promise<string | null> {
+    return null;
+  }
+
+  // (optional) returns message of the last commit
+  // used for EAS Update - implementation can be safely skipped
+  public async getLastCommitMessageAsync(): Promise<string | null> {
+    return null;
+  }
+
+  // (optional) checks if the file is ignored, an implementation should ensure
+  // that if file exists and `isFileIgnoredAsync` returns true, then that file
+  // should not be included in the project tarball.
+  //
+  // @param filePath has to be a relative normalized path pointing to a file
+  // located under the root of the repository
+  public async isFileIgnoredAsync(_filePath: string): Promise<boolean> {
+    return false;
+  }
+
+  /**
+   * Whether this VCS client can get the last commit message.
+   * Used for EAS Update - implementation can be false for noVcs client.
+   */
+  public abstract canGetLastCommitMessage(): boolean;
+}

package/src/lib/workflow.ts

@@ -0,0 +1,47 @@
+import { AndroidConfig, IOSConfig } from '@expo/config-plugins';
+import { Platform, Workflow } from '@expo/eas-build-job';
+import fs from 'fs-extra';
+import path from 'path';
+
+import { Client } from './vcs/vcs';
+
+export async function resolveWorkflowAsync(
+  projectDir: string,
+  platform: Platform,
+  vcsClient: Client
+): Promise<Workflow> {
+  let platformWorkflowMarkers: string[];
+  try {
+    platformWorkflowMarkers =
+      platform === Platform.ANDROID
+        ? [
+            path.join(projectDir, 'android/app/build.gradle'),
+            await AndroidConfig.Paths.getAndroidManifestAsync(projectDir),
+          ]
+        : [IOSConfig.Paths.getPBXProjectPath(projectDir)];
+  } catch {
+    return Workflow.MANAGED;
+  }
+
+  const vcsRootPath = path.normalize(await vcsClient.getRootPathAsync());
+  for (const marker of platformWorkflowMarkers) {
+    if (
+      (await fs.pathExists(marker)) &&
+      !(await vcsClient.isFileIgnoredAsync(path.relative(vcsRootPath, marker)))
+    ) {
+      return Workflow.GENERIC;
+    }
+  }
+  return Workflow.MANAGED;
+}
+
+export async function resolveWorkflowPerPlatformAsync(
+  projectDir: string,
+  vcsClient: Client
+): Promise<Record<Platform, Workflow>> {
+  const [android, ios] = await Promise.all([
+    resolveWorkflowAsync(projectDir, Platform.ANDROID, vcsClient),
+    resolveWorkflowAsync(projectDir, Platform.IOS, vcsClient),
+  ]);
+  return { android, ios };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "@tsconfig/node18/tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "importHelpers": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}