test (#71)

Co-authored-by: TyagiSunny <[email protected]>

packages/backend/package.json

@@ -39,7 +39,7 @@
     "@backstage/plugin-techdocs-backend": "^1.6.2",
     "@gitbeaker/node": "^34.6.0",
     "@octokit/rest": "^18.5.3",
-    "@sourceloop/cli": "^4.2.1",
+    "@sourceloop/cli": "^5.0.1",
     "app": "link:../app",
     "better-sqlite3": "^8.0.0",
     "dockerode": "^3.3.1",

packages/backend/src/plugins/sourceloop-extension.ts

@@ -1,7 +1,7 @@
 import { createTemplateAction } from '@backstage/plugin-scaffolder-node';
-import { container } from '../utils/container';
-import { WorkerPool } from 'workerpool';
-import { POOL } from '../keys';
+
+
+const utils=require('../utils');
 
 export function createExtensionAction() {
   return createTemplateAction({
@@ -21,15 +21,30 @@ export function createExtensionAction() {
       },
     },
     async handler(ctx: any) {
+
       const extensions = ctx.input.extensions;
+      const cwd=ctx.workspacePath;
       if (extensions) {
-        const pool = container.get<WorkerPool>(POOL);
-        const promises = extensions.map((extension: { name: string }) =>
-          pool.exec('extension', [extension.name, ctx.workspacePath]),
-        );
+        const promises = extensions.map(async (extension: { name: string }) =>{
+
+          const name=extension.name;
+          const env = utils.getEnv(cwd, 'extension');
+          const originalCwd = process.cwd();
+          process.chdir(cwd);
+          await utils.runWithEnv(env, 'extension', [name, '-y'], {
+            name,
+            config: JSON.stringify({
+              applicationName: name,
+              description: `${name} extension`,
+              ...utils.buildOptions,
+            }),
+          });
+          process.chdir(originalCwd);
+        });
         await Promise.all(promises);
         ctx.logger.info('Done generating all extensions.');
       }
+
     },
   });
 }

packages/backend/src/plugins/sourceloop-ms.ts

@@ -1,7 +1,6 @@
 import { createTemplateAction } from '@backstage/plugin-scaffolder-node';
-import { container } from '../utils/container';
-import { WorkerPool } from 'workerpool';
-import { POOL } from '../keys';
+
+const utils=require('../utils');
 
 export function createMicroserviceAction() {
   return createTemplateAction({
@@ -48,21 +47,64 @@ export function createMicroserviceAction() {
     },
     async handler(ctx: any) {
       const services = ctx.input.services;
-      const name = ctx.input.project;
+      const prefix = ctx.input.project;
       const databaseType = ctx.input.datasourceType;
       const sourceloop = ctx.input.sourceloop;
       const facade = ctx.input.facade;
+      const cwd=ctx.workspacePath;
       if (services) {
-        const pool = container.get<WorkerPool>(POOL);
-        await pool.exec(
-          'microservice',
-          [name, ctx.workspacePath, services, databaseType, sourceloop, facade],
-          {
-            on: (payload: {[x: string]: unknown}) => {
-              ctx.logger.info(payload.message);
-            },
-          },
-        );
+
+        const env = utils.getEnv(cwd, 'microservice');
+        const originalCwd = process.cwd();
+        process.chdir(cwd);
+        for (const service of services) {
+          if (sourceloop) {
+            ctx.logger.info(`Generating service based on ${service}`);
+            await utils.runWithEnv(env, 'microservice', [service, '-y'], {
+              uniquePrefix: prefix,
+              baseService: service,
+              datasourceType: databaseType,
+              datasourceName: 'db',
+              facade: false,
+              includeMigrations: true,
+              config: JSON.stringify({
+                applicationName: service,
+                description: `Sourceloop based ${service}`,
+                ...utils.buildOptions,
+              }),
+            });
+            ctx.logger.info('Done');
+          } else {
+            if(facade) {
+              ctx.logger.info(`Generating facade: ${service}`);
+              await utils.runWithEnv(env, 'microservice', [service.name, '-y'], {
+                uniquePrefix: prefix,
+                facade: true,
+                config: JSON.stringify({
+                  applicationName: service.name,
+                  description: `Sourceloop based ${service.name}`,
+                  ...utils.buildOptions,
+                }),
+              });
+              ctx.logger.info(`Done generating facade: ${service}`);
+            } else {
+              ctx.logger.info(`Generating microservice: ${service.name}`);
+              await utils.runWithEnv(env, 'microservice', [service.name, '-y'], {
+                uniquePrefix: prefix,
+                datasourceType: databaseType,
+                datasourceName: 'db',
+                facade: false,
+                config: JSON.stringify({
+                  applicationName: service.name,
+                  description: `Sourceloop based ${service.name}`,
+                  ...utils.buildOptions,
+                }),
+              });
+              ctx.logger.info(`Done generating microservice: ${service.name}`);
+            }
+          }
+        }
+        process.chdir(originalCwd);
         ctx.logger.info('Done generating all services.');
       }
     },

packages/backend/src/plugins/sourceloop-scaffold.ts

@@ -1,7 +1,6 @@
 import { createTemplateAction } from '@backstage/plugin-scaffolder-node';
-import { container } from '../utils/container';
-import { WorkerPool } from 'workerpool';
-import { POOL } from '../keys';
+
+const utils=require('../utils');
 
 export function createScaffoldAction() {
   return createTemplateAction({
@@ -36,15 +35,24 @@ export function createScaffoldAction() {
     },
     async handler(ctx: any) {
       ctx.logger.info(`Templating using Yeoman generator: ${ctx.input.name}`);
-      const pool = container.get<WorkerPool>(POOL);
-
-      await pool.exec('scaffold', [
-        ctx.input.name,
-        ctx.workspacePath,
-        ctx.input.issuePrefix,
-        ctx.input.repoUrl.owner,
-        ctx.input.description,
-      ]);
+
+      const name= ctx.input.name;
+      const cwd=ctx.workspacePath;
+      const issuePrefix=ctx.input.issuePrefix;
+      const owner=ctx.input.repoUrl.owner;
+      const description=ctx.input.description;
+      const env = utils.getEnv(cwd, 'scaffold');
+      const originalCwd = process.cwd();
+      process.chdir(cwd);
+      await utils.runWithEnv(env, 'scaffold', [], {
+        name,
+        cwd,
+        issuePrefix,
+        owner,
+        description,
+        integrateWithBackstage: true,
+      });
+      process.chdir(originalCwd);
     },
   });
 }

packages/backend/src/utils.ts

@@ -0,0 +1,45 @@
+// import yeomanenv from 'yeoman-environment';
+const yeomanenv = require('yeoman-environment');
+
+
+async function yeomanRun(workspace: string, name: string, args: string[] | undefined, opts: any) {
+  const env = getEnv(workspace, name);
+  await runWithEnv(env, name, args, opts);
+}
+
+function getEnv(workspace: string, name: string) {
+  const env = yeomanenv.createEnv([], { cwd: workspace });
+  registerGenerators(env, name);
+  return env;
+}
+
+async function runWithEnv(env: any, name: string, args: string[] | undefined, opts: any) {
+  const yeomanArgs = [`sl:${name}`, ...(args ?? [])];
+  return env.run(yeomanArgs, opts);
+}
+
+async function registerGenerators(env: any, generator: string) {
+  env.register(
+    require.resolve(`@sourceloop/cli/lib/generators/${generator}/index`),
+    `sl:${generator}`,
+  );
+}
+
+const buildOptions = {
+  loopbackBuild: true,
+  eslint: true,
+  prettier: true,
+  mocha: true,
+  vscode: true,
+  docker: true,
+  repositories: true,
+  services: true,
+};
+
+export {
+  yeomanRun,
+  getEnv,
+  runWithEnv,
+  registerGenerators,
+  buildOptions,
+};