fix(marketplace): use new Backstage lazy loading function (#583)

* Revert "fix(marketplace-cli): use CJS imports instead of ESM to fix double-encapsulation import issue (#577)"

This reverts commit 5a99fdd.

* fix(marketplace-cli): use new Backstage `lazy` loading function

Author: logonoff

workspaces/marketplace/.changeset/angry-cougars-punch.md

@@ -0,0 +1,5 @@
+---
+'@red-hat-developer-hub/marketplace-cli': patch
+---
+
+use new Backstage `lazy` loading function

workspaces/marketplace/packages/cli/src/commands/index.ts

@@ -14,31 +14,13 @@
  * limitations under the License.
  */
 import { Command } from 'commander';
-import { exitWithError } from '../lib/errors';
-import { assertError } from '@backstage/errors';
-
-// Wraps an action function so that it always exits and handles errors
-function lazy(
-  getActionFunc: () => Promise<(...args: any[]) => Promise<void>>,
-): (...args: any[]) => Promise<never> {
-  return async (...args: any[]) => {
-    try {
-      const actionFunc = await getActionFunc();
-      await actionFunc(...args);
-
-      process.exit(0);
-    } catch (error) {
-      assertError(error);
-      exitWithError(error);
-    }
-  };
-}
+import { lazy } from '../lib/lazy';
 
 export const registerCommands = (program: Command) => {
   program
     .command('init')
     .description('init')
-    .action(lazy(() => require('./init').default));
+    .action(lazy(() => import('./init'), 'default'));
 
   program
     .command('generate')
@@ -58,14 +40,14 @@ export const registerCommands = (program: Command) => {
       'metadata.namespace for the generated Package entities',
     )
     .option('--owner [owner]', 'spec.owner for the generated Package entities')
-    .action(lazy(() => require('./generate').default));
+    .action(lazy(() => import('./generate'), 'default'));
 
   program
     .command('verify')
     .description(
       'Verify a set of marketplace entities. By default, it will read entities from the standard input',
     )
-    .action(lazy(() => require('./verify').default));
+    .action(lazy(() => import('./verify'), 'default'));
 
   program
     .command('export-csv')
@@ -87,5 +69,5 @@ export const registerCommands = (program: Command) => {
       'The type of CSV to export. Can be one of: "plugin", "package", or "all". "all" will generate two files.',
       'all',
     )
-    .action(lazy(() => require('./export-csv').default));
+    .action(lazy(() => import('./export-csv'), 'default'));
 };

workspaces/marketplace/packages/cli/src/lib/lazy.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// taken from https://github.com/backstage/backstage/blob/master/packages/cli/src/lib/lazy.ts
+
+import { assertError } from '@backstage/errors';
+import { exitWithError } from './errors';
+
+type ActionFunc = (...args: any[]) => Promise<void>;
+type ActionExports<TModule extends object> = {
+  [KName in keyof TModule as TModule[KName] extends ActionFunc
+    ? KName
+    : never]: TModule[KName];
+};
+
+// Wraps an action function so that it always exits and handles errors
+export function lazy<TModule extends object>(
+  moduleLoader: () => Promise<TModule>,
+  exportName: keyof ActionExports<TModule>,
+): (...args: any[]) => Promise<never> {
+  return async (...args: any[]) => {
+    try {
+      const mod = await moduleLoader();
+      const actualModule = (
+        mod as unknown as { default: ActionExports<TModule> }
+      ).default;
+      const actionFunc = actualModule[exportName] as ActionFunc;
+      await actionFunc(...args);
+
+      process.exit(0);
+    } catch (error) {
+      assertError(error);
+      exitWithError(error);
+    }
+  };
+}