@ttoss/graphql-api 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { SchemaComposer } from 'graphql-compose';
+import Koa from 'koa';
+export { default as Router } from '@koa/router';
+
+declare const createServer: ({ schemaComposer, graphiql, }: {
+    schemaComposer: SchemaComposer<any>;
+    graphiql?: boolean | undefined;
+}) => Koa;
+
+export { createServer };

package/dist/server.js

@@ -0,0 +1,90 @@
+/** 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(
+// 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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  Router: () => import_router.default,
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_graphql_helix = require("graphql-helix");
+var import_koa = __toESM(require("koa"));
+var import_router = __toESM(require("@koa/router"));
+var import_koa_bodyparser = __toESM(require("koa-bodyparser"));
+var createServer = ({
+  schemaComposer,
+  graphiql = false
+}) => {
+  const server = new import_koa.default();
+  const router = new import_router.default();
+  server.use((0, import_koa_bodyparser.default)());
+  router.all("/graphql", async ctx => {
+    const request = {
+      body: ctx.request.body,
+      headers: ctx.headers,
+      method: ctx.method,
+      query: ctx.request.query
+    };
+    if ((0, import_graphql_helix.shouldRenderGraphiQL)(request)) {
+      if (graphiql) {
+        ctx.body = (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, ctx.res);
+  });
+  server.use(router.routes()).use(router.allowedMethods());
+  return server;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router,
+  createServer
+});

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@ttoss/graphql-api",
+  "version": "0.1.0",
+  "description": "A library for building GraphQL APIs.",
+  "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-graphql-api": "./bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "typings": "dist/index.d.ts",
+  "dependencies": {
+    "@koa/router": "^12.0.0",
+    "graphql-compose-connection": "^8.2.1",
+    "graphql-helix": "^1.13.0",
+    "koa": "^2.14.2",
+    "koa-bodyparser": "^4.4.0",
+    "npmlog": "^7.0.1",
+    "ts-node": "^10.9.1",
+    "yargs": "^17.7.2"
+  },
+  "peerDependencies": {
+    "graphql": "^16.6.0",
+    "graphql-compose": "^9.0.10"
+  },
+  "devDependencies": {
+    "@types/koa": "^2.13.6",
+    "@types/koa__router": "^12.0.0",
+    "@types/koa-bodyparser": "^4.3.10",
+    "@types/yargs": "^17.0.24",
+    "graphql": "^16.6.0",
+    "graphql-compose": "^9.0.10",
+    "jest": "^29.5.0",
+    "tsup": "^6.7.0",
+    "@ttoss/config": "^1.30.0"
+  },
+  "keywords": [
+    "api",
+    "graphql"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "server": [
+        "./dist/server.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "jest"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { register } from 'ts-node';
+import log from 'npmlog';
+import yargs from 'yargs';
+
+const logPrefix = 'graphql-api';
+
+register({
+  transpileOnly: true,
+});
+
+const argv: any = yargs(process.argv.slice(2)).argv;
+
+if (argv._.includes('build-schema')) {
+  log.info(logPrefix, 'Building schema...');
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const { schemaComposer } = require(path.resolve(
+    process.cwd(),
+    'src',
+    'schemaComposer.ts'
+  ));
+
+  const sdl = schemaComposer.toSDL();
+
+  /**
+   * Save to schema/schema.graphql. schema folder might not exist.
+   */
+  fs.mkdirSync('schema', { recursive: true });
+
+  fs.writeFileSync('schema/schema.graphql', sdl);
+
+  log.info(logPrefix, 'Schema built.');
+}

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;
+  recordId: 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, recordId: string | number): string => {
+  return base64([type, recordId].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, recordId] = unbasedGlobalId.split(':');
+  return { type, recordId };
+};

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

@@ -0,0 +1,3 @@
+export { composeWithRelay, toGlobalId, fromGlobalId } from './composeWithRelay';
+export { default as composeWithConnection } from 'graphql-compose-connection';
+export * from 'graphql-compose';

package/src/server.ts

@@ -0,0 +1,60 @@
+import { type SchemaComposer } from 'graphql-compose';
+import {
+  getGraphQLParameters,
+  processRequest,
+  renderGraphiQL,
+  sendResult,
+  shouldRenderGraphiQL,
+} from 'graphql-helix';
+import Koa from 'koa';
+import Router from '@koa/router';
+import bodyParser from 'koa-bodyparser';
+
+export { Router };
+
+export const createServer = ({
+  schemaComposer,
+  graphiql = false,
+}: {
+  schemaComposer: SchemaComposer<any>;
+  graphiql?: boolean;
+}): Koa => {
+  const server = new Koa();
+
+  const router = new Router();
+
+  server.use(bodyParser());
+
+  router.all('/graphql', async (ctx) => {
+    const request = {
+      body: ctx.request.body,
+      headers: ctx.headers,
+      method: ctx.method,
+      query: ctx.request.query,
+    };
+
+    if (shouldRenderGraphiQL(request)) {
+      if (graphiql) {
+        ctx.body = renderGraphiQL({});
+      }
+
+      return;
+    }
+
+    const { operationName, query, variables } = getGraphQLParameters(request);
+
+    const result = await processRequest({
+      operationName,
+      query,
+      variables,
+      request,
+      schema: schemaComposer.buildSchema(),
+    });
+
+    sendResult(result, ctx.res);
+  });
+
+  server.use(router.routes()).use(router.allowedMethods());
+
+  return server;
+};