Seed

.changeset/little-kids-double.md

@@ -0,0 +1,6 @@
+---
+'@aws-amplify/seed': minor
+'@aws-amplify/backend-cli': minor
+---
+
+adding seed feature

packages/cli/package.json

@@ -45,12 +45,14 @@
     "@aws-amplify/schema-generator": "^1.2.7",
     "@aws-sdk/client-amplify": "^3.624.0",
     "@aws-sdk/client-cloudformation": "^3.624.0",
+    "@aws-sdk/client-cognito-identity-provider": "^3.741.0",
     "@aws-sdk/client-s3": "^3.624.0",
     "@aws-sdk/credential-provider-ini": "^3.624.0",
     "@aws-sdk/credential-providers": "^3.624.0",
     "@aws-sdk/region-config-resolver": "^3.614.0",
     "@smithy/node-config-provider": "^2.1.3",
     "@smithy/shared-ini-file-loader": "^2.2.5",
+    "aws-cdk-lib": "^2.177.0",
     "envinfo": "^7.11.0",
     "execa": "^9.5.1",
     "is-ci": "^3.0.1",

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_command.test.ts

@@ -0,0 +1,143 @@
+import { after, before, describe, it, mock } from 'node:test';
+import fsp from 'fs/promises';
+import fs from 'fs';
+import * as path from 'path';
+import { SandboxSeedCommand } from './sandbox_seed_command.js';
+import yargs, { CommandModule } from 'yargs';
+import {
+  TestCommandError,
+  TestCommandRunner,
+} from '../../../test-utils/command_runner.js';
+import { createSandboxSecretCommand } from '../sandbox-secret/sandbox_secret_command_factory.js';
+import { EventHandler, SandboxCommand } from '../sandbox_command.js';
+import { SandboxSingletonFactory } from '@aws-amplify/sandbox';
+import { SandboxDeleteCommand } from '../sandbox-delete/sandbox_delete_command.js';
+import { ClientConfigGeneratorAdapter } from '../../../client-config/client_config_generator_adapter.js';
+import { format, printer } from '@aws-amplify/cli-core';
+import { CommandMiddleware } from '../../../command_middleware.js';
+import { SandboxSeedGeneratePolicyCommand } from './sandbox_seed_policy_command.js';
+import assert from 'node:assert';
+import { BackendIdentifier } from '@aws-amplify/plugin-types';
+import { SandboxBackendIdResolver } from '../sandbox_id_resolver.js';
+
+const seedFileContents = 'console.log(`seed has been run`);';
+
+const testBackendNameSpace = 'testSandboxId';
+const testSandboxName = 'testSandboxName';
+
+const testBackendId: BackendIdentifier = {
+  namespace: testBackendNameSpace,
+  name: testSandboxName,
+  type: 'sandbox',
+};
+
+//const testBackendIdStr = 'testBackendId';
+
+void describe('sandbox seed command', () => {
+  let commandRunner: TestCommandRunner;
+
+  const clientConfigGenerationMock = mock.fn<EventHandler>();
+  const clientConfigDeletionMock = mock.fn<EventHandler>();
+
+  const clientConfigGeneratorAdapterMock = {
+    generateClientConfigToFile: clientConfigGenerationMock,
+  } as unknown as ClientConfigGeneratorAdapter;
+
+  const commandMiddleware = new CommandMiddleware(printer);
+  let amplifySeedDir: string;
+  let fullPath: string;
+
+  const sandboxIdResolver: SandboxBackendIdResolver = {
+    resolve: () => Promise.resolve(testBackendId),
+  } as SandboxBackendIdResolver;
+
+  before(async () => {
+    const sandboxFactory = new SandboxSingletonFactory(
+      () => Promise.resolve(testBackendId),
+      printer,
+      format
+    );
+
+    const sandboxSeedCommand = new SandboxSeedCommand(sandboxIdResolver, [
+      new SandboxSeedGeneratePolicyCommand(sandboxIdResolver),
+    ]);
+
+    const sandboxCommand = new SandboxCommand(
+      sandboxFactory,
+      [
+        new SandboxDeleteCommand(sandboxFactory),
+        createSandboxSecretCommand(),
+        sandboxSeedCommand,
+      ],
+      clientConfigGeneratorAdapterMock,
+      commandMiddleware,
+      () => ({
+        successfulDeployment: [clientConfigGenerationMock],
+        successfulDeletion: [clientConfigDeletionMock],
+        failedDeployment: [],
+      })
+    );
+    const parser = yargs().command(sandboxCommand as unknown as CommandModule);
+    commandRunner = new TestCommandRunner(parser);
+  });
+
+  void describe('seed script exists', () => {
+    before(async () => {
+      await fsp.mkdir(path.join(process.cwd(), 'amplify', 'seed'), {
+        recursive: true,
+      });
+      amplifySeedDir = path.join(process.cwd(), 'amplify');
+      fullPath = path.join(process.cwd(), 'amplify', 'seed', 'seed.ts');
+      await fsp.writeFile(fullPath, seedFileContents, 'utf8');
+    });
+
+    after(async () => {
+      await fsp.rm(amplifySeedDir, { recursive: true, force: true });
+      if (process.env.AMPLIFY_SANDBOX_IDENTIFIER) {
+        delete process.env.AMPLIFY_SANDBOX_IDENTIFIER;
+      }
+    });
+
+    void it('runs seed if seed script is found', async () => {
+      const fsOpenSyncMock = mock.method(fs, 'openSync');
+      await commandRunner.runCommand('sandbox seed');
+
+      assert.equal(fsOpenSyncMock.mock.callCount(), 1);
+      mock.restoreAll();
+    });
+
+    // TO DO: should have a test to see if backendID is set, that will need to happen while seed command is running
+  });
+
+  void describe('seed script does not exist', () => {
+    before(async () => {
+      await fsp.mkdir(path.join(process.cwd(), 'amplify', 'seed'), {
+        recursive: true,
+      });
+      amplifySeedDir = path.join(process.cwd(), 'amplify');
+    });
+
+    after(async () => {
+      await fsp.rm(amplifySeedDir, { recursive: true, force: true });
+      if (process.env.AMPLIFY_SANDBOX_IDENTIFIER) {
+        delete process.env.AMPLIFY_SANDBOX_IDENTIFIER;
+      }
+    });
+
+    void it('throws error if seed script does not exist', async () => {
+      await assert.rejects(
+        () => commandRunner.runCommand('sandbox seed'),
+        (err: TestCommandError) => {
+          // file differences between Unix and Windows makes it tricky to add the path
+          assert.match(err.output, /SeedScriptNotFoundError/);
+          assert.match(err.output, /There is no file that corresponds to/);
+          assert.match(
+            err.output,
+            /Please make a file that corresponds to (.*) and put your seed logic in it/
+          );
+          return true;
+        }
+      );
+    });
+  });
+});

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_command.ts

@@ -0,0 +1,65 @@
+import { Argv, CommandModule } from 'yargs';
+import path from 'path';
+import { existsSync } from 'fs';
+import { execa } from 'execa';
+import { SandboxBackendIdResolver } from '../sandbox_id_resolver.js';
+import { AmplifyUserError } from '@aws-amplify/platform-core';
+import { SandboxCommandGlobalOptions } from '../option_types.js';
+
+/**
+ * Command that runs seed in sandbox environment
+ */
+export class SandboxSeedCommand implements CommandModule<object> {
+  /**
+   * @inheritDoc
+   */
+  readonly command: string;
+
+  /**
+   * @inheritDoc
+   */
+  readonly describe: string;
+
+  /**
+   * Seeds sandbox environment.
+   */
+  constructor(
+    private readonly backendIDResolver: SandboxBackendIdResolver,
+    private readonly seedSubCommands: CommandModule[]
+  ) {
+    this.command = 'seed';
+    this.describe = 'Seeds sandbox environment';
+  }
+
+  /**
+   * @inheritDoc
+   */
+  handler = async (): Promise<void> => {
+    const backendID = await this.backendIDResolver.resolve();
+    const seedPath = path.join('amplify', 'seed', 'seed.ts');
+    await execa('tsx', [seedPath], {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+      env: {
+        AMPLIFY_SANDBOX_IDENTIFIER: JSON.stringify(backendID),
+      },
+    });
+  };
+
+  /**
+   * @inheritDoc
+   */
+  builder = (yargs: Argv): Argv<SandboxCommandGlobalOptions> => {
+    return yargs.command(this.seedSubCommands).check(() => {
+      const seedPath = path.join(process.cwd(), 'amplify', 'seed', 'seed.ts');
+      if (!existsSync(seedPath)) {
+        // this only gets sent to outputs
+        throw new AmplifyUserError('SeedScriptNotFoundError', {
+          message: `There is no file that corresponds to ${seedPath}`,
+          resolution: `Please make a file that corresponds to ${seedPath} and put your seed logic in it`,
+        });
+      }
+      return true;
+    });
+  };
+}

packages/cli/src/commands/sandbox/sandbox-seed/sandbox_seed_policy_command.ts

@@ -0,0 +1,43 @@
+import { Argv, CommandModule } from 'yargs';
+import { printer } from '@aws-amplify/cli-core';
+import { SandboxBackendIdResolver } from '../sandbox_id_resolver.js';
+import { generateSeedPolicyTemplate } from '../../../seed-policy-generation/generate_seed_policy_template.js';
+
+/**
+ * Command that generates policy template with permissions to be able to run seed in sandbox environment
+ */
+export class SandboxSeedGeneratePolicyCommand implements CommandModule<object> {
+  /**
+   * @inheritDoc
+   */
+  readonly command: string;
+
+  /**
+   * @inheritDoc
+   */
+  readonly describe: string;
+
+  /**
+   * Generates policy to run seed, is a subcommand of seed
+   */
+  constructor(private readonly backendIdResolver: SandboxBackendIdResolver) {
+    this.command = 'generate-policy';
+    this.describe = 'Generates policy for seeding based on outputs';
+  }
+
+  /**
+   * @inheritDoc
+   */
+  handler = async (): Promise<void> => {
+    const backendId = await this.backendIdResolver.resolve();
+    const policyDocument = await generateSeedPolicyTemplate(backendId);
+    printer.print(JSON.stringify(policyDocument.toJSON(), null, 1));
+  };
+
+  /**
+   * @inheritDoc
+   */
+  builder = (yargs: Argv) => {
+    return yargs;
+  };
+}

packages/cli/src/commands/sandbox/sandbox_command_factory.ts

@@ -6,6 +6,7 @@ import {
 } from './sandbox_command.js';
 import { SandboxSingletonFactory } from '@aws-amplify/sandbox';
 import { SandboxDeleteCommand } from './sandbox-delete/sandbox_delete_command.js';
+import { SandboxSeedCommand } from './sandbox-seed/sandbox_seed_command.js';
 import { SandboxBackendIdResolver } from './sandbox_id_resolver.js';
 import { ClientConfigGeneratorAdapter } from '../../client-config/client_config_generator_adapter.js';
 import { LocalNamespaceResolver } from '../../backend-identifier/local_namespace_resolver.js';
@@ -24,6 +25,7 @@ import {
 import { S3Client } from '@aws-sdk/client-s3';
 import { AmplifyClient } from '@aws-sdk/client-amplify';
 import { CloudFormationClient } from '@aws-sdk/client-cloudformation';
+import { SandboxSeedGeneratePolicyCommand } from './sandbox-seed/sandbox_seed_policy_command.js';
 
 /**
  * Creates wired sandbox command.
@@ -75,7 +77,13 @@ export const createSandboxCommand = (): CommandModule<
   const commandMiddleWare = new CommandMiddleware(printer);
   return new SandboxCommand(
     sandboxFactory,
-    [new SandboxDeleteCommand(sandboxFactory), createSandboxSecretCommand()],
+    [
+      new SandboxDeleteCommand(sandboxFactory),
+      createSandboxSecretCommand(),
+      new SandboxSeedCommand(sandboxBackendIdPartsResolver, [
+        new SandboxSeedGeneratePolicyCommand(sandboxBackendIdPartsResolver),
+      ]),
+    ],
     clientConfigGeneratorAdapter,
     commandMiddleWare,
     eventHandlerFactory.getSandboxEventHandlers