@ttoss/graphql-api 0.2.0 → 0.3.0

package/README.md

@@ -163,6 +163,44 @@ composeWithConnection(AuthorTC, {
 });
 ```
 
+### 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`.
@@ -171,6 +209,16 @@ As Relay needs an introspection query to work, this package provides a way to bu
 ttoss-graphl-api build-schema
 ```
 
+You can add the `schema` script to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "schema": "ttoss-graphl-api build-schema"
+  }
+}
+```
+
 ## How to Create Tests
 
 We recommend testing the whole GraphQL API using the `graphql` object and the schema composer to provide the schema. For example:

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,8 +199,30 @@ 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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/graphql-api",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A library for building GraphQL APIs.",
   "author": "ttoss",
   "contributors": [
@@ -20,6 +20,7 @@
   "dependencies": {
     "graphql-compose": "^9.0.10",
     "graphql-compose-connection": "^8.2.1",
+    "graphql-middleware": "^6.1.34",
     "npmlog": "^7.0.1",
     "ts-node": "^10.9.1",
     "yargs": "^17.7.2"
@@ -30,6 +31,7 @@
   "devDependencies": {
     "@types/yargs": "^17.0.24",
     "graphql": "^16.6.0",
+    "graphql-shield": "^7.6.5",
     "jest": "^29.5.0",
     "tsup": "^6.7.0",
     "@ttoss/config": "^1.30.0"

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