Directory-Based Resolver Mapping for AWS AppSync

pipelines/
  ├── {TypeName}/
  │     └── {FieldName}/
  │           ├── meta.json
  │           ├── 0.resolver.js
  │           └── 1.resolver.js (optional additional functions)

type Query {
  listRestaurants(input: ListRestaurantsInput!): RestaurantPage!
}

pipelines/Query/listRestaurants/

// pipelines/Query/listRestaurants/0.resolver.js
export function request(ctx) {
  const { args } = ctx;
  return {
    operation: 'Query',
    query: {
      expression: '#location = :location',
      expressionNames: { '#location': 'location' },
      expressionValues: { ':location': args.input.location }
    },
  };
}

export function response(ctx) {
  return ctx.result;
}

// pipelines/Query/listRestaurants/meta.json
{
  "dataSourceConfigs": [
    {
      "type": "ddb",
      "tableArns": [
        "arn:aws:dynamodb:us-east-1:123456789012:table/RestaurantsTable"
      ]
    }
  ]
}

export function defineResolvers({ scope, api }) {
  const typeNamePaths = globSync(path.join(__dirname, `./pipelines/*`), { withFileTypes: true });

  for (const typeNamePath of typeNamePaths) {
    if (!typeNamePath.isDirectory()) continue;

    const fieldNamePaths = globSync(`${typeNamePath.fullpath()}/*`, { withFileTypes: true });
    for (const fieldNamePath of fieldNamePaths) {
      if (!fieldNamePath.isDirectory()) continue;

      definePipelineResolver({
        scope,
        api,
        typeName: typeNamePath.name,
        fieldName: fieldNamePath.name,
        path: fieldNamePath,
      });
    }
  }
}

function definePipelineResolver({
  scope,
  api,
  typeName,
  fieldName,
  path,
}) {
  const pipelineName = `${typeName}${upperFirst(fieldName)}Pipeline`;
  const functionDefs = [];
  let meta = null;

  // Scan resolver directory for files and configuration
  for (const child of path.readdirSync()) {
    if (child.isDirectory()) continue;

    const match = child.name.match(/^([0-9]+)\.resolver\.js$/i);
    if (match) {
      const index = +match[1];
      functionDefs.push({ index, path: child });
    } else if (child.name === 'meta.json') {
      meta = JSON.parse(fs.readFileSync(child.fullpath(), 'utf8'));
    }
  }

  // Sort functions by numerical prefix
  const sortedFunctionDefs = _.sortBy(functionDefs, ({ index }) => index);

  // Create pipeline configuration
  const pipelineConfig = sortedFunctionDefs.map(({ path, index }) => {
    const dataSourceConfig = meta.dataSourceConfigs[index];
    const dataSource = defineDataSource({ 
      scope, 
      name: `${pipelineName}DS${index}`, 
      api, 
      config: dataSourceConfig 
    });

    return defineFunction({
      name: `${pipelineName}Function${index}`,
      path,
      dataSource,
      scope,
      api,
    });
  });

  // Register the AppSync resolver
  new appsync.Resolver(scope, pipelineName, {
    api,
    typeName,
    fieldName,
    pipelineConfig,
    code: Code.fromInline(`
      function request(ctx) { return ctx; }
      function response(ctx) { return ctx.result; }
      export { request, response };
    `),
    runtime: FunctionRuntime.JS_1_0_0,
  });
}

function defineDdbDataSourceRole({
  scope,
  name,
  tableArns,
}: {
  scope: Construct;
  name: string;
  tableArns: string[];
}): Role | undefined {
  return new iam.Role(scope, name, {
    assumedBy: new iam.ServicePrincipal('appsync.amazonaws.com'),
    inlinePolicies: {
      AccessDynamoDbTables: new iam.PolicyDocument({
        statements: [
          new iam.PolicyStatement({
            actions: ['dynamodb:GetItem', 'dynamodb:Query', 'dynamodb:Scan' /* add actions as needed by resolvers */],
            resources: tableArns.reduce((collector: string[], tableArn: string) => {
              collector.push(tableArn);
              collector.push(`${tableArn}/index/*`);
              return collector;
            }, []),
          }),
        ],
      }),
    },
  });
}

function defineDataSource({
  scope,
  name,
  api,
  config,
}: {
  scope: Construct;
  name: string;
  api: IGraphqlApi;
  config: { type: string; tableArns: string[] };
}): BaseDataSource {
  if (config.type === 'ddb') {
    const serviceRole = defineDdbDataSourceRole({
      scope,
      name: `${name}ServiceRole`,
      tableArns: config.tableArns,
    });

    return new appsync.DynamoDbDataSource(scope, name, {
      api,
      table: dynamodb.Table.fromTableArn(scope, `${name}Table`, config.tableArns[0]),
      serviceRole,
    });
  }

  // Implement other types of data sources as needed

  throw new Error(`Unsupported data source type: ${config.type}`);
}

import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as path from 'path';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import { defineResolvers } from './resolvers';

export class ApiStack extends Stack {
  constructor(scope: Construct, id: string, props: StackProps) {
    super(scope, id, props);

    const graphqlApi = new appsync.GraphqlApi(this, 'GraphqlApi', {
      name: 'Api',
      definition: appsync.Definition.fromSchema(
        appsync.SchemaFile.fromAsset(path.join(__dirname, './shared/gql/schema.gql'))
      ),
    });

    // Register all resolvers from the directory structure
    defineResolvers({
      scope: this,
      api: graphqlApi,
    });
  }
}