@graphcommerce/hygraph-cli 8.1.0-canary.9 → 9.0.0-canary.101

package/src/migrateHygraphCli.ts

@@ -0,0 +1,113 @@
+import fs from 'fs'
+import { loadConfig } from '@graphcommerce/next-config'
+import dotenv from 'dotenv'
+import prompts, { PromptObject } from 'prompts'
+import { UpsertClient } from './UpsertClient'
+import * as availableMigrations from './migrations'
+import { readSchema } from './readSchema'
+import { MigrationFunction, Schema } from './types'
+import { getConfig } from './utils/getConfig'
+import { getEnvironment } from './utils/getEndpointUrl'
+import { getManagementClient } from './utils/getManagementClient'
+import { graphcommerceLog } from './utils/graphCommerceLog'
+
+dotenv.config()
+
+export async function migrateHygraphCli() {
+  const hygraphConfig = getConfig(loadConfig(process.cwd()))
+
+  /**
+   * Extracting the current GC version. Are we gonna use the current version to determine which
+   * scripts should be runned? Or do we let the user pick the migration from a list? 🤔
+   */
+  const packageJson = fs.readFileSync('package.json', 'utf8')
+  const packageData = JSON.parse(packageJson)
+  const graphcommerceVersion = packageData.dependencies['@graphcommerce/next-ui']
+  graphcommerceLog(`Graphcommerce version: ${graphcommerceVersion}`, 'info')
+
+  const mangementClient = getManagementClient(hygraphConfig)
+  // Extract the currently existing models, components and enumerations from the Hygraph schema.
+  const schemaViewer = await readSchema(mangementClient, hygraphConfig.projectId)
+  const schema: Schema = schemaViewer.viewer.project.environment.contentModel
+
+  // A list of possible migrations
+  const possibleMigrations: [string, MigrationFunction][] = Object.entries(availableMigrations)
+
+  // Here we setup the list we ask the user to choose from
+  const selectMigrationInput: PromptObject<string> = {
+    type: 'select',
+    name: 'selectedMigration',
+    message: '\x1b[36m\x1b[1m[]: Select migration',
+    choices: possibleMigrations.map(([name, migration]) => ({
+      title: name,
+      value: { name, migration },
+    })),
+  }
+
+  // Here we ask the user to choose a migration from a list of possible migrations
+  try {
+    graphcommerceLog('Available migrations: ', 'info')
+    const selectMigrationOutput = await prompts(selectMigrationInput)
+
+    let { migration, name } = selectMigrationOutput.selectedMigration as {
+      name: string
+      migration: MigrationFunction
+    }
+
+    graphcommerceLog(
+      `You have selected the ${selectMigrationOutput.selectedMigration.name} migration`,
+      'info',
+    )
+
+    try {
+      const { endpoint, migrations } = await getEnvironment(mangementClient, hygraphConfig)
+
+      const migrationExists = migrations.find(
+        (m) => m.name?.startsWith(name) && m.status === 'SUCCESS',
+      )
+      if (migrationExists) {
+        if (!process.argv.includes('--force')) {
+          graphcommerceLog(
+            `Migration ${name} as ${migrationExists.name} already exists in Hygraph with the status SUCCESS. To rerun this migration use the --force option. Exiting now..`,
+            'info',
+          )
+          process.exit(1)
+        } else {
+          graphcommerceLog(
+            `Migration ${name} as ${migrationExists.name} already exists in Hygraph with the status SUCCESS. Using --force, rerunning migration..`,
+            'warning',
+          )
+        }
+        name = `${name}-${Date.now()}`
+      }
+
+      // Here we try to run the migration
+      const result = await migration(
+        schema,
+        new UpsertClient({ authToken: hygraphConfig.authToken, endpoint, name }, schema),
+      )
+
+      graphcommerceLog(`Migration result: ${JSON.stringify(result)}`, 'info')
+      if (!result) {
+        graphcommerceLog(
+          'No migration client found. Please make sure your GC_HYGRAPH_WRITE_ACCESS_TOKEN in your env file is correct.',
+        )
+        process.exit(1)
+      }
+      if (result.status !== 'SUCCESS') {
+        graphcommerceLog(`Migration not successful: ${result.status} ${name}:\n${result.errors}`)
+        process.exit(1)
+      }
+
+      graphcommerceLog(`Migration successful: ${name}`, 'info')
+    } catch (err) {
+      if (err instanceof Error) {
+        const garbledErrorIndex = err.message.indexOf(': {"')
+        const msg = garbledErrorIndex > 0 ? err.message.slice(0, garbledErrorIndex) : err.message
+        graphcommerceLog(`${msg}`, 'error')
+      }
+    }
+  } catch (error) {
+    graphcommerceLog(`An error occurred: ${error}`, 'error')
+  }
+}

package/src/migrationActionFactory.ts

@@ -0,0 +1,230 @@
+import { loadConfig } from '@graphcommerce/next-config'
+import {
+  BatchMigrationCreateModelInput,
+  BatchMigrationCreateComponentInput,
+  BatchMigrationCreateEnumerationInput,
+  BatchMigrationCreateSimpleFieldInput,
+  BatchMigrationCreateEnumerableFieldInput,
+  BatchMigrationCreateRelationalFieldInput,
+  BatchMigrationCreateUnionFieldInput,
+  BatchMigrationCreateComponentFieldInput,
+  BatchMigrationDeleteComponentInput,
+  BatchMigrationDeleteEnumerationInput,
+  BatchMigrationDeleteModelInput,
+  BatchMigrationUpdateComponentFieldInput,
+  BatchMigrationUpdateComponentInput,
+  BatchMigrationUpdateEnumerableFieldInput,
+  BatchMigrationUpdateEnumerationInput,
+  BatchMigrationUpdateModelInput,
+  BatchMigrationUpdateRelationalFieldInput,
+  BatchMigrationUpdateSimpleFieldInput,
+  BatchMigrationUpdateUnionFieldInput,
+  BatchMigrationDeleteFieldInput,
+  BatchMigrationCreateComponentUnionFieldInput,
+  BatchMigrationUpdateComponentUnionFieldInput,
+  Client,
+} from '@hygraph/management-sdk'
+import dotenv from 'dotenv'
+import { Schema } from './types'
+import { graphcommerceLog, capitalize } from './utils/graphCommerceLog'
+
+dotenv.config()
+
+type AllHygraphTypes =
+  | 'model'
+  | 'component'
+  | 'enumeration'
+  | 'simpleField'
+  | 'componentField'
+  | 'enumerableField'
+  | 'relationalField'
+  | 'unionField'
+  | 'componentUnionField'
+
+type AllActions =
+  | BatchMigrationCreateModelInput
+  | BatchMigrationUpdateModelInput
+  | BatchMigrationDeleteModelInput
+  | BatchMigrationCreateComponentInput
+  | BatchMigrationUpdateComponentInput
+  | BatchMigrationDeleteComponentInput
+  | BatchMigrationCreateEnumerationInput
+  | BatchMigrationUpdateEnumerationInput
+  | BatchMigrationDeleteEnumerationInput
+  | BatchMigrationCreateSimpleFieldInput // type: SimpleFieldType
+  | BatchMigrationUpdateSimpleFieldInput
+  | BatchMigrationCreateEnumerableFieldInput
+  | BatchMigrationUpdateEnumerableFieldInput
+  | BatchMigrationCreateRelationalFieldInput // type: RelationalFieldType
+  | BatchMigrationUpdateRelationalFieldInput
+  | BatchMigrationCreateUnionFieldInput
+  | BatchMigrationUpdateUnionFieldInput
+  | BatchMigrationCreateComponentFieldInput
+  | BatchMigrationUpdateComponentFieldInput
+  | BatchMigrationDeleteFieldInput
+  | BatchMigrationCreateComponentUnionFieldInput
+  | BatchMigrationUpdateComponentUnionFieldInput
+
+export function migrationActionFactory(schema: Schema, client: Client) {
+  /**
+   * This constant is used to assign the right action of the management SDK to the migratioAction
+   * function
+   */
+  const actionMap = client
+    ? {
+        create: {
+          model: (innerprops: BatchMigrationCreateModelInput) => client.createModel(innerprops),
+          component: (innerprops: BatchMigrationCreateComponentInput) =>
+            client.createComponent(innerprops),
+          enumeration: (innerprops: BatchMigrationCreateEnumerationInput) =>
+            client.createEnumeration(innerprops),
+          simpleField: (innerprops: BatchMigrationCreateSimpleFieldInput) =>
+            client.createSimpleField(innerprops),
+          enumerableField: (innerprops: BatchMigrationCreateEnumerableFieldInput) =>
+            client.createEnumerableField(innerprops),
+          componentField: (innerprops: BatchMigrationCreateComponentFieldInput) =>
+            client.createComponentField(innerprops),
+          relationalField: (innerprops: BatchMigrationCreateRelationalFieldInput) =>
+            client.createRelationalField(innerprops),
+          unionField: (innerprops: BatchMigrationCreateUnionFieldInput) =>
+            client.createUnionField(innerprops),
+          componentUnionField: (innerprops: BatchMigrationCreateComponentUnionFieldInput) =>
+            client.createComponentUnionField(innerprops),
+        },
+        update: {
+          model: (innerprops: BatchMigrationUpdateModelInput) => client.updateModel(innerprops),
+          component: (innerprops: BatchMigrationUpdateComponentInput) =>
+            client.updateComponent(innerprops),
+          enumeration: (innerprops: BatchMigrationUpdateEnumerationInput) =>
+            client.updateEnumeration(innerprops),
+          simpleField: (innerprops: BatchMigrationUpdateSimpleFieldInput) =>
+            client.updateSimpleField(innerprops),
+          enumerableField: (innerprops: BatchMigrationUpdateEnumerableFieldInput) =>
+            client.updateEnumerableField(innerprops),
+          componentField: (innerprops: BatchMigrationUpdateComponentFieldInput) =>
+            client.updateComponentField(innerprops),
+          relationalField: (innerprops: BatchMigrationUpdateRelationalFieldInput) =>
+            client.updateRelationalField(innerprops),
+          unionField: (innerprops: BatchMigrationUpdateUnionFieldInput) =>
+            client.updateUnionField(innerprops),
+          componentUnionField: (innerprops: BatchMigrationUpdateComponentUnionFieldInput) =>
+            client.updateComponentUnionField(innerprops),
+        },
+        delete: {
+          model: (innerprops: BatchMigrationDeleteModelInput) => client.deleteModel(innerprops),
+          component: (innerprops: BatchMigrationDeleteComponentInput) =>
+            client.deleteComponent(innerprops),
+          enumeration: (innerprops: BatchMigrationDeleteEnumerationInput) =>
+            client.deleteEnumeration(innerprops),
+          simpleField: (innerprops: BatchMigrationDeleteFieldInput) =>
+            client.deleteField(innerprops),
+          enumerableField: (innerprops: BatchMigrationDeleteFieldInput) =>
+            client.deleteField(innerprops),
+          componentField: (innerprops: BatchMigrationDeleteFieldInput) =>
+            client.deleteField(innerprops),
+          relationalField: (innerprops: BatchMigrationDeleteFieldInput) =>
+            client.deleteField(innerprops),
+          unionField: (innerprops: BatchMigrationDeleteFieldInput) =>
+            client.deleteField(innerprops),
+          componentUnionField: (innerprops: BatchMigrationDeleteFieldInput) =>
+            client.deleteField(innerprops),
+        },
+      }
+    : undefined
+
+  /**
+   * This function is our variation on the client.migrationAction functions from the hygraph
+   * management sdk.
+   *
+   * MigrationAction() is better suited because it is a single function for all actions. More
+   * importantly, if the action fails, because a field with the apiID already exists for instance. it
+   * will skip this action but still continue the whole migration, while the management sdk function
+   * will bail.
+   *
+   * It takes the schema as argument, which is always the same.
+   *
+   * Then it takes the type of schema entity you want to do an action upon, and the action you want to
+   * do.
+   *
+   * The fourth arguments are the props that belong to the action you want to do. For instance, if you
+   * want to create a model, you need to pass the props that belong to a model.
+   *
+   * The last two arguments are optional. If you want to create a field, you need to pass the apiId of
+   * the model or component you want to create the field on. If you want to create a field on a
+   * component, you also need to pass the parentType, which is either 'model' or 'component'.
+   */
+  const migrationAction = (
+    _schema: unknown,
+    type: AllHygraphTypes,
+    action: 'create' | 'update' | 'delete',
+    props: AllActions,
+    parentApiId?: string,
+    parentType?: 'model' | 'component' | 'enumeration',
+  ) => {
+    /**
+     * Check if the entity already exists.
+     * If an update or deletion is made, it does not matter if the entity already exists
+     */
+    const alreadyExists = () => {
+      if (action !== 'create') {
+        return false
+      }
+      switch (type) {
+        case 'model':
+          return schema.models.some((model) => model.apiId === props.apiId)
+
+        case 'component':
+          return schema.components.some((component) => component.apiId === props.apiId)
+
+        case 'enumeration':
+          return schema.enumerations.some((enumeration) => enumeration.apiId === props.apiId)
+
+        case 'simpleField':
+        case 'enumerableField':
+        case 'relationalField':
+        case 'unionField':
+        case 'componentUnionField': {
+          let parent
+          switch (parentType) {
+            case 'model': {
+              parent = schema.models.find((model) => model.apiId === parentApiId)
+              break
+            }
+            case 'component': {
+              parent = schema.components.find((component) => component.apiId === parentApiId)
+              break
+            }
+            default:
+              return false
+          }
+          return parent?.fields.some((field) => field.apiId === props.apiId)
+        }
+        default: {
+          return false
+        }
+      }
+    }
+
+    const actionFunc = actionMap && actionMap[action] && actionMap[action][type]
+
+    if (!alreadyExists()) {
+      if (actionFunc) {
+        graphcommerceLog(`${capitalize(action)} ${type} with apiId ${props.apiId}...`)
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore | This error is a loss on typescript autocomplete, but the function is called correctly
+        actionFunc(props)
+      } else {
+        graphcommerceLog(`Action ${action} is not supported for ${type}`, 'error')
+      }
+    } else {
+      graphcommerceLog(
+        `${capitalize(type)} with apiId ${props.apiId} on ${parentApiId} already exists`,
+        'warning',
+      )
+    }
+  }
+
+  return {
+    migrationAction,
+  }
+}

package/src/migrations/graphcommerce5to6.ts

@@ -1,11 +1,9 @@
 import { RelationalFieldType, SimpleFieldType, VisibilityTypes } from '@hygraph/management-sdk'
-import { migrationAction, client } from '../migrationAction'
-import { Schema } from '../types'
+import { migrationActionFactory } from '../migrationActionFactory'
+import { MigrationFunction } from '../types'
 
-export const graphcommerce5to6 = async (schema: Schema) => {
-  if (!client) {
-    return 0
-  }
+export const graphcommerce5to6: MigrationFunction = async (schema, client) => {
+  const { migrationAction } = migrationActionFactory(schema, client)
 
   // ? ENUMERATIONS
   migrationAction(schema, 'enumeration', 'create', {

package/src/migrations/graphcommerce6to7.ts

@@ -1,11 +1,9 @@
 import { SimpleFieldType, VisibilityTypes } from '@hygraph/management-sdk'
-import { migrationAction, client } from '../migrationAction'
-import { Schema } from '../types'
+import { migrationActionFactory } from '../migrationActionFactory'
+import { MigrationFunction } from '../types'
 
-export const graphcommerce6to7 = async (schema: Schema) => {
-  if (!client) {
-    return 0
-  }
+export const graphcommerce6to7: MigrationFunction = async (schema, client) => {
+  const { migrationAction } = migrationActionFactory(schema, client)
 
   // ? ENUMERATIONS
   migrationAction(schema, 'enumeration', 'create', {

package/src/migrations/graphcommerce7to8.ts

@@ -1,11 +1,9 @@
 import { VisibilityTypes } from '@hygraph/management-sdk'
-import { migrationAction, client } from '../migrationAction'
-import { Schema } from '../types'
+import { migrationActionFactory } from '../migrationActionFactory'
+import { MigrationFunction } from '../types'
 
-export const graphcommerce7to8 = async (schema: Schema) => {
-  if (!client) {
-    return 0
-  }
+export const graphcommerce7to8: MigrationFunction = async (schema, client) => {
+  const { migrationAction } = migrationActionFactory(schema, client)
 
   const hasRow = schema.models
     .find((m) => m.apiId === 'DynamicRow')

package/src/migrations/graphcommerce8to9.ts

@@ -1,12 +1,16 @@
-import { migrationAction, client } from '../migrationAction'
-import { Schema } from '../types'
+import {
+  BatchMigrationCreateEnumerableFieldInput,
+  BatchMigrationCreateEnumerationInput,
+  BatchMigrationCreateModelInput,
+  BatchMigrationCreateSimpleFieldInput,
+  SimpleFieldType,
+  VisibilityTypes,
+} from '@hygraph/management-sdk'
+import { migrationActionFactory } from '../migrationActionFactory'
+import { MigrationFunction } from '../types'
 
-export const graphcommerce8to9 = async (schema: Schema) => {
-  if (!client) {
-    return 0
-  }
-
-  // This migration is for GC 8.0 and is not yet exported as a usable migration.
+export const graphcommerce8to9: MigrationFunction = async (schema, client) => {
+  const { migrationAction } = migrationActionFactory(schema, client)
 
   // Removes the deprecated 'Row' field which was deprecated in GC@7.1
   const hasRow = schema.models
@@ -20,5 +24,72 @@ export const graphcommerce8to9 = async (schema: Schema) => {
     })
   }
 
+  const hasRowCategory = schema.models.some((m) => m.apiId === 'RowCategory')
+
+  //
+  if (!hasRowCategory) {
+    migrationAction(schema, 'model', 'create', {
+      apiId: 'RowCategory',
+      displayName: 'Row Category',
+      apiIdPlural: 'RowProductLists',
+      description: 'A model that displays a category',
+    } satisfies BatchMigrationCreateModelInput)
+
+    migrationAction(
+      schema,
+      'simpleField',
+      'create',
+      {
+        position: 1,
+        type: SimpleFieldType.String,
+        formConfig: { renderer: 'GCMS_SLUG', config: { isLowercase: true } },
+        validations: {
+          String: {
+            matches: {
+              regex: '^[a-z0-9]+(?:[-/][a-z0-9]+)*$',
+              errorMessage: 'The category URL must be a valid slug',
+            },
+          },
+        },
+        parentApiId: 'RowCategory',
+        displayName: 'Category URL',
+        apiId: 'categoryUrl',
+        description: 'The URL of the category, may include slashes',
+        isTitle: true,
+        isLocalized: true,
+        isRequired: true,
+        visibility: VisibilityTypes.ReadWrite,
+      } satisfies BatchMigrationCreateSimpleFieldInput,
+      'RowCategory',
+      'model',
+    )
+
+    migrationAction(schema, 'enumeration', 'create', {
+      displayName: 'Row Category Variant',
+      apiId: 'RowCategoryVariant',
+      values: [
+        { displayName: 'Backstory', apiId: 'Backstory' },
+        { displayName: 'Grid', apiId: 'Grid' },
+        { displayName: 'Swipeable', apiId: 'Swipeable' },
+      ],
+    } satisfies BatchMigrationCreateEnumerationInput)
+
+    migrationAction(
+      schema,
+      'enumerableField',
+      'create',
+      {
+        displayName: 'Variant',
+        apiId: 'variant',
+        parentApiId: 'RowCategory',
+        enumerationApiId: 'RowCategoryVariant',
+        description: 'As what variant wil the RowCategory be displayed',
+        isRequired: true,
+      } satisfies BatchMigrationCreateEnumerableFieldInput,
+      'RowCategory',
+      'model',
+    )
+  }
+
   return client.run(true)
 }

package/src/readSchema.ts

@@ -1,38 +1,25 @@
-import { ApolloClient, InMemoryCache, gql, HttpLink } from '@apollo/client'
-import { GraphCommerceConfig } from '@graphcommerce/next-config'
-import { fetch } from '@whatwg-node/fetch'
+import { ApolloClient, gql, NormalizedCacheObject } from '@apollo/client'
+import { Schema } from './types'
 
-export const readSchema = async (config: GraphCommerceConfig) => {
-  if (!config.hygraphProjectId) {
-    throw new Error('Please provide GC_HYGRAPH_PROJECT_ID in your env file.')
-  }
-
-  if (!config.hygraphWriteAccessToken) {
-    throw new Error('Please provide GC_HYGRAPH_WRITE_ACCESS_TOKEN in your env file.')
-  }
-
-  const projectId = config.hygraphProjectId
-
-  if (!config.hygraphManagementApi) {
-    throw new Error('Please provide GC_HYGRAPH_MANAGEMENT_API in your env file.')
-  }
-
-  const hygraphClient = new ApolloClient({
-    link: new HttpLink({
-      uri: config.hygraphManagementApi,
-      fetch,
-      headers: { Authorization: `Bearer ${config.hygraphWriteAccessToken}` },
-    }),
-    cache: new InMemoryCache(),
-  })
-
-  const { data } = await hygraphClient.query({
+export const readSchema = async (
+  managementClient: ApolloClient<NormalizedCacheObject>,
+  projectId: string,
+) => {
+  const { data } = await managementClient.query({
     query: gql`
       query getSchema($projectId: ID!) {
         viewer {
           project(id: $projectId) {
             environment(name: "master") {
               contentModel {
+                locales {
+                  id
+                  apiId
+                }
+                stages {
+                  id
+                  apiId
+                }
                 models {
                   apiId
                   apiIdPlural
@@ -61,5 +48,13 @@ export const readSchema = async (config: GraphCommerceConfig) => {
     },
   })
 
-  return data
+  return data as {
+    viewer: {
+      project: {
+        environment: {
+          contentModel: Schema
+        }
+      }
+    }
+  }
 }

package/src/types.ts

@@ -1,11 +1,16 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
-import type { Model, Component, Enumeration } from '@hygraph/management-sdk'
+import type { Model, Component, Enumeration, Client, Locale, Stage } from '@hygraph/management-sdk'
 import type { MigrationInfo } from '@hygraph/management-sdk/dist/src/ManagementAPIClient'
+import type { UpsertClient } from './UpsertClient'
 
 export type Migration = (name: string | undefined) => Promise<MigrationInfo>
 
+export type MigrationFunction = (schema: Schema, client: UpsertClient) => Promise<0 | MigrationInfo>
+
 export type Schema = {
   models: Model[]
   components: Component[]
   enumerations: Enumeration[]
+  locales: Locale[]
+  stages: Stage[]
 }

package/src/utils/getConfig.ts

@@ -0,0 +1,33 @@
+import { GraphCommerceConfig } from '@graphcommerce/next-config'
+
+export type HygraphConfig = {
+  projectId: string
+  authToken: string
+  uri: string
+}
+
+export function getConfig(config: GraphCommerceConfig) {
+  let {
+    hygraphProjectId: projectId,
+    hygraphWriteAccessToken: authToken,
+    hygraphManagementApi: uri,
+    hygraphEndpoint,
+  } = config
+
+  if (!authToken) {
+    throw new Error('Please provide GC_HYGRAPH_WRITE_ACCESS_TOKEN in your env file.')
+  }
+
+  if (!projectId) {
+    projectId = new URL(hygraphEndpoint).pathname.split('/')?.[1]
+  }
+
+  if (!uri) {
+    const endpoint = new URL(hygraphEndpoint)
+    endpoint.hostname = `management-${endpoint.hostname}`.replace('.cdn', '')
+    endpoint.pathname = 'graphql'
+    uri = endpoint.toString()
+  }
+
+  return { projectId, authToken, uri }
+}

package/src/utils/getEndpointUrl.ts

@@ -0,0 +1,65 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client'
+import gql from 'graphql-tag'
+import { HygraphConfig } from './getConfig'
+
+export async function getEnvironment(
+  client: ApolloClient<NormalizedCacheObject>,
+  config: HygraphConfig,
+) {
+  const endpoints = await client.query<
+    {
+      viewer: {
+        id: string
+        project: {
+          environments: {
+            name: string
+            endpoint: string
+            migrations: {
+              name: string
+              status: string
+            }[]
+          }[]
+        }
+      }
+    },
+    { projectId: string }
+  >({
+    query: gql`
+      query Environments($projectId: ID!) {
+        viewer {
+          id
+          project(id: $projectId) {
+            environments {
+              name
+              endpoint
+              migrations {
+                name
+                status
+              }
+            }
+          }
+        }
+      }
+    `,
+    variables: { projectId: config.projectId },
+    errorPolicy: 'all',
+  })
+
+  if (endpoints.errors) {
+    const isBadInput = endpoints.errors.some((e) => e.extensions?.code === 'BAD_USER_INPUT')
+    if (isBadInput) {
+      throw Error(`
+        Could not find environment for projectId ${config.projectId}. 
+        Please check your GC_HYGRAPH_PROJECT_ID in your env file.
+      `)
+    }
+
+    throw new Error(`An error occurred: ${endpoints.errors.map((e) => e.message).join('\n')}`)
+  }
+
+  const environment =
+    endpoints.data.viewer.project.environments.find((env) => env.name === 'master') ??
+    endpoints.data.viewer.project.environments?.[0]
+
+  return environment
+}