feat: generate api code

.changeset/fuzzy-socks-begin.md

@@ -0,0 +1,7 @@
+---
+'@aws-amplify/model-generator': minor
+---
+
+Add wrapper to around types, documents, and model generation (`generateAPICode`).
+
+Change `createGraphqlDocumentGenerator` and `createGraphqlTypesGenerator` to use backendIdentifier and credentialProvider.

.eslint_dictionary.js

@@ -39,12 +39,14 @@ export default [
   'inheritdoc',
   'invokable',
   'invoker',
+  'javascript',
   'jsdoc',
   'lang',
   'lsof',
   'lstat',
   'mfas',
   'mkdtemp',
+  'modelgen',
   'multifactor',
   'nodejs',
   'npmrc',
@@ -65,6 +67,7 @@ export default [
   'repo',
   'resolvers',
   'saml',
+  'scala',
   'schema',
   'schemas',
   'searchable',

packages/model-generator/API.md

@@ -4,21 +4,71 @@
 
 ```ts
 
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
+import { BackendIdentifier } from '@aws-amplify/deployed-backend-client';
 import { ModelsTarget } from '@aws-amplify/graphql-generator';
 import { StatementsTarget } from '@aws-amplify/graphql-generator';
 import { TypesTarget } from '@aws-amplify/graphql-generator';
 
 // @public
-export const createGraphqlDocumentGenerator: ({ apiId, }: GraphqlDocumentGeneratorFactoryParams) => GraphqlDocumentGenerator;
+export const createGraphqlDocumentGenerator: ({ backendIdentifier, credentialProvider, }: GraphqlDocumentGeneratorFactoryParams) => GraphqlDocumentGenerator;
 
 // @public (undocumented)
 export type DocumentGenerationParameters = {
     language: TargetLanguage;
+    maxDepth?: number;
+    typenameIntrospection?: boolean;
 };
 
+// @public
+export const generateApiCode: (props: GenerateApiCodeProps) => Promise<GeneratedOutput>;
+
+// @public (undocumented)
+export type GenerateApiCodeProps = GenerateOptions & BackendIdentifier & {
+    credentialProvider: AwsCredentialIdentityProvider;
+};
+
+// @public (undocumented)
+export type GeneratedOutput = {
+    [filename: string]: string;
+};
+
+// @public (undocumented)
+export type GenerateGraphqlCodegenOptions = {
+    format: 'graphql-codegen';
+    statementTarget: 'javascript' | 'graphql' | 'flow' | 'typescript' | 'angular';
+    maxDepth?: number;
+    typeNameIntrospection?: boolean;
+    typeTarget?: 'json' | 'swift' | 'typescript' | 'flow' | 'scala' | 'flow-modern' | 'angular';
+    multipleSwiftFiles?: boolean;
+};
+
+// @public (undocumented)
+export type GenerateIntrospectionOptions = {
+    format: 'introspection';
+};
+
+// @public (undocumented)
+export type GenerateModelsOptions = {
+    format: 'modelgen';
+    modelTarget: 'java' | 'swift' | 'javascript' | 'typescript' | 'dart';
+    generateIndexRules?: boolean;
+    emitAuthProvider?: boolean;
+    useExperimentalPipelinedTransformer?: boolean;
+    transformerVersion?: boolean;
+    respectPrimaryKeyAttributesOnConnectionField?: boolean;
+    generateModelsForLazyLoadAndCustomSelectionSet?: boolean;
+    addTimestampFields?: boolean;
+    handleListNullabilityTransparently?: boolean;
+};
+
+// @public (undocumented)
+export type GenerateOptions = GenerateGraphqlCodegenOptions | GenerateModelsOptions | GenerateIntrospectionOptions;
+
 // @public (undocumented)
 export type GenerationResult = {
     writeToDirectory: (directoryPath: string) => Promise<void>;
+    operations: Record<string, string>;
 };
 
 // @public (undocumented)
@@ -28,7 +78,8 @@ export type GraphqlDocumentGenerator = {
 
 // @public (undocumented)
 export type GraphqlDocumentGeneratorFactoryParams = {
-    apiId: string;
+    backendIdentifier: BackendIdentifier;
+    credentialProvider: AwsCredentialIdentityProvider;
 };
 
 // @public (undocumented)
@@ -44,6 +95,14 @@ export type GraphqlTypesGenerator = {
 // @public (undocumented)
 export type ModelsGenerationParameters = {
     target: ModelsTarget;
+    generateIndexRules?: boolean;
+    emitAuthProvider?: boolean;
+    useExperimentalPipelinedTransformer?: boolean;
+    transformerVersion?: boolean;
+    respectPrimaryKeyAttributesOnConnectionField?: boolean;
+    generateModelsForLazyLoadAndCustomSelectionSet?: boolean;
+    addTimestampFields?: boolean;
+    handleListNullabilityTransparently?: boolean;
 };
 
 // @public (undocumented)
@@ -52,6 +111,7 @@ export type TargetLanguage = StatementsTarget;
 // @public (undocumented)
 export type TypesGenerationParameters = {
     target: TypesTarget;
+    multipleSwiftFiles?: boolean;
 };
 
 // (No @packageDocumentation comment for this package)

packages/model-generator/package.json

@@ -22,6 +22,7 @@
     "@aws-amplify/graphql-generator": "^0.1.0",
     "@aws-sdk/client-appsync": "^3.398.0",
     "@aws-sdk/client-s3": "^3.414.0",
+    "@aws-sdk/credential-providers": "^3.414.0",
     "@aws-sdk/types": "^3.413.0"
   }
 }

packages/model-generator/src/appsync_graphql_generation_result.ts

@@ -12,7 +12,7 @@ export class AppsyncGraphqlGenerationResult implements GenerationResult {
    * @param operations A record of FileName to FileContent
    * in the format of Record<string,string>
    */
-  constructor(private operations: ClientOperations) {}
+  constructor(public operations: ClientOperations) {}
   private writeSchemaToFile = async (
     basePath: string,
     filePath: string,

packages/model-generator/src/create_graphql_document_generator.test.ts

@@ -1,11 +1,25 @@
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
+import { BackendIdentifier } from '@aws-amplify/deployed-backend-client';
 import { createGraphqlDocumentGenerator } from './create_graphql_document_generator.js';
 
 describe('model generator factory', () => {
-  it('throws an error if a null apiId is passed in', async () => {
+  it('throws an error if a null backendIdentifier is passed in', async () => {
     assert.throws(() =>
-      createGraphqlDocumentGenerator({ apiId: null as unknown as string })
+      createGraphqlDocumentGenerator({
+        backendIdentifier: null as unknown as BackendIdentifier,
+        credentialProvider: null as unknown as AwsCredentialIdentityProvider,
+      })
+    );
+  });
+
+  it('throws an error if a null backendIdentifier is passed in', async () => {
+    assert.throws(() =>
+      createGraphqlDocumentGenerator({
+        backendIdentifier: { stackName: 'foo' },
+        credentialProvider: null as unknown as AwsCredentialIdentityProvider,
+      })
     );
   });
 });

packages/model-generator/src/create_graphql_document_generator.ts

@@ -1,25 +1,51 @@
 import { AppSyncClient } from '@aws-sdk/client-appsync';
+import {
+  BackendIdentifier,
+  BackendOutputClient,
+} from '@aws-amplify/deployed-backend-client';
+import { graphqlOutputKey } from '@aws-amplify/backend-output-schemas';
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
 import { AppsyncGraphqlGenerationResult } from './appsync_graphql_generation_result.js';
 import { AppSyncIntrospectionSchemaFetcher } from './appsync_schema_fetcher.js';
 import { AppSyncGraphqlDocumentGenerator } from './graphql_document_generator.js';
 import { GraphqlDocumentGenerator } from './model_generator.js';
 
 export type GraphqlDocumentGeneratorFactoryParams = {
-  apiId: string;
+  backendIdentifier: BackendIdentifier;
+  credentialProvider: AwsCredentialIdentityProvider;
 };
 
 /**
  * Factory function to compose a model generator
  */
 export const createGraphqlDocumentGenerator = ({
-  apiId,
+  backendIdentifier,
+  credentialProvider,
 }: GraphqlDocumentGeneratorFactoryParams): GraphqlDocumentGenerator => {
-  if (!apiId) {
-    throw new Error('`apiId` must be defined');
+  if (!backendIdentifier) {
+    throw new Error('`backendIdentifier` must be defined');
   }
+  if (!credentialProvider) {
+    throw new Error('`credentialProvider` must be defined');
+  }
+
+  const fetchSchema = async () => {
+    const backendOutputClient = new BackendOutputClient(
+      credentialProvider,
+      backendIdentifier
+    );
+    const output = await backendOutputClient.getOutput();
+    const apiId = output[graphqlOutputKey]?.payload.awsAppsyncApiId;
+    if (!apiId) {
+      throw new Error(`Unable to determine AppSync API ID.`);
+    }
+
+    return new AppSyncIntrospectionSchemaFetcher(new AppSyncClient()).fetch(
+      apiId
+    );
+  };
   return new AppSyncGraphqlDocumentGenerator(
-    () =>
-      new AppSyncIntrospectionSchemaFetcher(new AppSyncClient()).fetch(apiId),
+    fetchSchema,
     (fileMap) => new AppsyncGraphqlGenerationResult(fileMap)
   );
 };

packages/model-generator/src/create_graphql_types_generator.test.ts

@@ -1,11 +1,25 @@
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
+import { BackendIdentifier } from '@aws-amplify/deployed-backend-client';
 import { createGraphqlTypesGenerator } from './create_graphql_types_generator.js';
 
 describe('types generator factory', () => {
-  it('throws an error if a null apiId is passed in', async () => {
+  it('throws an error if a null backendIdentifier is passed in', async () => {
     assert.throws(() =>
-      createGraphqlTypesGenerator({ apiId: null as unknown as string })
+      createGraphqlTypesGenerator({
+        backendIdentifier: null as unknown as BackendIdentifier,
+        credentialProvider: null as unknown as AwsCredentialIdentityProvider,
+      })
+    );
+  });
+
+  it('throws an error if a null backendIdentifier is passed in', async () => {
+    assert.throws(() =>
+      createGraphqlTypesGenerator({
+        backendIdentifier: { stackName: 'foo' },
+        credentialProvider: null as unknown as AwsCredentialIdentityProvider,
+      })
     );
   });
 });

packages/model-generator/src/create_graphql_types_generator.ts

@@ -1,25 +1,51 @@
 import { AppSyncClient } from '@aws-sdk/client-appsync';
+import {
+  BackendIdentifier,
+  BackendOutputClient,
+} from '@aws-amplify/deployed-backend-client';
+import { graphqlOutputKey } from '@aws-amplify/backend-output-schemas';
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
 import { AppsyncGraphqlGenerationResult } from './appsync_graphql_generation_result.js';
 import { AppSyncIntrospectionSchemaFetcher } from './appsync_schema_fetcher.js';
 import { AppSyncGraphqlTypesGenerator } from './graphql_types_generator.js';
 import { GraphqlTypesGenerator } from './model_generator.js';
 
 export type GraphqlTypesGeneratorFactoryParams = {
-  apiId: string;
+  backendIdentifier: BackendIdentifier;
+  credentialProvider: AwsCredentialIdentityProvider;
 };
 
 /**
  * Factory function to compose a model generator
  */
 export const createGraphqlTypesGenerator = ({
-  apiId,
+  backendIdentifier,
+  credentialProvider,
 }: GraphqlTypesGeneratorFactoryParams): GraphqlTypesGenerator => {
-  if (!apiId) {
-    throw new Error('`apiId` must be defined');
+  if (!backendIdentifier) {
+    throw new Error('`backendIdentifier` must be defined');
   }
+  if (!credentialProvider) {
+    throw new Error('`credentialProvider` must be defined');
+  }
+
+  const fetchSchema = async () => {
+    const backendOutputClient = new BackendOutputClient(
+      credentialProvider,
+      backendIdentifier
+    );
+    const output = await backendOutputClient.getOutput();
+    const apiId = output[graphqlOutputKey]?.payload.awsAppsyncApiId;
+    if (!apiId) {
+      throw new Error(`Unable to determine AppSync API ID.`);
+    }
+
+    return new AppSyncIntrospectionSchemaFetcher(new AppSyncClient()).fetch(
+      apiId
+    );
+  };
   return new AppSyncGraphqlTypesGenerator(
-    () =>
-      new AppSyncIntrospectionSchemaFetcher(new AppSyncClient()).fetch(apiId),
+    fetchSchema,
     (fileMap) => new AppsyncGraphqlGenerationResult(fileMap)
   );
 };

packages/model-generator/src/generate_api_code.test.ts

@@ -0,0 +1,17 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { GenerateApiCodeProps, generateApiCode } from './generate_api_code.js';
+
+describe('generateAPICode', () => {
+  describe('graphql-codegen', () => {});
+  describe('modelgen', () => {});
+  describe('introspection', () => {});
+
+  it('throws error on unknown format', async () => {
+    const props = {
+      format: 'unsupported',
+      stackName: 'stack_name',
+    } as unknown as GenerateApiCodeProps;
+    await assert.rejects(() => generateApiCode(props));
+  });
+});