Initial commit

Author: bboure

.babelrc

@@ -0,0 +1,13 @@
+{
+  "plugins": [
+    "@babel/plugin-transform-modules-commonjs"
+  ],
+  "presets": [
+    ["@babel/preset-env",
+        {
+            "shippedProposals": true,
+            "targets": { "node": "8.12" }
+        }
+    ]
+  ]
+}

.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.js]
+indent_style = space
+indent_size = 2

.eslintrc.yml

@@ -0,0 +1,13 @@
+env:
+  browser: true
+  es6: true
+extends: airbnb-base
+globals:
+  Atomics: readonly
+  SharedArrayBuffer: readonly
+parserOptions:
+  ecmaVersion: 2018
+  sourceType: module
+parser: babel-eslint
+rules:
+  no-console: off

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+lib

README.md

@@ -0,0 +1,57 @@
+This serverless plugin is a wrapper for [amplify-appsync-simulator](amplify-appsync-simulator) made for testing AppSync APIs built with [serverless-appsync-plugin](https://github.com/sid88in/serverless-appsync-plugin).
+
+
+# Requires
+- [serverless framework](https://github.com/serverless/serverless)
+- [serverless-appsync-plugin](https://github.com/sid88in/serverless-appsync-plugin)
+- [serverless-offline](https://github.com/dherault/serverless-offline)
+- [serverless-dynamodb-local](https://github.com/99xt/serverless-dynamodb-local) (when using dynamodb resolvers only)
+
+# Usage
+
+This plugin relies on your serverless yml file and on the `serverless-offline` plugin*.
+
+To start it, run the followin command:
+````bash
+sls offline start
+````
+
+You should see in the logs something like:
+
+````bash
+...
+Serverless: AppSync endpoint: http://localhost:20002/graphql
+Serverless: GraphiQl: http://localhost:20002
+...
+````
+
+(*): If you are using DynamoDb resolvers, you'll also need [serverless-dynamodb-local](https://github.com/99xt/serverless-dynamodb-local)
+
+# Configuration
+
+Put options under `custom.appsync-simulator` in your `serverless.yml` file
+
+| option | default | description |
+|--------|---------|-------------|
+| port   | 20002   | AppSync operations port |
+| wsPort | 20003   | AppSync subscriptions port |
+| location | . (base directory)   | Location of the lambda functions handlers. |
+
+Example:
+
+````yml
+custom:
+  appsync-simulator:
+    location: '.webpack/service' # use webpack build directory
+````
+
+# Caveats
+
+This plugin currently only supports resolvers implemented by `amplify-appsync-simulator`.
+At the time of writing, this is:
+
+- NONE
+- AWS_LAMBDA (*)
+- AMAZON_DYNAMODB
+
+(*) Note: This plugin also supports `AWS_LAMBDA`'s `BatchInvoke` (which Amplify Simulator doesn't)

package.json

@@ -0,0 +1,35 @@
+{
+  "name": "serverless-appsync-simulator",
+  "version": "0.1.0",
+  "main": "lib/index.js",
+  "author": "bboure",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "babel src/ -d lib/ --delete-dir-on-start",
+    "prepare": "yarn run build"
+  },
+  "files": [
+    "/lib"
+  ],
+  "dependencies": {
+    "amplify-appsync-simulator": "^1.5.0",
+    "amplify-util-mock": "^3.5.0",
+    "aws-sdk": "^2.585.0",
+    "dataloader": "^2.0.0",
+    "lodash": "^4.17.15"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.7.4",
+    "@babel/core": "^7.7.4",
+    "@babel/plugin-transform-modules-commonjs": "^7.7.4",
+    "@babel/preset-env": "^7.7.4",
+    "babel-eslint": "^10.0.3",
+    "eslint": "^6.7.1",
+    "eslint-config-airbnb-base": "^14.0.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-node": "^10.0.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.1"
+  }
+}

src/data-loaders/LambdaDataLoader.js

@@ -0,0 +1,33 @@
+const DataLoader = require('dataloader');
+
+const batchLoaders = {};
+
+const getBatchDataResolver = (loaderName, resolver) => {
+  if (batchLoaders[loaderName] === undefined) {
+    batchLoaders[loaderName] = new DataLoader(resolver, { cache: false });
+  }
+  return batchLoaders[loaderName];
+};
+
+export default class LambdaDataLoader {
+  constructor(config) {
+    this.config = config;
+  }
+
+  async load(req) {
+    try {
+      let result;
+      if (req.operation === 'BatchInvoke') {
+        const dataLoader = getBatchDataResolver(this.config.name, this.config.invoke);
+        result = await dataLoader.load(req.payload);
+      } else {
+        result = await this.config.invoke(req.payload);
+      }
+      return result;
+    } catch (e) {
+      console.log('Lambda Data source failed with the following error');
+      console.log(e);
+      throw e;
+    }
+  }
+}

src/data-loaders/NotImplementedDataLoader.js

@@ -0,0 +1,6 @@
+/* eslint-disable class-methods-use-this */
+export default class NotImplementedDataLoader {
+  async load() {
+    throw new Error('Data Loader not implemented');
+  }
+}

src/getAppSyncConfig.js

@@ -0,0 +1,119 @@
+import {
+  AmplifyAppSyncSimulatorAuthenticationType as AuthTypes,
+} from 'amplify-appsync-simulator';
+import { invoke } from 'amplify-util-mock/lib/utils/lambda/invoke';
+import fs from 'fs';
+import { find } from 'lodash';
+import path from 'path';
+
+export default function getAppSyncConfig(context, appSyncConfig) {
+  const getFileMap = (basePath, filePath) => ({
+    path: filePath,
+    content: fs.readFileSync(path.join(basePath, filePath), { encoding: 'utf8' }),
+  });
+
+  const makeDataSource = (source) => {
+    if (source.name === undefined || source.type === undefined) {
+      return null;
+    }
+
+    const dataSource = {
+      name: source.name,
+      type: source.type,
+    };
+
+    switch (source.type) {
+      case 'AMAZON_DYNAMODB': {
+        const { port } = context.options.dynamoDb;
+        return {
+          ...dataSource,
+          config: {
+            endpoint: `http://localhost:${port}`,
+            region: 'localhost',
+            tableName: source.config.tableName, // FIXME: Handle Ref:
+          },
+        };
+      }
+      case 'AWS_LAMBDA': {
+        const { functionName } = source.config;
+        if (context.serverless.service.functions[functionName] === undefined) {
+          return null;
+        }
+
+        const [fileName, handler] = context.serverless.service.functions[functionName].handler.split('.');
+        return {
+          ...dataSource,
+          invoke: (payload) => invoke({
+            packageFolder: context.serverless.config.servicePath,
+            handler,
+            fileName: path.join(context.options.location, fileName),
+            event: payload,
+            environment: context.serverless.service.provider.environment || {},
+          }),
+        };
+      }
+      default:
+        return dataSource;
+    }
+  };
+
+  const makeResolver = (resolver) => ({
+    kind: 'UNIT',
+    fieldName: resolver.field,
+    typeName: resolver.type,
+    dataSourceName: resolver.dataSource,
+    requestMappingTemplateLocation: resolver.request,
+    responseMappingTemplateLocation: resolver.response,
+  });
+
+  const makeAuthType = (authType) => {
+    const auth = {
+      authenticationType: authType.authenticationType,
+    };
+
+    if (auth.authenticationType === AuthTypes.AMAZON_COGNITO_USER_POOLS) {
+      auth.cognitoUserPoolConfig = {
+        AppIdClientRegex: authType.userPoolConfig.appIdClientRegex,
+      };
+    } else if (auth.authenticationType === AuthTypes.OPENID_CONNECT) {
+      auth.openIDConnectConfig = {
+        Issuer: authType.openIdConnectConfig.issuer,
+        ClientId: authType.openIdConnectConfig.clientId,
+      };
+    }
+
+    return auth;
+  };
+
+  const makeAppSync = () => ({
+    name: appSyncConfig.name,
+    apiKey: context.options.apiKey || '123456',
+    defaultAuthenticationType: makeAuthType(appSyncConfig),
+    additionalAuthenticationProviders: (appSyncConfig.additionalAuthenticationProviders || [])
+      .map(makeAuthType),
+  });
+
+  const mappingTemplatesLocation = path.join(
+    context.serverless.config.servicePath,
+    appSyncConfig.mappingTemplatesLocation || 'mapping-templates',
+  );
+
+  return {
+    appSync: makeAppSync(),
+    schema: getFileMap(context.serverless.config.servicePath, appSyncConfig.schema || 'schema.graphql'),
+    resolvers: appSyncConfig.mappingTemplates.map(makeResolver),
+    dataSources: appSyncConfig.dataSources.map(makeDataSource).filter((v) => v !== null),
+    mappingTemplates: appSyncConfig.mappingTemplates.reduce((acc, template) => {
+      const requestTemplate = template.request || `${template.type}.${template.field}.request.vtl`;
+      if (!find(acc, (e) => e.path === requestTemplate)) {
+        acc.push(getFileMap(mappingTemplatesLocation, requestTemplate));
+      }
+      const responseTemplate = template.response || `${template.type}.${template.field}.response.vtl`;
+      if (!find(acc, (e) => e.path === responseTemplate)) {
+        acc.push(getFileMap(mappingTemplatesLocation, responseTemplate));
+      }
+
+      return acc;
+    }, []),
+  };
+}

src/index.js

@@ -0,0 +1,80 @@
+import {
+  AmplifyAppSyncSimulator,
+  addDataLoader,
+  removeDataLoader,
+} from 'amplify-appsync-simulator';
+import { get, merge } from 'lodash';
+import getAppSyncConfig from './getAppSyncConfig';
+import LambdaDataLoader from './data-loaders/LambdaDataLoader';
+import NotImplementedDataLoader from './data-loaders/NotImplementedDataLoader';
+
+class ServerlessAppSyncSimulator {
+  constructor(serverless) {
+    this.serverless = serverless;
+    this.serverlessLog = serverless.cli.log.bind(serverless.cli);
+    this.options = merge(
+      {
+        port: 20002,
+        wsPort: 20003,
+        location: '.',
+        dynamoDb: {
+          port: get(this.serverless.service, 'custom.dynamodb.start.port', 8000),
+        },
+      },
+      get(this.serverless.service, 'custom.appsync-simulator', {}),
+    );
+    this.simulator = null;
+
+    // Hack: appsync-cli-simulator does not support BatchInvoke.
+    removeDataLoader('AWS_LAMBDA');
+    addDataLoader('AWS_LAMBDA', LambdaDataLoader);
+    addDataLoader('HTTP', NotImplementedDataLoader);
+    addDataLoader('RELATIONAL_DATABASE', NotImplementedDataLoader);
+    addDataLoader('AMAZON_ELASTICSEARCH', NotImplementedDataLoader);
+
+    this.hooks = {
+      'before:offline:start:init': this.startServer.bind(this),
+      'before:offline:start:end': this.endServer.bind(this),
+    };
+  }
+
+  async startServer() {
+    try {
+      this.simulator = new AmplifyAppSyncSimulator({
+        port: this.options.port,
+        wsPort: this.options.wsPort,
+      });
+
+      await this.simulator.start();
+
+      // TODO: suport several API's
+      const appSync = Array.isArray(this.serverless.service.custom.appSync)
+        ? this.serverless.service.custom.appSync[0]
+        : this.serverless.service.custom.appSync;
+
+      const config = getAppSyncConfig({
+        serverless: this.serverless,
+        options: this.options,
+      }, appSync);
+
+
+      if (process.env.SLS_DEBUG) {
+        this.serverlessLog(`AppSync Config ${appSync.name}`);
+        this.serverlessLog(JSON.stringify(config, null, 4));
+      }
+
+      this.simulator.init(config);
+      this.serverlessLog(`AppSync endpoint: ${this.simulator.url}/graphql`);
+      this.serverlessLog(`GraphiQl: ${this.simulator.url}`);
+    } catch (error) {
+      this.serverlessLog(error);
+    }
+  }
+
+  endServer() {
+    this.serverlessLog('Halting AppSync Simulator');
+    this.simulator.stop();
+  }
+}
+
+module.exports = ServerlessAppSyncSimulator;