Add support to generate file inclusion for common schema also

languages/c/src/types/JSONHelpers.mjs

@@ -51,5 +51,6 @@ function getJsonContainerDefinition (schema, name, props) {
 }
 
 export {
-    getJsonContainerDefinition
+    getJsonContainerDefinition,
+    getJsonDataStructName
 }

languages/c/src/types/NativeHelpers.mjs

@@ -211,20 +211,6 @@ const generateEnum = (schema, prefix)=> {
   }
 }
 
-const getIncludeDefinitions = (json = {}, jsonData = false) => {
-  return getExternalSchemaPaths(json)
-    .map(ref => {
-      const mod = ref.split('#')[0].split('/').pop()
-      let i = `#include "Common/${capitalize(mod)}.h"`
-      if(jsonData === true) {
-        i += '\n' + `#include "JsonData_${capitalize(mod)}.h"`
-      }
-      return i
-    })
-    .filter((item, index, arr) => arr.indexOf(item) === index)
-    .concat([`#include "Firebolt/Types.h"`])
-}
-
 function getPropertyGetterSignature(method, module, paramType) {
   let m = `${capitalize(getModuleName(module))}_Get${capitalize(method.name)}`
   return `${description(method.name, method.summary)}\nuint32 ${m}( ${paramType === 'char*' ? 'FireboltTypes_StringHandle' : paramType}* ${method.result.name || method.name} )`
@@ -251,7 +237,6 @@ export {
     getIncludeGuardClose,
     getNativeType,
     getModuleName,
-    getIncludeDefinitions,
     getPropertyGetterSignature,
     getPropertySetterSignature,
     getPropertyEventCallbackSignature,

languages/c/templates/imports/default.cpp

@@ -0,0 +1 @@
+#include "JsonData_${info.title}.h"

languages/c/templates/imports/default.jsondata

@@ -0,0 +1 @@
+#include "JsonData_${info.title}.h"

languages/c/templates/modules/src/Module.cpp

@@ -16,11 +16,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "Firebolt.h"
-#include "${info.title}.h"
-#include "JsonData_${info.title}.h"
-
+#include "FireboltSDK.h"
 /* ${IMPORTS} */
+#include "${info.title}.h"
 
 namespace FireboltSDK {
     namespace ${info.title} {

languages/c/templates/schemas/include/Common/Module.h

@@ -20,6 +20,7 @@
 #define _COMMON_${info.TITLE}_H
 
 #include "Firebolt.h"
+/* ${IMPORTS} */
 
 #ifdef __cplusplus
 extern "C" {

languages/c/templates/schemas/src/JsonData_Module.h

@@ -16,6 +16,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#pragma once
+
+/* ${IMPORTS} */
+#include "Common/${info.title}.h"
+
 namespace FireboltSDK {
     namespace ${info.title} {
     // Types

languages/c/templates/schemas/src/Module_Common.cpp

@@ -16,9 +16,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "Firebolt.h"
-#include "${info.title}.h"
-#include "Common/${info.title}.h"
+#include "FireboltSDK.h"
+/* ${IMPORTS} */
 #include "JsonData_${info.title}.h"
 
 /* ${ENUMS} */

src/macrofier/engine.mjs

@@ -46,6 +46,7 @@ const _inspector = obj => {
 // getMethodSignatureParams(method, module, options = { destination: 'file.txt' })
 // getSchemaType(schema, module, options = { destination: 'file.txt', title: true })
 // getSchemaShape(schema, module, options = { name: 'Foo', destination: 'file.txt' })
+// getJsonType(schema, module, options = { name: 'Foo', prefix: '', descriptions: false, level: 0 })
 
 let types = {
   getMethodSignature: ()=>null,
@@ -133,6 +134,24 @@ const getLinkForSchema = (schema, json, { name = '' } = {}) => {
   return '#'
 }
 
+const getComponentExternalSchema = (json) => {
+  let refSchemas = []
+  if (json.components && json.components.schemas) {
+    Object.entries(json.components.schemas).forEach(([name, schema]) => {
+      let refs = getLinkedSchemaPaths(schema).map(path => getPathOr(null, path, schema))
+      refs.map(ref => {
+        let title = ''
+        if (ref.includes('x-schemas')) {
+          if (ref.split('/')[2] !== json.info.title) {
+            title = ref.split('/')[2]
+          }
+        }
+        title && !refSchemas.includes(title) ? refSchemas.push(title) : null
+      })
+    })
+  }
+  return (refSchemas)
+}
 
 // Maybe methods array of objects
 const getMethods = compose(
@@ -319,7 +338,7 @@ const generateMacros = (obj, templates, languages, options = {}) => {
   // grab the options so we don't have to pass them from method to method
   Object.assign(state, options)
 
-  const imports = generateImports(obj, templates)
+  const imports = generateImports(obj, templates, { destination : (options.destination ? options.destination : '') })
   const initialization = generateInitialization(obj, templates)
   const enums = generateEnums(obj, templates, { destination : (options.destination ? options.destination : '') })
   const eventsEnum = generateEvents(obj, templates)
@@ -345,7 +364,7 @@ const generateMacros = (obj, templates, languages, options = {}) => {
   const schemasArray = generateSchemas(obj, templates, { baseUrl: '', section: 'schemas' }).filter(s => (options.copySchemasIntoModules || !s.uri))
   const accessorsArray = generateSchemas(obj, templates, { baseUrl: '', section: 'accessors' }).filter(s => (options.copySchemasIntoModules || !s.uri))
   const schemas = schemasArray.length ? getTemplate('/sections/schemas', templates).replace(/\$\{schema.list\}/g, schemasArray.map(s => s.body).filter(body => body).join('\n')) : ''
-  const typesArray = schemasArray.filter(x => !x.enum)
+  const typesArray = schemasArray.length ? schemasArray.filter(x => !x.enum) : []
   const types = (typesArray.length ? getTemplate('/sections/types', templates).replace(/\$\{schema.list\}/g, typesArray.map(s => s.body).filter(body => body).join('\n')) : '') + methodTypes
 
   const accessors = (accessorsArray.length ? getTemplate('/sections/accessors', templates).replace(/\$\{schema.list\}/g, accessorsArray.map(s => s.body).filter(body => body).join('\n')) : '') + methodAccessors
@@ -632,7 +651,6 @@ function generateSchemas(json, templates, options) {
     if (['ListenResponse', 'ProviderRequest', 'ProviderResponse', 'FederatedResponse', 'FederatedRequest'].includes(name)) {
       return
     }    
-
     let content = getTemplate('/schemas/default', templates)
 
     if (!schema.examples || schema.examples.length === 0) {
@@ -695,11 +713,11 @@ function generateSchemas(json, templates, options) {
       if (!isDeprecatedMethod(schema)) {
         schema.params.forEach(param => {
           if (param.schema && (param.schema.type === 'object')) {
-            list.push([param.name, param.schema, '', { prefix : schema.name}])
+            list.push([param.name, param.schema, '', { prefix : schema.name }])
           }
         })
         if (schema.result.schema && (schema.result.schema.type === 'object')) {
-          list.push([schema.result.name, schema.result.schema, '', { prefix : schema.name}])
+          list.push([schema.result.name, schema.result.schema, '', { prefix : schema.name }])
         }
       }
     }
@@ -741,8 +759,8 @@ function getRelatedSchemaLinks(schema = {}, json = {}, templates = {}, options =
   return links
 }
 
-const generateImports = (json, templates) => {
-  let imports = getTemplate('/imports/default', templates)
+const generateImports = (json, templates, options = { destination: '' }) => {
+  let imports = ''
 
   if (rpcMethodsOrEmptyArray(json).length) {
     imports += getTemplate('/imports/rpc', templates)
@@ -771,11 +789,22 @@ const generateImports = (json, templates) => {
   if (methodsWithXMethodsInResult(json).length) {
     imports += getTemplate('/imports/x-method', templates)
   }
+  const suffix = options.destination.split('.').pop()
+  const prefix = options.destination.split('/').pop().split('_')[0].toLowerCase()
+
+  let template = prefix ? getTemplate(`/imports/default.${prefix}`, templates) : ''
+  if (!template) {
+    template = getTemplate(suffix ? `/imports/default.${suffix}` : '/imports/default', templates)
+  }
 
-  if (json['x-schemas'] && Object.keys(json['x-schemas']).length > 0) {
-    imports += Object.keys(json['x-schemas']).map(shared => getTemplate('/imports/default', templates).replace(/\$\{info.title\}/g, shared)).join('\n')
+  if (json['x-schemas'] && Object.keys(json['x-schemas']).length > 0 && !json.info['x-uri-titles']) {
+    imports += Object.keys(json['x-schemas']).map(shared => template.replace(/\$\{info.title\}/g, shared)).join('')
   }
 
+  let componentExternalSchema = getComponentExternalSchema(json)
+  if (componentExternalSchema.length && json.info['x-uri-titles']) {
+    imports += componentExternalSchema.map(shared => template.replace(/\$\{info.title\}/g, shared)).join('')
+  }
   return imports
 }
 
@@ -1019,9 +1048,8 @@ function insertMethodMacros(template, methodObj, json, templates, examples={}) {
   const pullsResultType = pullsResult && types.getSchemaShape(pullsResult, json, { destination: state.destination, section: state.section })
   const pullsForType = pullsResult && types.getSchemaType(pullsResult, json, { destination: state.destination, section: state.section  })
   const pullsParamsType = pullsParams ? types.getSchemaShape(pullsParams, json, { destination: state.destination, section: state.section  }) : ''
- 
+
   let seeAlso = ''
-
   if (isPolymorphicPullMethod(methodObj) && pullsForType) {
     seeAlso = `See also: [${pullsForType}](#${pullsForType.toLowerCase()}-1)` // this assumes the schema will be after the method...
   }

src/shared/typescript.mjs

@@ -327,7 +327,7 @@ function getSchemaShape(schema = {}, module = {}, { name = '', level = 0, title,
   function getJsonType(schema, module, { destination, link = false, title = false, code = false, asPath = false, event = false, expandEnums = true, baseUrl = '' } = {}) {
     return ''
   }
-  
+
   function getTypeScriptType(jsonType) {
     if (jsonType === 'integer') {
       return 'number'