@aws-amplify/amplify-util-uibuilder 1.6.5 → 1.6.6-rc.4b3db16df.0

package/src/__tests__/detachedFormCleanup.test.ts

@@ -0,0 +1,78 @@
+// @aws-amplify/codegen-ui is in project dependencies
+import { StudioSchema } from '@aws-amplify/codegen-ui'; // eslint-disable-line import/no-extraneous-dependencies
+import {AmplifyStudioClient} from '../clients'; // eslint-disable-line import/no-extraneous-dependencies
+import {
+  isFormDetachedFromModel, isFormSchemaCustomized, isStudioForm, deleteDetachedForms
+} from '../commands/utils';
+
+const amplifyStudioClientMock = AmplifyStudioClient as any;
+
+const formWithNoCustomization: StudioSchema = {
+  id: 'f-123456',
+  name: 'BlogCreateForm',
+  formActionType: 'create',
+  dataType: {
+    dataSourceType: 'DataStore',
+    dataTypeName: 'Blog',
+  },
+  fields: {},
+  sectionalElements: {},
+  style: {},
+  cta: {},
+};
+
+const formWithStyle: StudioSchema = {
+  ...formWithNoCustomization,
+  dataType: { dataSourceType: 'Custom', dataTypeName: 'Blog' },
+  style: {
+    horizontalGap: { value: '20px' },
+  },
+};
+
+const formWithFields: StudioSchema = {
+  ...formWithNoCustomization,
+  dataType: { dataSourceType: 'Custom', dataTypeName: 'Blog' },
+  fields: {
+    name: { inputType: { type: 'TextField' } },
+  },
+};
+
+describe('detachedFormCleanup', () => {
+
+  it('isStudioForm should return true', () => {
+    expect(isStudioForm(formWithNoCustomization)).toBe(true);
+  });
+
+  it('isStudioForm should return false', () => {
+    expect(isStudioForm(undefined)).toBe(false);
+  });
+
+  it('isFormSchemaCustomized should return false', () => {
+    expect(isFormSchemaCustomized(formWithNoCustomization)).toBe(false);
+  });
+
+  it('isFormSchemaCustomized should return true', () => {
+    expect(isFormSchemaCustomized(formWithStyle)).toBe(true);
+    expect(isFormSchemaCustomized(formWithFields)).toBe(true);
+  });
+
+  it('isFormDetachedFromModel should return true for a DataStore form with detached model', () => {
+    expect(isFormDetachedFromModel(formWithNoCustomization, new Set<string>())).toBe(true);
+  });
+
+  it('isFormDetachedFromModel should return false for a Custom form', () => {
+    expect(isFormDetachedFromModel(formWithStyle, new Set<string>())).toBe(false);
+  });
+
+  it('isFormDetachedFromModel should return false for a DataStore form with an attached model', () => {
+    expect(isFormDetachedFromModel(formWithNoCustomization, new Set<string>().add('Blog'))).toBe(false);
+  });
+
+  it('should delete detached forms', async () => {
+    const mockedDeleteForm = jest.fn().mockReturnValue(undefined);
+    amplifyStudioClientMock.deleteForm = mockedDeleteForm;
+    await deleteDetachedForms([{id: '12345', name: 'BlogCreateForm'}], amplifyStudioClientMock);
+    expect(mockedDeleteForm).toBeCalledTimes(1);
+    expect(mockedDeleteForm).toHaveBeenCalledWith('12345');
+  });
+});

package/src/__tests__/generateComponents.test.ts

@@ -9,8 +9,10 @@ const utilsMock = utils as any;
 
 utilsMock.shouldRenderComponents = jest.fn().mockReturnValue(true);
 utilsMock.notifyMissingPackages = jest.fn().mockReturnValue(true);
+utilsMock.getAmplifyDataSchema = jest.fn().mockReturnValue(({}));
+
 jest.mock('../commands/utils/featureFlags', () => ({
-  getTransformerVersion: jest.fn().mockImplementation(() => 2),
+  getTransformerVersion: jest.fn().mockReturnValue(2),
 }));
 
 describe('can generate components', () => {
@@ -37,6 +39,13 @@ describe('can generate components', () => {
           name: 'testSchema',
           schemaVersion: '1.0',
         },
+        {
+          resultType: 'FAILURE',
+          schemaName: 'testSchema',
+          name: 'testSchema',
+          schemaVersion: '1.0',
+          schema: { id: 'f-123456', name: 'testSchema' },
+        },
       ],
     };
     mockedExport = jest.fn().mockReturnValue({
@@ -70,22 +79,15 @@ describe('can generate components', () => {
     utilsMock.getAmplifyDataSchema = jest.fn().mockReturnValue(undefined);
     utilsMock.generateAmplifyUiBuilderIndexFile = jest.fn().mockReturnValue(true);
     utilsMock.generateAmplifyUiBuilderUtilFile = jest.fn().mockReturnValue(true);
+    utilsMock.deleteDetachedForms = jest.fn();
   });
 
   it('runs generateComponents', async () => {
-    await run(context);
+    await run(context, 'PostPull');
     expect(mockedExport).toBeCalledTimes(3);
     expect(utilsMock.generateUiBuilderComponents).toBeCalledTimes(1);
     expect(utilsMock.generateUiBuilderThemes).toBeCalledTimes(1);
     expect(utilsMock.generateUiBuilderForms).toBeCalledTimes(1);
-  });
-
-  it('does not run generateComponents if not Amplify Admin app', async () => {
-    utilsMock.shouldRenderComponents = jest.fn().mockReturnValue(false);
-    await run(context);
-    expect(mockedExport).toBeCalledTimes(0);
-    expect(utilsMock.generateUiBuilderComponents).toBeCalledTimes(0);
-    expect(utilsMock.generateUiBuilderThemes).toBeCalledTimes(0);
-    expect(utilsMock.generateUiBuilderForms).toBeCalledTimes(0);
+    expect(utilsMock.deleteDetachedForms).toBeCalledTimes(1);
   });
 });

package/src/__tests__/handleEvents.test.ts

@@ -0,0 +1,27 @@
+import { run as runPostPull } from '../event-handlers/handle-PostPull';
+import { run as runPostPush } from '../event-handlers/handle-PostPush';
+import { run as generateComponents } from '../commands/generateComponents';
+
+jest.mock('../commands/generateComponents');
+
+describe('can handle events', () => {
+  let context: any;
+
+  beforeEach(() => {
+    context = {
+      amplify: {
+        invokePluginMethod: jest.fn(),
+      },
+    };
+  });
+
+  it('handles postPull', async () => {
+    await runPostPull(context);
+    expect(generateComponents).toHaveBeenCalledWith(context, 'PostPull');
+  });
+
+  it('handles postPush', async () => {
+    await runPostPush(context);
+    expect(generateComponents).toHaveBeenCalledWith(context, 'PostPush');
+  });
+});

package/src/__tests__/prePushHandler.test.ts

@@ -0,0 +1,105 @@
+// aws-sdk, amplify-cli-core, amplify-prompts are in package dependencies
+import aws from 'aws-sdk'; // eslint-disable-line import/no-extraneous-dependencies
+import { Form } from 'aws-sdk/clients/amplifyuibuilder'; // eslint-disable-line import/no-extraneous-dependencies
+import { printer } from 'amplify-prompts'; // eslint-disable-line import/no-extraneous-dependencies
+import * as utils from '../commands/utils';
+import { prePushHandler } from '../utils/prePushHandler';
+
+jest.mock('../commands/utils');
+jest.mock('amplify-cli-core');
+jest.mock('../commands/utils/featureFlags', () => ({
+  getTransformerVersion: jest.fn().mockImplementation(() => 2),
+}));
+
+const awsMock = aws as any;
+const utilsMock = utils as any;
+
+utilsMock.shouldRenderComponents = jest.fn().mockImplementation(() => true);
+
+describe('handlePrePush', () => {
+  let context: any;
+  let mockedExport: jest.Mock<any, any>;
+  let exportedForms: Form[];
+
+  beforeEach(() => {
+    context = {
+      amplify: {
+        invokePluginMethod: () => ({ models: { Comment: {} } }),
+      },
+      input: {
+        options: {
+          appId: 'testAppId',
+          envName: 'testEnvName',
+        },
+      },
+    };
+
+    exportedForms = [
+      {
+        name: 'BlogCreateForm',
+        formActionType: 'create',
+        fields: {},
+        style: {},
+        schemaVersion: '1.0',
+        sectionalElements: {},
+        appId: '1234',
+        environmentName: 'staging',
+        dataType: {
+          dataSourceType: 'DataStore',
+          dataTypeName: 'Blog',
+        },
+        id: '12345',
+      },
+      {
+        name: 'BlogUpdateForm',
+        formActionType: 'update',
+        fields: {},
+        style: {},
+        schemaVersion: '1.0',
+        sectionalElements: {},
+        appId: '1234',
+        environmentName: 'staging',
+        dataType: {
+          dataSourceType: 'DataStore',
+          dataTypeName: 'Blog',
+        },
+        id: '12345',
+      },
+    ];
+
+    mockedExport = jest.fn(() => ({
+      entities: exportedForms,
+    }));
+
+    awsMock.AmplifyUIBuilder = jest.fn(() => ({
+      exportForms: jest.fn(() => ({
+        promise: () => mockedExport(),
+      })),
+      getMetadata: jest.fn(() => ({
+        promise: jest.fn(() => ({
+          features: {
+            autoGenerateForms: 'true',
+            autoGenerateViews: 'true',
+          },
+        })),
+      })),
+    }));
+  });
+
+  it('runs handlePrePush', async () => {
+    utilsMock.isFormDetachedFromModel = jest.fn().mockImplementation(() => true);
+    utilsMock.isFormSchemaCustomized = jest.fn().mockImplementation(() => true);
+    const spy = jest.spyOn(printer, 'warn');
+    await prePushHandler(context);
+    expect(spy).toHaveBeenCalledWith('The following forms will no longer be available because the connected data model no longer exists: BlogCreateForm, BlogUpdateForm');
+  });
+
+  it('runs handlePrePush without schema', async () => {
+    context.amplify.invokePluginMethod = jest.fn()
+      .mockImplementation(() => ({ models: { Comment: {} } }))
+      .mockImplementation(() => (null));
+    const spy = jest.spyOn(printer, 'debug');
+    await prePushHandler(context);
+    expect(spy).toHaveBeenCalledWith('Local schema not found');
+  });
+});

package/src/__tests__/shouldRenderComponents.test.ts

@@ -1,7 +1,5 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
-import {
-  $TSContext, AmplifyCategories, AmplifySupportedService, CloudformationProviderFacade,
-} from 'amplify-cli-core';
+import {$TSContext} from 'amplify-cli-core';
 import aws from 'aws-sdk'; // eslint-disable-line import/no-extraneous-dependencies
 import { shouldRenderComponents } from '../commands/utils/shouldRenderComponents';
 
@@ -10,26 +8,21 @@ const awsMock = aws as any;
 jest.mock('amplify-cli-core', () => ({
   ...jest.requireActual('amplify-cli-core'),
   stateManager: {
-    getMeta: jest.fn(() => ({
-      [AmplifyCategories.API]: {
-        MyResourceName: {
-          service: AmplifySupportedService.APPSYNC,
-        },
+    getProjectConfig: jest.fn().mockReturnValue({
+      providers: ['awscloudformation'],
+      frontend: 'javascript',
+      javascript: {
+        framework: 'react',
       },
-    })),
-    // eslint-disable-next-line spellcheck/spell-checker
-    getCLIJSON: jest.fn().mockReturnValue({ features: { graphqltransformer: { transformerversion: 2 } } }),
-    setCLIJSON: jest.fn(),
-  },
-  FeatureFlags: {
-    getBoolean: () => true,
-    getNumber: jest.fn().mockReturnValue(2),
-    reloadValues: jest.fn(),
+    })
   },
 }));
-CloudformationProviderFacade.isAmplifyAdminApp = jest.fn().mockReturnValue({
-  isAdminApp: true,
-});
+
+jest.mock('../clients', () => ({
+  AmplifyStudioClient: {
+    isAmplifyApp: jest.fn().mockReturnValue(true)
+  }
+}));
 
 describe('should render components', () => {
   let context: $TSContext | any;
@@ -47,9 +40,6 @@ describe('should render components', () => {
       })),
     }));
     context = {
-      amplify: {
-        invokePluginMethod: () => ({}),
-      },
       input: {
         options: {
           'no-codegen': false,
@@ -57,38 +47,61 @@ describe('should render components', () => {
           envName: 'testEnvName',
         },
       },
-      exeInfo: {
-        projectConfig: {
-          providers: ['awscloudformation'],
-          frontend: 'javascript',
-          javascript: {
-            framework: 'react',
-          },
-        },
-      },
     };
   });
+
   it('works with a valid config', async () => {
     const shouldIt = await shouldRenderComponents(context);
     expect(shouldIt).toBe(true);
   });
+
   it("doesn't work if --no-codegen flag is set", async () => {
     context.input.options['no-codegen'] = true;
     const shouldIt = await shouldRenderComponents(context);
     expect(shouldIt).toBe(false);
   });
+
   it("doesn't work if provider is not awscloudformation", async () => {
-    context.exeInfo.projectConfig.providers = [];
+    jest.mock('amplify-cli-core', () => ({
+      stateManager: {
+        getProjectConfig: jest.fn().mockReturnValue({
+          providers: [],
+          frontend: 'javascript',
+          javascript: {
+            framework: 'react',
+          },
+        })
+      }
+    }));
     const shouldIt = await shouldRenderComponents(context);
     expect(shouldIt).toBe(false);
   });
+
   it('should return false if frontend is ios', async () => {
-    context.exeInfo.projectConfig.frontend = 'ios';
+    jest.mock('amplify-cli-core', () => ({
+      stateManager: {
+        getProjectConfig: jest.fn().mockReturnValue({
+          providers: [],
+          frontend: 'ios',
+        })
+      },
+    }));
     const shouldIt = await shouldRenderComponents(context);
     expect(shouldIt).toBe(false);
   });
+
   it('should return false if frontend is vue', async () => {
-    context.exeInfo.projectConfig.javascript.framework = 'vue';
+    jest.mock('amplify-cli-core', () => ({
+      stateManager: {
+        getProjectConfig: jest.fn().mockReturnValue({
+          providers: [],
+          frontend: 'javascript',
+          javascript: {
+            framework: 'vue',
+          },
+        })
+      },
+    }));
     const shouldIt = await shouldRenderComponents(context);
     expect(shouldIt).toBe(false);
   });

package/src/__tests__/syncAmplifyUiComponents.test.ts

@@ -262,7 +262,7 @@ describe('should sync amplify ui builder components', () => {
     const forms = generateUiBuilderForms(context, [{}, {}]);
     expect(forms.every(form => form.resultType === 'FAILURE')).toBeTruthy();
   });
-  it('can generate uibuilder forms from data schema if autogen true', async () => {
+  it('can generate uibuilder forms from data schema if autogenerate true', async () => {
     createUiBuilderComponentDependencyMock.createUiBuilderForm = jest.fn().mockImplementation(() => ({}));
     const forms = generateUiBuilderForms(context, [], exampleSchema, true);
     expect(forms.every(form => form.resultType === 'SUCCESS')).toBeTruthy();
@@ -270,7 +270,7 @@ describe('should sync amplify ui builder components', () => {
     expect(forms.length).toEqual(2);
   });
 
-  it('should not autogen forms for join tables or unsupported models', async () => {
+  it('should not autogenerate forms for join tables or unsupported models', async () => {
     expect(Object.keys(exampleSchema.models)).toStrictEqual(['Author', 'JoinTable', 'EmptyModel']);
     createUiBuilderComponentDependencyMock.createUiBuilderForm = jest.fn().mockImplementation(
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -282,7 +282,7 @@ describe('should sync amplify ui builder components', () => {
     expect(forms.map(f => (f.schema as any).name)).toStrictEqual(['Author', 'Author']);
   });
 
-  it('does not generate uibuilder forms from data schema if autogen false', async () => {
+  it('does not generate uibuilder forms from data schema if autogenerate false', async () => {
     createUiBuilderComponentDependencyMock.createUiBuilderForm = jest.fn().mockImplementation(() => ({}));
     const forms = generateUiBuilderForms(context, [], exampleSchema, false);
     expect(forms.length).toEqual(0);

package/src/clients/amplify-studio-client.ts

@@ -230,6 +230,19 @@ export default class AmplifyStudioClient {
     }
   };
 
+  deleteForm = async (formId: string, envName?: string, appId?: string): Promise<void> => {
+    const environmentName = envName || this.#envName;
+    const resolvedAppId = appId || this.#appId;
+    try {
+      await this.#amplifyUiBuilder
+        .deleteForm({ id: formId, environmentName, appId: resolvedAppId })
+        .promise();
+    } catch (err) {
+      printer.debug(err.toString());
+      throw err;
+    }
+  }
+
   getModels = async (resourceName: string, envName?: string, appId?: string): Promise<string | undefined> => {
     try {
       const environmentName = envName || this.#envName;

package/src/commands/cloneComponentsFromEnv.ts

@@ -11,7 +11,7 @@ export const run = async (context: $TSContext): Promise<void> => {
   const args = extractArgs(context);
   const sourceEnvName = args.sourceEnvName ? args.sourceEnvName : context.exeInfo.sourceEnvName;
   const newEnvName = args.newEnvName ? args.newEnvName : context.exeInfo.localEnvInfo.envName;
-  const appId = args.appId ?? context.exeInfo.teamProviderInfo[sourceEnvName].awscloudformation.AmplifyAppId;
+  const appId = args.appId ?? context.exeInfo?.teamProviderInfo?.[sourceEnvName]?.awscloudformation?.AmplifyAppId;
   const studioClient = await AmplifyStudioClient.setClientInfo(context, sourceEnvName, appId);
 
   const [existingComponents, existingComponentsNewEnv] = await Promise.all([

package/src/commands/generateComponents.ts

@@ -13,12 +13,15 @@ import {
   generateAmplifyUiBuilderIndexFile,
   generateUiBuilderForms,
   generateAmplifyUiBuilderUtilFile,
+  isStudioForm,
+  isFormDetachedFromModel,
+  deleteDetachedForms,
 } from './utils';
 
 /**
  * Pulls ui components from Studio backend and generates the code in the user's file system
  */
-export const run = async (context: $TSContext): Promise<void> => {
+export const run = async (context: $TSContext, eventType: 'PostPush' | 'PostPull'): Promise<void> => {
   if (!(await shouldRenderComponents(context))) {
     return;
   }
@@ -32,9 +35,9 @@ export const run = async (context: $TSContext): Promise<void> => {
       getAmplifyDataSchema(studioClient),
     ]);
 
-    const nothingWouldAutogen = !dataSchema || !studioClient.metadata.autoGenerateForms || !studioClient.isGraphQLSupported;
+    const nothingWouldAutogenerate = !dataSchema || !studioClient.metadata.autoGenerateForms || !studioClient.isGraphQLSupported;
 
-    if (nothingWouldAutogen && [componentSchemas, themeSchemas, formSchemas].every(group => !group.entities.length)) {
+    if (nothingWouldAutogenerate && [componentSchemas, themeSchemas, formSchemas].every(group => !group.entities.length)) {
       printer.debug('Skipping UI component generation since none are found.');
       return;
     }
@@ -44,13 +47,18 @@ export const run = async (context: $TSContext): Promise<void> => {
       component: generateUiBuilderComponents(context, componentSchemas.entities, dataSchema),
       theme: generateUiBuilderThemes(context, themeSchemas.entities),
       form: generateUiBuilderForms(
-        context, formSchemas.entities, dataSchema, studioClient.metadata.autoGenerateForms && studioClient.isGraphQLSupported,
+        context,
+        formSchemas.entities,
+        dataSchema,
+        studioClient.metadata.autoGenerateForms && studioClient.isGraphQLSupported,
       ),
     };
 
     const successfulSchemas: StudioSchema[] = [];
+    const detachedForms: {id: string, name: string}[] = [];
     let hasSuccessfulForm = false;
     const failedResponseNames: string[] = [];
+    const modelNames = dataSchema?.models ? new Set(Object.keys(dataSchema.models)) : new Set<string>();
 
     Object.entries(generatedResults).forEach(([key, results]) => {
       results.forEach(result => {
@@ -60,6 +68,22 @@ export const run = async (context: $TSContext): Promise<void> => {
             hasSuccessfulForm = true;
           }
         } else {
+          const failedSchema = result.schema;
+          /**
+           * A form resource may fail to generate because it's DataStore model type
+           * no longer exists.
+           */
+          if (
+            isStudioForm(failedSchema)
+            && failedSchema.id
+            && dataSchema
+            && eventType === 'PostPush'
+            && isFormDetachedFromModel(failedSchema, modelNames)
+          ) {
+            // Don't need to add form to failedResponseNames if it is going to be deleted
+            detachedForms.push({id: failedSchema.id, name: failedSchema.name});
+            return;
+          }
           failedResponseNames.push(result.schemaName);
         }
       });
@@ -88,6 +112,8 @@ export const run = async (context: $TSContext): Promise<void> => {
     }
 
     notifyMissingPackages(context);
+
+    deleteDetachedForms(detachedForms, studioClient);
   } catch (e) {
     printer.debug(e);
     spinner.fail('Failed to sync UI components');

package/src/commands/utils/detachedFormCleanup.ts

@@ -0,0 +1,55 @@
+import { StudioForm, StudioSchema } from '@aws-amplify/codegen-ui';
+import { Form } from 'aws-sdk/clients/amplifyuibuilder';
+import { AmplifyStudioClient } from '../../clients';
+import { printer } from 'amplify-prompts';
+import asyncPool from 'tiny-async-pool';
+
+/**
+ * Does the form's reference DataStore type exist in the list of models
+ */
+export const isFormDetachedFromModel = (formSchema: StudioForm | Form, modelNames: Set<string>): boolean => {
+  return formSchema.dataType.dataSourceType === 'DataStore' && !modelNames.has(formSchema.dataType.dataTypeName);
+};
+
+/**
+ * A form schema will be customized if fields, style, sectionalElements objects aren't empty
+ * @param schema The schema to test
+ * @returns boolean
+ */
+export const isFormSchemaCustomized = (formSchema: StudioForm | Form): boolean => {
+  const { fields, style, sectionalElements } = formSchema;
+  // Fields and sectionalElements just need an empty check
+  if (!isEmpty({ ...fields, ...sectionalElements })) {
+    return true;
+  }
+
+  // Check style
+  // If not empty, at least one style must be defined
+  return Object.values(style).some(styleConfig => styleConfig !== undefined);
+};
+
+/**
+ * Is the schema a StudioForm
+ */
+export const isStudioForm = (schema: StudioSchema | undefined): schema is StudioForm => {
+  if (!schema) return false;
+  return 'formActionType' in schema;
+};
+
+export const deleteDetachedForms = async (detachedForms: {id: string, name: string}[], studioClient: AmplifyStudioClient) => {
+  const deleteForm = async ({id, name}: {id: string, name: string}) => {
+    try {
+      // Try to delete the form but don't stop any other operations if it fails
+      await studioClient.deleteForm(id);
+      return {status: 'SUCCESS', message: `Deleted detached form ${name}`};
+    } catch (error) {
+      return {status: 'FAIL', message: `Failed to delete detached form ${name}`}
+    }
+  };
+  for await (const status of asyncPool(5, detachedForms, deleteForm)) {
+    printer.debug(status.message);
+  };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isEmpty = (obj?: any): boolean => Object.keys(obj).length === 0;

package/src/commands/utils/index.ts

@@ -5,3 +5,4 @@ export * from './getUiBuilderComponentsPath';
 export * from './notifyMissingPackages';
 export * from './shouldRenderComponents';
 export * from './syncAmplifyUiBuilderComponents';
+export * from './detachedFormCleanup';

package/src/commands/utils/shouldRenderComponents.ts

@@ -1,5 +1,5 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
-import { $TSContext } from 'amplify-cli-core';
+import { $TSContext, stateManager } from 'amplify-cli-core';
 import { printer } from 'amplify-prompts';
 import { AmplifyStudioClient } from '../../clients';
 import { getAppId } from './environmentHelpers';
@@ -8,6 +8,8 @@ import { getAppId } from './environmentHelpers';
  * process to decide if we should render components
  */
 export const shouldRenderComponents = async (context: $TSContext): Promise<boolean> => {
+  const projectConfig = stateManager.getProjectConfig();
+
   if (process.env.FORCE_RENDER) {
     printer.debug('Forcing component render since environment variable flag is set.');
     return true;
@@ -17,22 +19,22 @@ export const shouldRenderComponents = async (context: $TSContext): Promise<boole
     return false;
   }
 
-  if (!context?.exeInfo?.projectConfig) {
+  if (!projectConfig) {
     printer.debug('Not pulling components because there is no projectConfig set for this project.');
     return false;
   }
 
-  if (!context.exeInfo.projectConfig.providers.includes('awscloudformation')) {
+  if (!projectConfig.providers.includes('awscloudformation')) {
     printer.debug('Not pulling components because there is no "awscloudformation" provider.');
     return false;
   }
 
-  if (context.exeInfo.projectConfig.frontend !== 'javascript') {
+  if (projectConfig.frontend !== 'javascript') {
     printer.debug('Not pulling components because this project is not configured as a javascript frontend.');
     return false;
   }
 
-  if (context.exeInfo.projectConfig.javascript.framework !== 'react') {
+  if (projectConfig.javascript.framework !== 'react') {
     printer.debug('Not pulling components because this project is not configured with the "react" framework.');
     return false;
   }

package/src/commands/utils/syncAmplifyUiBuilderComponents.ts

@@ -120,7 +120,9 @@ export const generateUiBuilderForms = (
     } catch (e) {
       printer.debug(`Failure caught processing ${schema.name}`);
       printer.debug(e);
-      return { resultType: 'FAILURE', schemaName: schema.name, error: e };
+      return {
+        resultType: 'FAILURE', schemaName: schema.name, schema, error: e,
+      };
     }
   };
   const formResults = formSchemas.map((schema: StudioForm) => {

package/src/event-handlers/handle-PostPull.ts

@@ -7,7 +7,7 @@ import { run as generateComponents } from '../commands/generateComponents';
  */
 export const run = async (context: $TSContext): Promise<void> => {
   try {
-    await generateComponents(context);
+    await generateComponents(context, 'PostPull');
   } catch (e) {
     // Swallow all errors from the uibuilder plugin
     printer.debug(e);

package/src/event-handlers/handle-PostPush.ts

@@ -7,7 +7,7 @@ import { run as generateComponents } from '../commands/generateComponents';
  */
 export const run = async (context: $TSContext): Promise<void> => {
   try {
-    await generateComponents(context);
+    await generateComponents(context, 'PostPush');
   } catch (e) {
     // Swallow all errors from the uibuilder plugin
     printer.debug(e);