correctly handle stack argument for generate schema command (#2028)

rtpascual · web-flow · commit 9e11e5ded609 · 2024-09-20T09:41:18.000-07:00
* correctly handle stack argument for generate schema command

* PR feedback

* update type

* add await

* update resolver methods
diff --git a/.changeset/fluffy-months-prove.md b/.changeset/fluffy-months-prove.md
@@ -0,0 +1,5 @@
+---
+'@aws-amplify/backend-cli': patch
+---
+
+correctly handle stack argument for generate schema command
diff --git a/packages/cli/src/backend-identifier/backend_identifier_resolver.test.ts b/packages/cli/src/backend-identifier/backend_identifier_resolver.test.ts
@@ -3,38 +3,82 @@ import { describe, it } from 'node:test';
 import { AppBackendIdentifierResolver } from './backend_identifier_resolver.js';
 
 void describe('BackendIdentifierResolver', () => {
-  void it('returns an App Name and Branch identifier', async () => {
-    const backendIdResolver = new AppBackendIdentifierResolver({
-      resolve: () => Promise.resolve('testAppName'),
+  void describe('resolveDeployedBackendIdentifier', () => {
+    void it('returns an App Name and Branch identifier', async () => {
+      const backendIdResolver = new AppBackendIdentifierResolver({
+        resolve: () => Promise.resolve('testAppName'),
+      });
+      assert.deepStrictEqual(
+        await backendIdResolver.resolveDeployedBackendIdentifier({
+          branch: 'test',
+        }),
+        {
+          appName: 'testAppName',
+          branchName: 'test',
+        }
+      );
     });
-    assert.deepStrictEqual(
-      await backendIdResolver.resolve({ branch: 'test' }),
-      {
-        appName: 'testAppName',
-        branchName: 'test',
-      }
-    );
-  });
-  void it('returns a App Id identifier', async () => {
-    const backendIdResolver = new AppBackendIdentifierResolver({
-      resolve: () => Promise.resolve('testAppName'),
-    });
-    const actual = await backendIdResolver.resolve({
-      appId: 'my-id',
-      branch: 'my-branch',
+    void it('returns a App Id identifier', async () => {
+      const backendIdResolver = new AppBackendIdentifierResolver({
+        resolve: () => Promise.resolve('testAppName'),
+      });
+      const actual = await backendIdResolver.resolveDeployedBackendIdentifier({
+        appId: 'my-id',
+        branch: 'my-branch',
+      });
+      assert.deepStrictEqual(actual, {
+        namespace: 'my-id',
+        name: 'my-branch',
+        type: 'branch',
+      });
     });
-    assert.deepStrictEqual(actual, {
-      namespace: 'my-id',
-      name: 'my-branch',
-      type: 'branch',
+    void it('returns a Stack name identifier', async () => {
+      const backendIdResolver = new AppBackendIdentifierResolver({
+        resolve: () => Promise.resolve('testAppName'),
+      });
+      assert.deepEqual(
+        await backendIdResolver.resolveDeployedBackendIdentifier({
+          stack: 'my-stack',
+        }),
+        {
+          stackName: 'my-stack',
+        }
+      );
     });
   });
-  void it('returns a Stack name identifier', async () => {
-    const backendIdResolver = new AppBackendIdentifierResolver({
-      resolve: () => Promise.resolve('testAppName'),
+
+  void describe('resolveDeployedBackendIdToBackendId', () => {
+    void it('returns backend identifier from App Name and Branch identifier', async () => {
+      const backendIdResolver = new AppBackendIdentifierResolver({
+        resolve: () => Promise.resolve('testAppName'),
+      });
+      assert.deepEqual(
+        await backendIdResolver.resolveBackendIdentifier({
+          appId: 'testAppName',
+          branch: 'test',
+        }),
+        {
+          namespace: 'testAppName',
+          name: 'test',
+          type: 'branch',
+        }
+      );
     });
-    assert.deepEqual(await backendIdResolver.resolve({ stack: 'my-stack' }), {
-      stackName: 'my-stack',
+    void it('returns backend identifier from Stack identifier', async () => {
+      const backendIdResolver = new AppBackendIdentifierResolver({
+        resolve: () => Promise.resolve('testAppName'),
+      });
+      assert.deepEqual(
+        await backendIdResolver.resolveBackendIdentifier({
+          stack: 'amplify-reasonableName-userName-branch-testHash',
+        }),
+        {
+          namespace: 'reasonableName',
+          name: 'userName',
+          type: 'branch',
+          hash: 'testHash',
+        }
+      );
     });
   });
 });
diff --git a/packages/cli/src/backend-identifier/backend_identifier_resolver.ts b/packages/cli/src/backend-identifier/backend_identifier_resolver.ts
@@ -1,5 +1,7 @@
 import { DeployedBackendIdentifier } from '@aws-amplify/deployed-backend-client';
 import { NamespaceResolver } from './local_namespace_resolver.js';
+import { BackendIdentifier } from '@aws-amplify/plugin-types';
+import { BackendIdentifierConversions } from '@aws-amplify/platform-core';
 
 export type BackendIdentifierParameters = {
   stack?: string;
@@ -8,9 +10,12 @@ export type BackendIdentifierParameters = {
 };
 
 export type BackendIdentifierResolver = {
-  resolve: (
+  resolveDeployedBackendIdentifier: (
     args: BackendIdentifierParameters
   ) => Promise<DeployedBackendIdentifier | undefined>;
+  resolveBackendIdentifier: (
+    args: BackendIdentifierParameters
+  ) => Promise<BackendIdentifier | undefined>;
 };
 
 /**
@@ -22,7 +27,7 @@ export class AppBackendIdentifierResolver implements BackendIdentifierResolver {
    * Instantiates BackendIdentifierResolver
    */
   constructor(private readonly namespaceResolver: NamespaceResolver) {}
-  resolve = async (
+  resolveDeployedBackendIdentifier = async (
     args: BackendIdentifierParameters
   ): Promise<DeployedBackendIdentifier | undefined> => {
     if (args.stack) {
@@ -41,4 +46,25 @@ export class AppBackendIdentifierResolver implements BackendIdentifierResolver {
     }
     return undefined;
   };
+  resolveBackendIdentifier = async (
+    args: BackendIdentifierParameters
+  ): Promise<BackendIdentifier | undefined> => {
+    if (args.stack) {
+      return BackendIdentifierConversions.fromStackName(args.stack);
+    } else if (args.appId && args.branch) {
+      return {
+        namespace: args.appId,
+        name: args.branch,
+        type: 'branch',
+      };
+    } else if (args.branch) {
+      return {
+        namespace: await this.namespaceResolver.resolve(),
+        name: args.branch,
+        type: 'branch',
+      };
+    }
+
+    return undefined;
+  };
 }
diff --git a/packages/cli/src/backend-identifier/backend_identifier_with_sandbox_fallback.test.ts b/packages/cli/src/backend-identifier/backend_identifier_with_sandbox_fallback.test.ts
@@ -15,7 +15,7 @@ void it('if backend identifier resolves without error, the resolved id is return
     defaultResolver,
     sandboxResolver
   );
-  const resolvedId = await backendIdResolver.resolve({
+  const resolvedId = await backendIdResolver.resolveDeployedBackendIdentifier({
     appId: 'hello',
     branch: 'world',
   });
@@ -45,7 +45,9 @@ void it('uses the sandbox id if the default identifier resolver fails', async ()
     defaultResolver,
     sandboxResolver
   );
-  const resolvedId = await backendIdResolver.resolve({});
+  const resolvedId = await backendIdResolver.resolveDeployedBackendIdentifier(
+    {}
+  );
   assert.deepEqual(resolvedId, {
     namespace: appName,
     type: 'sandbox',
diff --git a/packages/cli/src/backend-identifier/backend_identifier_with_sandbox_fallback.ts b/packages/cli/src/backend-identifier/backend_identifier_with_sandbox_fallback.ts
@@ -20,9 +20,20 @@ export class BackendIdentifierResolverWithFallback
   /**
    * resolves the backend id, falling back to the sandbox id if there is an error
    */
-  resolve = async (args: BackendIdentifierParameters) => {
+  resolveDeployedBackendIdentifier = async (
+    args: BackendIdentifierParameters
+  ) => {
     return (
-      (await this.defaultResolver.resolve(args)) ??
+      (await this.defaultResolver.resolveDeployedBackendIdentifier(args)) ??
+      (await this.fallbackResolver.resolve())
+    );
+  };
+  /**
+   * Resolves deployed backend id to backend id, falling back to the sandbox id if there is an error
+   */
+  resolveBackendIdentifier = async (args: BackendIdentifierParameters) => {
+    return (
+      (await this.defaultResolver.resolveBackendIdentifier(args)) ??
       (await this.fallbackResolver.resolve())
     );
   };
diff --git a/packages/cli/src/commands/generate/forms/generate_forms_command.test.ts b/packages/cli/src/commands/generate/forms/generate_forms_command.test.ts
@@ -242,7 +242,14 @@ void describe('generate forms command', () => {
   void it('throws user error if the stack deployment is currently in progress', async () => {
     const fakeSandboxId = 'my-fake-app-my-fake-username';
     const backendIdResolver = {
-      resolve: mock.fn(() =>
+      resolveDeployedBackendIdentifier: mock.fn(() =>
+        Promise.resolve({
+          namespace: fakeSandboxId,
+          name: fakeSandboxId,
+          type: 'sandbox',
+        })
+      ),
+      resolveBackendIdentifier: mock.fn(() =>
         Promise.resolve({
           namespace: fakeSandboxId,
           name: fakeSandboxId,
@@ -289,7 +296,14 @@ void describe('generate forms command', () => {
   void it('throws user error if the stack does not exist', async () => {
     const fakeSandboxId = 'my-fake-app-my-fake-username';
     const backendIdResolver = {
-      resolve: mock.fn(() =>
+      resolveDeployedBackendIdentifier: mock.fn(() =>
+        Promise.resolve({
+          namespace: fakeSandboxId,
+          name: fakeSandboxId,
+          type: 'sandbox',
+        })
+      ),
+      resolveBackendIdentifier: mock.fn(() =>
         Promise.resolve({
           namespace: fakeSandboxId,
           name: fakeSandboxId,
@@ -333,7 +347,14 @@ void describe('generate forms command', () => {
   void it('throws user error if credentials are expired when getting backend outputs', async () => {
     const fakeSandboxId = 'my-fake-app-my-fake-username';
     const backendIdResolver = {
-      resolve: mock.fn(() =>
+      resolveDeployedBackendIdentifier: mock.fn(() =>
+        Promise.resolve({
+          namespace: fakeSandboxId,
+          name: fakeSandboxId,
+          type: 'sandbox',
+        })
+      ),
+      resolveBackendIdentifier: mock.fn(() =>
         Promise.resolve({
           namespace: fakeSandboxId,
           name: fakeSandboxId,
@@ -380,7 +401,14 @@ void describe('generate forms command', () => {
   void it('throws user error if access is denied when getting backend outputs', async () => {
     const fakeSandboxId = 'my-fake-app-my-fake-username';
     const backendIdResolver = {
-      resolve: mock.fn(() =>
+      resolveDeployedBackendIdentifier: mock.fn(() =>
+        Promise.resolve({
+          namespace: fakeSandboxId,
+          name: fakeSandboxId,
+          type: 'sandbox',
+        })
+      ),
+      resolveBackendIdentifier: mock.fn(() =>
         Promise.resolve({
           namespace: fakeSandboxId,
           name: fakeSandboxId,
diff --git a/packages/cli/src/commands/generate/forms/generate_forms_command.ts b/packages/cli/src/commands/generate/forms/generate_forms_command.ts
@@ -52,7 +52,9 @@ export class GenerateFormsCommand
   }
 
   getBackendIdentifier = async (args: GenerateFormsCommandOptions) => {
-    return await this.backendIdentifierResolver.resolve(args);
+    return await this.backendIdentifierResolver.resolveDeployedBackendIdentifier(
+      args
+    );
   };
 
   /**
@@ -61,9 +63,10 @@ export class GenerateFormsCommand
   handler = async (
     args: ArgumentsCamelCase<GenerateFormsCommandOptions>
   ): Promise<void> => {
-    const backendIdentifier = await this.backendIdentifierResolver.resolve(
-      args
-    );
+    const backendIdentifier =
+      await this.backendIdentifierResolver.resolveDeployedBackendIdentifier(
+        args
+      );
 
     if (!backendIdentifier) {
       throw new Error('Could not resolve the backend identifier');
diff --git a/packages/cli/src/commands/generate/graphql-client-code/generate_graphql_client_code_command.ts b/packages/cli/src/commands/generate/graphql-client-code/generate_graphql_client_code_command.ts
@@ -89,9 +89,10 @@ export class GenerateGraphqlClientCodeCommand
   handler = async (
     args: ArgumentsCamelCase<GenerateGraphqlClientCodeCommandOptions>
   ): Promise<void> => {
-    const backendIdentifier = await this.backendIdentifierResolver.resolve(
-      args
-    );
+    const backendIdentifier =
+      await this.backendIdentifierResolver.resolveDeployedBackendIdentifier(
+        args
+      );
     const out = this.getOutDir(args);
     const format = args.format ?? GenerateApiCodeFormat.GRAPHQL_CODEGEN;
     const formatParams = this.formatParamBuilders[format](args);
diff --git a/packages/cli/src/commands/generate/outputs/generate_outputs_command.ts b/packages/cli/src/commands/generate/outputs/generate_outputs_command.ts
@@ -54,9 +54,10 @@ export class GenerateOutputsCommand
   handler = async (
     args: ArgumentsCamelCase<GenerateOutputsCommandOptions>
   ): Promise<void> => {
-    const backendIdentifier = await this.backendIdentifierResolver.resolve(
-      args
-    );
+    const backendIdentifier =
+      await this.backendIdentifierResolver.resolveDeployedBackendIdentifier(
+        args
+      );
 
     if (!backendIdentifier) {
       throw new Error('Could not resolve the backend identifier');
diff --git a/packages/cli/src/commands/generate/schema-from-database/generate_schema_command.test.ts b/packages/cli/src/commands/generate/schema-from-database/generate_schema_command.test.ts
@@ -117,9 +117,15 @@ void describe('generate graphql-client-code command', () => {
 
   void it('generates and writes schema for stack', async () => {
     await commandRunner.runCommand(
-      'schema-from-database --stack stack_name --connection-uri-secret CONN_STRING --out schema.rds.ts'
+      'schema-from-database --stack amplify-reasonableName-userName-sandbox-testHash --connection-uri-secret CONN_STRING --out schema.rds.ts'
     );
     assert.equal(secretClientGetSecret.mock.callCount(), 1);
+    assert.deepEqual(secretClientGetSecret.mock.calls[0].arguments[0], {
+      namespace: 'reasonableName',
+      name: 'userName',
+      type: 'sandbox',
+      hash: 'testHash',
+    });
     assert.equal(schemaGeneratorGenerateMethod.mock.callCount(), 1);
     assert.deepEqual(schemaGeneratorGenerateMethod.mock.calls[0].arguments[0], {
       connectionUri: {
diff --git a/packages/cli/src/commands/generate/schema-from-database/generate_schema_command.ts b/packages/cli/src/commands/generate/schema-from-database/generate_schema_command.ts
@@ -2,7 +2,6 @@ import { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
 import { BackendIdentifierResolver } from '../../../backend-identifier/backend_identifier_resolver.js';
 import { ArgumentsKebabCase } from '../../../kebab_case.js';
 import { SecretClient } from '@aws-amplify/backend-secret';
-import { BackendIdentifier } from '@aws-amplify/plugin-types';
 import { SchemaGenerator } from '@aws-amplify/schema-generator';
 import { AmplifyFault } from '@aws-amplify/platform-core';
 
@@ -54,9 +53,8 @@ export class GenerateSchemaCommand
   handler = async (
     args: ArgumentsCamelCase<GenerateSchemaCommandOptions>
   ): Promise<void> => {
-    const backendIdentifier = await this.backendIdentifierResolver.resolve(
-      args
-    );
+    const backendIdentifier =
+      await this.backendIdentifierResolver.resolveBackendIdentifier(args);
 
     if (!backendIdentifier) {
       throw new AmplifyFault('BackendIdentifierFault', {
@@ -68,7 +66,7 @@ export class GenerateSchemaCommand
     const outputFile = args.out as string;
 
     const connectionUriSecret = await this.secretClient.getSecret(
-      backendIdentifier as BackendIdentifier,
+      backendIdentifier,
       {
         name: connectionUriSecretName,
       }
@@ -77,12 +75,9 @@ export class GenerateSchemaCommand
     const sslCertSecretName = args.sslCertSecret as string;
     let sslCertSecret;
     if (sslCertSecretName) {
-      sslCertSecret = await this.secretClient.getSecret(
-        backendIdentifier as BackendIdentifier,
-        {
-          name: sslCertSecretName,
-        }
-      );
+      sslCertSecret = await this.secretClient.getSecret(backendIdentifier, {
+        name: sslCertSecretName,
+      });
     }
 
     await this.schemaGenerator.generate({

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@aws-amplify/backend-cli': patch
 +---
++
 +correctly handle stack argument for generate schema command