@ttoss/appsync-api 0.7.4 → 0.8.0

package/dist/server.js

@@ -19,6 +19,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/appsync-api",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "A library for building GraphQL APIs for AWS AppSync.",
   "license": "UNLICENSED",
   "author": "ttoss",
@@ -33,19 +33,20 @@
   "sideEffects": false,
   "typings": "dist/index.d.ts",
   "dependencies": {
-    "@ttoss/cloudformation": "^0.5.0",
+    "@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",
     "graphql-compose": "^9.0.10"
   },
   "devDependencies": {
-    "@ttoss/config": "^1.28.0",
+    "@ttoss/config": "^1.28.1",
     "@types/aws-lambda": "^8.10.110",
-    "carlin": "^1.23.1",
+    "carlin": "^1.23.2",
     "graphql": "^16.6.0",
     "graphql-compose": "^9.0.10"
   },
@@ -68,5 +69,5 @@
       ]
     }
   },
-  "gitHead": "6fbc10064e36429416efae0435cea250c5a39d52"
+  "gitHead": "84ebce1283e142519776d7045c484269d3dbabe4"
 }

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/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';

package/dist/esm/chunk-NQOARNEJ.js

@@ -1,27 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-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 __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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
-));
-
-export {
-  __commonJS,
-  __toESM
-};