@ttoss/appsync-api 0.7.4 → 0.8.0

package/README.md

@@ -77,3 +77,36 @@ server.listen(4000, () => {
   );
 });
 ```
+
+## Schema Composer
+
+The `schemaComposer` object is a [`graphql-compose`](https://graphql-compose.github.io/docs/intro/quick-start.html) object that defines your API's schema and handle resolvers. You can use `schemaComposer` to create types, queries, mutations, and subscriptions.
+
+### Connections
+
+This packages provides the method `composeWithConnection` to create a connection type and queries for a given type, based on [graphql-compose-connection](https://graphql-compose.github.io/docs/plugins/plugin-connection.html) plugin and following the [Relay Connection Specification](https://facebook.github.io/relay/graphql/connections.htm).
+
+```typescript
+import { composeWithConnection } from '@ttoss/appsync-api';
+
+composeWithConnection(AuthorTC, {
+  findManyResolver: AuthorTC.getResolver('findMany'),
+  countResolver: AuthorTC.getResolver('count'),
+  sort: {
+    ASC: {
+      value: {
+        scanIndexForward: true,
+      },
+      cursorFields: ['id'],
+      beforeCursorQuery: (rawQuery, cursorData, resolveParams) => {
+        if (!rawQuery.id) rawQuery.id = {};
+        rawQuery.id.$lt = cursorData.id;
+      },
+      afterCursorQuery: (rawQuery, cursorData, resolveParams) => {
+        if (!rawQuery.id) rawQuery.id = {};
+        rawQuery.id.$gt = cursorData.id;
+      },
+    },
+  },
+});
+```

package/dist/cli.d.ts

@@ -1 +1,2 @@
 
+export { }

package/dist/cli.js

@@ -15,6 +15,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));

package/dist/esm/chunk-Y27A2LBZ.js

@@ -0,0 +1,360 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+
+// src/createApiTemplate.ts
+import { graphql } from "graphql-compose";
+
+// ../../node_modules/tslib/tslib.es6.js
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+
+// ../../node_modules/lower-case/dist.es2015/index.js
+function lowerCase(str) {
+  return str.toLowerCase();
+}
+
+// ../../node_modules/no-case/dist.es2015/index.js
+var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+function noCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
+  var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+  var start = 0;
+  var end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+function replace(input, re, value) {
+  if (re instanceof RegExp)
+    return input.replace(re, value);
+  return re.reduce(function(input2, re2) {
+    return input2.replace(re2, value);
+  }, input);
+}
+
+// ../../node_modules/pascal-case/dist.es2015/index.js
+function pascalCaseTransform(input, index) {
+  var firstChar = input.charAt(0);
+  var lowerChars = input.substr(1).toLowerCase();
+  if (index > 0 && firstChar >= "0" && firstChar <= "9") {
+    return "_" + firstChar + lowerChars;
+  }
+  return "" + firstChar.toUpperCase() + lowerChars;
+}
+function pascalCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return noCase(input, __assign({ delimiter: "", transform: pascalCaseTransform }, options));
+}
+
+// ../carlin/src/deploy/lambdaLayer/getPackageLambdaLayerStackName.ts
+var lambdaLayerStackNamePrefix = `LambdaLayer`;
+var getPackageLambdaLayerStackName = (packageName) => {
+  const [scopedName, version] = packageName.split("@").filter((part) => {
+    return !!part;
+  });
+  return [
+    lambdaLayerStackNamePrefix,
+    pascalCase(scopedName),
+    version.replace(/[^0-9.]/g, "").replace(/\./g, "-")
+  ].join("-");
+};
+
+// package.json
+var package_default = {
+  name: "@ttoss/appsync-api",
+  version: "0.8.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: {
+    "ttoss-appsync-api": "./bin/cli.js"
+  },
+  files: [
+    "dist",
+    "src"
+  ],
+  scripts: {
+    build: "tsup",
+    test: "jest"
+  },
+  sideEffects: false,
+  typings: "dist/index.d.ts",
+  dependencies: {
+    "@ttoss/cloudformation": "^0.5.1",
+    express: "^4.18.2",
+    "graphql-compose-connection": "^8.2.1",
+    "graphql-helix": "^1.13.0",
+    minimist: "^1.2.8"
+  },
+  peerDependencies: {
+    graphql: "^16.6.0",
+    "graphql-compose": "^9.0.10"
+  },
+  devDependencies: {
+    "@ttoss/config": "^1.28.1",
+    "@types/aws-lambda": "^8.10.110",
+    carlin: "^1.23.2",
+    graphql: "^16.6.0",
+    "graphql-compose": "^9.0.10"
+  },
+  keywords: [
+    "api",
+    "appsync",
+    "aws",
+    "graphql"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  typesVersions: {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      server: [
+        "./dist/server.d.ts"
+      ]
+    }
+  }
+};
+
+// src/createApiTemplate.ts
+var AppSyncGraphQLApiLogicalId = "AppSyncGraphQLApi";
+var AppSyncGraphQLSchemaLogicalId = "AppSyncGraphQLSchema";
+var AppSyncLambdaFunctionLogicalId = "AppSyncLambdaFunction";
+var AppSyncLambdaFunctionAppSyncDataSourceLogicalId = "AppSyncLambdaFunctionAppSyncDataSource";
+var AppSyncGraphQLApiKeyLogicalId = "AppSyncGraphQLApiKey";
+var createApiTemplate = ({
+  additionalAuthenticationProviders,
+  authenticationType = "AMAZON_COGNITO_USER_POOLS",
+  schemaComposer,
+  dataSource,
+  lambdaFunction,
+  userPoolConfig
+}) => {
+  const sdl = schemaComposer.toSDL();
+  graphql.validateSchema(schemaComposer.buildSchema());
+  const resolveMethods = schemaComposer.getResolveMethods();
+  const resolveMethodsEntries = Object.entries(resolveMethods).flatMap(
+    ([typeName, fieldResolvers]) => {
+      return Object.entries(fieldResolvers).map(([fieldName]) => {
+        return {
+          fieldName,
+          typeName
+        };
+      });
+    }
+  );
+  const getGraphQLComposeDependenciesLambdaLayers = () => {
+    const { peerDependencies } = package_default;
+    const lambdaLayerStackNames = Object.entries(peerDependencies).map(
+      ([dependencyName, dependencyVersion]) => {
+        return getPackageLambdaLayerStackName(
+          [dependencyName, dependencyVersion].join("@")
+        );
+      }
+    );
+    return lambdaLayerStackNames.map((lambdaLayerStackName) => {
+      return {
+        "Fn::ImportValue": lambdaLayerStackName
+      };
+    });
+  };
+  const template = {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Parameters: {
+      Environment: {
+        Default: "Staging",
+        Type: "String",
+        AllowedValues: ["Staging", "Production"]
+      },
+      LambdaS3Bucket: {
+        Type: "String"
+      },
+      LambdaS3Key: {
+        Type: "String"
+      },
+      LambdaS3ObjectVersion: {
+        Type: "String"
+      }
+    },
+    Resources: {
+      [AppSyncGraphQLApiLogicalId]: {
+        Type: "AWS::AppSync::GraphQLApi",
+        Properties: {
+          AuthenticationType: authenticationType,
+          Name: {
+            "Fn::Join": [
+              ":",
+              [{ Ref: "AWS::StackName" }, AppSyncGraphQLApiLogicalId]
+            ]
+          }
+        }
+      },
+      [AppSyncGraphQLSchemaLogicalId]: {
+        Type: "AWS::AppSync::GraphQLSchema",
+        Properties: {
+          ApiId: { "Fn::GetAtt": [AppSyncGraphQLApiLogicalId, "ApiId"] },
+          Definition: sdl
+        }
+      },
+      [AppSyncLambdaFunctionLogicalId]: {
+        Type: "AWS::Lambda::Function",
+        Properties: {
+          Code: {
+            S3Bucket: { Ref: "LambdaS3Bucket" },
+            S3Key: { Ref: "LambdaS3Key" },
+            S3ObjectVersion: { Ref: "LambdaS3ObjectVersion" }
+          },
+          Handler: "index.handler",
+          Layers: getGraphQLComposeDependenciesLambdaLayers(),
+          MemorySize: 512,
+          Role: lambdaFunction.roleArn,
+          Runtime: "nodejs18.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
+    };
+  }
+  return template;
+};
+
+export {
+  AppSyncGraphQLSchemaLogicalId,
+  createApiTemplate
+};

package/dist/esm/cli.js

@@ -1,8 +1,7 @@
 /** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
 import {
   AppSyncGraphQLSchemaLogicalId
-} from "./chunk-Z4Y6MT22.js";
-import "./chunk-NQOARNEJ.js";
+} from "./chunk-Y27A2LBZ.js";
 
 // src/cli.ts
 import * as fs from "fs";

package/dist/esm/index.js

@@ -1,17 +1,16 @@
 /** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
 import {
   createApiTemplate
-} from "./chunk-Z4Y6MT22.js";
-import "./chunk-NQOARNEJ.js";
+} from "./chunk-Y27A2LBZ.js";
 
 // src/createAppSyncResolverHandler.ts
 var createAppSyncResolverHandler = ({
-  schemaComposer
+  schemaComposer: schemaComposer2
 }) => {
   return async (event, context) => {
     const { info, arguments: args, source } = event;
     const { parentTypeName, fieldName } = info;
-    const resolver = schemaComposer.getResolveMethods()[parentTypeName][fieldName];
+    const resolver = schemaComposer2.getResolveMethods()[parentTypeName][fieldName];
     return resolver(
       source,
       args,
@@ -20,7 +19,165 @@ var createAppSyncResolverHandler = ({
     );
   };
 };
+
+// src/composeWithRelay/composeWithRelay.ts
+import { ObjectTypeComposer } from "graphql-compose";
+
+// src/composeWithRelay/nodeFieldConfig.ts
+import {
+  getProjectionFromAST
+} from "graphql-compose";
+
+// src/composeWithRelay/globalId.ts
+var base64 = (i) => {
+  return Buffer.from(i, "ascii").toString("base64");
+};
+var unbase64 = (i) => {
+  return Buffer.from(i, "base64").toString("ascii");
+};
+var toGlobalId = (type, id) => {
+  return base64([type, id].join(":"));
+};
+var fromGlobalId = (globalId) => {
+  const unbasedGlobalId = unbase64(globalId);
+  const [type, id] = unbasedGlobalId.split(":");
+  return { type, id };
+};
+
+// src/composeWithRelay/nodeFieldConfig.ts
+var getNodeFieldConfig = (typeMapForRelayNode, nodeInterface) => {
+  return {
+    description: "Fetches an object that has globally unique ID among all types",
+    type: nodeInterface,
+    args: {
+      id: {
+        type: "ID!",
+        description: "The globally unique ID among all types"
+      }
+    },
+    resolve: (source, args, context, info) => {
+      if (!args.id || !(typeof args.id === "string")) {
+        return null;
+      }
+      const { type } = fromGlobalId(args.id);
+      if (!typeMapForRelayNode[type]) {
+        return null;
+      }
+      const { tc, resolver: findById } = typeMapForRelayNode[type];
+      if (findById && findById.resolve && tc) {
+        const graphqlType = tc.getType();
+        let projection;
+        if (info) {
+          projection = getProjectionFromAST({
+            ...info,
+            returnType: graphqlType
+          });
+        } else {
+          projection = {};
+        }
+        const idArgName = Object.keys(findById.args)[0];
+        return findById.resolve({
+          source,
+          args: { [idArgName]: args.id },
+          // eg. mongoose has _id fieldname, so should map
+          context,
+          info,
+          projection
+        }).then((res) => {
+          if (!res)
+            return res;
+          res.__nodeType = graphqlType;
+          return res;
+        });
+      }
+      return null;
+    }
+  };
+};
+
+// src/composeWithRelay/nodeInterface.ts
+import { InterfaceTypeComposer } from "graphql-compose";
+var NodeTC = InterfaceTypeComposer.createTemp({
+  name: "Node",
+  description: "An object, that can be fetched by the globally unique ID among all types.",
+  fields: {
+    id: {
+      type: "ID!",
+      description: "The globally unique ID among all types."
+    }
+  },
+  resolveType: (payload) => {
+    return payload.__nodeType.name ? payload.__nodeType.name : null;
+  }
+});
+var NodeInterface = NodeTC.getType();
+var getNodeInterface = (sc) => {
+  if (sc.hasInstance("Node", InterfaceTypeComposer)) {
+    return sc.get("Node");
+  }
+  sc.set("Node", NodeTC);
+  return NodeTC;
+};
+
+// src/composeWithRelay/composeWithRelay.ts
+var TypeMapForRelayNode = {};
+var composeWithRelay = (tc) => {
+  if (!(tc instanceof ObjectTypeComposer)) {
+    throw new Error(
+      "You should provide ObjectTypeComposer instance to composeWithRelay method"
+    );
+  }
+  const nodeInterface = getNodeInterface(tc.schemaComposer);
+  const nodeFieldConfig = getNodeFieldConfig(
+    TypeMapForRelayNode,
+    nodeInterface
+  );
+  if (tc.getTypeName() === "Query" || tc.getTypeName() === "RootQuery") {
+    tc.setField("node", nodeFieldConfig);
+    return tc;
+  }
+  if (tc.getTypeName() === "Mutation" || tc.getTypeName() === "RootMutation") {
+    return tc;
+  }
+  if (!tc.hasRecordIdFn()) {
+    throw new Error(
+      `ObjectTypeComposer(${tc.getTypeName()}) should have recordIdFn. This function returns ID from provided object.`
+    );
+  }
+  const findById = tc.getResolver("findById");
+  if (!findById) {
+    throw new Error(
+      `ObjectTypeComposer(${tc.getTypeName()}) provided to composeWithRelay should have findById resolver.`
+    );
+  }
+  TypeMapForRelayNode[tc.getTypeName()] = {
+    resolver: findById,
+    tc
+  };
+  tc.addFields({
+    id: {
+      type: "ID!",
+      description: "The globally unique ID among all types",
+      resolve: (source) => {
+        return toGlobalId(tc.getTypeName(), tc.getRecordId(source));
+      }
+    }
+  });
+  tc.addInterface(nodeInterface);
+  return tc;
+};
+
+// src/composeWithRelay/index.ts
+import { schemaComposer } from "graphql-compose";
+composeWithRelay(schemaComposer.Query);
+
+// src/index.ts
+import { default as default2 } from "graphql-compose-connection";
 export {
+  default2 as composeWithConnection,
+  composeWithRelay,
   createApiTemplate,
-  createAppSyncResolverHandler
+  createAppSyncResolverHandler,
+  fromGlobalId,
+  toGlobalId
 };

package/dist/esm/server.js

@@ -1,5 +1,4 @@
 /** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-import "./chunk-NQOARNEJ.js";
 
 // src/server.ts
 import {

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { SchemaComposer } from 'graphql-compose';
+import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import { CloudFormationTemplate } from '@ttoss/cloudformation';
 import { AppSyncResolverHandler as AppSyncResolverHandler$1 } from 'aws-lambda';
 export { AppSyncIdentityCognito } from 'aws-lambda';
+export { default as composeWithConnection } from 'graphql-compose-connection';
 
 type StringOrImport = string | {
     'Fn::ImportValue': string;
@@ -33,4 +34,21 @@ declare const createAppSyncResolverHandler: ({ schemaComposer, }: {
     schemaComposer: SchemaComposer<any>;
 }) => AppSyncResolverHandler<any, any, any>;
 
-export { AppSyncResolverHandler, createApiTemplate, createAppSyncResolverHandler };
+declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>) => ObjectTypeComposer<any, TContext>;
+
+type ResolvedGlobalId = {
+    type: string;
+    id: string;
+};
+/**
+ * Takes a type name and an ID specific to that type name, and returns a
+ * "global ID" that is unique among all types.
+ */
+declare const toGlobalId: (type: string, id: string | number) => string;
+/**
+ * Takes the "global ID" created by toGlobalID, and returns the type name and ID
+ * used to create it.
+ */
+declare const fromGlobalId: (globalId: string) => ResolvedGlobalId;
+
+export { AppSyncResolverHandler, composeWithRelay, createApiTemplate, createAppSyncResolverHandler, fromGlobalId, toGlobalId };