@toptal/davinci-graphql-codegen 0.1.1-alpha-feature-comm-620-graphql-codegen.1420 → 0.1.1-alpha-feature-comm-620-graphql-codegen.1441

package/README.md

@@ -1,73 +1,68 @@
-# 🛠   Generating Operation Types
+# ⚛ GraphQL Codegen
 
-In order to generate operation types for your GraphQL Gateway, you'd need to add this library as a dependency on your app/host/lib and the GraphQL schemas lib dependency too:
+GraphQL Codegen is a library developed by Toptal with the idea in mind of improving DX when generating types for your application. Easy to configure (almost no-config) and extend, and easy to import and use. With this library you'd be able to generate types for all your schemas without worring much about implementation details, and if you need to customize or use a specific plugin to suit your needs, it would be piece of cake just by adding the plugin name to the config (package specific or global).
 
-```
-yarn workspace @toptal/modularity-template-my-lib add @toptal/modularity-template-codegen@0.0.1 @toptal/modularity-template-graphql@0.0.1 @graphql-typed-document-node/core
-```
+# 🛠 Generating Schema Types
 
-_PS: Note that we specify the package version, otherwise, yarn will throw you an error saying that it cannot find the module._
+In order to generate schema types for your GraphQL Gateway the reccomended way is that you create a `lib/graphql` package in your monorepo and create a `codegen.json` file were you will store some configuration needed for later usage. This file will contain a structure like the following<sup>1</sup>:
 
-Then add this `script` to your `package.json`.
-
-`libs/my-lib/package.json`
-```
-"codegen:operations": "codegen generate:operations"
+```json
+[
+  {
+    "schema": "gs://gqlgw-introspection/staging_talent_schema.graphql",
+    "target": "talent"
+  },
+  {
+    "schema": "gs://gqlgw-introspection/staging_staff_schema.graphql",
+    "target": "staff"
+  },
+  {
+    "schema": "gs://gqlgw-introspection/staging_lens_schema.graphql",
+    "target": "lens"
+  }
+]
 ```
 
-Then create a `codegen.json` file at the root folder of your package that contains the following data/structure:
+The array contains many objects with the following shape:
 
-```json
+```ts
 {
-  "schema": "@toptal/modularity-template-graphql/talent",
-  "documents": "src/**/*.gql"
+  schema: string
+  target: string
 }
 ```
 
-This `schema` property in the `codegen.json` file is where this utility is going to go fetch your schema to download it, parse it and then generate the appropriate typescript types for all your GraphQL operations. In this example we're telling the utility to fetch the schema from `@toptal/modularity-tempalte-graphql` which is the dependency that we have just installed and also telling it that the `schema` we would like to use is the `talent` schema. This is because we store our schemas within `lib/graphl` like so:
+The `schema` property will point to a protocol (https:// or gs://) or a relative path where the schema will be fetched from. The `target` property will indicate where the schema is going to be stored.
 
 ![Captura de pantalla 2021-10-11 a las 11 03 00](https://user-images.githubusercontent.com/9496960/136763291-7ab3f50e-17e0-4fc8-a4b5-965cc15ac0fd.png)
 
-`@toptal/modularity-template-graphql` will internally resolve to `lib/graphql`, this is a more convenient and comfortable way of working with the `lib/graphql` package and won't break implementations.
+_<sup>1</sup> *This structure might be subject to change in a future iteration of this project*_
 
-**ℹ️   Heads-up:** The `documents` property is a `glob pattern` that tells this utility where your GraphQL operations are located. Please note that this `glob pattern` does not start with `./` as we use `process.env.INIT_CWD` to resolve where this utility was launched from and therefore, using `./src/**/*.gql` will break the implementation and won't be able to resolve your files.
+After creating the package and applying the default configurations you should add Davinci as a dependency of `@toptal/modularity-template-graphql` (it's how we name this package within our monorepo to resolve to `libs/graphql`) and add this `script` to your `package.json`:
 
-# 🛠   Generating Schema Types
+```
+"generate-schema": "davinci graphql-codegen generate-schema"
+```
 
-In order to generate schema types for your GraphQL Gateway, you'd have to go to `lib/graphql` and modify the `codegen.json`. This file contains a structure like the following<sup>1</sup>:
+When you run the above command, it will iterate over the `schemas` you have configured in your `codegen.json` and then create those schemas locally for you to commit to your repo, and then make use of them for generating operation types.
+
+# 🛠 Generating Operation Types
+
+In order to generate operation types for your GraphQL Gateway, you'd need to add this `script` to your `package.json`.
 
-```json
-[
-  {
-    "schema": "https://staging.toptal.net/gateway/graphql/talent/graphql",
-    "target": "talent"
-  },
-  {
-    "schema": "https://staging.toptal.net/gateway/graphql/gateway/graphql",
-    "target": "gateway"
-  },
-  {
-    "schema": "https://staging.toptal.net/gateway/graphql/lens/graphql",
-    "target": "lens"
-  },
-  {
-    "schema": "https://staging.toptal.net/gateway/graphql/chronicles/graphql",
-    "target": "chronicles"
-  },
-  {
-    "schema": "https://staging.toptal.net/gateway/graphql/staff/graphql",
-    "target": "staff"
-  }
-]
+```
+"generate-operations": "davinci graphql-codegen generate-operations"
 ```
 
-The array contains many objects with the following shape:
+Then create a `codegen.json` file at the root folder of your package that contains the following data/structure:
 
-```ts
-schema: string;
-target: string;
+```json
+{
+  "schema": "@toptal/modularity-template-graphql/talent",
+  "documents": "src/**/*.gql"
+}
 ```
 
-The `schema` property will point to the URL where the schema will be fetched from. The `target` property will indicate where the schema is going to be store. As per the example above, your should name it the same way as your gateway, for instance: the talent gateway would have a target of "talent". Later on, as you have already read on the "Generate Operation Types" section, you'd use this target to retrieve the schemas from like so: `@toptal/modularity-template-graphql/talent`.
+The `schema` property in the `codegen.json` file is where this utility is going to go search for your schema, parse it and then generate the appropriate typescript types for all your GraphQL operations. In this example we're telling the utility to use the schema located at `@toptal/modularity-tempalte-graphql`, which is the package were we will store our schemas. In this example, `@toptal/modularity-template-graphql/talent` will resolve to `libs/graphql/talent`, but it can be any package were you'd like to store your schemas at.
 
-_<sup>1</sup> *This structure might be subject to change in a future iteration of this project*_
+The `documents` property is a `glob pattern` that tells this utility where your GraphQL operations are located. Please note that this `glob pattern` does not start with `./` as we use `process.env.INIT_CWD` to resolve where this utility was launched from and therefore, using `./src/**/*.gql` will break the implementation and won't be able to resolve your files.

package/bin/davinci-graphql-codegen.js

@@ -16,8 +16,8 @@ Commands:
 
   help [command...]                       Provides help for a given command
   exit                                    Exits application
-  generate:operations                     generate graphql operation types based off generated schemas
-  generate:schema                         generate graphql schemas
+  generate-operations                     generate graphql operation types based off generated schemas
+  generate-schema                         generate graphql schemas
   `
 )
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-graphql-codegen",
-  "version": "0.1.1-alpha-feature-comm-620-graphql-codegen.1420+772235c2",
+  "version": "0.1.1-alpha-feature-comm-620-graphql-codegen.1441+6a5ae6bf",
   "description": "Codegen",
   "author": "Toptal",
   "license": "ISC",
@@ -28,9 +28,9 @@
     "@graphql-codegen/typescript-operations": "^2.1.4",
     "@graphql-codegen/typescript-resolvers": "^2.2.1",
     "@graphql-typed-document-node/core": "^3.1.0",
-    "@toptal/davinci-cli-shared": "1.5.1-alpha-feature-comm-620-graphql-codegen.83+772235c2",
+    "@toptal/davinci-cli-shared": "1.5.1-alpha-feature-comm-620-graphql-codegen.87+6a5ae6bf",
     "chalk": "^4.1.2",
     "graphql": "^15.7.1"
   },
-  "gitHead": "772235c2a3e93c6d06cd233dc7c77a532831c83e"
+  "gitHead": "6a5ae6bf6d03c85803bd8892e2ee922df3f4f337"
 }

package/src/commands/generate-operations.js

@@ -10,7 +10,7 @@ async function codegenGenerateOperations() {
   const codegen = await readConfig()
 
   switch (operation) {
-    case 'generate:operations':
+    case 'generate-operations':
       for await (const { schema, documents } of codegen) {
         await generateOperations({
           schema,
@@ -24,7 +24,7 @@ async function codegenGenerateOperations() {
 }
 
 const codegenGenerateOperationsCreator = {
-  command: 'generate:operations',
+  command: 'generate-operations',
   description: 'generate graphql operation types based off generated schemas',
   action: () => {
     codegenGenerateOperations()

package/src/commands/generate-schema.js

@@ -11,7 +11,7 @@ async function codegenGenerateSchema() {
   const codegen = await readConfig()
 
   switch (operation) {
-    case 'generate:schema': {
+    case 'generate-schema': {
       for await (const { schema, documents, target } of codegen) {
         await generateSchema({
           schema,
@@ -28,7 +28,7 @@ async function codegenGenerateSchema() {
 }
 
 const codegenGenerateSchemaCreator = {
-  command: 'generate:schema',
+  command: 'generate-schema',
   description: 'generate graphql schemas',
   action: () => {
     codegenGenerateSchema()