eas-cli 16.21.0 → 16.23.0

package/build/commands/workflow/create.js

@@ -2,28 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowCreate = void 0;
 const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const promises_1 = tslib_1.__importDefault(require("fs/promises"));
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
-const prompts_1 = tslib_1.__importDefault(require("prompts"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
-const flags_1 = require("../../commandUtils/flags");
+const buildProfileUtils_1 = require("../../commandUtils/workflow/buildProfileUtils");
+const creation_1 = require("../../commandUtils/workflow/creation");
+const validation_1 = require("../../commandUtils/workflow/validation");
 const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
 const workflowFile_1 = require("../../utils/workflowFile");
-const DEFAULT_WORKFLOW_NAME = 'workflow.yml';
-const HELLO_WORLD_TEMPLATE = `name: Hello World
-
-on:
-  push:
-    branches: ['*']
-
-jobs:
-  hello_world:
-    steps:
-      - uses: eas/checkout
-      - run: echo "Hello, World"
-`;
 class WorkflowCreate extends EasCommand_1.default {
     static description = 'create a new workflow configuration YAML file';
     static args = [
@@ -34,65 +25,148 @@ class WorkflowCreate extends EasCommand_1.default {
         },
     ];
     static flags = {
-        ...flags_1.EASNonInteractiveFlag,
+        'skip-validation': core_1.Flags.boolean({
+            description: 'If set, the workflow file will not be validated before being created',
+            default: false,
+        }),
     };
     static contextDefinition = {
+        ...this.ContextOptions.DynamicProjectConfig,
         ...this.ContextOptions.ProjectDir,
+        ...this.ContextOptions.LoggedIn,
     };
     async runAsync() {
         const { args: { name: argFileName }, flags, } = await this.parse(WorkflowCreate);
-        const { projectDir } = await this.getContextAsync(WorkflowCreate, {
-            nonInteractive: flags['non-interactive'],
-        });
-        let fileName = argFileName;
-        if (!fileName) {
-            const response = await (0, prompts_1.default)({
-                type: 'text',
-                name: 'fileName',
-                message: 'What would you like to name your workflow file?',
-                initial: DEFAULT_WORKFLOW_NAME,
-                validate: value => {
-                    try {
-                        workflowFile_1.WorkflowFile.validateYamlExtension(value);
-                        return true;
+        try {
+            const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, projectDir, } = await this.getContextAsync(WorkflowCreate, {
+                nonInteractive: false,
+                withServerSideEnvironment: null,
+            });
+            const { exp: originalExpoConfig, projectId } = await getDynamicPrivateProjectConfigAsync();
+            let expoConfig = originalExpoConfig;
+            let workflowStarter;
+            while (!workflowStarter) {
+                workflowStarter = await chooseTemplateAsync();
+                switch (workflowStarter.name) {
+                    case creation_1.WorkflowStarterName.BUILD:
+                    case creation_1.WorkflowStarterName.DEPLOY:
+                    case creation_1.WorkflowStarterName.UPDATE: {
+                        const shouldProceed = await (0, buildProfileUtils_1.runBuildConfigureIfNeededAsync)({
+                            projectDir,
+                            expoConfig,
+                        });
+                        if (!shouldProceed) {
+                            workflowStarter = undefined;
+                            continue;
+                        }
+                        break;
                     }
-                    catch (error) {
-                        return error instanceof Error ? error.message : 'Invalid file name';
+                    default:
+                        break;
+                }
+                switch (workflowStarter.name) {
+                    case creation_1.WorkflowStarterName.DEPLOY:
+                    case creation_1.WorkflowStarterName.UPDATE: {
+                        const shouldProceed = await (0, buildProfileUtils_1.runUpdateConfigureIfNeededAsync)({
+                            projectDir,
+                            expoConfig,
+                        });
+                        if (!shouldProceed) {
+                            workflowStarter = undefined;
+                            continue;
+                        }
+                        // Need to refetch the Expo config because it may have changed
+                        expoConfig = (await getDynamicPrivateProjectConfigAsync()).exp;
+                        break;
                     }
-                },
-            });
-            if (!response.fileName) {
-                log_1.default.warn('Workflow creation cancelled.');
-                process.exit(0);
+                    default:
+                        break;
+                }
+            }
+            const { fileName, filePath } = await chooseFileNameAsync(argFileName, projectDir, workflowStarter);
+            // Customize the template if needed
+            workflowStarter = await (0, creation_1.customizeTemplateIfNeededAsync)(workflowStarter, projectDir, expoConfig);
+            log_1.default.debug(`Creating workflow file ${fileName} from template ${workflowStarter.name}`);
+            const yamlString = [
+                workflowStarter.header,
+                (0, validation_1.workflowContentsFromParsedYaml)(workflowStarter.template),
+            ].join('\n');
+            if (!flags['skip-validation']) {
+                await (0, validation_1.validateWorkflowFileAsync)({ yamlConfig: yamlString, filePath: fileName }, projectDir, graphqlClient, projectId);
+            }
+            await ensureWorkflowsDirectoryExistsAsync({ projectDir });
+            filePath && (await promises_1.default.writeFile(filePath, yamlString));
+            log_1.default.withTick(`Created ${chalk_1.default.bold(filePath)}`);
+            log_1.default.addNewLineIfNone();
+            log_1.default.log((0, creation_1.howToRunWorkflow)(fileName, workflowStarter));
+            // Next steps
+            if (workflowStarter.nextSteps && workflowStarter.nextSteps.length > 0) {
+                log_1.default.addNewLineIfNone();
+                log_1.default.log('Next steps:');
+                log_1.default.addNewLineIfNone();
+                log_1.default.log((0, formatFields_1.default)(workflowStarter.nextSteps.map((step, index) => ({
+                    label: `${index + 1}.`,
+                    value: step,
+                }))));
             }
-            fileName = response.fileName;
-        }
-        try {
-            await this.ensureWorkflowsDirectoryExistsAsync({ projectDir });
-            await this.createWorkflowFileAsync({ fileName, projectDir });
         }
         catch (error) {
+            (0, validation_1.logWorkflowValidationErrors)(error);
             log_1.default.error('Failed to create workflow file.');
-            throw error;
         }
     }
-    async ensureWorkflowsDirectoryExistsAsync({ projectDir, }) {
+}
+exports.WorkflowCreate = WorkflowCreate;
+async function ensureWorkflowsDirectoryExistsAsync({ projectDir, }) {
+    try {
+        await promises_1.default.access(path_1.default.join(projectDir, '.eas', 'workflows'));
+    }
+    catch {
+        await promises_1.default.mkdir(path_1.default.join(projectDir, '.eas', 'workflows'), { recursive: true });
+        log_1.default.withTick(`Created directory ${chalk_1.default.bold(path_1.default.join(projectDir, '.eas', 'workflows'))}`);
+    }
+}
+async function chooseTemplateAsync() {
+    const workflowStarter = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'starter',
+        message: 'Select a workflow template:',
+        choices: creation_1.workflowStarters.map(starter => ({
+            title: starter.displayName,
+            value: starter,
+        })),
+    })).starter;
+    return workflowStarter;
+}
+async function chooseFileNameAsync(initialValue, projectDir, workflowStarter) {
+    let fileName = initialValue;
+    let filePath = '';
+    while ((fileName?.length ?? 0) === 0) {
+        fileName = (await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'fileName',
+            message: 'What would you like to name your workflow file?',
+            initial: workflowStarter.defaultFileName,
+        })).fileName;
+        if (!fileName) {
+            fileName = undefined;
+            continue;
+        }
         try {
-            await promises_1.default.access(path_1.default.join(projectDir, '.eas', 'workflows'));
+            workflowFile_1.WorkflowFile.validateYamlExtension(fileName);
         }
-        catch {
-            await promises_1.default.mkdir(path_1.default.join(projectDir, '.eas', 'workflows'), { recursive: true });
-            log_1.default.withTick(`Created directory ${chalk_1.default.bold(path_1.default.join(projectDir, '.eas', 'workflows'))}`);
+        catch (error) {
+            log_1.default.error(error instanceof Error ? error.message : 'Invalid YAML file name extension');
+            fileName = undefined;
+            continue;
         }
-    }
-    async createWorkflowFileAsync({ fileName, projectDir, }) {
-        workflowFile_1.WorkflowFile.validateYamlExtension(fileName);
-        const filePath = path_1.default.join(projectDir, '.eas', 'workflows', fileName);
+        filePath = path_1.default.join(projectDir, '.eas', 'workflows', fileName);
         if (await fs_extra_1.default.pathExists(filePath)) {
-            throw new Error(`Workflow file already exists: ${filePath}`);
+            log_1.default.error(`Workflow file already exists: ${filePath}`);
+            log_1.default.error('Please choose a different file name.');
+            log_1.default.newLine();
+            fileName = undefined;
         }
-        await promises_1.default.writeFile(filePath, HELLO_WORLD_TEMPLATE);
-        log_1.default.withTick(`Created ${chalk_1.default.bold(filePath)}`);
     }
+    return { fileName: fileName ?? '', filePath };
 }
-exports.WorkflowCreate = WorkflowCreate;

package/build/graphql/generated.d.ts

@@ -166,6 +166,7 @@ export type Account = {
     displayName?: Maybe<Scalars['String']['output']>;
     /** Environment secrets for an account */
     environmentSecrets: Array<EnvironmentSecret>;
+    environmentVariableEnvironments: Array<Scalars['EnvironmentVariableEnvironment']['output']>;
     /** Environment variables for an account */
     environmentVariables: Array<EnvironmentVariable>;
     /** Environment variables for an account with decrypted secret values */
@@ -1139,6 +1140,7 @@ export type App = Project & {
     devDomainName?: Maybe<AppDevDomainName>;
     /** Environment secrets for an app */
     environmentSecrets: Array<EnvironmentSecret>;
+    environmentVariableEnvironments: Array<Scalars['EnvironmentVariableEnvironment']['output']>;
     /** Environment variables for an app */
     environmentVariables: Array<EnvironmentVariable>;
     /** Environment variables for an app with decrypted secret values */
@@ -12704,6 +12706,20 @@ export type AppByIdWorkflowsQuery = {
                 fileName: string;
                 createdAt: any;
                 updatedAt: any;
+                revisionsPaginated: {
+                    __typename?: 'WorkflowRevisionsConnection';
+                    edges: Array<{
+                        __typename?: 'WorkflowRevisionEdge';
+                        node: {
+                            __typename?: 'WorkflowRevision';
+                            id: string;
+                            blobSha: string;
+                            commitSha?: string | null;
+                            createdAt: any;
+                            yamlConfig: string;
+                        };
+                    }>;
+                };
             }>;
         };
     };
@@ -13749,6 +13765,20 @@ export type EnvironmentSecretsByAppIdQuery = {
         };
     };
 };
+export type AppEnvironmentVariableEnvironmentsQueryVariables = Exact<{
+    appId: Scalars['String']['input'];
+}>;
+export type AppEnvironmentVariableEnvironmentsQuery = {
+    __typename?: 'RootQuery';
+    app: {
+        __typename?: 'AppQuery';
+        byId: {
+            __typename?: 'App';
+            id: string;
+            environmentVariableEnvironments: Array<any>;
+        };
+    };
+};
 export type EnvironmentVariablesIncludingSensitiveByAppIdQueryVariables = Exact<{
     appId: Scalars['String']['input'];
     filterNames?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;
@@ -15670,6 +15700,20 @@ export type WorkflowFragment = {
     fileName: string;
     createdAt: any;
     updatedAt: any;
+    revisionsPaginated: {
+        __typename?: 'WorkflowRevisionsConnection';
+        edges: Array<{
+            __typename?: 'WorkflowRevisionEdge';
+            node: {
+                __typename?: 'WorkflowRevision';
+                id: string;
+                blobSha: string;
+                commitSha?: string | null;
+                createdAt: any;
+                yamlConfig: string;
+            };
+        }>;
+    };
 };
 export type WorkflowJobFragment = {
     __typename?: 'WorkflowJob';

package/build/graphql/queries/EnvironmentVariablesQuery.d.ts

@@ -1,35 +1,35 @@
-import { EnvironmentVariableEnvironment } from '../../build/utils/environment';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { EnvironmentVariableFragment } from '../generated';
 type EnvironmentVariableWithLinkedEnvironments = EnvironmentVariableFragment & {
-    linkedEnvironments?: EnvironmentVariableEnvironment[] | null;
+    linkedEnvironments?: string[] | null;
 };
 export type EnvironmentVariableWithFileContent = EnvironmentVariableFragment & {
     valueWithFileContent?: string | null | undefined;
 };
 export declare const EnvironmentVariablesQuery: {
+    environmentVariableEnvironmentsAsync(graphqlClient: ExpoGraphqlClient, appId: string): Promise<string[]>;
     byAppIdWithSensitiveAsync(graphqlClient: ExpoGraphqlClient, { appId, environment, filterNames, includeFileContent, }: {
         appId: string;
-        environment?: EnvironmentVariableEnvironment | undefined;
+        environment?: string | undefined;
         filterNames?: string[] | undefined;
         includeFileContent?: boolean | undefined;
     }): Promise<EnvironmentVariableWithFileContent[]>;
     byAppIdAsync(graphqlClient: ExpoGraphqlClient, { appId, environment, filterNames, includeFileContent, }: {
         appId: string;
-        environment?: EnvironmentVariableEnvironment | undefined;
+        environment?: string | undefined;
         filterNames?: string[] | undefined;
         includeFileContent?: boolean | undefined;
     }): Promise<(EnvironmentVariableWithFileContent & EnvironmentVariableWithLinkedEnvironments)[]>;
     sharedAsync(graphqlClient: ExpoGraphqlClient, { appId, filterNames, environment, includeFileContent, }: {
         appId: string;
         filterNames?: string[] | undefined;
-        environment?: EnvironmentVariableEnvironment | undefined;
+        environment?: string | undefined;
         includeFileContent?: boolean | undefined;
     }): Promise<(EnvironmentVariableWithFileContent & EnvironmentVariableWithLinkedEnvironments)[]>;
     sharedWithSensitiveAsync(graphqlClient: ExpoGraphqlClient, { appId, filterNames, environment, includeFileContent, }: {
         appId: string;
         filterNames?: string[] | undefined;
-        environment?: EnvironmentVariableEnvironment | undefined;
+        environment?: string | undefined;
         includeFileContent?: boolean | undefined;
     }): Promise<EnvironmentVariableWithFileContent[]>;
 };

package/build/graphql/queries/EnvironmentVariablesQuery.js

@@ -8,6 +8,21 @@ const client_1 = require("../client");
 const EnvironmentVariable_1 = require("../types/EnvironmentVariable");
 const EnvironmentVariableWithSecret_1 = require("../types/EnvironmentVariableWithSecret");
 exports.EnvironmentVariablesQuery = {
+    async environmentVariableEnvironmentsAsync(graphqlClient, appId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query AppEnvironmentVariableEnvironments($appId: String!) {
+              app {
+                byId(appId: $appId) {
+                  id
+                  environmentVariableEnvironments
+                }
+              }
+            }
+          `, { appId }, { additionalTypenames: ['App'] })
+            .toPromise());
+        return data.app?.byId.environmentVariableEnvironments ?? [];
+    },
     async byAppIdWithSensitiveAsync(graphqlClient, { appId, environment, filterNames, includeFileContent = false, }) {
         const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `

package/build/graphql/types/Workflow.js

@@ -10,5 +10,16 @@ exports.WorkflowFragmentNode = (0, graphql_tag_1.default) `
     fileName
     createdAt
     updatedAt
+    revisionsPaginated(first: 1) {
+      edges {
+        node {
+          id
+          blobSha
+          commitSha
+          createdAt
+          yamlConfig
+        }
+      }
+    }
   }
 `;

package/build/utils/prompts.d.ts

@@ -1,20 +1,23 @@
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { EnvironmentSecretType, EnvironmentVariableVisibility } from '../graphql/generated';
 import { RequestedPlatform } from '../platform';
+export declare function getProjectEnvironmentVariableEnvironmentsAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<string[]>;
 export declare function promptVariableTypeAsync(nonInteractive: boolean, initialType?: EnvironmentSecretType): Promise<EnvironmentSecretType>;
 export declare function parseVisibility(stringVisibility: 'plaintext' | 'sensitive' | 'secret'): EnvironmentVariableVisibility;
 export declare function promptVariableVisibilityAsync(nonInteractive: boolean, selectedVisibility?: EnvironmentVariableVisibility | null): Promise<EnvironmentVariableVisibility>;
 type EnvironmentPromptArgs = {
     nonInteractive: boolean;
-    selectedEnvironments?: EnvironmentVariableEnvironment[];
-    availableEnvironments?: EnvironmentVariableEnvironment[];
+    selectedEnvironments?: string[];
+    graphqlClient?: ExpoGraphqlClient;
+    projectId?: string;
+    canEnterCustomEnvironment?: boolean;
 };
 export declare function promptVariableEnvironmentAsync(input: EnvironmentPromptArgs & {
     multiple: true;
-}): Promise<EnvironmentVariableEnvironment[]>;
+}): Promise<string[]>;
 export declare function promptVariableEnvironmentAsync(input: EnvironmentPromptArgs & {
     multiple?: false;
-}): Promise<EnvironmentVariableEnvironment>;
+}): Promise<string>;
 export declare function promptVariableValueAsync({ nonInteractive, required, hidden, filePath, initial, }: {
     nonInteractive: boolean;
     required?: boolean;

package/build/utils/prompts.js

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptPlatformAsync = exports.promptVariableNameAsync = exports.promptVariableValueAsync = exports.promptVariableEnvironmentAsync = exports.promptVariableVisibilityAsync = exports.parseVisibility = exports.promptVariableTypeAsync = void 0;
+exports.promptPlatformAsync = exports.promptVariableNameAsync = exports.promptVariableValueAsync = exports.promptVariableEnvironmentAsync = exports.promptVariableVisibilityAsync = exports.parseVisibility = exports.promptVariableTypeAsync = exports.getProjectEnvironmentVariableEnvironmentsAsync = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const environment_1 = require("../build/utils/environment");
 const generated_1 = require("../graphql/generated");
+const EnvironmentVariablesQuery_1 = require("../graphql/queries/EnvironmentVariablesQuery");
 const platform_1 = require("../platform");
 const prompts_1 = require("../prompts");
+const DEFAULT_ENVIRONMENTS = Object.values(environment_1.DefaultEnvironment);
+async function getProjectEnvironmentVariableEnvironmentsAsync(graphqlClient, projectId) {
+    try {
+        const environments = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.environmentVariableEnvironmentsAsync(graphqlClient, projectId);
+        return environments;
+    }
+    catch {
+        throw new Error('Failed to fetch available environments');
+    }
+}
+exports.getProjectEnvironmentVariableEnvironmentsAsync = getProjectEnvironmentVariableEnvironmentsAsync;
+const CUSTOM_ENVIRONMENT_VALUE = '~~CUSTOM~~';
 async function promptVariableTypeAsync(nonInteractive, initialType) {
     if (nonInteractive) {
         throw new Error('The `--type` flag must be set when running in `--non-interactive` mode.');
@@ -39,6 +52,23 @@ function parseVisibility(stringVisibility) {
     }
 }
 exports.parseVisibility = parseVisibility;
+async function promptCustomEnvironmentAsync() {
+    const { customEnvironment } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'customEnvironment',
+        message: 'Enter custom environment name:',
+        validate: (value) => {
+            if (!value || value.trim() === '') {
+                return 'Environment name cannot be empty';
+            }
+            if (!value.match(/^[a-zA-Z0-9_-]+$/)) {
+                return 'Environment name may only contain letters, numbers, underscores, and hyphens';
+            }
+            return true;
+        },
+    });
+    return customEnvironment;
+}
 async function promptVariableVisibilityAsync(nonInteractive, selectedVisibility) {
     if (nonInteractive) {
         throw new Error('The `--visibility` flag must be set when running in `--non-interactive` mode.');
@@ -62,26 +92,55 @@ async function promptVariableVisibilityAsync(nonInteractive, selectedVisibility)
     ]);
 }
 exports.promptVariableVisibilityAsync = promptVariableVisibilityAsync;
-async function promptVariableEnvironmentAsync({ nonInteractive, selectedEnvironments, multiple = false, availableEnvironments, }) {
+async function promptVariableEnvironmentAsync({ nonInteractive, selectedEnvironments, multiple = false, canEnterCustomEnvironment = false, graphqlClient, projectId, }) {
     if (nonInteractive) {
         throw new Error('The `--environment` flag must be set when running in `--non-interactive` mode.');
     }
+    let allEnvironments = DEFAULT_ENVIRONMENTS;
+    if (graphqlClient && projectId) {
+        const projectEnvironments = await getProjectEnvironmentVariableEnvironmentsAsync(graphqlClient, projectId);
+        allEnvironments = [...new Set([...DEFAULT_ENVIRONMENTS, ...projectEnvironments])];
+    }
     if (!multiple) {
-        return await (0, prompts_1.selectAsync)('Select environment:', (availableEnvironments ?? Object.values(environment_1.EnvironmentVariableEnvironment)).map(environment => ({
-            title: environment.toLocaleLowerCase(),
+        const choices = allEnvironments.map(environment => ({
+            title: environment,
             value: environment,
-        })));
+        }));
+        if (canEnterCustomEnvironment) {
+            choices.push({
+                title: 'Other (enter custom environment)',
+                value: CUSTOM_ENVIRONMENT_VALUE,
+            });
+        }
+        const selectedEnvironment = await (0, prompts_1.selectAsync)('Select environment:', choices);
+        if (selectedEnvironment === CUSTOM_ENVIRONMENT_VALUE) {
+            return await promptCustomEnvironmentAsync();
+        }
+        return selectedEnvironment;
+    }
+    const choices = allEnvironments.map(environment => ({
+        title: environment,
+        value: environment,
+        selected: selectedEnvironments?.includes(environment),
+    }));
+    if (canEnterCustomEnvironment) {
+        choices.push({
+            title: 'Other (enter custom environment)',
+            value: CUSTOM_ENVIRONMENT_VALUE,
+            selected: false,
+        });
     }
     const { environments } = await (0, prompts_1.promptAsync)({
         message: 'Select environment:',
         name: 'environments',
         type: 'multiselect',
-        choices: Object.values(environment_1.EnvironmentVariableEnvironment).map(environment => ({
-            title: environment.toLocaleLowerCase(),
-            value: environment,
-            selected: selectedEnvironments?.includes(environment),
-        })),
+        choices,
     });
+    if (environments?.includes(CUSTOM_ENVIRONMENT_VALUE)) {
+        const customEnvironment = await promptCustomEnvironmentAsync();
+        const filteredEnvironments = environments.filter((env) => env !== CUSTOM_ENVIRONMENT_VALUE);
+        return [...filteredEnvironments, customEnvironment];
+    }
     return environments;
 }
 exports.promptVariableEnvironmentAsync = promptVariableEnvironmentAsync;

package/build/utils/variableUtils.d.ts

@@ -1,8 +1,6 @@
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 import { EnvironmentVariableFragment } from '../graphql/generated';
 import { EnvironmentVariableWithFileContent } from '../graphql/queries/EnvironmentVariablesQuery';
-export declare function isEnvironment(environment: string): environment is EnvironmentVariableEnvironment;
 export declare function formatVariableName(variable: EnvironmentVariableFragment): string;
 export declare function formatVariableValue(variable: EnvironmentVariableWithFileContent): string;
-export declare function performForEnvironmentsAsync(environments: EnvironmentVariableEnvironment[] | null, fun: (environment: EnvironmentVariableEnvironment | undefined) => Promise<any>): Promise<any[]>;
+export declare function performForEnvironmentsAsync(environments: string[] | null, fun: (environment: string | undefined) => Promise<any>): Promise<any[]>;
 export declare function formatVariable(variable: EnvironmentVariableWithFileContent): string;

package/build/utils/variableUtils.js

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatVariable = exports.performForEnvironmentsAsync = exports.formatVariableValue = exports.formatVariableName = exports.isEnvironment = void 0;
+exports.formatVariable = exports.performForEnvironmentsAsync = exports.formatVariableValue = exports.formatVariableName = void 0;
 const tslib_1 = require("tslib");
 const dateformat_1 = tslib_1.__importDefault(require("dateformat"));
 const formatFields_1 = tslib_1.__importDefault(require("./formatFields"));
-const environment_1 = require("../build/utils/environment");
 const generated_1 = require("../graphql/generated");
-function isEnvironment(environment) {
-    return Object.values(environment_1.EnvironmentVariableEnvironment).includes(environment);
-}
-exports.isEnvironment = isEnvironment;
 function formatVariableName(variable) {
     const name = variable.name;
     const scope = variable.scope === generated_1.EnvironmentVariableScope.Project ? 'project' : 'shared';

package/build/worker/assets.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 import { GzipOptions } from 'minizlib';
-import { EnvironmentVariableEnvironment } from '../build/utils/environment';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 interface AssetMapOptions {
     maxFileSize: number;
@@ -36,7 +35,7 @@ export interface CreateManifestResult {
 interface CreateManifestParams {
     projectId: string;
     projectDir: string;
-    environment?: EnvironmentVariableEnvironment;
+    environment?: string;
 }
 /** Creates a manifest configuration sent up for deployment */
 export declare function createManifestAsync(params: CreateManifestParams, graphqlClient: ExpoGraphqlClient): Promise<CreateManifestResult>;