@ttoss/graphql-api 0.4.6 → 0.5.0

package/README.md

@@ -140,7 +140,7 @@ _We inspired ourselves on [graphql-compose-relay](https://graphql-compose.github
 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';
+import { composeWithConnection } from '@ttoss/graphql-api';
 
 AuthorTC.addResolver({
   name: 'findMany',
@@ -190,7 +190,7 @@ schemaComposer.Query.addFields({
 });
 ```
 
-When you `composeWithConnection` a type, it will add the resolver `connection` to the type, so you can add to `Query` or any other type:
+When you `composeWithConnection` a type composer, it will add the resolver `connection` to the type composer, so you can add to `Query` or any other type composer. For example:
 
 ```ts
 schemaComposer.Query.addFields({
@@ -204,6 +204,8 @@ The resolver `connection` has the following arguments based on the [Relay Connec
 - `after`: the cursor to start the query.
 - `last`: the number of nodes to return.
 - `before`: the cursor to start the query.
+- `limit`: the limit of nodes to return. It's the `first` or `last` argument plus one. It's used to know if there are more nodes to return to set `hasNextPage` or `hasPreviousPage` [PageInfo](https://relay.dev/graphql/connections.htm#sec-undefined.PageInfo) fields. For example, if `first` is `10`, `limit` will be `11`. If the resolver returns `11` nodes, the resolver will return `10` but it knows there are more nodes to return, so `hasNextPage` will be `true`.
+- `skip`: it's the `count` minus `last`. It only works on [backward pagination](https://relay.dev/graphql/connections.htm#sec-Backward-pagination-arguments).
 - `sort`: the sort option to use. It's the keys of the `sort` object. In our example, it's `ASC` and `DESC`.
 - `filter`: the filter to use. It'll exist if you add the `filter` to `findManyResolver` for example, the implementation below will add the `filter` argument with the `name` and `book` fields:
 
@@ -249,10 +251,14 @@ The resolver that will be used to find the nodes. It receives the following argu
         after?: string;
         last?: number;
         before?: string;
+        /**
+         * It's the `first` or `last` argument plus one.
+         */
+        limit: number;
         /**
          * The `filter` argument, if provided on the query.
          */
-        filter: {
+        filter?: {
           name: string;
           book: string;
         };
@@ -278,6 +284,8 @@ The resolver that will be used to find the nodes. It receives the following argu
 
 #### `countResolver`
 
+The resolver that will be used to count the nodes.
+
 #### `sort`
 
 It's an object that defines the sort options. Each key is the sort name and the value is an object with the following properties:
@@ -383,16 +391,22 @@ As Relay needs an introspection query to work, this package provides a way to bu
 ttoss-graphl-api build-schema
 ```
 
-You can add the `build` script to your `package.json`:
+You can add the `build-schema` script to your `package.json`:
 
 ```json
 {
   "scripts": {
-    "build": "ttoss-graphl-api build-schema"
+    "build-schema": "ttoss-graphl-api build-schema"
   }
 }
 ```
 
+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
+```
+
 ## 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/cli.js

@@ -31,6 +31,7 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var typescriptPlugin = __toESM(require("@graphql-codegen/typescript"));
 var import_core = require("@graphql-codegen/core");
+var import_helpers = require("yargs/helpers");
 var import_graphql = require("graphql");
 var import_ts_node = require("ts-node");
 var import_npmlog = __toESM(require("npmlog"));
@@ -43,46 +44,57 @@ var logPrefix = "graphql-api";
     moduleResolution: "NodeNext"
   }
 });
-var argv = (0, import_yargs.default)(process.argv.slice(2)).argv;
-(async () => {
-  if (argv._.includes("build-schema")) {
-    import_npmlog.default.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 {
-      schemaComposer
-    } = require(path.resolve(process.cwd(), "src", "schemaComposer.ts"));
-    const sdl = schemaComposer.toSDL();
-    const codegenConfig = {
-      documents: [],
-      config: {
-        declarationKind: {
-          type: "interface",
-          interface: "interface"
-        },
-        namingConvention: "keep"
+var buildSchema = async ({
+  directory
+}) => {
+  import_npmlog.default.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 {
+    schemaComposer
+  } = require(path.resolve(process.cwd(), directory, "schemaComposer.ts"));
+  const sdl = schemaComposer.toSDL();
+  const codegenConfig = {
+    documents: [],
+    config: {
+      declarationKind: {
+        type: "interface",
+        interface: "interface"
       },
-      filename: "schema/types.ts",
-      schema: (0, import_graphql.parse)(sdl),
-      plugins: [{
-        typescript: {}
-      }],
-      pluginMap: {
-        typescript: typescriptPlugin
-      }
-    };
-    await fs.promises.writeFile("schema/schema.graphql", sdl);
-    import_npmlog.default.info(logPrefix, "Generating types...");
-    const typesOutput = await (0, import_core.codegen)(codegenConfig);
-    const typesOutputIgnore = ["/* eslint-disable */"].join("\n");
-    await fs.promises.writeFile("schema/types.ts", `${typesOutputIgnore}
+      namingConvention: "keep"
+    },
+    filename: "schema/types.ts",
+    schema: (0, import_graphql.parse)(sdl),
+    plugins: [{
+      typescript: {}
+    }],
+    pluginMap: {
+      typescript: typescriptPlugin
+    }
+  };
+  await fs.promises.writeFile("schema/schema.graphql", sdl);
+  import_npmlog.default.info(logPrefix, "Generating types...");
+  const typesOutput = await (0, import_core.codegen)(codegenConfig);
+  const typesOutputIgnore = ["/* eslint-disable */"].join("\n");
+  await fs.promises.writeFile("schema/types.ts", `${typesOutputIgnore}
 ${typesOutput}`);
-    import_npmlog.default.info(logPrefix, "Schema and types generated!");
-  }
-})();
+  import_npmlog.default.info(logPrefix, "Schema and types generated!");
+};
+(0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).command("build-schema", "fetch the contents of the URL", yargs2 => {
+  return yargs2.options({
+    directory: {
+      alias: ["d"],
+      type: "string",
+      describe: "Schema composer directory relative to the project root",
+      default: "src"
+    }
+  });
+}, argv => {
+  return buildSchema(argv);
+}).demandCommand(1).strictOptions().parse();

package/dist/esm/cli.js

@@ -6,6 +6,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import { codegen } from "@graphql-codegen/core";
+import { hideBin } from "yargs/helpers";
 import { parse } from "graphql";
 import { register } from "ts-node";
 import log from "npmlog";
@@ -18,46 +19,57 @@ register({
     moduleResolution: "NodeNext"
   }
 });
-var argv = yargs(process.argv.slice(2)).argv;
-(async () => {
-  if (argv._.includes("build-schema")) {
-    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 {
-      schemaComposer
-    } = __require(path.resolve(process.cwd(), "src", "schemaComposer.ts"));
-    const sdl = schemaComposer.toSDL();
-    const codegenConfig = {
-      documents: [],
-      config: {
-        declarationKind: {
-          type: "interface",
-          interface: "interface"
-        },
-        namingConvention: "keep"
+var buildSchema = async ({
+  directory
+}) => {
+  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 {
+    schemaComposer
+  } = __require(path.resolve(process.cwd(), directory, "schemaComposer.ts"));
+  const sdl = schemaComposer.toSDL();
+  const codegenConfig = {
+    documents: [],
+    config: {
+      declarationKind: {
+        type: "interface",
+        interface: "interface"
       },
-      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}
+      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!");
-  }
-})();
+  log.info(logPrefix, "Schema and types generated!");
+};
+yargs(hideBin(process.argv)).command("build-schema", "fetch the contents of the URL", yargs2 => {
+  return yargs2.options({
+    directory: {
+      alias: ["d"],
+      type: "string",
+      describe: "Schema composer directory relative to the project root",
+      default: "src"
+    }
+  });
+}, argv => {
+  return buildSchema(argv);
+}).demandCommand(1).strictOptions().parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/graphql-api",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "A library for building GraphQL APIs using ttoss ecosystem.",
   "author": "ttoss",
   "contributors": [
@@ -39,7 +39,7 @@
     "graphql-middleware": "^6.1.35",
     "graphql-shield": "^7.6.5",
     "npmlog": "^7.0.1",
-    "ts-node": "^10.9.1",
+    "ts-node": "^10.9.2",
     "yargs": "^17.7.2"
   },
   "peerDependencies": {
@@ -50,7 +50,7 @@
     "graphql": "^16.8.1",
     "jest": "^29.7.0",
     "tsup": "^8.0.1",
-    "@ttoss/config": "^1.31.3"
+    "@ttoss/config": "^1.31.4"
   },
   "keywords": [
     "api",

package/src/cli.ts

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as typescriptPlugin from '@graphql-codegen/typescript';
 import { codegen } from '@graphql-codegen/core';
+import { hideBin } from 'yargs/helpers';
 import { parse } from 'graphql';
 import { register } from 'ts-node';
 import log from 'npmlog';
@@ -17,70 +18,87 @@ register({
   },
 });
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const argv: any = yargs(process.argv.slice(2)).argv;
+const buildSchema = async ({ directory }: { directory: string }) => {
+  log.info(logPrefix, 'Building schema...');
 
-(async () => {
-  if (argv._.includes('build-schema')) {
-    log.info(logPrefix, 'Building schema...');
+  await fs.promises.mkdir('schema', { recursive: true });
 
-    await fs.promises.mkdir('schema', { recursive: true });
-
-    /**
-     * Create schema/types.ts if it doesn't exist. We need to do this because
-     * graphql-codegen will throw an error if the file doesn't exist and the
-     * code import the types from that file.
-     */
-    try {
-      await fs.promises.access('schema/types.ts');
-    } catch {
-      await fs.promises.writeFile('schema/types.ts', '');
-    }
+  /**
+   * Create schema/types.ts if it doesn't exist. We need to do this because
+   * graphql-codegen will throw an error if the file doesn't exist and the
+   * code import the types from that file.
+   */
+  try {
+    await fs.promises.access('schema/types.ts');
+  } catch {
+    await fs.promises.writeFile('schema/types.ts', '');
+  }
 
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { schemaComposer } = require(
-      path.resolve(process.cwd(), 'src', 'schemaComposer.ts')
-    );
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const { schemaComposer } = require(
+    path.resolve(process.cwd(), directory, 'schemaComposer.ts')
+  );
 
-    const sdl = schemaComposer.toSDL();
+  const sdl = schemaComposer.toSDL();
 
-    /**
-     * https://the-guild.dev/graphql/codegen/docs/advanced/programmatic-usage
-     */
-    const codegenConfig = {
-      documents: [],
-      config: {
-        declarationKind: {
-          type: 'interface',
-          interface: 'interface',
-        },
-        namingConvention: 'keep',
+  /**
+   * https://the-guild.dev/graphql/codegen/docs/advanced/programmatic-usage
+   */
+  const codegenConfig = {
+    documents: [],
+    config: {
+      declarationKind: {
+        type: 'interface',
+        interface: 'interface',
       },
-      filename: 'schema/types.ts',
-      schema: parse(sdl),
-      plugins: [
-        {
-          typescript: {},
-        },
-      ],
-      pluginMap: {
-        typescript: typescriptPlugin,
+      namingConvention: 'keep',
+    },
+    filename: 'schema/types.ts',
+    schema: parse(sdl),
+    plugins: [
+      {
+        typescript: {},
       },
-    };
+    ],
+    pluginMap: {
+      typescript: typescriptPlugin,
+    },
+  };
 
-    await fs.promises.writeFile('schema/schema.graphql', sdl);
+  await fs.promises.writeFile('schema/schema.graphql', sdl);
 
-    log.info(logPrefix, 'Generating types...');
+  log.info(logPrefix, 'Generating types...');
 
-    const typesOutput = await codegen(codegenConfig);
+  const typesOutput = await codegen(codegenConfig);
 
-    const typesOutputIgnore = ['/* eslint-disable */'].join('\n');
+  const typesOutputIgnore = ['/* eslint-disable */'].join('\n');
 
-    await fs.promises.writeFile(
-      'schema/types.ts',
-      `${typesOutputIgnore}\n${typesOutput}`
-    );
+  await fs.promises.writeFile(
+    'schema/types.ts',
+    `${typesOutputIgnore}\n${typesOutput}`
+  );
 
-    log.info(logPrefix, 'Schema and types generated!');
-  }
-})();
+  log.info(logPrefix, 'Schema and types generated!');
+};
+
+yargs(hideBin(process.argv))
+  .command(
+    'build-schema',
+    'fetch the contents of the URL',
+    (yargs) => {
+      return yargs.options({
+        directory: {
+          alias: ['d'],
+          type: 'string',
+          describe: 'Schema composer directory relative to the project root',
+          default: 'src',
+        },
+      });
+    },
+    (argv) => {
+      return buildSchema(argv);
+    }
+  )
+  .demandCommand(1)
+  .strictOptions()
+  .parse();