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

package/LICENSE.md

@@ -0,0 +1,5 @@
+/\* Copyright (C) Toptal LLC - All Rights Reserved
+
+- Unauthorized copying of this file, via any medium is strictly prohibited
+- Proprietary and confidential
+  \*/

package/README.md

@@ -0,0 +1,73 @@
+# 🛠   Generating Operation Types
+
+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:
+
+```
+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
+```
+
+_PS: Note that we specify the package version, otherwise, yarn will throw you an error saying that it cannot find the module._
+
+Then add this `script` to your `package.json`.
+
+`libs/my-lib/package.json`
+```
+"codegen:operations": "codegen generate:operations"
+```
+
+Then create a `codegen.json` file at the root folder of your package that contains the following data/structure:
+
+```json
+{
+  "schema": "@toptal/modularity-template-graphql/talent",
+  "documents": "src/**/*.gql"
+}
+```
+
+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:
+
+![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.
+
+**ℹ️   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.
+
+# 🛠   Generating Schema Types
+
+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>:
+
+```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"
+  }
+]
+```
+
+The array contains many objects with the following shape:
+
+```ts
+schema: string;
+target: string;
+```
+
+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`.
+
+_<sup>1</sup> *This structure might be subject to change in a future iteration of this project*_

package/bin/davinci-graphql-codegen.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+const cliEngine = require('@toptal/davinci-cli-shared')
+
+const codegenGenerateSchemaCreator = require('../src/commands/generate-schema')
+const codegenGenerateOperationsCreator = require('../src/commands/generate-operations')
+
+cliEngine.loadCommands([
+  codegenGenerateSchemaCreator,
+  codegenGenerateOperationsCreator
+])
+
+cliEngine.help(
+  () => `
+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
+  `
+)
+
+const args = cliEngine.bootstrap({ use: 'minimist' })
+
+// eslint-disable-next-line @typescript-eslint/no-shadow
+cliEngine.catchErrorCommand((args, cb) => {
+  cliEngine.execCommand(`${args.commands.join(' ')}`)
+  cb()
+})
+
+if (args._ && args._.length) {
+  cliEngine.execCommand(`${args._.join(' ')}`)
+}

package/esbuild.js

@@ -0,0 +1,16 @@
+const esbuild = require('esbuild')
+// Automatically exclude all node_modules from the bundled version
+const { nodeExternalsPlugin } = require('esbuild-node-externals')
+
+esbuild
+  .build({
+    entryPoints: ['./bin/davinci-graphql-codegen.ts'],
+    outdir: 'dist-package',
+    bundle: true,
+    minify: false,
+    platform: 'node',
+    sourcemap: true,
+    target: 'node14',
+    plugins: [nodeExternalsPlugin()]
+  })
+  .catch(() => process.exit(1))

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@toptal/davinci-graphql-codegen",
+  "version": "0.1.1-alpha-feature-comm-620-graphql-codegen.1420+772235c2",
+  "description": "Codegen",
+  "author": "Toptal",
+  "license": "ISC",
+  "homepage": "https://github.com/toptal/davinci/tree/master/packages/graphql-codegen#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "davinci-graphql-codegen": "./bin/davinci-graphql-codegen.js"
+  },
+  "main": "./src/index.js",
+  "scripts": {
+    "build:package": "../../bin/build-package.js",
+    "prepublishOnly": "../../bin/prepublish.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@google-cloud/storage": "^5.16.1",
+    "@graphql-codegen/add": "^3.1.0",
+    "@graphql-codegen/cli": "^2.2.0",
+    "@graphql-codegen/introspection": "^2.1.0",
+    "@graphql-codegen/typed-document-node": "^2.1.4",
+    "@graphql-codegen/typescript": "^2.2.2",
+    "@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",
+    "chalk": "^4.1.2",
+    "graphql": "^15.7.1"
+  },
+  "gitHead": "772235c2a3e93c6d06cd233dc7c77a532831c83e"
+}

package/src/commands/generate-operations.js

@@ -0,0 +1,34 @@
+const { generateOperations } = require('../generate')
+const readConfig = require('../read-config')
+const processArgs = require('../services/process-args')
+
+const args = processArgs(process.argv.slice(2))
+const operation = args.operation
+
+// eslint-disable-next-line func-style
+async function codegenGenerateOperations() {
+  const codegen = await readConfig()
+
+  switch (operation) {
+    case 'generate:operations':
+      for await (const { schema, documents } of codegen) {
+        await generateOperations({
+          schema,
+          documents
+        })
+      }
+      break
+    default:
+      throw new Error(`❌ Unrecognized operation`)
+  }
+}
+
+const codegenGenerateOperationsCreator = {
+  command: 'generate:operations',
+  description: 'generate graphql operation types based off generated schemas',
+  action: () => {
+    codegenGenerateOperations()
+  }
+}
+
+module.exports = codegenGenerateOperationsCreator

package/src/commands/generate-schema.js

@@ -0,0 +1,38 @@
+const { generateSchema } = require('../generate')
+const readConfig = require('../read-config')
+const processArgs = require('../services/process-args')
+
+const args = processArgs(process.argv.slice(2))
+const operation = args.operation
+const projectId = args.projectId || 'toptal-hub'
+
+// eslint-disable-next-line func-style
+async function codegenGenerateSchema() {
+  const codegen = await readConfig()
+
+  switch (operation) {
+    case 'generate:schema': {
+      for await (const { schema, documents, target } of codegen) {
+        await generateSchema({
+          schema,
+          documents,
+          target,
+          projectId
+        })
+      }
+      break
+    }
+    default:
+      throw new Error(`❌ Unrecognized operation`)
+  }
+}
+
+const codegenGenerateSchemaCreator = {
+  command: 'generate:schema',
+  description: 'generate graphql schemas',
+  action: () => {
+    codegenGenerateSchema()
+  }
+}
+
+module.exports = codegenGenerateSchemaCreator

package/src/generate/index.js

@@ -0,0 +1,4 @@
+const generateOperations = require('./operations')
+const generateSchema = require('./schema')
+
+module.exports = { generateOperations, generateSchema }

package/src/generate/operations.js

@@ -0,0 +1,50 @@
+const { generate } = require('@graphql-codegen/cli')
+
+const {
+  commonOperationTypesConfig,
+  autoGenerationComments
+} = require('../shared-config/shared-config')
+const getRelativeFilePath = require('../services/get-relative-file-path')
+
+const generateOperations = async ({ schema, documents }) => {
+  const docsPath = getRelativeFilePath(documents)
+
+  // @toptal/modularity-template-graphql/talent -> talent
+  const target = schema.split('/').pop()
+  // @toptal/modularity-template-graphql/talent -> @toptal/modularity-template-graphql/talent
+  const schemaPath = schema.split('/').slice(0, 2).join('/')
+
+  await generate(
+    {
+      documents: docsPath,
+      config: {
+        ...commonOperationTypesConfig
+      },
+      generates: {
+        [schemaPath]: {
+          schema: require.resolve(`${schemaPath}/${target}/schema.graphql`),
+          preset: 'near-operation-file',
+          presetConfig: {
+            extension: '.ts',
+            baseTypesPath: `~${schema}/schema`
+          },
+          plugins: [
+            'typescript-operations',
+            'typed-document-node',
+            {
+              add: {
+                content: autoGenerationComments
+              }
+            }
+          ]
+        }
+      },
+      hooks: {
+        afterAllFileWrite: 'prettier --write'
+      }
+    },
+    true
+  )
+}
+
+module.exports = generateOperations

package/src/generate/schema.js

@@ -0,0 +1,51 @@
+const { generate } = require('@graphql-codegen/cli')
+const chalk = require('chalk')
+
+const {
+  commonSchemaTypesConfig,
+  autoGenerationComments
+} = require('../shared-config/shared-config')
+const schemaLoader = require('../services/schema-loader')
+
+const generateSchema = async ({ schema, target, projectId }) => {
+  const {
+    schema: schemaPath,
+    destination: destinationPathTs
+  } = await schemaLoader(schema, target, projectId)
+
+  console.log(`ℹ️  Generating [${chalk.green(target)}] schema`)
+
+  await generate(
+    {
+      schema: schemaPath,
+      generates: {
+        // [destinationPath]: {
+        //   plugins: ['introspection']
+        // },
+        [destinationPathTs]: {
+          schema: schema.startsWith('https://')
+            ? schema
+            : require.resolve(schemaPath),
+          plugins: [
+            'typescript',
+            'typescript-resolvers',
+            {
+              add: {
+                content: autoGenerationComments
+              }
+            }
+          ]
+        }
+      },
+      hooks: {
+        afterAllFileWrite: 'prettier --write'
+      },
+      config: {
+        ...commonSchemaTypesConfig
+      }
+    },
+    true
+  )
+}
+
+module.exports = generateSchema

package/src/index.js

@@ -0,0 +1,6 @@
+const codegenGenerateSchemaCreator = require('./commands/generate-schema')
+const codegenGenerateOperationsCreator = require('./commands/generate-operations')
+
+module.exports = {
+  commands: [codegenGenerateSchemaCreator, codegenGenerateOperationsCreator]
+}

package/src/read-config/index.js

@@ -0,0 +1,3 @@
+const readConfig = require('./read-config')
+
+module.exports = readConfig

package/src/read-config/read-config.js

@@ -0,0 +1,21 @@
+const chalk = require('chalk')
+
+const getRelativeFilePath = require('../services/get-relative-file-path')
+const toArray = require('../services/to-array')
+
+const readConfig = async () => {
+  console.log(`🔍 Searching for ${chalk.bold('codegen.json')} file`)
+  let codegenConfig
+
+  const codegenPath = getRelativeFilePath('codegen.json')
+
+  try {
+    codegenConfig = require(codegenPath)
+  } catch (error) {
+    throw new Error(`❌ There is no ${chalk.bold('codegen.json')} file`)
+  }
+
+  return toArray(codegenConfig)
+}
+
+module.exports = readConfig

package/src/services/detect-schema-source.js

@@ -0,0 +1,17 @@
+const isSchemaFromBucket = schema => {
+  return schema.startsWith('gs://')
+}
+
+const isSchemaFromHttp = schema => {
+  return schema.startsWith('https://')
+}
+
+const isLocalSchema = schema => {
+  return !isSchemaFromBucket(schema) && !isSchemaFromHttp(schema)
+}
+
+module.exports = {
+  isSchemaFromBucket,
+  isSchemaFromHttp,
+  isLocalSchema
+}

package/src/services/get-relative-file-path.js

@@ -0,0 +1,5 @@
+const getRelativeFilePath = file => {
+  return `${process.cwd()}/${file}`
+}
+
+module.exports = getRelativeFilePath

package/src/services/gs-schema-loader.js

@@ -0,0 +1,20 @@
+const { Storage } = require('@google-cloud/storage')
+
+const getRelativeFilePath = require('../services/get-relative-file-path')
+const parseGSURI = require('./parse-gs-uri')
+
+const gsSchemaLoader = async (projectId, source, destination) => {
+  // Creates a Google Storage Client
+  const storage = new Storage({ projectId })
+
+  const { bucketName, fileName } = parseGSURI(source)
+
+  await storage
+    .bucket(bucketName)
+    .file(fileName)
+    .download({
+      destination: getRelativeFilePath(destination)
+    })
+}
+
+module.exports = gsSchemaLoader

package/src/services/parse-gs-uri.js

@@ -0,0 +1,16 @@
+const parseGSURI = source => {
+  // Eg: Source Parts -> ['gqlgw-introspection', 'staging_talent_schema', '.graphql']
+  const sourceParts = source
+    .split(/(?:gs:\/\/)([a-zA-Z-]*)(?:\/)([a-zA-Z-_]*)([.a-zA-Z]*)/)
+    .filter(Boolean)
+
+  const bucketName = sourceParts[0]
+  const fileName = `${sourceParts.slice(-2).join('')}`
+
+  return {
+    bucketName,
+    fileName
+  }
+}
+
+module.exports = parseGSURI

package/src/services/process-args.js

@@ -0,0 +1,25 @@
+const processArgs = args => {
+  const obj = {}
+
+  args.forEach(arg => {
+    if (arg.includes('generate:')) {
+      obj.operation = arg
+
+      return
+    }
+
+    // Eg: Parts -> ['projectId', 'toptal-hub']
+    const parts = arg
+      .split(/(?:--)([a-zA-Z]*)(?:=)([a-zA-Z-]*)/i)
+      .filter(Boolean)
+
+    const key = parts[0]
+    const value = parts[1]
+
+    obj[key] = value
+  })
+
+  return obj
+}
+
+module.exports = processArgs

package/src/services/schema-loader.js

@@ -0,0 +1,35 @@
+const { existsSync, copyFileSync } = require('fs')
+
+const gsSchemaLoader = require('./gs-schema-loader')
+const getRelativeFilePath = require('./get-relative-file-path')
+const {
+  isSchemaFromBucket,
+  isLocalSchema,
+  isSchemaFromHttp
+} = require('./detect-schema-source')
+
+module.exports = async (schema, target, projectId) => {
+  const schemaPath = isSchemaFromHttp(schema)
+    ? schema
+    : getRelativeFilePath(`${target}/schema.graphql`)
+
+  if (isSchemaFromBucket(schema)) {
+    await gsSchemaLoader(projectId, schema, `${target}/schema.graphql`)
+  }
+
+  if (isLocalSchema(schema)) {
+    if (!existsSync(schema)) {
+      console.log(`Couldn't find a source schema file ${schema}`)
+      process.exit(1)
+    }
+    copyFileSync(schema, `${target}/schema.graphql`)
+  }
+
+  // const destinationPathJson = getRelativeFilePath(`${target}/schema.json`)
+  const destinationPathTs = getRelativeFilePath(`${target}/schema.ts`)
+
+  return {
+    schema: schemaPath,
+    destination: destinationPathTs
+  }
+}

package/src/services/to-array.js

@@ -0,0 +1,9 @@
+const toArray = value => {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  return [value]
+}
+
+module.exports = toArray

package/src/shared-config/index.js

@@ -0,0 +1,3 @@
+const sharedConfig = require('./shared-config')
+
+module.exports = sharedConfig

package/src/shared-config/shared-config.js

@@ -0,0 +1,50 @@
+const commonTypesConfig = {
+  skipTypename: true,
+  exportFragmentSpreadSubTypes: true,
+  avoidOptionals: {
+    field: true,
+    inputValue: false,
+    object: true
+  },
+  namingConvention: {
+    enumValues: 'upper-case#upperCase'
+  },
+  scalars: {
+    BigDecimal: 'string',
+    Date: 'string',
+    ISO8601Date: 'string',
+    ISO8601DateTime: 'string',
+    JobTypeEnum: 'string',
+    JSON: 'string',
+    PageSize: 'number',
+    Time: 'string',
+    TimeOfDay: 'string',
+    Upload: 'unknown'
+  }
+}
+
+const commonSchemaTypesConfig = {
+  ...commonTypesConfig,
+  resolverTypeWrapperSignature:
+    '(parent: unknown, args: any) => ({ [K in keyof Partial<T>]: TypeOrMockList<T[K]> }) | null',
+  allowParentTypeOverride: false,
+  noSchemaStitching: true,
+  optionalInfoArgument: true,
+  optionalResolveType: true
+}
+
+const commonOperationTypesConfig = {
+  ...commonTypesConfig,
+  dedupeFragments: true
+}
+
+const autoGenerationComments = [
+  '/* eslint-disable */',
+  '/* ⚠️ THIS IS AN AUTOGENERATED FILE, DO NOT EDIT ⚠️  */'
+]
+
+module.exports = {
+  commonOperationTypesConfig,
+  commonSchemaTypesConfig,
+  autoGenerationComments
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist-package",
+    "noEmit": false,
+    "paths": {}
+  }
+}