@ttoss/graphql-api 0.1.0 → 0.3.0

package/README.md

@@ -13,7 +13,7 @@ This package provides an opinionated way to create an GraphQL API using ttoss ec
 pnpm add @ttoss/graphql-api graphql
 ```
 
-## Getting Started
+## Quickstart
 
 This library uses [`graphql-compose`](https://graphql-compose.github.io/) to create the GraphQL schema. It re-export all the [`graphql-compose`](https://graphql-compose.github.io/) types and methods, so you can use it directly from this package.
 
@@ -134,6 +134,73 @@ composeWithRelay(UserTC);
 
 _We inspired ourselves on [graphql-compose-relay](https://graphql-compose.github.io/docs/plugins/plugin-relay.html) to create `composeWithRelay`._
 
+### 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;
+      },
+    },
+  },
+});
+```
+
+### Middlewares
+
+This package provides a way to add middlewares to your final schema. You can add middlewares compatible with [`graphql-middleware`](https://github.com/dimatill/graphql-middleware) by passing them to the `middlewares` option on `buildSchema` method. For example, you can use [GraphQL Shield](https://the-guild.dev/graphql/shield) to add authorization to your API:
+
+```typescript
+import { buildSchema } from '@ttoss/graphql-api';
+import { allow, deny, shield } from 'graphql-shield';
+import { schemaComposer } from './schemaComposer';
+
+const NotAuthorizedError = new Error('Not authorized!');
+/**
+ * The error name is the same value `errorType` on GraphQL errors response.
+ */
+NotAuthorizedError.name = 'NotAuthorizedError';
+
+const permissions = shield(
+  {
+    Query: {
+      '*': deny,
+      author: allow,
+    },
+    Author: {
+      id: allow,
+      name: allow,
+    },
+  },
+  {
+    fallbackRule: deny,
+    fallbackError: NotAuthorizedError,
+  }
+);
+
+const schema = buildSchema({
+  schemaComposer,
+  middlewares; [permissions],
+})
+```
+
 ## Building Schema
 
 As Relay needs an introspection query to work, this package provides a way to build the GraphQL schema by running `ttoss-graphl-api build-schema`.
@@ -142,19 +209,54 @@ As Relay needs an introspection query to work, this package provides a way to bu
 ttoss-graphl-api build-schema
 ```
 
-## Server
+You can add the `schema` script to your `package.json`:
 
-This package provides a Koa server to run your GraphQL API. You can use the `createServer` method to create the server.
+```json
+{
+  "scripts": {
+    "schema": "ttoss-graphl-api build-schema"
+  }
+}
+```
 
-```ts
-import { createServer } from '@ttoss/graphql-api/server';
+## How to Create Tests
 
-const server = createServer({
-  schemaComposer,
-  graphiql: true,
-});
+We recommend testing the whole GraphQL API using the `graphql` object and the schema composer to provide the schema. For example:
 
-server.listen(3000, () => {
-  console.log('Server listening on port 3000');
+```ts
+import { graphql } from 'graphql';
+import { schemaComposer } from './schemaComposer';
+
+test('testing my query', () => {
+  const author = {
+    id: '1',
+    name: 'John Doe',
+  };
+
+  const response = await graphql({
+    schema: schemaComposer.buildSchema(),
+    source: /* GraphQL */ `
+      query ($id: ID!) {
+        node(id: $id) {
+          id
+          ... on Author {
+            name
+          }
+        }
+      }
+    `,
+    variableValues: {
+      id: author.id,
+    },
+  });
+
+  expect(response).toEqual({
+    data: {
+      node: {
+        id: author.id,
+        name: author.name,
+      },
+    },
+  });
 });
 ```

package/dist/esm/index.js

@@ -153,4 +153,25 @@ composeWithRelay(schemaComposer.Query);
 // src/index.ts
 import { default as default2 } from "graphql-compose-connection";
 export * from "graphql-compose";
-export { default2 as composeWithConnection, composeWithRelay, fromGlobalId, toGlobalId };
+
+// src/buildSchema.ts
+import { applyMiddleware } from "graphql-middleware";
+var buildSchema = ({
+  schemaComposer: schemaComposer2,
+  middlewares
+}) => {
+  if (!schemaComposer2) {
+    throw new Error("No schemaComposer provided");
+  }
+  const schema = schemaComposer2.buildSchema();
+  if (middlewares) {
+    return applyMiddleware(schema, ...middlewares.map(middleware => {
+      if (middleware.generate) {
+        return middleware.generate(schema);
+      }
+      return middleware;
+    }));
+  }
+  return schema;
+};
+export { buildSchema, default2 as composeWithConnection, composeWithRelay, fromGlobalId, toGlobalId };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import { ObjectTypeComposer } from 'graphql-compose';
+import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
 export * from 'graphql-compose';
 export { default as composeWithConnection } from 'graphql-compose-connection';
+import { GraphQLSchema } from 'graphql';
+import { IMiddleware, IMiddlewareGenerator } from 'graphql-middleware';
 
 declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>) => ObjectTypeComposer<any, TContext>;
 
@@ -19,4 +21,10 @@ declare const toGlobalId: (type: string, recordId: string | number) => string;
  */
 declare const fromGlobalId: (globalId: string) => ResolvedGlobalId;
 
-export { composeWithRelay, fromGlobalId, toGlobalId };
+type BuildSchemaInput<TContext = any> = {
+    schemaComposer: SchemaComposer<TContext>;
+    middlewares?: (IMiddleware | IMiddlewareGenerator<any, TContext, any>)[];
+};
+declare const buildSchema: ({ schemaComposer, middlewares, }: BuildSchemaInput) => GraphQLSchema;
+
+export { BuildSchemaInput, buildSchema, composeWithRelay, fromGlobalId, toGlobalId };

package/dist/index.js

@@ -39,6 +39,7 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  buildSchema: () => buildSchema,
   composeWithConnection: () => import_graphql_compose_connection.default,
   composeWithRelay: () => composeWithRelay,
   fromGlobalId: () => fromGlobalId,
@@ -198,10 +199,33 @@ composeWithRelay(import_graphql_compose4.schemaComposer.Query);
 // src/index.ts
 var import_graphql_compose_connection = __toESM(require("graphql-compose-connection"));
 __reExport(src_exports, require("graphql-compose"), module.exports);
+
+// src/buildSchema.ts
+var import_graphql_middleware = require("graphql-middleware");
+var buildSchema = ({
+  schemaComposer: schemaComposer2,
+  middlewares
+}) => {
+  if (!schemaComposer2) {
+    throw new Error("No schemaComposer provided");
+  }
+  const schema = schemaComposer2.buildSchema();
+  if (middlewares) {
+    return (0, import_graphql_middleware.applyMiddleware)(schema, ...middlewares.map(middleware => {
+      if (middleware.generate) {
+        return middleware.generate(schema);
+      }
+      return middleware;
+    }));
+  }
+  return schema;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildSchema,
   composeWithConnection,
   composeWithRelay,
   fromGlobalId,
-  toGlobalId
+  toGlobalId,
+  ...require("graphql-compose")
 });

package/package.json

@@ -1,21 +1,11 @@
 {
   "name": "@ttoss/graphql-api",
-  "version": "0.1.0",
+  "version": "0.3.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": {
@@ -28,26 +18,20 @@
   "sideEffects": false,
   "typings": "dist/index.d.ts",
   "dependencies": {
-    "@koa/router": "^12.0.0",
+    "graphql-compose": "^9.0.10",
     "graphql-compose-connection": "^8.2.1",
-    "graphql-helix": "^1.13.0",
-    "koa": "^2.14.2",
-    "koa-bodyparser": "^4.4.0",
+    "graphql-middleware": "^6.1.34",
     "npmlog": "^7.0.1",
     "ts-node": "^10.9.1",
     "yargs": "^17.7.2"
   },
   "peerDependencies": {
-    "graphql": "^16.6.0",
-    "graphql-compose": "^9.0.10"
+    "graphql": "^16.6.0"
   },
   "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",
+    "graphql-shield": "^7.6.5",
     "jest": "^29.5.0",
     "tsup": "^6.7.0",
     "@ttoss/config": "^1.30.0"
@@ -59,16 +43,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./dist/index.d.ts"
-      ],
-      "server": [
-        "./dist/server.d.ts"
-      ]
-    }
-  },
   "scripts": {
     "build": "tsup",
     "test": "jest"

package/src/buildSchema.ts

@@ -0,0 +1,43 @@
+import { type GraphQLSchema } from 'graphql';
+import {
+  type IMiddleware,
+  type IMiddlewareGenerator,
+  applyMiddleware,
+} from 'graphql-middleware';
+import { type SchemaComposer } from 'graphql-compose';
+
+export type BuildSchemaInput<TContext = any> = {
+  schemaComposer: SchemaComposer<TContext>;
+  middlewares?: (IMiddleware | IMiddlewareGenerator<any, TContext, any>)[];
+};
+
+export const buildSchema = ({
+  schemaComposer,
+  middlewares,
+}: BuildSchemaInput): GraphQLSchema => {
+  if (!schemaComposer) {
+    throw new Error('No schemaComposer provided');
+  }
+
+  const schema = schemaComposer.buildSchema();
+
+  if (middlewares) {
+    return applyMiddleware(
+      schema,
+      ...middlewares.map((middleware) => {
+        /**
+         * https://github.com/dimatill/graphql-middleware/issues/433#issuecomment-1170187160
+         */
+        if ((middleware as IMiddlewareGenerator<any, any, any>).generate) {
+          return (middleware as IMiddlewareGenerator<any, any, any>).generate(
+            schema
+          );
+        }
+
+        return middleware;
+      })
+    );
+  }
+
+  return schema;
+};

package/src/index.ts

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

package/dist/esm/server.js

@@ -1,46 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-import "./chunk-SAO2ACBY.js";
-
-// src/server.ts
-import { getGraphQLParameters, processRequest, renderGraphiQL, sendResult, shouldRenderGraphiQL } from "graphql-helix";
-import Koa from "koa";
-import Router from "@koa/router";
-import bodyParser from "koa-bodyparser";
-var createServer = ({
-  schemaComposer,
-  graphiql = false
-}) => {
-  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;
-};
-export { Router, createServer };

package/dist/server.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,90 +0,0 @@
-/** 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/src/server.ts

@@ -1,60 +0,0 @@
-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;
-};