eoas 1.0.2 → 1.0.3

package/dist/lib/vcs/local.d.ts

@@ -0,0 +1,19 @@
+export declare function getRootPath(): string;
+/**
+ * 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 declare class Ignore {
+    private readonly rootDir;
+    private ignoreMapping;
+    constructor(rootDir: string);
+    initIgnoreAsync(): Promise<void>;
+    ignores(relativePath: string): boolean;
+}
+export declare function makeShallowCopyAsync(src: string, dst: string): Promise<void>;

package/dist/lib/vcs/local.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShallowCopyAsync = exports.Ignore = exports.getRootPath = void 0;
+const tslib_1 = require("tslib");
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const ignore_1 = tslib_1.__importDefault(require("ignore"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const EASIGNORE_FILENAME = '.easignore';
+const GITIGNORE_FILENAME = '.gitignore';
+const DEFAULT_IGNORE = `
+.git
+node_modules
+`;
+function getRootPath() {
+    const rootPath = process.env.EAS_PROJECT_ROOT ?? process.cwd();
+    if (!path_1.default.isAbsolute(rootPath)) {
+        return path_1.default.resolve(process.cwd(), rootPath);
+    }
+    return rootPath;
+}
+exports.getRootPath = getRootPath;
+/**
+ * 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.
+ */
+class Ignore {
+    rootDir;
+    ignoreMapping = [];
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    async initIgnoreAsync() {
+        const easIgnorePath = path_1.default.join(this.rootDir, EASIGNORE_FILENAME);
+        if (await fs_extra_1.default.pathExists(easIgnorePath)) {
+            this.ignoreMapping = [
+                ['', (0, ignore_1.default)().add(DEFAULT_IGNORE)],
+                ['', (0, ignore_1.default)().add(await fs_extra_1.default.readFile(easIgnorePath, 'utf-8'))],
+            ];
+            return;
+        }
+        const ignoreFilePaths = (await (0, fast_glob_1.default)(`**/${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),
+                (0, ignore_1.default)().add(await fs_extra_1.default.readFile(path_1.default.join(this.rootDir, filePath), 'utf-8')),
+            ];
+        }));
+        this.ignoreMapping = [['', (0, ignore_1.default)().add(DEFAULT_IGNORE)], ...ignoreMapping];
+    }
+    ignores(relativePath) {
+        for (const [prefix, ignore] of this.ignoreMapping) {
+            if (relativePath.startsWith(prefix) && ignore.ignores(relativePath.slice(prefix.length))) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.Ignore = Ignore;
+async function makeShallowCopyAsync(src, dst) {
+    const ignore = new Ignore(src);
+    await ignore.initIgnoreAsync();
+    await fs_extra_1.default.copy(src, dst, {
+        filter: (srcFilePath) => {
+            if (srcFilePath === src) {
+                return true;
+            }
+            return !ignore.ignores(path_1.default.relative(src, srcFilePath));
+        },
+    });
+}
+exports.makeShallowCopyAsync = makeShallowCopyAsync;

package/dist/lib/vcs/vcs.d.ts

@@ -0,0 +1,25 @@
+export declare abstract class Client {
+    abstract makeShallowCopyAsync(destinationPath: string): Promise<void>;
+    abstract getRootPathAsync(): Promise<string>;
+    ensureRepoExistsAsync(): Promise<void>;
+    isCommitRequiredAsync(): Promise<boolean>;
+    hasUncommittedChangesAsync(): Promise<boolean | undefined>;
+    commitAsync(_arg: {
+        commitMessage: string;
+        commitAllFiles?: boolean;
+        nonInteractive: boolean;
+    }): Promise<void>;
+    trackFileAsync(_file: string): Promise<void>;
+    showDiffAsync(): Promise<void>;
+    /** (optional) print list of changed files */
+    showChangedFilesAsync(): Promise<void>;
+    getCommitHashAsync(): Promise<string | undefined>;
+    getBranchNameAsync(): Promise<string | null>;
+    getLastCommitMessageAsync(): Promise<string | null>;
+    isFileIgnoredAsync(_filePath: string): Promise<boolean>;
+    /**
+     * Whether this VCS client can get the last commit message.
+     * Used for EAS Update - implementation can be false for noVcs client.
+     */
+    abstract canGetLastCommitMessage(): boolean;
+}

package/dist/lib/vcs/vcs.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+class Client {
+    // (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.
+    async ensureRepoExistsAsync() { }
+    // (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
+    async isCommitRequiredAsync() {
+        return false;
+    }
+    // (optional) hasUncommittedChangesAsync should check whether there are changes in local repository
+    async hasUncommittedChangesAsync() {
+        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
+    async commitAsync(_arg) {
+        // 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
+    async trackFileAsync(_file) { }
+    // (optional) print diff of the changes that will be commited in the next call to
+    // `commitAsync({ commitAllFiles: false })`
+    async showDiffAsync() { }
+    /** (optional) print list of changed files */
+    async showChangedFilesAsync() { }
+    // (optional) returns hash of the last commit
+    // used for metadata - implementation can be safely skipped
+    async getCommitHashAsync() {
+        return undefined;
+    }
+    // (optional) returns name of the current branch
+    // used for EAS Update - implementation can be safely skipped
+    async getBranchNameAsync() {
+        return null;
+    }
+    // (optional) returns message of the last commit
+    // used for EAS Update - implementation can be safely skipped
+    async getLastCommitMessageAsync() {
+        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
+    async isFileIgnoredAsync(_filePath) {
+        return false;
+    }
+}
+exports.Client = Client;

package/dist/lib/workflow.d.ts

@@ -0,0 +1,4 @@
+import { Platform, Workflow } from '@expo/eas-build-job';
+import { Client } from './vcs/vcs';
+export declare function resolveWorkflowAsync(projectDir: string, platform: Platform, vcsClient: Client): Promise<Workflow>;
+export declare function resolveWorkflowPerPlatformAsync(projectDir: string, vcsClient: Client): Promise<Record<Platform, Workflow>>;

package/dist/lib/workflow.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkflowPerPlatformAsync = exports.resolveWorkflowAsync = void 0;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+async function resolveWorkflowAsync(projectDir, platform, vcsClient) {
+    let platformWorkflowMarkers;
+    try {
+        platformWorkflowMarkers =
+            platform === eas_build_job_1.Platform.ANDROID
+                ? [
+                    path_1.default.join(projectDir, 'android/app/build.gradle'),
+                    await config_plugins_1.AndroidConfig.Paths.getAndroidManifestAsync(projectDir),
+                ]
+                : [config_plugins_1.IOSConfig.Paths.getPBXProjectPath(projectDir)];
+    }
+    catch {
+        return eas_build_job_1.Workflow.MANAGED;
+    }
+    const vcsRootPath = path_1.default.normalize(await vcsClient.getRootPathAsync());
+    for (const marker of platformWorkflowMarkers) {
+        if ((await fs_extra_1.default.pathExists(marker)) &&
+            !(await vcsClient.isFileIgnoredAsync(path_1.default.relative(vcsRootPath, marker)))) {
+            return eas_build_job_1.Workflow.GENERIC;
+        }
+    }
+    return eas_build_job_1.Workflow.MANAGED;
+}
+exports.resolveWorkflowAsync = resolveWorkflowAsync;
+async function resolveWorkflowPerPlatformAsync(projectDir, vcsClient) {
+    const [android, ios] = await Promise.all([
+        resolveWorkflowAsync(projectDir, eas_build_job_1.Platform.ANDROID, vcsClient),
+        resolveWorkflowAsync(projectDir, eas_build_job_1.Platform.IOS, vcsClient),
+    ]);
+    return { android, ios };
+}
+exports.resolveWorkflowPerPlatformAsync = resolveWorkflowPerPlatformAsync;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eoas",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "index.js",
   "scripts": {
     "build": "tsc --project tsconfig.json",
@@ -88,5 +88,9 @@
     "commands": "./dist/commands",
     "dirname": "eoas",
     "topicSeparator": ":"
-  }
+  },
+  "files": [
+    "/bin",
+    "/dist"
+  ]
 }

package/.eslintignore

@@ -1 +0,0 @@
-node_modules

package/.eslintrc.js

@@ -1,73 +0,0 @@
-module.exports = {
-  root: true,
-  extends: ['universe/node'],
-  plugins: ['node'],
-  ignorePatterns: ['bin/'],
-  rules: {
-    'no-console': 'warn',
-    'no-constant-condition': ['warn', { checkLoops: false }],
-    'sort-imports': [
-      'warn',
-      {
-        ignoreDeclarationSort: true,
-      },
-    ],
-    curly: 'warn',
-    'import/no-cycle': 'error',
-    'import/no-extraneous-dependencies': [
-      'error',
-      { devDependencies: ['**/__tests__/**/*', '**/__mocks__/**/*'] },
-    ],
-    'import/no-relative-packages': 'error',
-    'no-restricted-imports': [
-      'error',
-      {
-        paths: [
-          {
-            name: 'lodash',
-            message: "Don't use lodash, it's heavy!",
-          },
-        ],
-      },
-    ],
-    'no-underscore-dangle': ['error', { allow: ['__typename'] }],
-    'node/no-sync': 'error',
-  },
-  overrides: [
-    {
-      files: ['*.ts', '*.d.ts'],
-      parserOptions: {
-        project: './tsconfig.json',
-      },
-      rules: {
-        '@typescript-eslint/explicit-function-return-type': [
-          'warn',
-          {
-            allowExpressions: true,
-          },
-        ],
-        '@typescript-eslint/prefer-nullish-coalescing': ['warn', { ignorePrimitives: true }],
-        '@typescript-eslint/no-confusing-void-expression': 'warn',
-        '@typescript-eslint/await-thenable': 'error',
-        '@typescript-eslint/no-misused-promises': [
-          'error',
-          {
-            checksVoidReturn: false,
-          },
-        ],
-        '@typescript-eslint/no-floating-promises': 'error',
-        'no-void': ['warn', { allowAsStatement: true }],
-        'no-return-await': 'off',
-        '@typescript-eslint/return-await': ['error', 'always'],
-        '@typescript-eslint/no-confusing-non-null-assertion': 'warn',
-        '@typescript-eslint/no-extra-non-null-assertion': 'warn',
-        '@typescript-eslint/prefer-as-const': 'warn',
-        '@typescript-eslint/prefer-includes': 'warn',
-        '@typescript-eslint/prefer-readonly': 'warn',
-        '@typescript-eslint/prefer-string-starts-ends-with': 'warn',
-        '@typescript-eslint/prefer-ts-expect-error': 'warn',
-        '@typescript-eslint/no-unnecessary-type-assertion': 'warn',
-      },
-    },
-  ],
-};

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "printWidth": 100,
-  "tabWidth": 2,
-  "singleQuote": true,
-  "bracketSameLine": true,
-  "trailingComma": "es5",
-  "arrowParens": "avoid",
-  "endOfLine": "auto"
-}

package/src/commands/generate-certs.ts

@@ -1,95 +0,0 @@
-import {
-  convertCertificateToCertificatePEM,
-  convertKeyPairToPEM,
-  generateKeyPair,
-  generateSelfSignedCodeSigningCertificate,
-} from '@expo/code-signing-certificates';
-import { Command } from '@oclif/core';
-import { ensureDirSync, writeFile } from 'fs-extra';
-import path from 'path';
-
-import Log from '../lib/log';
-import { promptAsync } from '../lib/prompts';
-
-export default class GenerateCerts extends Command {
-  static override args = {};
-  static override description = 'Generate private & public certificates for code signing';
-  static override examples = ['<%= config.bin %> <%= command.id %>'];
-  static override flags = {};
-  public async run(): Promise<void> {
-    const { certificateOutputDir } = await promptAsync({
-      message:
-        'In which directory would you like to store your code signing certificate (used by your expo app)?',
-      name: 'certificateOutputDir',
-      type: 'text',
-      initial: './keysStore',
-      validate: v => {
-        try {
-          // eslint-disable-next-line
-          ensureDirSync(path.join(process.cwd(), v));
-          return true;
-        } catch {
-          return false;
-        }
-      },
-    });
-    const { keyOutputDir } = await promptAsync({
-      message:
-        'In which directory would you like to store your key pair (used by your OTA Server) ?. ⚠️ Those keysStore are sensitive and should be kept private.',
-      name: 'keyOutputDir',
-      type: 'text',
-      initial: './keysStore',
-      validate: v => {
-        try {
-          // eslint-disable-next-line
-          ensureDirSync(path.join(process.cwd(), v));
-          return true;
-        } catch {
-          return false;
-        }
-      },
-    });
-    const { certificateCommonName } = await promptAsync({
-      message: 'Please enter your Organization name',
-      name: 'certificateCommonName',
-      type: 'text',
-      initial: 'Your Organization Name',
-      validate: v => {
-        return !!v;
-      },
-    });
-    const { certificateValidityDurationYears } = await promptAsync({
-      message: 'How many years should the certificate be valid for?',
-      name: 'certificateValidityDurationYears',
-      type: 'number',
-      initial: 10,
-      validate: v => {
-        return v > 0 && Number.isInteger(v);
-      },
-    });
-    const validityDurationYears = Math.floor(Number(certificateValidityDurationYears));
-    const certificateOutput = path.resolve(process.cwd(), certificateOutputDir);
-    const keyOutput = path.resolve(process.cwd(), keyOutputDir);
-    const validityNotBefore = new Date();
-    const validityNotAfter = new Date();
-    validityNotAfter.setFullYear(validityNotAfter.getFullYear() + validityDurationYears);
-    const keyPair = generateKeyPair();
-    const certificate = generateSelfSignedCodeSigningCertificate({
-      keyPair,
-      validityNotBefore,
-      validityNotAfter,
-      commonName: certificateCommonName,
-    });
-    const keyPairPEM = convertKeyPairToPEM(keyPair);
-    const certificatePEM = convertCertificateToCertificatePEM(certificate);
-    await Promise.all([
-      writeFile(path.join(keyOutput, 'public-key.pem'), keyPairPEM.publicKeyPEM),
-      writeFile(path.join(keyOutput, 'private-key.pem'), keyPairPEM.privateKeyPEM),
-      writeFile(path.join(certificateOutput, 'certificate.pem'), certificatePEM),
-    ]);
-    Log.succeed(
-      `Generated public and private keys output in ${keyOutputDir}. Please follow the documentation to securely store them and do not commit them to your repository.`
-    );
-    Log.succeed(`Generated code signing certificate output in ${certificateOutputDir}.`);
-  }
-}

package/src/commands/init.ts

@@ -1,117 +0,0 @@
-import { Command } from '@oclif/core';
-import fs from 'fs-extra';
-import path from 'path';
-
-import {
-  createOrModifyExpoConfigAsync,
-  getExpoConfigUpdateUrl,
-  getPrivateExpoConfigAsync,
-} from '../lib/expoConfig';
-import Log from '../lib/log';
-import { ora } from '../lib/ora';
-import { isExpoInstalled } from '../lib/package';
-import { confirmAsync, promptAsync } from '../lib/prompts';
-import { isValidUpdateUrl } from '../lib/utils';
-
-export default class Init extends Command {
-  static override args = {};
-  static override description = 'Configure your existing expo project with Expo Open OTA';
-  static override examples = ['<%= config.bin %> <%= command.id %>'];
-  static override flags = {};
-  public async run(): Promise<void> {
-    const projectDir = process.cwd();
-    const hasExpo = isExpoInstalled(projectDir);
-    if (!hasExpo) {
-      Log.error('Expo is not installed in this project. Please install Expo first.');
-      return;
-    }
-    const config = await getPrivateExpoConfigAsync(projectDir);
-    if (!config) {
-      Log.error(
-        'Could not find Expo config in this project. Please make sure you have an Expo config.'
-      );
-      return;
-    }
-    const { updateUrl: promptedUrl } = await promptAsync({
-      message: 'Enter the URL of your update server (ex: https://customota.com)',
-      name: 'updateUrl',
-      type: 'text',
-      initial: getExpoConfigUpdateUrl(config),
-      validate: v => {
-        return !!v && isValidUpdateUrl(v);
-      },
-    });
-    let manifestEndpoint = `${promptedUrl}/manifest`;
-    const updateUrl = getExpoConfigUpdateUrl(config);
-    if (updateUrl && !updateUrl.includes('expo.dev')) {
-      const confirmed = await confirmAsync({
-        message: `Expo config already has an update URL set to ${updateUrl}. Do you want to replace it?`,
-        name: 'replace',
-        type: 'confirm',
-      });
-      if (!confirmed) {
-        manifestEndpoint = updateUrl;
-      }
-    }
-    const confirmed = await confirmAsync({
-      message: 'Do you have already generated your certificates and keysStore for code signing?',
-      name: 'certificates',
-      type: 'confirm',
-    });
-    if (!confirmed) {
-      Log.fail('You need to generate your certificates first by using npx eoas generate-keysStore');
-      return;
-    }
-    const { codeSigningCertificatePath } = await promptAsync({
-      message: 'Enter the path to your code signing certificate (ex: ./keysStore/certificate.pem)',
-      name: 'codeSigningCertificatePath',
-      type: 'text',
-      initial: './keysStore/certificate.pem',
-      validate: v => {
-        try {
-          const fullPath = path.resolve(projectDir, v);
-          // eslint-disable-next-line
-          const fileExists = fs.existsSync(fullPath);
-          if (!fileExists) {
-            Log.newLine();
-            Log.error('File does not exist');
-            return false;
-          }
-          // eslint-disable-next-line
-          const key = fs.readFileSync(fullPath, 'utf8');
-          if (!key) {
-            Log.error('Empty key');
-            return false;
-          }
-          return true;
-        } catch {
-          return false;
-        }
-      },
-    });
-    const newUpdateConfig = {
-      url: manifestEndpoint,
-      codeSigningMetadata: {
-        keyid: 'main',
-        alg: 'rsa-v1_5-sha256' as const,
-      },
-      codeSigningCertificate: codeSigningCertificatePath,
-      enabled: true,
-      requestHeaders: {
-        'expo-channel-name': 'process.env.RELEASE_CHANNEL',
-      },
-    };
-    const updateConfigSpinner = ora('Updating Expo config').start();
-    try {
-      await createOrModifyExpoConfigAsync(projectDir, {
-        updates: newUpdateConfig,
-      });
-      updateConfigSpinner.succeed(
-        'Expo config successfully updated do not forget to format the file with prettier or eslint'
-      );
-    } catch (e) {
-      updateConfigSpinner.fail('Failed to update Expo config');
-      Log.error(e);
-    }
-  }
-}