@ttoss/appsync-api 0.4.4 → 0.5.0

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import * as express_serve_static_core from 'express-serve-static-core';
+import { SchemaComposer } from 'graphql-compose';
+
+declare const createServer: ({ schemaComposer, }: {
+    schemaComposer: SchemaComposer<any>;
+}) => express_serve_static_core.Express;
+
+export { createServer };

package/dist/server.js

@@ -0,0 +1,66 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_graphql_helix = require("graphql-helix");
+var import_express = __toESM(require("express"));
+var createServer = ({
+  schemaComposer
+}) => {
+  const server = (0, import_express.default)();
+  server.use(import_express.default.json());
+  server.use("/graphql", async (req, res) => {
+    const request = {
+      body: req.body,
+      headers: req.headers,
+      method: req.method,
+      query: req.query
+    };
+    if ((0, import_graphql_helix.shouldRenderGraphiQL)(request)) {
+      res.send((0, import_graphql_helix.renderGraphiQL)());
+      return;
+    }
+    const { operationName, query, variables } = (0, import_graphql_helix.getGraphQLParameters)(request);
+    const result = await (0, import_graphql_helix.processRequest)({
+      operationName,
+      query,
+      variables,
+      request,
+      schema: schemaComposer.buildSchema()
+    });
+    (0, import_graphql_helix.sendResult)(result, res);
+  });
+  return server;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer
+});

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "@ttoss/appsync-api",
-  "version": "0.4.4",
-  "description": "",
+  "version": "0.5.0",
+  "description": "A library for building GraphQL APIs for AWS AppSync.",
   "license": "UNLICENSED",
   "author": "ttoss",
   "contributors": [
     "Pedro Arantes <pedro@arantespp.com> (https://arantespp.com)"
   ],
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js"
+    },
+    "./server": {
+      "import": "./dist/esm/server.js",
+      "require": "./dist/server.js"
+    }
+  },
   "main": "dist/index.js",
   "module": "dist/esm/index.js",
   "bin": {
@@ -20,21 +30,43 @@
     "build": "tsup",
     "test": "jest"
   },
+  "sideEffects": false,
   "typings": "dist/index.d.ts",
   "dependencies": {
     "@ttoss/cloudformation": "^0.3.0",
-    "graphql": "^16.6.0",
-    "graphql-compose": "^9.0.10",
+    "express": "^4.18.2",
+    "graphql-helix": "^1.13.0",
     "minimist": "^1.2.7"
   },
+  "peerDependencies": {
+    "graphql": "^16.6.0",
+    "graphql-compose": "^9.0.10"
+  },
   "devDependencies": {
     "@ttoss/config": "^1.26.0",
     "@types/aws-lambda": "^8.10.109",
-    "carlin": "^1.21.4"
+    "carlin": "^1.21.4",
+    "graphql": "^16.6.0",
+    "graphql-compose": "^9.0.10"
   },
-  "keywords": [],
+  "keywords": [
+    "api",
+    "appsync",
+    "aws",
+    "graphql"
+  ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f7fcb1caa22adf045f0ec7d15a678bfe48a3913d"
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "server": [
+        "./dist/server.d.ts"
+      ]
+    }
+  },
+  "gitHead": "702cb6f1dd3411f53c5172eb50ce9d5e3fa5c3cc"
 }

package/src/cli.ts

@@ -11,9 +11,6 @@ if (argv._.includes('build-schema')) {
   const sdl =
     template.Resources[AppSyncGraphQLSchemaLogicalId].Properties.Definition;
 
-  // eslint-disable-next-line no-console
-  console.log(sdl);
-
   /**
    * Save to schema/schema.graphql. schema folder might not exist.
    */

package/src/createApiTemplate.ts

@@ -1,27 +1,35 @@
 import { type SchemaComposer, graphql } from 'graphql-compose';
 import { getPackageLambdaLayerStackName } from 'carlin/src/deploy/lambdaLayer/getPackageLambdaLayerStackName';
-import { readPackageJson } from 'carlin/src/utils/packageJson';
 import packageJson from '../package.json';
-import type { CloudFormationTemplate } from 'carlin/src/utils/cloudFormationTemplate';
+import type { CloudFormationTemplate } from '@ttoss/cloudformation';
 
 const AppSyncGraphQLApiLogicalId = 'AppSyncGraphQLApi';
 
 export const AppSyncGraphQLSchemaLogicalId = 'AppSyncGraphQLSchema';
 
-const AppSyncLambdaFunctionIAMRoleLogicalId = 'AppSyncLambdaFunctionIAMRole';
-
 export const AppSyncLambdaFunctionLogicalId = 'AppSyncLambdaFunction';
 
-const AppSyncLambdaFunctionAppSyncDataSourceIAMRoleLogicalId =
-  'AppSyncLambdaFunctionAppSyncDataSourceIAMRole';
-
 const AppSyncLambdaFunctionAppSyncDataSourceLogicalId =
   'AppSyncLambdaFunctionAppSyncDataSource';
 
+type Role =
+  | string
+  | {
+      'Fn::ImportValue': string;
+    };
+
 export const createApiTemplate = ({
   schemaComposer,
+  dataSource,
+  lambdaFunction,
 }: {
   schemaComposer: SchemaComposer<any>;
+  dataSource: {
+    roleArn: Role;
+  };
+  lambdaFunction: {
+    roleArn: Role;
+  };
 }): CloudFormationTemplate => {
   /**
    * It should be on top of the file, otherwise it will have empty Mutation
@@ -48,21 +56,23 @@ export const createApiTemplate = ({
     }
   );
 
-  const { name } = packageJson;
-
-  const { dependencies } = readPackageJson();
-
-  const dependencyVersion = dependencies[name];
+  const getGraphQLComposeDependenciesLambdaLayers = () => {
+    const { peerDependencies } = packageJson;
 
-  if (!dependencyVersion) {
-    throw new Error(
-      `The package ${name} is not installed in the project. Please install it with "yarn add ${name}".`
+    const lambdaLayerStackNames = Object.entries(peerDependencies).map(
+      ([dependencyName, dependencyVersion]) => {
+        return getPackageLambdaLayerStackName(
+          [dependencyName, dependencyVersion].join('@')
+        );
+      }
     );
-  }
 
-  const lambdaLayerStackName = getPackageLambdaLayerStackName(
-    [name, dependencyVersion].join('@')
-  );
+    return lambdaLayerStackNames.map((lambdaLayerStackName) => {
+      return {
+        'Fn::ImportValue': lambdaLayerStackName,
+      };
+    });
+  };
 
   const template: CloudFormationTemplate = {
     AWSTemplateFormatVersion: '2010-09-09',
@@ -102,27 +112,6 @@ export const createApiTemplate = ({
           Definition: sdl,
         },
       },
-      [AppSyncLambdaFunctionIAMRoleLogicalId]: {
-        Type: 'AWS::IAM::Role',
-        Properties: {
-          AssumeRolePolicyDocument: {
-            Version: '2012-10-17',
-            Statement: [
-              {
-                Effect: 'Allow',
-                Action: 'sts:AssumeRole',
-                Principal: {
-                  Service: 'lambda.amazonaws.com',
-                },
-              },
-            ],
-          },
-          ManagedPolicyArns: [
-            'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole',
-          ],
-          Path: '/custom-iam/',
-        },
-      },
       [AppSyncLambdaFunctionLogicalId]: {
         Type: 'AWS::Lambda::Function',
         Properties: {
@@ -132,15 +121,9 @@ export const createApiTemplate = ({
             S3ObjectVersion: { Ref: 'LambdaS3ObjectVersion' },
           },
           Handler: 'index.handler',
-          Layers: [
-            {
-              'Fn::ImportValue': lambdaLayerStackName,
-            },
-          ],
+          Layers: getGraphQLComposeDependenciesLambdaLayers(),
           MemorySize: 512,
-          Role: {
-            'Fn::GetAtt': [AppSyncLambdaFunctionIAMRoleLogicalId, 'Arn'],
-          },
+          Role: lambdaFunction.roleArn,
           Runtime: 'nodejs18.x',
           /**
            * https://docs.aws.amazon.com/general/latest/gr/appsync.html
@@ -149,44 +132,6 @@ export const createApiTemplate = ({
           Timeout: 29,
         },
       },
-      [AppSyncLambdaFunctionAppSyncDataSourceIAMRoleLogicalId]: {
-        Type: 'AWS::IAM::Role',
-        Properties: {
-          AssumeRolePolicyDocument: {
-            Version: '2012-10-17',
-            Statement: [
-              {
-                Effect: 'Allow',
-                Action: 'sts:AssumeRole',
-                Principal: {
-                  Service: 'appsync.amazonaws.com',
-                },
-              },
-            ],
-          },
-          ManagedPolicyArns: [
-            'arn:aws:iam::aws:policy/service-role/AWSAppSyncPushToCloudWatchLogs',
-          ],
-          Path: '/custom-iam/',
-          Policies: [
-            {
-              PolicyName: 'AppSyncGraphQLApiIAMRolePolicyName',
-              PolicyDocument: {
-                Version: '2012-10-17',
-                Statement: [
-                  {
-                    Effect: 'Allow',
-                    Action: ['lambda:InvokeFunction'],
-                    Resource: [
-                      { 'Fn::GetAtt': [AppSyncLambdaFunctionLogicalId, 'Arn'] },
-                    ],
-                  },
-                ],
-              },
-            },
-          ],
-        },
-      },
       [AppSyncLambdaFunctionAppSyncDataSourceLogicalId]: {
         Type: 'AWS::AppSync::DataSource',
         Properties: {
@@ -197,12 +142,7 @@ export const createApiTemplate = ({
             },
           },
           Name: 'AppSyncLambdaFunctionAppSyncDataSource',
-          ServiceRoleArn: {
-            'Fn::GetAtt': [
-              AppSyncLambdaFunctionAppSyncDataSourceIAMRoleLogicalId,
-              'Arn',
-            ],
-          },
+          ServiceRoleArn: dataSource.roleArn,
           Type: 'AWS_LAMBDA',
         },
       },

package/src/{appSyncResolverHandler.ts → createAppSyncResolverHandler.ts}

@@ -1,7 +1,13 @@
-import type { AppSyncResolverHandler } from 'aws-lambda';
+import type { AppSyncResolverHandler as AwsAppSyncResolverHandler } from 'aws-lambda';
 import type { SchemaComposer } from 'graphql-compose';
 
-export const appSyncResolverHandler = ({
+export type AppSyncResolverHandler<
+  TArguments,
+  TResult,
+  TSource = Record<string, any> | null
+> = AwsAppSyncResolverHandler<TArguments, TResult, TSource>;
+
+export const createAppSyncResolverHandler = ({
   schemaComposer,
 }: {
   schemaComposer: SchemaComposer<any>;

package/src/index.ts

@@ -1,3 +1,6 @@
 export { type ResolverResolveParams, schemaComposer } from 'graphql-compose';
 export { createApiTemplate } from './createApiTemplate';
-export { appSyncResolverHandler } from './appSyncResolverHandler';
+export {
+  type AppSyncResolverHandler,
+  createAppSyncResolverHandler,
+} from './createAppSyncResolverHandler';

package/src/server.ts

@@ -0,0 +1,47 @@
+import { type SchemaComposer } from 'graphql-compose';
+import {
+  getGraphQLParameters,
+  processRequest,
+  renderGraphiQL,
+  sendResult,
+  shouldRenderGraphiQL,
+} from 'graphql-helix';
+import express from 'express';
+
+export const createServer = ({
+  schemaComposer,
+}: {
+  schemaComposer: SchemaComposer<any>;
+}) => {
+  const server = express();
+
+  server.use(express.json());
+
+  server.use('/graphql', async (req, res) => {
+    const request = {
+      body: req.body,
+      headers: req.headers,
+      method: req.method,
+      query: req.query,
+    };
+
+    if (shouldRenderGraphiQL(request)) {
+      res.send(renderGraphiQL());
+      return;
+    }
+
+    const { operationName, query, variables } = getGraphQLParameters(request);
+
+    const result = await processRequest({
+      operationName,
+      query,
+      variables,
+      request,
+      schema: schemaComposer.buildSchema(),
+    });
+
+    sendResult(result, res);
+  });
+
+  return server;
+};