Merge pull request #21 from Contentstack-Solutions/fix/global_field

fix: added support to create global fields type uniquely for all fields

Author: abhinav-from-contentstack

package.json

@@ -1,7 +1,7 @@
 {
   "name": "contentstack-cli-tsgen",
   "description": "Generate TypeScript typings from a Stack.",
-  "version": "1.0.14",
+  "version": "2.0.0",
   "author": "Michael Davis",
   "bugs": "https://github.com/Contentstack-Solutions/contentstack-cli-tsgen/issues",
   "dependencies": {

src/commands/tsgen.ts

@@ -1,5 +1,6 @@
 import {Command, flags} from '@contentstack/cli-command'
-import {stackConnect, StackConnectionConfig} from '../lib/stack/client'
+import {getGlobalFields, stackConnect, StackConnectionConfig} from '../lib/stack/client'
+import {ContentType} from '../lib/stack/schema'
 import tsgenRunner from '../lib/tsgen/runner'
 
 export default class TypeScriptCodeGeneratorCommand extends Command {
@@ -69,10 +70,19 @@ export default class TypeScriptCodeGeneratorCommand extends Command {
         environment: token.environment || '',
       }
 
-      const client = await stackConnect(this.deliveryAPIClient.Stack, config)
+      const [client, globalFields] = await Promise.all([stackConnect(this.deliveryAPIClient.Stack, config), getGlobalFields(config)])
 
-      if (client.types) {
-        const result = await tsgenRunner(outputPath, client.types, prefix, includeDocumentation)
+      let schemas: ContentType[] = []
+      if (client.types?.length) {
+        if ((globalFields as any)?.global_fields?.length) {
+          schemas = schemas.concat((globalFields as any).global_fields as ContentType)
+          schemas = schemas.map(schema => ({
+            ...schema,
+            schema_type: 'global_field',
+          }))
+        }
+        schemas = schemas.concat(client.types)
+        const result = await tsgenRunner(outputPath, schemas, prefix, includeDocumentation)
         this.log(`Wrote ${result.definitions} Content Types to '${result.outputPath}'.`)
       } else {
         this.log('No Content Types exist in the Stack.')

src/lib/stack/client.ts

@@ -1,3 +1,16 @@
+import * as http from 'https'
+
+type RegionUrlMap = {
+  [prop: string]: string;
+};
+
+const REGION_URL_MAPPING: RegionUrlMap = {
+  na: 'cdn.contentstack.io',
+  us: 'cdn.contentstack.io',
+  eu: 'eu-cdn.contentstack.com',
+  'azure-na': 'azure-na-cdn.contentstack.com',
+}
+
 export type StackConnectionConfig = {
   apiKey: string;
   token: string;
@@ -34,3 +47,41 @@ export async function stackConnect(client: any, config: StackConnectionConfig) {
     )
   }
 }
+
+// Currently delivery sdk does not support querying global fields on a stack. Hence direct call is required.
+export async function getGlobalFields(config: StackConnectionConfig) {
+  try {
+    return new Promise((resolve, reject) => {
+      const options: any = {
+        host: (REGION_URL_MAPPING as any)[config.region],
+        path: 'v3/global_fields?include_branch=false',
+        port: 443,
+        method: 'GET',
+        headers: {
+          api_key: config.apiKey,
+          access_token: config.token,
+        },
+      }
+      const req = http.request(options, res => {
+        res.setEncoding('utf8')
+        let body = ''
+        res.on('data', chunk => {
+          body += chunk
+        })
+        res.on('end', () => {
+          if (res.statusCode === 200) {
+            resolve(JSON.parse(body))
+          } else {
+            reject(body)
+          }
+        })
+      })
+      req.on('error', error => {
+        reject(error)
+      })
+      req.end()
+    })
+  } catch (error) {
+    throw new Error('Could not connect to the stack. Please check your credentials.')
+  }
+}

src/lib/stack/schema.ts

@@ -21,6 +21,7 @@ export type FieldOptions = {
 export type Block = {
   title: string;
   schema: Schema;
+  reference_to?: string;
 } & Identifier;
 
 export type GlobalField = {
@@ -55,4 +56,7 @@ export type ContentType = {
   description: string;
   schema: Schema;
   _version: number;
+  reference_to?: string;
+  data_type?: string;
+  schema_type?: string;
 } & Identifier;

src/lib/tsgen/factory.ts

@@ -89,10 +89,11 @@ export default function (userOptions: TSGenOptions) {
     if (flag === TypeFlags.BuiltinJS) {
       visitedJSTypes.add(type)
     } else if (flag === TypeFlags.UserGlobalField) {
-      visitedGlobalFields.add(type)
+      const _type = name_type(field.reference_to)
+      visitedGlobalFields.add(_type)
 
-      if (!cachedGlobalFields[type]) {
-        cachedGlobalFields[type] = {
+      if (!cachedGlobalFields[_type]) {
+        cachedGlobalFields[_type] = {
           definition: visit_content_type(field),
         }
       }
@@ -116,7 +117,7 @@ export default function (userOptions: TSGenOptions) {
   function define_interface(
     contentType: ContentstackTypes.ContentType | ContentstackTypes.GlobalField
   ) {
-    return ['export interface', name_type(contentType.uid)].join(' ')
+    return ['export interface', name_type(contentType.data_type === 'global_field' ? (contentType.reference_to as string) : contentType.uid)].join(' ')
   }
 
   function op_array(type: string, field: ContentstackTypes.Field) {
@@ -195,9 +196,13 @@ export default function (userOptions: TSGenOptions) {
   }
 
   function visit_field(field: ContentstackTypes.Field) {
+    let fieldType = ''
+    if (field.data_type === 'global_field' && cachedGlobalFields[name_type(field.reference_to)]) {
+      fieldType = name_type(field.reference_to)
+    }
     return [
       field.uid + op_required(field.mandatory) + ':',
-      visit_field_type(field) + ';',
+      fieldType || visit_field_type(field) + ';',
     ].join(' ')
   }
 
@@ -231,9 +236,7 @@ export default function (userOptions: TSGenOptions) {
   ) {
     return (
       '{' +
-      [block.uid + ':', '{' + visit_fields(block.schema || []) + '};'].join(
-        ' '
-      ) +
+      [block.uid + ':', block.reference_to ? name_type(block.reference_to as string) + ';' : '{' + visit_fields(block.schema || []) + '};'].join(' ') +
       visit_block_names(field, block) +
       '}'
     )
@@ -276,7 +279,7 @@ export default function (userOptions: TSGenOptions) {
       )
     }
 
-    const name = name_type(field.uid)
+    const name = name_type(field.reference_to)
 
     return name
   }
@@ -293,7 +296,19 @@ export default function (userOptions: TSGenOptions) {
     return ['(', references.join(' | '), ')', '[]'].join('')
   }
 
-  return function (contentType: ContentstackTypes.ContentType): TSGenResult {
+  return function (contentType: ContentstackTypes.ContentType): TSGenResult|any {
+    if (contentType.schema_type === 'global_field') {
+      const name = name_type(contentType.uid)
+      if (!cachedGlobalFields[name]) {
+        cachedGlobalFields[name] = {
+          definition: visit_content_type(contentType),
+        }
+      }
+      return {
+        definition: cachedGlobalFields[name].definition,
+        isGlobalField: true,
+      }
+    }
     return {
       definition: visit_content_type(contentType),
       metadata: {

src/lib/tsgen/runner.ts

@@ -43,11 +43,15 @@ export default async function tsgenRunner(outputFile: string, contentTypes: any[
   for (const contentType of contentTypes) {
     const tsgenResult = tsgen(contentType)
 
-    definitions.push(tsgenResult.definition)
+    if (tsgenResult.isGlobalField) {
+      globalFields.add(tsgenResult.definition)
+    } else {
+      definitions.push(tsgenResult.definition)
 
-    tsgenResult.metadata.types.globalFields.forEach((field: string) => {
-      globalFields.add(tsgenResult.metadata.dependencies.globalFields[field].definition)
-    })
+      tsgenResult.metadata.types.globalFields.forEach((field: string) => {
+        globalFields.add(tsgenResult.metadata.dependencies.globalFields[field].definition)
+      })
+    }
   }
 
   const output = await format(