@ttoss/appsync-api 0.7.5 → 0.8.1

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/esm/{chunk-CXLYPHQJ.js → chunk-RWRQSJ4M.js}

@@ -79,7 +79,7 @@ var getPackageLambdaLayerStackName = (packageName) => {
 // package.json
 var package_default = {
   name: "@ttoss/appsync-api",
-  version: "0.7.5",
+  version: "0.8.1",
   description: "A library for building GraphQL APIs for AWS AppSync.",
   license: "UNLICENSED",
   author: "ttoss",
@@ -114,8 +114,9 @@ var package_default = {
   dependencies: {
     "@ttoss/cloudformation": "^0.5.1",
     express: "^4.18.2",
+    "graphql-compose-connection": "^8.2.1",
     "graphql-helix": "^1.13.0",
-    minimist: "^1.2.7"
+    minimist: "^1.2.8"
   },
   peerDependencies: {
     graphql: "^16.6.0",
@@ -163,7 +164,11 @@ var createApiTemplate = ({
   lambdaFunction,
   userPoolConfig
 }) => {
-  const sdl = schemaComposer.toSDL();
+  const sdl = schemaComposer.toSDL({
+    commentDescriptions: false,
+    omitDescriptions: true,
+    omitScalars: true
+  });
   graphql.validateSchema(schemaComposer.buildSchema());
   const resolveMethods = schemaComposer.getResolveMethods();
   const resolveMethodsEntries = Object.entries(resolveMethods).flatMap(

package/dist/esm/cli.js

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

package/dist/esm/index.js

@@ -1,16 +1,16 @@
 /** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
 import {
   createApiTemplate
-} from "./chunk-CXLYPHQJ.js";
+} from "./chunk-RWRQSJ4M.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,
@@ -19,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/index.d.ts

@@ -1,7 +1,79 @@
-import { SchemaComposer } from 'graphql-compose';
-import { CloudFormationTemplate } from '@ttoss/cloudformation';
+import { SchemaComposer, ObjectTypeComposer } from 'graphql-compose';
 import { AppSyncResolverHandler as AppSyncResolverHandler$1 } from 'aws-lambda';
 export { AppSyncIdentityCognito } from 'aws-lambda';
+export { default as composeWithConnection } from 'graphql-compose-connection';
+
+interface Parameter {
+    AllowedValues?: string[];
+    Default?: string | number;
+    Description?: string;
+    Type: string;
+    NoEcho?: boolean;
+}
+type Parameters = {
+    [key: string]: Parameter;
+};
+interface Resource {
+    Type: string;
+    DeletionPolicy?: 'Delete' | 'Retain';
+    Description?: string;
+    DependsOn?: string[] | string;
+    Condition?: string;
+    Properties: any;
+}
+interface IAMRoleResource extends Resource {
+    Type: 'AWS::IAM::Role';
+    Properties: {
+        AssumeRolePolicyDocument: {
+            Version: '2012-10-17';
+            Statement: {
+                Effect: 'Allow' | 'Deny';
+                Action: string;
+                Principal: any;
+            }[];
+        };
+        ManagedPolicyArns?: string[];
+        Path?: string;
+        Policies?: {
+            PolicyName: string;
+            PolicyDocument: {
+                Version: '2012-10-17';
+                Statement: {
+                    Effect: 'Allow' | 'Deny';
+                    Action: string | string[];
+                    Resource: string | string[] | {
+                        [key: string]: string;
+                    } | {
+                        [key: string]: string;
+                    }[];
+                }[];
+            };
+        }[];
+    };
+}
+type Resources = {
+    [key: string]: IAMRoleResource | Resource;
+};
+type Output = {
+    Description?: string;
+    Value: string | any;
+    Export?: {
+        Name: string | any;
+    };
+};
+type Outputs = {
+    [key: string]: Output;
+};
+type CloudFormationTemplate = {
+    AWSTemplateFormatVersion: '2010-09-09';
+    Description?: string;
+    Transform?: 'AWS::Serverless-2016-10-31';
+    Mappings?: any;
+    Conditions?: any;
+    Parameters?: Parameters;
+    Resources: Resources;
+    Outputs?: Outputs;
+};
 
 type StringOrImport = string | {
     'Fn::ImportValue': string;
@@ -33,4 +105,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 };

package/dist/index.js

@@ -1,8 +1,10 @@
 /** 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)
@@ -16,13 +18,25 @@ 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
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  composeWithConnection: () => import_graphql_compose_connection.default,
+  composeWithRelay: () => composeWithRelay,
   createApiTemplate: () => createApiTemplate,
-  createAppSyncResolverHandler: () => createAppSyncResolverHandler
+  createAppSyncResolverHandler: () => createAppSyncResolverHandler,
+  fromGlobalId: () => fromGlobalId,
+  toGlobalId: () => toGlobalId
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -105,7 +119,7 @@ var getPackageLambdaLayerStackName = (packageName) => {
 // package.json
 var package_default = {
   name: "@ttoss/appsync-api",
-  version: "0.7.5",
+  version: "0.8.1",
   description: "A library for building GraphQL APIs for AWS AppSync.",
   license: "UNLICENSED",
   author: "ttoss",
@@ -140,8 +154,9 @@ var package_default = {
   dependencies: {
     "@ttoss/cloudformation": "^0.5.1",
     express: "^4.18.2",
+    "graphql-compose-connection": "^8.2.1",
     "graphql-helix": "^1.13.0",
-    minimist: "^1.2.7"
+    minimist: "^1.2.8"
   },
   peerDependencies: {
     graphql: "^16.6.0",
@@ -184,14 +199,18 @@ var AppSyncGraphQLApiKeyLogicalId = "AppSyncGraphQLApiKey";
 var createApiTemplate = ({
   additionalAuthenticationProviders,
   authenticationType = "AMAZON_COGNITO_USER_POOLS",
-  schemaComposer,
+  schemaComposer: schemaComposer2,
   dataSource,
   lambdaFunction,
   userPoolConfig
 }) => {
-  const sdl = schemaComposer.toSDL();
-  import_graphql_compose.graphql.validateSchema(schemaComposer.buildSchema());
-  const resolveMethods = schemaComposer.getResolveMethods();
+  const sdl = schemaComposer2.toSDL({
+    commentDescriptions: false,
+    omitDescriptions: true,
+    omitScalars: true
+  });
+  import_graphql_compose.graphql.validateSchema(schemaComposer2.buildSchema());
+  const resolveMethods = schemaComposer2.getResolveMethods();
   const resolveMethodsEntries = Object.entries(resolveMethods).flatMap(
     ([typeName, fieldResolvers]) => {
       return Object.entries(fieldResolvers).map(([fieldName]) => {
@@ -381,12 +400,12 @@ var createApiTemplate = ({
 
 // 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,
@@ -395,8 +414,164 @@ var createAppSyncResolverHandler = ({
     );
   };
 };
+
+// src/composeWithRelay/composeWithRelay.ts
+var import_graphql_compose4 = require("graphql-compose");
+
+// src/composeWithRelay/nodeFieldConfig.ts
+var import_graphql_compose2 = require("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 = (0, import_graphql_compose2.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
+var import_graphql_compose3 = require("graphql-compose");
+var NodeTC = import_graphql_compose3.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", import_graphql_compose3.InterfaceTypeComposer)) {
+    return sc.get("Node");
+  }
+  sc.set("Node", NodeTC);
+  return NodeTC;
+};
+
+// src/composeWithRelay/composeWithRelay.ts
+var TypeMapForRelayNode = {};
+var composeWithRelay = (tc) => {
+  if (!(tc instanceof import_graphql_compose4.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
+var import_graphql_compose5 = require("graphql-compose");
+composeWithRelay(import_graphql_compose5.schemaComposer.Query);
+
+// src/index.ts
+var import_graphql_compose_connection = __toESM(require("graphql-compose-connection"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  composeWithConnection,
+  composeWithRelay,
   createApiTemplate,
-  createAppSyncResolverHandler
+  createAppSyncResolverHandler,
+  fromGlobalId,
+  toGlobalId
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/appsync-api",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "A library for building GraphQL APIs for AWS AppSync.",
   "license": "UNLICENSED",
   "author": "ttoss",
@@ -35,8 +35,9 @@
   "dependencies": {
     "@ttoss/cloudformation": "^0.5.1",
     "express": "^4.18.2",
+    "graphql-compose-connection": "^8.2.1",
     "graphql-helix": "^1.13.0",
-    "minimist": "^1.2.7"
+    "minimist": "^1.2.8"
   },
   "peerDependencies": {
     "graphql": "^16.6.0",
@@ -68,5 +69,5 @@
       ]
     }
   },
-  "gitHead": "d4df96176c1d3fce4ebf7842de5847a618a33d9e"
+  "gitHead": "128418716cbc6dd7d4a41a6925b455b7e4784f9f"
 }

package/src/composeWithRelay/composeWithRelay.ts

@@ -0,0 +1,67 @@
+import { ObjectTypeComposer } from 'graphql-compose';
+import { getNodeFieldConfig } from './nodeFieldConfig';
+import { getNodeInterface } from './nodeInterface';
+import { toGlobalId } from './globalId';
+
+// all wrapped typeComposers with Relay, stored in this variable
+// for futher type resolving via NodeInterface.resolveType method
+export const TypeMapForRelayNode: any = {};
+
+export const composeWithRelay = <TContext>(
+  tc: ObjectTypeComposer<any, TContext>
+): ObjectTypeComposer<any, TContext> => {
+  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') {
+    // just skip
+    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;
+};

package/src/composeWithRelay/globalId.ts

@@ -0,0 +1,32 @@
+export type Base64String = string;
+
+export type ResolvedGlobalId = {
+  type: string;
+  id: string;
+};
+
+export const base64 = (i: string): Base64String => {
+  return Buffer.from(i, 'ascii').toString('base64');
+};
+
+export const unbase64 = (i: Base64String): string => {
+  return Buffer.from(i, 'base64').toString('ascii');
+};
+
+/**
+ * Takes a type name and an ID specific to that type name, and returns a
+ * "global ID" that is unique among all types.
+ */
+export const toGlobalId = (type: string, id: string | number): string => {
+  return base64([type, id].join(':'));
+};
+
+/**
+ * Takes the "global ID" created by toGlobalID, and returns the type name and ID
+ * used to create it.
+ */
+export const fromGlobalId = (globalId: string): ResolvedGlobalId => {
+  const unbasedGlobalId = unbase64(globalId);
+  const [type, id] = unbasedGlobalId.split(':');
+  return { type, id };
+};

package/src/composeWithRelay/index.ts

@@ -0,0 +1,7 @@
+import { composeWithRelay } from './composeWithRelay';
+import { schemaComposer } from 'graphql-compose';
+
+composeWithRelay(schemaComposer.Query);
+
+export { composeWithRelay };
+export { fromGlobalId, toGlobalId } from './globalId';

package/src/composeWithRelay/nodeFieldConfig.ts

@@ -0,0 +1,82 @@
+import {
+  type InterfaceTypeComposer,
+  type ObjectTypeComposerFieldConfigDefinition,
+  getProjectionFromAST,
+} from 'graphql-compose';
+import { fromGlobalId } from './globalId';
+import type { GraphQLResolveInfo } from 'graphql-compose/lib/graphql';
+import type { ObjectTypeComposer, Resolver } from 'graphql-compose';
+
+export type TypeMapForRelayNode<TSource, TContext> = {
+  [typeName: string]: {
+    resolver: Resolver<TSource, TContext>;
+    tc: ObjectTypeComposer<TSource, TContext>;
+  };
+};
+
+// this fieldConfig must be set to RootQuery.node field
+export const getNodeFieldConfig = (
+  typeMapForRelayNode: TypeMapForRelayNode<any, any>,
+  nodeInterface: InterfaceTypeComposer<any, any>
+): ObjectTypeComposerFieldConfigDefinition<any, any> => {
+  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: any,
+      args: { [argName: string]: any },
+      context: any,
+      info: GraphQLResolveInfo
+    ) => {
+      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();
+
+        // set `returnType` for proper work of `getProjectionFromAST`
+        // it will correctly add required fields for `relation` to `projection`
+        let projection;
+        if (info) {
+          projection = getProjectionFromAST({
+            ...info,
+            returnType: graphqlType,
+          });
+        } else {
+          projection = {};
+        }
+
+        // suppose that first argument is argument with id field
+        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: any) => {
+            if (!res) return res;
+            res.__nodeType = graphqlType;
+            return res;
+          });
+      }
+
+      return null;
+    },
+  };
+};

package/src/composeWithRelay/nodeInterface.ts

@@ -0,0 +1,31 @@
+import { InterfaceTypeComposer, type SchemaComposer } from 'graphql-compose';
+
+const 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: any) => {
+    // `payload.__nodeType` was added to payload via nodeFieldConfig.resolve
+    return payload.__nodeType.name ? payload.__nodeType.name : null;
+  },
+});
+
+export const NodeInterface = NodeTC.getType();
+
+export const getNodeInterface = <TContext>(
+  sc: SchemaComposer<TContext>
+): InterfaceTypeComposer<any, TContext> => {
+  if (sc.hasInstance('Node', InterfaceTypeComposer)) {
+    return sc.get('Node') as any;
+  }
+
+  sc.set('Node', NodeTC);
+
+  return NodeTC;
+};

package/src/createApiTemplate.ts

@@ -1,7 +1,13 @@
 import { type SchemaComposer, graphql } from 'graphql-compose';
 import { getPackageLambdaLayerStackName } from 'carlin/src/deploy/lambdaLayer/getPackageLambdaLayerStackName';
 import packageJson from '../package.json';
-import type { CloudFormationTemplate } from '@ttoss/cloudformation';
+/**
+ * Absolute path to avoid:
+ * The inferred type of 'template' cannot be named without a reference to
+ * '@ttoss/appsync-api/node_modules/@ttoss/cloudformation'. This is likely not
+ * portable. A type annotation is necessary.ts(2742)
+ */
+import type { CloudFormationTemplate } from '../../cloudformation/src';
 
 export const AppSyncGraphQLApiLogicalId = 'AppSyncGraphQLApi';
 
@@ -53,7 +59,11 @@ export const createApiTemplate = ({
    * It should be on top of the file, otherwise it will have empty Mutation
    * or Subscription if there are no resolvers for them.
    */
-  const sdl = schemaComposer.toSDL();
+  const sdl = schemaComposer.toSDL({
+    commentDescriptions: false,
+    omitDescriptions: true,
+    omitScalars: true,
+  });
 
   graphql.validateSchema(schemaComposer.buildSchema());
 

package/src/index.ts

@@ -4,3 +4,5 @@ export {
   createAppSyncResolverHandler,
 } from './createAppSyncResolverHandler';
 export type { AppSyncIdentityCognito } from 'aws-lambda';
+export { composeWithRelay, toGlobalId, fromGlobalId } from './composeWithRelay';
+export { default as composeWithConnection } from 'graphql-compose-connection';