@ttoss/appsync-api 0.18.33 → 0.18.35

package/src/createApiTemplate.ts

@@ -1,360 +0,0 @@
-import { type SchemaComposer, graphql } from '@ttoss/graphql-api';
-
-/**
- * Absolute path to avoid:
- * The inferred type of 'template' cannot be named without a reference to
- * '@ttoss/appsync-api/node_modules/@ttoss/cloudformation'. This is likely not
- * portable. A type annotation is necessary.ts(2742)
- */
-import type { CloudFormationTemplate } from '../../cloudformation/src/';
-
-export const AppSyncGraphQLApiLogicalId = 'AppSyncGraphQLApi';
-
-export const AppSyncGraphQLSchemaLogicalId = 'AppSyncGraphQLSchema';
-
-export const AppSyncLambdaFunctionLogicalId = 'AppSyncLambdaFunction';
-
-const AppSyncLambdaFunctionAppSyncDataSourceLogicalId =
-  'AppSyncLambdaFunctionAppSyncDataSource';
-
-export const AppSyncGraphQLApiKeyLogicalId = 'AppSyncGraphQLApiKey';
-
-type StringOrImport =
-  | string
-  | {
-      'Fn::ImportValue': string;
-    };
-
-/**
- * https://docs.aws.amazon.com/appsync/latest/devguide/security-authz.html
- */
-type AuthenticationType =
-  | 'API_KEY'
-  | 'AWS_LAMBDA'
-  | 'AWS_IAM'
-  | 'OPENID_CONNECT'
-  | 'AMAZON_COGNITO_USER_POOLS';
-
-export const createApiTemplate = ({
-  additionalAuthenticationProviders,
-  authenticationType = 'AMAZON_COGNITO_USER_POOLS',
-  schemaComposer,
-  dataSource,
-  lambdaFunction,
-  userPoolConfig,
-  customDomain,
-}: {
-  additionalAuthenticationProviders?: AuthenticationType[];
-  authenticationType?: AuthenticationType;
-  customDomain?: {
-    domainName: string;
-    certificateArn: string;
-    hostedZoneName?: string;
-  };
-  dataSource: {
-    roleArn: StringOrImport;
-  };
-  lambdaFunction: {
-    environment?: {
-      variables: Record<string, string>;
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    layers?: any;
-    roleArn: StringOrImport;
-  };
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  schemaComposer: SchemaComposer<any>;
-  userPoolConfig?: {
-    appIdClientRegex: StringOrImport;
-    awsRegion: StringOrImport;
-    defaultAction: 'ALLOW' | 'DENY';
-    userPoolId: StringOrImport;
-  };
-}): CloudFormationTemplate => {
-  /**
-   * It should be on top of the file, otherwise it will have empty Mutation
-   * or Subscription if there are no resolvers for them.
-   */
-  const sdlWithoutComments = schemaComposer.toSDL({
-    commentDescriptions: false,
-    omitDescriptions: true,
-    omitScalars: true,
-  });
-
-  graphql.validateSchema(schemaComposer.buildSchema());
-
-  /**
-   * Get FieldName and TypeName. `resolveMethods` is a Map of
-   * `typeName: { fieldName: resolverFn }`
-   */
-  const resolveMethods = schemaComposer.getResolveMethods();
-
-  const resolveMethodsEntries = Object.entries(resolveMethods)
-    .flatMap(([typeName, fieldResolvers]) => {
-      return Object.entries(fieldResolvers).map(([fieldName, resolver]) => {
-        if (typeof resolver !== 'function') {
-          return undefined;
-        }
-
-        if (typeName.toLowerCase().includes('enum')) {
-          return undefined;
-        }
-
-        return {
-          fieldName,
-          typeName,
-        };
-      });
-    })
-    .filter(Boolean) as Array<{ fieldName: string; typeName: string }>;
-
-  const template: CloudFormationTemplate = {
-    AWSTemplateFormatVersion: '2010-09-09',
-    Parameters: {
-      Environment: {
-        Default: 'Staging',
-        Type: 'String',
-        AllowedValues: ['Staging', 'Production'],
-      },
-      LambdaS3Bucket: {
-        Type: 'String',
-      },
-      LambdaS3Key: {
-        Type: 'String',
-      },
-      LambdaS3ObjectVersion: {
-        Type: 'String',
-      },
-    },
-    Resources: {
-      /**
-       * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-graphqlapi.html#cfn-appsync-graphqlapi-name
-       */
-      [AppSyncGraphQLApiLogicalId]: {
-        Type: 'AWS::AppSync::GraphQLApi',
-        Properties: {
-          AuthenticationType: authenticationType,
-          Name: {
-            Ref: 'AWS::StackName',
-          },
-        },
-      },
-      [AppSyncGraphQLSchemaLogicalId]: {
-        Type: 'AWS::AppSync::GraphQLSchema',
-        Properties: {
-          ApiId: { 'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'ApiId'] },
-          Definition: sdlWithoutComments,
-        },
-      },
-      [AppSyncLambdaFunctionLogicalId]: {
-        Type: 'AWS::Lambda::Function',
-        Properties: {
-          Code: {
-            S3Bucket: { Ref: 'LambdaS3Bucket' },
-            S3Key: { Ref: 'LambdaS3Key' },
-            S3ObjectVersion: { Ref: 'LambdaS3ObjectVersion' },
-          },
-          Handler: 'index.handler',
-          Layers: lambdaFunction.layers,
-          MemorySize: 512,
-          Role: lambdaFunction.roleArn,
-          Runtime: 'nodejs20.x',
-          /**
-           * https://docs.aws.amazon.com/general/latest/gr/appsync.html
-           * Request execution time for mutations, queries, and subscriptions: 30 seconds
-           */
-          Timeout: 29,
-        },
-      },
-      [AppSyncLambdaFunctionAppSyncDataSourceLogicalId]: {
-        Type: 'AWS::AppSync::DataSource',
-        Properties: {
-          ApiId: { 'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'ApiId'] },
-          LambdaConfig: {
-            LambdaFunctionArn: {
-              'Fn::GetAtt': [AppSyncLambdaFunctionLogicalId, 'Arn'],
-            },
-          },
-          Name: 'AppSyncLambdaFunctionAppSyncDataSource',
-          ServiceRoleArn: dataSource.roleArn,
-          Type: 'AWS_LAMBDA',
-        },
-      },
-    },
-    Outputs: {
-      AppSyncApiGraphQLUrl: {
-        Export: {
-          Name: {
-            'Fn::Join': [
-              ':',
-              [{ Ref: 'AWS::StackName' }, 'AppSyncApiGraphQLUrl'],
-            ],
-          },
-        },
-        Value: {
-          'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'GraphQLUrl'],
-        },
-      },
-      AppSyncApiArn: {
-        Export: {
-          Name: {
-            'Fn::Join': [':', [{ Ref: 'AWS::StackName' }, 'AppSyncApiArn']],
-          },
-        },
-        Value: {
-          'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'Arn'],
-        },
-      },
-    },
-  };
-
-  resolveMethodsEntries.forEach(({ fieldName, typeName }) => {
-    template.Resources[`${fieldName}${typeName}AppSyncResolver`] = {
-      Type: 'AWS::AppSync::Resolver',
-      DependsOn: AppSyncGraphQLSchemaLogicalId,
-      Properties: {
-        ApiId: { 'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'ApiId'] },
-        FieldName: fieldName,
-        TypeName: typeName,
-        DataSourceName: {
-          'Fn::GetAtt': [
-            AppSyncLambdaFunctionAppSyncDataSourceLogicalId,
-            'Name',
-          ],
-        },
-      },
-    };
-  });
-
-  const apiKey =
-    additionalAuthenticationProviders?.includes('API_KEY') ||
-    authenticationType === 'API_KEY';
-
-  const cognitoUserPoolAuth =
-    additionalAuthenticationProviders?.includes('AMAZON_COGNITO_USER_POOLS') ||
-    authenticationType === 'AMAZON_COGNITO_USER_POOLS';
-
-  if (additionalAuthenticationProviders) {
-    template.Resources[
-      AppSyncGraphQLApiLogicalId
-    ].Properties.AdditionalAuthenticationProviders =
-      additionalAuthenticationProviders?.map((provider) => {
-        return {
-          AuthenticationType: provider,
-        };
-      });
-  }
-
-  if (apiKey) {
-    template.Resources[AppSyncGraphQLApiKeyLogicalId] = {
-      Type: 'AWS::AppSync::ApiKey',
-      Properties: {
-        ApiId: { 'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'ApiId'] },
-      },
-    };
-
-    if (!template.Outputs) {
-      template.Outputs = {};
-    }
-
-    template.Outputs[AppSyncGraphQLApiKeyLogicalId] = {
-      Value: {
-        'Fn::GetAtt': [AppSyncGraphQLApiKeyLogicalId, 'ApiKey'],
-      },
-    };
-  }
-
-  if (cognitoUserPoolAuth) {
-    if (!userPoolConfig) {
-      throw new Error(
-        'userPoolConfig is required when using AMAZON_COGNITO_USER_POOLS authentication.'
-      );
-    }
-
-    template.Resources[AppSyncGraphQLApiLogicalId].Properties.UserPoolConfig = {
-      AppIdClientRegex: userPoolConfig.appIdClientRegex,
-      AwsRegion: userPoolConfig.awsRegion,
-      DefaultAction: userPoolConfig.defaultAction,
-      UserPoolId: userPoolConfig.userPoolId,
-    };
-  }
-
-  if (lambdaFunction.environment?.variables) {
-    template.Resources[AppSyncLambdaFunctionLogicalId].Properties.Environment =
-      {
-        Variables: lambdaFunction.environment.variables,
-      };
-  }
-
-  if (customDomain) {
-    const AppSyncDomainNameLogicalId = 'AppSyncDomainName';
-
-    /**
-     * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-appsync-domainname.html
-     */
-    template.Resources[AppSyncDomainNameLogicalId] = {
-      Type: 'AWS::AppSync::DomainName',
-      Properties: {
-        CertificateArn: customDomain.certificateArn,
-        Description: 'Custom domain for AppSync API',
-        DomainName: customDomain.domainName,
-      },
-    };
-
-    if (customDomain.hostedZoneName) {
-      const hostedZoneName = customDomain.hostedZoneName.endsWith('.')
-        ? customDomain.hostedZoneName
-        : `${customDomain.hostedZoneName}.`;
-
-      /**
-       * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-route53-recordset.html
-       */
-      template.Resources.AppSyncDomainNameRoute53RecordSet = {
-        Type: 'AWS::Route53::RecordSet',
-        Properties: {
-          HostedZoneName: hostedZoneName,
-          Name: customDomain.domainName,
-          ResourceRecords: [
-            {
-              'Fn::GetAtt': [AppSyncDomainNameLogicalId, 'AppSyncDomainName'],
-            },
-          ],
-          TTL: '900',
-          Type: 'CNAME',
-        },
-      };
-    }
-
-    template.Resources.AppSyncDomainNameApiAssociation = {
-      Type: 'AWS::AppSync::DomainNameApiAssociation',
-      Properties: {
-        ApiId: {
-          'Fn::GetAtt': [AppSyncGraphQLApiLogicalId, 'ApiId'],
-        },
-        DomainName: {
-          'Fn::GetAtt': [AppSyncDomainNameLogicalId, 'DomainName'],
-        },
-      },
-    };
-
-    if (!template.Outputs) {
-      template.Outputs = {};
-    }
-
-    template.Outputs.DomainName = {
-      Description: 'Custom domain name for AppSync API',
-      Value: {
-        'Fn::GetAtt': [AppSyncDomainNameLogicalId, 'DomainName'],
-      },
-    };
-
-    template.Outputs.CloudFrontDomainName = {
-      Description: 'CloudFront domain name for AppSync API',
-      Value: {
-        'Fn::GetAtt': [AppSyncDomainNameLogicalId, 'AppSyncDomainName'],
-      },
-    };
-  }
-
-  return template;
-};

package/src/createAppSyncResolverHandler.ts

@@ -1,95 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BuildSchemaInput, buildSchema } from '@ttoss/graphql-api';
-import { type GraphQLObjectType } from 'graphql';
-import type { AppSyncResolverHandler as AwsAppSyncResolverHandler } from 'aws-lambda';
-
-export type AppSyncResolverHandler<
-  TArguments,
-  TResult,
-  TSource = Record<string, any> | null,
-> = AwsAppSyncResolverHandler<TArguments, TResult, TSource>;
-
-export const createAppSyncResolverHandler = ({
-  ...buildSchemaInput
-}: BuildSchemaInput): AppSyncResolverHandler<any, any, any> => {
-  return async (event, appSyncHandlerContext) => {
-    const { schemaComposer } = buildSchemaInput;
-
-    /**
-     * https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html
-     */
-    const { info, arguments: args, source, request } = event;
-
-    const { parentTypeName, fieldName } = info;
-
-    const context = {
-      handler: appSyncHandlerContext,
-      request,
-      identity: event.identity,
-    };
-
-    const schema = buildSchema(buildSchemaInput);
-
-    const parentType = schema.getType(parentTypeName) as GraphQLObjectType;
-
-    if (!parentType) {
-      throw new Error(`Type ${parentTypeName} not found`);
-    }
-
-    const field = parentType.getFields()[fieldName];
-
-    const resolver = field?.resolve;
-
-    if (!resolver) {
-      throw new Error(`Resolver for ${parentTypeName}.${fieldName} not found`);
-    }
-
-    /**
-     * `composeWithConnection` findMany resolver needs sort to be the enum
-     * value defined in the enum instead the enum name.
-     * For example, if the config `sort.ID_ASC.value` is `{ order : 'ASC' }`,
-     * then the value of the argument `sort` enm should be
-     * `{ order : 'ASC' }` instead of `'ID_ASC'`.
-     */
-    const argsWithEnumValues = (() => {
-      const fieldsArgsIsEnumType = field.args.filter((arg) => {
-        return schemaComposer.isEnumType(arg.type);
-      });
-
-      const enumArgs = fieldsArgsIsEnumType
-        .map((enumArg) => {
-          if (!args[enumArg.name]) {
-            return { [enumArg.name]: enumArg.defaultValue };
-          }
-
-          const values = schemaComposer.getETC(enumArg.type).getFields();
-
-          return {
-            [enumArg.name]: values[args[enumArg.name]].value,
-          };
-        })
-        .reduce((acc, curr) => {
-          return { ...acc, ...curr };
-        }, {});
-
-      /**
-       * If `args.sort` has sort name, i.e. `ID_ASC`, then `enumArgs` will
-       * replace it with the value of the enum, i.e. `{ order : 'ASC' }`.
-       */
-      return { ...args, ...enumArgs };
-    })();
-
-    const response = await resolver(
-      source,
-      argsWithEnumValues,
-      context,
-      info as any
-    );
-
-    if (response instanceof Error) {
-      throw response;
-    }
-
-    return response;
-  };
-};

package/src/index.ts

@@ -1,6 +0,0 @@
-export { createApiTemplate } from './createApiTemplate';
-export {
-  type AppSyncResolverHandler,
-  createAppSyncResolverHandler,
-} from './createAppSyncResolverHandler';
-export type { AppSyncIdentityCognito } from 'aws-lambda';