fix: added args to gen crud

packages/generator/src/cmd.ts

@@ -22,62 +22,84 @@ const chalk = require('chalk')
 const getUserResponseFromCLI: any = async (
   eligibleDatasources: dsDefinition[],
 ) => {
-  console.log(chalk.white('Select') + chalk.green(' datasource / schema') + chalk.white(' to generate CRUD APIs'))
-
-  let { value: selectedDatasource } = await cliSelect({
-    values: [
-      ...eligibleDatasources,
-      { dsName: 'For all', dsFilePath: '' },
-      { dsName: 'Cancel', dsFilePath: '' },
-    ],
-    valueRenderer: (value, selected) => {
-      if (selected) {
-        return value.dsName === 'Cancel'
-          ? chalk.red(value.dsName)
-          : chalk.blue(value.dsName)
-      } else {
-        return value.dsName
-      }
-    },
-  })
-
+  console.log(
+    chalk.white('Select') +
+      chalk.green(' datasource / schema') +
+      chalk.white(' to generate CRUD APIs'),
+  )
+  let selectedDatasource: any
+  if (process.argv[2]) {
+    selectedDatasource = eligibleDatasources.filter((item)=> (item.dsName === process.argv[2]))[0]
+  } else {
+    let { value } = await cliSelect({
+      values: [
+        ...eligibleDatasources,
+        { dsName: 'For all', dsFilePath: '' },
+        { dsName: 'Cancel', dsFilePath: '' },
+      ],
+      valueRenderer: (value, selected) => {
+        if (selected) {
+          return value.dsName === 'Cancel'
+            ? chalk.red(value.dsName)
+            : chalk.blue(value.dsName)
+        } else {
+          return value.dsName
+        }
+      },
+    })
+    selectedDatasource = value
+  }
   return { selectedDatasource, allDatasources: eligibleDatasources }
 }
 const getUserResponseFromCLIForEventsource: any = async () => {
-  const pattern = path.join(process.cwd(), 'src/eventsources/*.yaml').replace(/\\/g, '/');
+  const pattern = path
+    .join(process.cwd(), 'src/eventsources/*.yaml')
+    .replace(/\\/g, '/')
   const findApoloEventSources = async (pattern: any) => {
     return new Promise((resolve, reject) => {
       glob(pattern, (err, files) => {
         if (err) {
-          reject(err);
-          return;
+          reject(err)
+          return
         }
-        resolve(files);
-      });
-    });
-  };
-  const availableApolloEventSources: any = await findApoloEventSources(pattern);
+        resolve(files)
+      })
+    })
+  }
+  const availableApolloEventSources: any = await findApoloEventSources(pattern)
   const allEventsources = availableApolloEventSources
     .map((file: any) => path.parse(file).name)
-    .filter((name: string) => name !== "cron");
-  console.log(chalk.white('Select') + chalk.green(' eventsource') + chalk.white(' to generate CRUD APIs. Currently we are supporting')+chalk.blue(' http')+chalk.white(' and ')+chalk.blue('graphql ')+chalk.white('eventsources'))
-  let { value: selectedEventsource } = await cliSelect({
-    values: [
-      ...allEventsources,
-    ],
-    valueRenderer: (value, selected) => {
+    .filter((name: string) => name !== 'cron')
+  console.log(
+    chalk.white('Select') +
+      chalk.green(' eventsource') +
+      chalk.white(' to generate CRUD APIs. Currently we are supporting') +
+      chalk.blue(' http') +
+      chalk.white(' and ') +
+      chalk.blue('graphql ') +
+      chalk.white('eventsources'),
+  )
+  let selectedEventsource: any
+  if (process.argv[3]) {
+    selectedEventsource = process.argv[3]
+  } else {
+    let { value } = await cliSelect({
+      values: [...allEventsources],
+      valueRenderer: (value, selected) => {
+        return value
+      },
+    })
 
-      return value
+    selectedEventsource = value
+  }
 
-    },
-  })
   return selectedEventsource
 }
 
-const invokeGenerationForPrismaDS = async ({
-  dsName,
-  dsFilePath,
-}: dsDefinition, eventsource: string) => {
+const invokeGenerationForPrismaDS = async (
+  { dsName, dsFilePath }: dsDefinition,
+  eventsource: string,
+) => {
   const samplePrismaSchema = getSchemaSync(dsFilePath)
   let dmmf = await getDMMF({
     datamodel: samplePrismaSchema,
@@ -128,12 +150,10 @@ const invokeGenerationForPrismaDS = async ({
   console.log(chalk.green(`Events and Workflows are generated for ${dsName}`))
 }
 
-const invokeGenerationForElasticgraphDS = async ({
-  dsName,
-  dsFilePath,
-  dsType,
-  dsConfig,
-}: dsDefinition, eventsource: string) => {
+const invokeGenerationForElasticgraphDS = async (
+  { dsName, dsFilePath, dsType, dsConfig }: dsDefinition,
+  eventsource: string,
+) => {
   // get the backend_path from elasticgraph dsConfig
   // read all the ${backend_path}/schema/entities iterativily
   const { schema_backend } = <egDatasourceConfig>dsConfig
@@ -160,12 +180,14 @@ const invokeGenerationForElasticgraphDS = async ({
         }, {})
 
         Object.keys(entities).forEach(async (entityKey) => {
-          await elasticgraphGenerator.eventGen({
-            basePathForGeneration,
-            dataSourceName: (dsName || '').replace(/(.yml|.yaml)/, ''),
-            entityName: entityKey,
-            entityFields: entities[entityKey],
-          }, eventsource,
+          await elasticgraphGenerator.eventGen(
+            {
+              basePathForGeneration,
+              dataSourceName: (dsName || '').replace(/(.yml|.yaml)/, ''),
+              entityName: entityKey,
+              entityFields: entities[entityKey],
+            },
+            eventsource,
           )
 
           const METHODS: METHOD[] = ['create', 'update', 'delete', 'search']
@@ -193,7 +215,6 @@ const invokeGenerationForElasticgraphDS = async ({
 const generateCrudAPIs = async () => {
   try {
     let datasourceDir = path.join(process.cwd(), 'src', 'datasources')
-
     // find eligible datasource, as of now elasticgraph and prisma are eligible
     // for auto generation, and here onwards let's consider .prisma also as a datasource
     let eligibleDatasources = await findDatasources(datasourceDir)
@@ -202,23 +223,35 @@ const generateCrudAPIs = async () => {
       eligibleDatasources,
     )
 
-    let availableEventsource = await getUserResponseFromCLIForEventsource();
-    // console.log(eligibleeventsource)
+    let availableEventsource = await getUserResponseFromCLIForEventsource()
     if (selectedDatasource.dsName === 'For all') {
-      allDatasources.map(async (dsDefinition: dsDefinition, availableEventsource: any) => {
-        if (selectedDatasource.dsType === 'prisma') {
-          await invokeGenerationForPrismaDS(dsDefinition, availableEventsource)
-        } else {
-          console.error('No mechanism is defined to handle this kinda schema.')
-        }
-      })
+      allDatasources.map(
+        async (dsDefinition: dsDefinition, availableEventsource: any) => {
+          if (selectedDatasource.dsType === 'prisma') {
+            await invokeGenerationForPrismaDS(
+              dsDefinition,
+              availableEventsource,
+            )
+          } else {
+            console.error(
+              'No mechanism is defined to handle this kinda schema.',
+            )
+          }
+        },
+      )
     } else if (selectedDatasource.dsName === 'Cancel') {
       throw Error('Auto API generation canceled.')
     } else {
       if (selectedDatasource.dsType === 'prisma') {
-        await invokeGenerationForPrismaDS(selectedDatasource, availableEventsource)
+        await invokeGenerationForPrismaDS(
+          selectedDatasource,
+          availableEventsource,
+        )
       } else if (selectedDatasource.dsType === 'elasticgraph') {
-        await invokeGenerationForElasticgraphDS(selectedDatasource, availableEventsource)
+        await invokeGenerationForElasticgraphDS(
+          selectedDatasource,
+          availableEventsource,
+        )
       } else {
         console.error(
           "No mechanism is defined to generate API's from this kinda schema.",
@@ -232,4 +265,4 @@ const generateCrudAPIs = async () => {
 
 generateCrudAPIs().catch((error) => {
   console.log(chalk.red(error))
-})
+})