@ttoss/graphql-api 0.8.0 → 0.8.1

package/README.md

@@ -9,26 +9,14 @@ This package offers an opinionated approach to building a GraphQL API using the
    As **Relay** is the primary GraphQL client in the ttoss ecosystem, this package implements the [Relay Server Specification](https://relay.dev/docs/guides/graphql-server-specification/) for seamless client-server interaction.
 
 1. **Schema Building**:  
-   Generate the GraphQL schema required for Relay's introspection queries by running:
-
-   ```bash
-   ttoss-graphql-api build-schema
-   ```
+   Generate the GraphQL schema required for Relay's introspection queries with [@ttoss/graphql-api-cli](https://ttoss.dev/docs/modules/packages/graphql-api-cli/).
 
 1. **TypeScript Types Generation**:
-   Automatically generate TypeScript types for your GraphQL schema with the same command:
-
-   ```bash
-   ttoss-graphql-api build-schema
-   ```
+   Automatically generate TypeScript types for your GraphQL schema with [@ttoss/graphql-api-cli](https://ttoss.dev/docs/modules/packages/graphql-api-cli/).
 
 1. **AWS AppSync Support**:
    Create GraphQL APIs compatible with AWS AppSync. Additionally, this package includes support for running a local GraphQL API server for development and testing purposes.
 
-## ESM Only
-
-This package is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
-
 ## Installation
 
 ```bash
@@ -450,39 +438,7 @@ import { allow, deny, shield } from '@ttoss/graphql-api/shield';
 
 ## Building Schema and Types
 
-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`. It build the schema using the `schemaComposer` from `src/schemaComposer.ts` file and save the schema in `schema/schema.graphql` file and TypeScript types in `schema/types.ts` file.
-
-```bash
-ttoss-graphl-api build-schema
-```
-
-You can add the `build-schema` script to your `package.json`:
-
-```json
-{
-  "scripts": {
-    "build-schema": "ttoss-graphl-api build-schema"
-  }
-}
-```
-
-### Options
-
-#### `--directory`/`-d`
-
-If your `schemaComposer` is in a different directory, you can pass the `--directory`/`-d` option to `ttoss-graphl-api build-schema` command:
-
-```bash
-ttoss-graphl-api build-schema -d tests
-```
-
-#### `--external`
-
-External dependencies to ignore during build. If you don't set this option, the `build-schema` command will use the `dependencies` and `devDependencies` from your `package.json` file.
-
-```bash
-ttoss-graphl-api build-schema --external graphql-compose,graphql
-```
+Check [@ttoss/graphql-api-cli](https://ttoss.dev/docs/modules/packages/graphql-api-cli/) for more information about how to build the schema and types.
 
 ## How to Create Tests
 

package/dist/index.d.cts

@@ -0,0 +1,16 @@
+import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
+export * from 'graphql-compose';
+export { composeWithConnection } from 'graphql-compose-connection';
+import { GraphQLSchema } from 'graphql';
+import { IMiddleware, IMiddlewareGenerator } from 'graphql-middleware';
+export { IMiddleware as Middleware } from 'graphql-middleware';
+
+declare const composeWithRelay: <TContext>(tc: ObjectTypeComposer<any, TContext>) => ObjectTypeComposer<any, TContext>;
+
+type BuildSchemaInput<TContext = unknown> = {
+    schemaComposer: SchemaComposer<TContext>;
+    middlewares?: (IMiddleware | IMiddlewareGenerator<unknown, TContext, unknown>)[];
+};
+declare const buildSchema: ({ schemaComposer, middlewares, }: BuildSchemaInput) => GraphQLSchema;
+
+export { type BuildSchemaInput, buildSchema, composeWithRelay };

package/dist/index.js

@@ -0,0 +1,200 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  buildSchema: () => buildSchema,
+  composeWithConnection: () => import_graphql_compose_connection.composeWithConnection,
+  composeWithRelay: () => composeWithRelay
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/composeWithRelay/composeWithRelay.ts
+var import_graphql_compose3 = require("graphql-compose");
+
+// src/composeWithRelay/nodeFieldConfig.ts
+var import_graphql_compose = require("graphql-compose");
+var import_ids = require("@ttoss/ids");
+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"
+      }
+    },
+    // eslint-disable-next-line max-params
+    resolve: (source, args, context, info) => {
+      if (!args.id || !(typeof args.id === "string")) {
+        return null;
+      }
+      const {
+        type
+      } = (0, import_ids.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_compose.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_compose2 = require("graphql-compose");
+var NodeTC = import_graphql_compose2.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_compose2.InterfaceTypeComposer)) {
+    return sc.get("Node");
+  }
+  sc.set("Node", NodeTC);
+  return NodeTC;
+};
+
+// src/composeWithRelay/composeWithRelay.ts
+var import_ids2 = require("@ttoss/ids");
+var TypeMapForRelayNode = {};
+var composeWithRelay = tc => {
+  if (!(tc instanceof import_graphql_compose3.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 (0, import_ids2.toGlobalId)(tc.getTypeName(), tc.getRecordId(source).toString());
+      }
+    }
+  });
+  tc.addInterface(nodeInterface);
+  return tc;
+};
+
+// src/composeWithRelay/index.ts
+var import_graphql_compose4 = require("graphql-compose");
+composeWithRelay(import_graphql_compose4.schemaComposer.Query);
+
+// src/index.ts
+var import_graphql_compose_connection = 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,
+  ...require("graphql-compose")
+});

package/dist/shield.d.cts

@@ -0,0 +1,2 @@
+export * from 'graphql-shield';
+export { IMiddleware, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, IMiddlewareTypeMap } from 'graphql-middleware';

package/dist/shield.js

@@ -0,0 +1,29 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+
+// src/shield.ts
+var shield_exports = {};
+module.exports = __toCommonJS(shield_exports);
+__reExport(shield_exports, require("graphql-shield"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("graphql-shield")
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/graphql-api",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A library for building GraphQL APIs using ttoss ecosystem.",
   "license": "MIT",
   "author": "ttoss",
@@ -25,17 +25,11 @@
       "types": "./dist/shield.d.ts"
     }
   },
-  "bin": {
-    "ttoss-graphql-api": "./bin/cli.js"
-  },
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "dependencies": {
-    "@graphql-codegen/core": "^4.0.2",
-    "@graphql-codegen/typescript": "^4.1.2",
-    "esbuild": "^0.24.0",
     "graphql-compose": "^9.0.11",
     "graphql-compose-connection": "^8.2.1",
     "graphql-middleware": "^6.1.35",
@@ -47,7 +41,6 @@
     "graphql": "^16.6.0"
   },
   "devDependencies": {
-    "commander": "^12.1.0",
     "graphql": "^16.9.0",
     "jest": "^29.7.0",
     "tsup": "^8.3.5",
@@ -62,7 +55,7 @@
     "provenance": true
   },
   "scripts": {
-    "build-config": "tsup-node",
+    "build": "tsup",
     "test": "jest --projects tests/unit"
   }
 }

package/bin/cli.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '../dist/esm/cli.js';

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-import 'graphql-shield';
-import 'graphql-middleware';

package/dist/esm/cli.js

@@ -1,173 +0,0 @@
-/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
-
-// src/cli.ts
-import * as esbuild from "esbuild";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as typescriptPlugin from "@graphql-codegen/typescript";
-import { Command } from "commander";
-import { codegen } from "@graphql-codegen/core";
-import { parse } from "graphql";
-import log from "npmlog";
-
-// package.json
-var package_default = {
-  name: "@ttoss/graphql-api",
-  version: "0.8.0",
-  description: "A library for building GraphQL APIs using ttoss ecosystem.",
-  license: "MIT",
-  author: "ttoss",
-  contributors: ["Pedro Arantes <pedro@arantespp.com> (https://arantespp.com)"],
-  repository: {
-    type: "git",
-    url: "https://github.com/ttoss/ttoss.git",
-    directory: "packages/graphql-api"
-  },
-  type: "module",
-  exports: {
-    ".": "./src/index.ts",
-    "./shield": "./src/shield.ts"
-  },
-  bin: {
-    "ttoss-graphql-api": "./bin/cli.js"
-  },
-  files: ["dist"],
-  scripts: {
-    "build-config": "tsup-node",
-    test: "jest --projects tests/unit"
-  },
-  sideEffects: false,
-  dependencies: {
-    "@graphql-codegen/core": "^4.0.2",
-    "@graphql-codegen/typescript": "^4.1.2",
-    "@ttoss/ids": "workspace:^",
-    esbuild: "^0.24.0",
-    "graphql-compose": "^9.0.11",
-    "graphql-compose-connection": "^8.2.1",
-    "graphql-middleware": "^6.1.35",
-    "graphql-shield": "^7.6.5",
-    npmlog: "^7.0.1"
-  },
-  peerDependencies: {
-    graphql: "^16.6.0"
-  },
-  devDependencies: {
-    "@ttoss/config": "workspace:^",
-    commander: "^12.1.0",
-    graphql: "^16.9.0",
-    jest: "^29.7.0",
-    tsup: "^8.3.5"
-  },
-  keywords: ["api", "graphql"],
-  publishConfig: {
-    access: "public",
-    exports: {
-      ".": {
-        import: "./dist/esm/index.js",
-        require: "./dist/index.js",
-        types: "./dist/index.d.ts"
-      },
-      "./shield": {
-        import: "./dist/esm/shield.js",
-        require: "./dist/shield.js",
-        types: "./dist/shield.d.ts"
-      }
-    },
-    provenance: true
-  }
-};
-
-// src/cli.ts
-var logPrefix = "graphql-api";
-var importSchemaComposer = async ({
-  external,
-  schemaComposerPath
-}) => {
-  const lastEntryPointName = schemaComposerPath.split("/").pop();
-  const filename = lastEntryPointName?.split(".")[0];
-  const outfile = path.resolve(process.cwd(), "out", filename + ".js");
-  const packageJsonPath = path.resolve(process.cwd(), "package.json");
-  const packageJson = await fs.promises.readFile(packageJsonPath, "utf-8");
-  const dependencies = Object.keys(JSON.parse(packageJson).dependencies).filter(dependency => {
-    if (dependency.startsWith("@ttoss/")) {
-      return false;
-    }
-    if (dependency === "graphql") {
-      return false;
-    }
-    return true;
-  });
-  const result = await esbuild.build({
-    bundle: true,
-    entryPoints: [schemaComposerPath],
-    external: external || dependencies,
-    format: "esm",
-    outfile,
-    platform: "node",
-    target: "ES2023",
-    treeShaking: true
-  });
-  if (result.errors.length > 0) {
-    console.error("Error building config file: ", filename);
-    throw result.errors;
-  }
-  try {
-    return await import(outfile);
-  } catch (error) {
-    console.error("Failed importing build config file: ", filename);
-    throw error;
-  }
-};
-var buildSchema = async ({
-  directory,
-  external
-}) => {
-  log.info(logPrefix, "Building schema...");
-  await fs.promises.mkdir("schema", {
-    recursive: true
-  });
-  try {
-    await fs.promises.access("schema/types.ts");
-  } catch {
-    await fs.promises.writeFile("schema/types.ts", "");
-  }
-  const schemaComposerPath = path.resolve(process.cwd(), directory, "schemaComposer.ts");
-  const {
-    schemaComposer
-  } = await importSchemaComposer({
-    external,
-    schemaComposerPath
-  });
-  const sdl = schemaComposer.toSDL();
-  const codegenConfig = {
-    documents: [],
-    config: {
-      declarationKind: {
-        type: "interface",
-        interface: "interface"
-      },
-      namingConvention: "keep"
-    },
-    filename: "schema/types.ts",
-    schema: parse(sdl),
-    plugins: [{
-      typescript: {}
-    }],
-    pluginMap: {
-      typescript: typescriptPlugin
-    }
-  };
-  await fs.promises.writeFile("schema/schema.graphql", sdl);
-  log.info(logPrefix, "Generating types...");
-  const typesOutput = await codegen(codegenConfig);
-  const typesOutputIgnore = ["/* eslint-disable */"].join("\n");
-  await fs.promises.writeFile("schema/types.ts", `${typesOutputIgnore}
-${typesOutput}`);
-  log.info(logPrefix, "Schema and types generated!");
-};
-var program = new Command();
-program.name("ttoss-graphql-api").version(package_default.version, "-v, --version", "Output the current version of the GraphQL API");
-program.command("build-schema").option("-d, --directory <directory>", "Schema composer directory", "src").option("--external <external...>", "External dependencies to ignore during build").action(options => {
-  return buildSchema(options);
-});
-program.parse(process.argv);