Feat: Use sandbox id by default for generation commands

.changeset/giant-dolls-lick.md

@@ -0,0 +1,5 @@
+---
+'@aws-amplify/backend-cli': minor
+---
+
+Defaults to the sandbox identifier when no branch or stack is passed in the CLI

packages/cli/src/backend-identifier/backend_identifier_resolver.ts

@@ -6,6 +6,13 @@ type BackendIdentifierParameters = {
   appId?: string;
   branch?: string;
 };
+
+export type BackendIdentityResolver = {
+  resolve: (
+    args: BackendIdentifierParameters
+  ) => Promise<DeployedBackendIdentifier | undefined>;
+};
+
 /**
  * Translates args to BackendIdentifier.
  * Throws if translation can't be made (this should never happen if command validation works correctly).
@@ -17,7 +24,7 @@ export class BackendIdentifierResolver {
   constructor(private readonly namespaceResolver: NamespaceResolver) {}
   resolve = async (
     args: BackendIdentifierParameters
-  ): Promise<DeployedBackendIdentifier> => {
+  ): Promise<DeployedBackendIdentifier | undefined> => {
     if (args.stack) {
       return { stackName: args.stack };
     } else if (args.appId && args.branch) {
@@ -32,8 +39,6 @@ export class BackendIdentifierResolver {
         branchName: args.branch,
       };
     }
-    throw new Error(
-      'Unable to resolve BackendIdentifier with provided parameters'
-    );
+    return undefined;
   };
 }

packages/cli/src/backend-identifier/backend_identifier_with_sandbox_fallback.test.ts

@@ -0,0 +1,54 @@
+import assert from 'node:assert';
+import { it } from 'node:test';
+import { SandboxBackendIdResolver } from '../commands/sandbox/sandbox_id_resolver.js';
+import { BackendIdentifierResolver } from './backend_identifier_resolver.js';
+import { BackendIdentifierResolverWithFallback } from './backend_identifier_with_sandbox_fallback.js';
+
+void it('if backend identifier resolves without error, the resolved id is returned', async () => {
+  const namespaceResolver = {
+    resolve: () => Promise.resolve('testAppName'),
+  };
+
+  const defaultResolver = new BackendIdentifierResolver(namespaceResolver);
+  const sandboxResolver = new SandboxBackendIdResolver(namespaceResolver);
+  const backendIdResolver = new BackendIdentifierResolverWithFallback(
+    defaultResolver,
+    sandboxResolver
+  );
+  const resolvedId = await backendIdResolver.resolve({
+    appId: 'hello',
+    branch: 'world',
+  });
+  assert.deepEqual(resolvedId, {
+    namespace: 'hello',
+    name: 'world',
+    type: 'branch',
+  });
+});
+
+void it('uses the sandbox id if the default identifier resolver fails', async () => {
+  const appName = 'testAppName';
+  const namespaceResolver = {
+    resolve: () => Promise.resolve(appName),
+  };
+
+  const defaultResolver = new BackendIdentifierResolver(namespaceResolver);
+  const username = 'test-user';
+  const sandboxResolver = new SandboxBackendIdResolver(
+    namespaceResolver,
+    () =>
+      ({
+        username,
+      } as never)
+  );
+  const backendIdResolver = new BackendIdentifierResolverWithFallback(
+    defaultResolver,
+    sandboxResolver
+  );
+  const resolvedId = await backendIdResolver.resolve({});
+  assert.deepEqual(resolvedId, {
+    namespace: appName,
+    type: 'sandbox',
+    name: 'test-user',
+  });
+});

packages/cli/src/backend-identifier/backend_identifier_with_sandbox_fallback.ts

@@ -0,0 +1,26 @@
+import { SandboxBackendIdResolver } from '../commands/sandbox/sandbox_id_resolver.js';
+import { BackendIdentifierResolver } from './backend_identifier_resolver.js';
+
+/**
+ * Resolves the backend id when branch or stack is passed as an arg, otherwise returns a sandbox backend identifier
+ */
+export class BackendIdentifierResolverWithFallback {
+  /**
+   * Accepts the sandbox id resolver as a parameter
+   */
+  constructor(
+    private defaultResolver: BackendIdentifierResolver,
+    private fallbackResolver: SandboxBackendIdResolver
+  ) {}
+  /**
+   * resolves the backend id, falling back to the sandbox id if there is an error
+   */
+  public resolve = async (
+    ...args: Parameters<BackendIdentifierResolver['resolve']>
+  ) => {
+    return (
+      (await this.defaultResolver.resolve(...args)) ??
+      (await this.fallbackResolver.resolve())
+    );
+  };
+}

packages/cli/src/commands/generate/config/generate_config_command.ts

@@ -1,6 +1,6 @@
 import { Argv, CommandModule } from 'yargs';
 import { ClientConfigFormat } from '@aws-amplify/client-config';
-import { BackendIdentifierResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
+import { BackendIdentityResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
 import { ClientConfigGeneratorAdapter } from '../../../client-config/client_config_generator_adapter.js';
 import { ArgumentsKebabCase } from '../../../kebab_case.js';
 import { handleCommandFailure } from '../../../command_failure_handler.js';
@@ -37,7 +37,7 @@ export class GenerateConfigCommand
    */
   constructor(
     private readonly clientConfigGenerator: ClientConfigGeneratorAdapter,
-    private readonly backendIdentifierResolver: BackendIdentifierResolver
+    private readonly backendIdentifierResolver: BackendIdentityResolver
   ) {
     this.command = 'config';
     this.describe = 'Generates client config';
@@ -51,6 +51,10 @@ export class GenerateConfigCommand
       args
     );
 
+    if (!backendIdentifier) {
+      throw new Error('Could not resolve the backend identifier');
+    }
+
     await this.clientConfigGenerator.generateClientConfigToFile(
       backendIdentifier,
       args['out-dir'],

packages/cli/src/commands/generate/forms/generate_forms_command.test.ts

@@ -6,8 +6,10 @@ import path from 'node:path';
 import { describe, it, mock } from 'node:test';
 import yargs, { CommandModule } from 'yargs';
 import { BackendIdentifierResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
+import { BackendIdentifierResolverWithFallback } from '../../../backend-identifier/backend_identifier_with_sandbox_fallback.js';
 import { FormGenerationHandler } from '../../../form-generation/form_generation_handler.js';
 import { TestCommandRunner } from '../../../test-utils/command_runner.js';
+import { SandboxBackendIdResolver } from '../../sandbox/sandbox_id_resolver.js';
 import { GenerateFormsCommand } from './generate_forms_command.js';
 
 void describe('generate forms command', () => {
@@ -150,4 +152,63 @@ void describe('generate forms command', () => {
       );
     });
   });
+  void it('if neither branch nor stack are provided, the sandbox id is used by default', async () => {
+    const credentialProvider = fromNodeProviderChain();
+
+    const appNameResolver = {
+      resolve: () => Promise.resolve('testAppName'),
+    };
+
+    const defaultResolver = new BackendIdentifierResolver(appNameResolver);
+
+    const mockedSandboxIdResolver = new SandboxBackendIdResolver(
+      appNameResolver
+    );
+
+    const fakeSandboxId = 'my-fake-app-my-fake-username';
+
+    const sandboxIdResolver = mock.method(mockedSandboxIdResolver, 'resolve');
+    sandboxIdResolver.mock.mockImplementation(() => fakeSandboxId);
+
+    const backendIdResolver = new BackendIdentifierResolverWithFallback(
+      defaultResolver,
+      mockedSandboxIdResolver
+    );
+    const formGenerationHandler = new FormGenerationHandler({
+      credentialProvider,
+    });
+
+    const fakedBackendOutputClient = BackendOutputClientFactory.getInstance({
+      credentials: credentialProvider,
+    });
+
+    const generateFormsCommand = new GenerateFormsCommand(
+      backendIdResolver,
+      () => fakedBackendOutputClient,
+      formGenerationHandler
+    );
+
+    const generationMock = mock.method(formGenerationHandler, 'generate');
+    generationMock.mock.mockImplementation(async () => undefined);
+    mock
+      .method(fakedBackendOutputClient, 'getOutput')
+      .mock.mockImplementation(async () => ({
+        [graphqlOutputKey]: {
+          payload: {
+            awsAppsyncApiId: 'test_api_id',
+            amplifyApiModelSchemaS3Uri: 'test_schema',
+            awsAppsyncApiEndpoint: 'test_endpoint',
+          },
+        },
+      }));
+    const parser = yargs().command(
+      generateFormsCommand as unknown as CommandModule
+    );
+    const commandRunner = new TestCommandRunner(parser);
+    await commandRunner.runCommand('forms');
+    assert.deepEqual(
+      generationMock.mock.calls[0].arguments[0].backendIdentifier,
+      fakeSandboxId
+    );
+  });
 });

packages/cli/src/commands/generate/forms/generate_forms_command.ts

@@ -2,7 +2,7 @@ import path from 'path';
 import { Argv, CommandModule } from 'yargs';
 import { BackendOutputClient } from '@aws-amplify/deployed-backend-client';
 import { graphqlOutputKey } from '@aws-amplify/backend-output-schemas';
-import { BackendIdentifierResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
+import { BackendIdentityResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
 import { DEFAULT_UI_PATH } from '../../../form-generation/default_form_generation_output_paths.js';
 import { FormGenerationHandler } from '../../../form-generation/form_generation_handler.js';
 import { ArgumentsKebabCase } from '../../../kebab_case.js';
@@ -39,14 +39,18 @@ export class GenerateFormsCommand
    * Creates client config generation command.
    */
   constructor(
-    private readonly backendIdentifierResolver: BackendIdentifierResolver,
+    private readonly backendIdentifierResolver: BackendIdentityResolver,
     private readonly backendOutputClientBuilder: () => BackendOutputClient,
     private readonly formGenerationHandler: FormGenerationHandler
   ) {
     this.command = 'forms';
     this.describe = 'Generates UI forms';
   }
 
+  getBackendIdentifier = async (args: GenerateFormsCommandOptions) => {
+    return await this.backendIdentifierResolver.resolve(args);
+  };
+
   /**
    * @inheritDoc
    */
@@ -55,6 +59,10 @@ export class GenerateFormsCommand
       args
     );
 
+    if (!backendIdentifier) {
+      throw new Error('Could not resolve the backend identifier');
+    }
+
     const backendOutputClient = this.backendOutputClientBuilder();
 
     const output = await backendOutputClient.getOutput(backendIdentifier);
@@ -121,12 +129,6 @@ export class GenerateFormsCommand
         array: true,
         group: 'Form Generation',
       })
-      .check((argv) => {
-        if (!argv.stack && !argv.branch) {
-          throw new Error('Either --stack or --branch must be provided');
-        }
-        return true;
-      })
       .fail((msg, err) => {
         handleCommandFailure(msg, err, yargs);
         yargs.exit(1, err);

packages/cli/src/commands/generate/generate_command_factory.ts

@@ -6,12 +6,14 @@ import { GenerateFormsCommand } from './forms/generate_forms_command.js';
 import { CwdPackageJsonReader } from '@aws-amplify/platform-core';
 import { GenerateGraphqlClientCodeCommand } from './graphql-client-code/generate_graphql_client_code_command.js';
 import { LocalNamespaceResolver } from '../../backend-identifier/local_namespace_resolver.js';
-import { BackendIdentifierResolver } from '../../backend-identifier/backend_identifier_resolver.js';
 import { ClientConfigGeneratorAdapter } from '../../client-config/client_config_generator_adapter.js';
 import { GenerateApiCodeAdapter } from './graphql-client-code/generate_api_code_adapter.js';
 import { FormGenerationHandler } from '../../form-generation/form_generation_handler.js';
 import { BackendOutputClientFactory } from '@aws-amplify/deployed-backend-client';
+import { SandboxBackendIdResolver } from '../sandbox/sandbox_id_resolver.js';
 import { CommandMiddleware } from '../../command_middleware.js';
+import { BackendIdentifierResolverWithFallback } from '../../backend-identifier/backend_identifier_with_sandbox_fallback.js';
+import { BackendIdentifierResolver } from '../../backend-identifier/backend_identifier_resolver.js';
 
 /**
  * Creates wired generate command.
@@ -21,12 +23,13 @@ export const createGenerateCommand = (): CommandModule => {
   const clientConfigGenerator = new ClientConfigGeneratorAdapter(
     credentialProvider
   );
-  const localAppNameResolver = new LocalNamespaceResolver(
+  const namespaceResolver = new LocalNamespaceResolver(
     new CwdPackageJsonReader()
   );
 
-  const backendIdentifierResolver = new BackendIdentifierResolver(
-    localAppNameResolver
+  const backendIdentifierResolver = new BackendIdentifierResolverWithFallback(
+    new BackendIdentifierResolver(namespaceResolver),
+    new SandboxBackendIdResolver(namespaceResolver)
   );
 
   const generateConfigCommand = new GenerateConfigCommand(

packages/cli/src/commands/generate/graphql-client-code/generate_graphql_client_code_command.ts

@@ -1,5 +1,5 @@
 import { Argv, CommandModule } from 'yargs';
-import { BackendIdentifierResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
+import { BackendIdentityResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
 import { isAbsolute, resolve } from 'path';
 import {
   GenerateApiCodeAdapter,
@@ -78,7 +78,7 @@ export class GenerateGraphqlClientCodeCommand
    */
   constructor(
     private readonly generateApiCodeAdapter: GenerateApiCodeAdapter,
-    private readonly backendIdentifierResolver: BackendIdentifierResolver
+    private readonly backendIdentifierResolver: BackendIdentityResolver
   ) {
     this.command = 'graphql-client-code';
     this.describe = 'Generates graphql API code';