Authoring a new plugin

amplify plugin init

$ amplify my-amplify-plugin help
help command to be implemented.

npm install -g my-amplify-plugin
amplify plugin add my-amplify-plugin
amplify my-amplify-plugin help

|_my-amplify-plugin/
  |_commands/
  |   |_ help.js
  |   |_ version.js
  |
  |_event-handlers
  |   |_handle-PostInit.js
  |   |_handle-PostPush.js
  |   |_handle-PreInit.js
  |   |_handle-PrePush.js
  |
  |_amplify-plugin.json
  |_index.js
  |_package.json

{
  "name": "my-amplify-plugin",
  "type": "util",
  "commands": [
    "version",
    "help"
  ],
  "eventHandlers": [
    "PreInit",
    "PostInit",
    "PrePush",
    "PostPush"
  ]
}

const path = require('path');

async function executeAmplifyCommand(context) {
  const commandsDirPath = path.normalize(path.join(__dirname, 'commands'));
  const commandPath = path.join(commandsDirPath, context.input.command);
  const commandModule = require(commandPath);
  await commandModule.run(context);
}

async function handleAmplifyEvent(context, args) {
  const eventHandlersDirPath = path.normalize(path.join(__dirname, 'event-handlers'));
  const eventHandlerPath = path.join(eventHandlersDirPath, `handle-${args.event}`);
  const eventHandlerModule = require(eventHandlerPath);
  await eventHandlerModule.run(context, args);
}

module.exports = {
  executeAmplifyCommand,
  handleAmplifyEvent,
};

import { GraphQLTransform } from '@aws-amplify/graphql-transformer-core';
import { FeatureFlagProvider, TransformerPluginProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { AuthTransformer } from '@aws-amplify/graphql-auth-transformer';
import { BelongsToTransformer, HasManyTransformer, HasOneTransformer, ManyToManyTransformer } from '@aws-amplify/graphql-relational-transformer';
import { DefaultValueTransformer } from '@aws-amplify/graphql-default-value-transformer';
import { FunctionTransformer } from '@aws-amplify/graphql-function-transformer';
import { HttpTransformer } from '@aws-amplify/graphql-http-transformer';
import { IndexTransformer, PrimaryKeyTransformer } from '@aws-amplify/graphql-index-transformer';
import { ModelTransformer } from '@aws-amplify/graphql-model-transformer';
import { PredictionsTransformer } from '@aws-amplify/graphql-predictions-transformer';
import { SearchableModelTransformer } from '@aws-amplify/graphql-searchable-transformer';

// This adapter class supports the propagation of feature flag values from the CLI to the transformers
class TransformerFeatureFlagAdapter implements FeatureFlagProvider {
  getBoolean(featureName: string, defaultValue?: boolean): boolean {
    throw new Error('Method not implemented.');
  }
  getString(featureName: string, defaultValue?: string): string {
    throw new Error('Method not implemented.');
  }
  getNumber(featureName: string, defaultValue?: number): number {
    throw new Error('Method not implemented.');
  }
  getObject(featureName: string, defaultValue?: object): object {
    throw new Error('Method not implemented.');
  }
}

const modelTransformer = new ModelTransformer();
const indexTransformer = new IndexTransformer();
const hasOneTransformer = new HasOneTransformer();
const authTransformer = new AuthTransformer({
  authConfig: {
    defaultAuthentication: {
      authenticationType: 'API_KEY',
    },
    additionalAuthenticationProviders: [
      {
        authenticationType: 'AMAZON_COGNITO_USER_POOLS',
        userPoolConfig: {
          userPoolId: 'us-east-1_abcdefghi',
        }
      }
    ]
  },
  addAwsIamAuthInOutputSchema: true,
});

const transformers: TransformerPluginProvider[] = [
  modelTransformer,
  new FunctionTransformer(),
  new HttpTransformer(),
  new PredictionsTransformer(),
  new PrimaryKeyTransformer(),
  indexTransformer,
  new BelongsToTransformer(),
  new HasManyTransformer(),
  hasOneTransformer,
  new ManyToManyTransformer(modelTransformer, indexTransformer, hasOneTransformer, authTransformer),
  new DefaultValueTransformer(),
  authTransformer,
  new SearchableModelTransformer(),
];

const graphQLTransform = new GraphQLTransform  ({
  transformers,
  featureFlags: new TransformerFeatureFlagAdapter(),
  sandboxModeEnabled: false,
});

const schema = `
type Post @model {
    id: ID!
    title: String!
    comments: [Comment] @hasMany
}
type Comment @model {
    id: ID!
    content: String!
    post: Post @belongsTo
}
`;

const { rootStack, stacks, schema } = graphQLTransform.transform(schema);

console.log('Schema compiled successfully.')

public transform(schema: string): DeploymentResources {

  // ...

  for (const transformer of this.transformers) {
    // Run the prepare function one time per transformer.
    if (isFunction(transformer.before)) {
      transformer.before(context);
    }

    // Transform each definition in the input document.
    for (const def of context.inputDocument.definitions as TypeDefinitionNode[]) {
      switch (def.kind) {
        case 'ObjectTypeDefinition':
          this.transformObject(transformer, def, context);
          // Walk the fields and call field transformers.
          break;
        case 'InterfaceTypeDefinition':
          this.transformInterface(transformer, def, context);
          // Walk the fields and call field transformers.
          break;
        case 'ScalarTypeDefinition':
          this.transformScalar(transformer, def, context);
          break;
        case 'UnionTypeDefinition':
          this.transformUnion(transformer, def, context);
          break;
        case 'EnumTypeDefinition':
          this.transformEnum(transformer, def, context);
          break;
        case 'InputObjectTypeDefinition':
          this.transformInputObject(transformer, def, context);
          break;
        // Note: Extension and operation definition nodes are not supported.
        default:
          continue;
        }
      }
    }
  }

  // Validate
  for (const transformer of this.transformers) {
    if (isFunction(transformer.validate)) {
      transformer.validate(context);
    }
  }

  // Prepare
  for (const transformer of this.transformers) {
    if (isFunction(transformer.prepare)) {
      transformer.prepare(context);
    }
  }

  // Transform Schema
  for (const transformer of this.transformers) {
    if (isFunction(transformer.transformSchema)) {
      transformer.transformSchema(context);
    }
  }

  // After is called in the reverse order as if they were popping off a stack.
  let reverseThroughTransformers = this.transformers.length - 1;
  while (reverseThroughTransformers >= 0) {
    const transformer = this.transformers[reverseThroughTransformers];
    if (isFunction(transformer.after)) {
      transformer.after(context);
    }

    reverseThroughTransformers -= 1;
  }

  // ...

  // Return the deployment resources.
  // In the future there will likely be a formatter concept here.
  return this.synthesize(context);
}

{
    "transformers":[
        "some-transformer-via-npm",
        "file:///some/absolute/local/module"
    ]
}

export const directiveDefinition = /* GraphQL */ `
  directive @model(
    queries: ModelQueryMap
    mutations: ModelMutationMap
    subscriptions: ModelSubscriptionMap
    timestamps: TimestampConfiguration
  ) on OBJECT
`;

type Post @model {
    id: ID!
    title: String!
}

export class ModelTransformer extends TransformerModelBase implements TransformerModelProvider {
  // ...
}

/**
 * Users extend the TransformerPluginBase class and implement the relevant functions.
 */
export class ModelTransformer extends TransformerModelBase implements TransformerModelProvider {
  constructor(options: ModelTransformerOptions = {}) {
    super('amplify-model-transformer', directiveDefinition);
  }

  // ...
}

prepare = (context: TransformerPrepareStepContextProvider) => {
    for (const modelTypeName of this.typesWithModelDirective) {
      const type = context.output.getObject(modelTypeName);
      context.providerRegistry.registerDataSourceProvider(type!, this);
    }
  };