@axinom/mosaic-cli 0.14.2-rc.8 → 0.15.0-rc.0

package/src/commands/create-extension-config/create-extension-config.ts

@@ -0,0 +1,92 @@
+import { exec } from 'child_process';
+import * as findNearestFile from 'find-nearest-file';
+import * as fs from 'fs';
+import * as path from 'path';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+
+/**
+ * Regex to determine version of yarn installed in project: Classic, or Modern.
+ * Required to correctly build yarn command to retrieve list of installed packages.
+ */
+const yarnClassicVersionRegex = /^1\..*$/gim;
+
+/**
+ * Regex for Mosaic libraries.
+ */
+const mosaicLibraryRegex =
+  /(?<prefix>@axinom\/mosaic-)(?<library>[-A-Za-z0-9]+)/gim;
+
+/**
+ * Find all Mosaic packages used in project.
+ * @returns list of installed packages.
+ */
+const findInstalledPackages = async (): Promise<string[]> => {
+  let installedMosaicLibs: string[] = [];
+  const yarnVersionResult = await execAsync('yarn -v');
+
+  if (yarnVersionResult.stderr) {
+    console.log(yarnVersionResult.stderr);
+  }
+
+  if (yarnVersionResult.stdout) {
+    const packagesListCommand = yarnClassicVersionRegex.test(
+      yarnVersionResult.stdout,
+    )
+      ? 'yarn list --pattern @axinom/mosaic-* --depth=0'
+      : 'yarn info @axinom/mosaic-* --recursive --all --name-only';
+
+    const packagesListResult = await execAsync(packagesListCommand);
+    if (packagesListResult.stdout) {
+      installedMosaicLibs = [
+        ...new Set(packagesListResult.stdout.match(mosaicLibraryRegex) ?? []),
+      ];
+    }
+    if (packagesListResult.stderr) {
+      console.log(packagesListResult.stderr);
+    }
+  }
+  return installedMosaicLibs;
+};
+
+/**
+ * Provides path to '.mosaic' configuration file.
+ * Path to file provided based on the location of `yarn.lock`.
+ */
+export const getExtensionConfigPath = (): string => {
+  const yarnLockFilePath = findNearestFile('yarn.lock');
+  if (yarnLockFilePath) {
+    return path.resolve(path.dirname(yarnLockFilePath), '.mosaic');
+  }
+  return path.resolve('.mosaic');
+};
+
+/**
+ * Creates `.mosaic` configuration file with list of libraries, that provide extension for Mosaic CLI.
+ */
+export const createExtensionConfig = async (): Promise<void> => {
+  console.log(`Starting extension configuration generation!`);
+  const installedMosaicLibs = await findInstalledPackages();
+  const extensions: string[] = [];
+  await Promise.all(
+    installedMosaicLibs.map(async (lib: string) => {
+      //filter libraries, that have cli extension
+      try {
+        const result = await import(lib);
+        if (result.cliExtension) {
+          extensions.push(lib);
+        }
+      } catch (error) {
+        //mosaic libraries, that are always(?) failing to load:
+        //all `@axinom/mosaic-*-workflows`, @axinom/mosaic-portal, @axinom/mosaic-ui, @axinom/mosaic-home, @axinom/mosaic-id-link
+        //todo: extend regex to exclude libraries?
+      }
+    }),
+  );
+  console.log(`Modular CLI extensions: ${extensions}`);
+  //save library names, that can be used in command line
+  const configFilePath = getExtensionConfigPath();
+  const config = `CLI_EXTENSIONS=${extensions.join(',')}`;
+  fs.writeFileSync(configFilePath, config);
+  console.log(`Success! Extensions configuration file path: ${configFilePath}`);
+};

package/src/commands/create-extension-config/index.ts

@@ -0,0 +1,23 @@
+import * as dotenv from 'dotenv';
+import { CommandModule } from 'yargs';
+import {
+  createExtensionConfig,
+  getExtensionConfigPath,
+} from './create-extension-config';
+
+export const createExtensionConfigCommand: CommandModule<unknown, undefined> = {
+  command: 'create-extension-config',
+  describe:
+    'Creates Mosaic CLI configuration file, that allows to access commands from all installed Mosaic libraries through `mosaic` script.',
+  handler: createExtensionConfig,
+};
+
+export const getExtensions = (): string[] => {
+  dotenv.config({
+    path: getExtensionConfigPath(),
+  });
+  if (process.env.CLI_EXTENSIONS) {
+    return process.env.CLI_EXTENSIONS.split(',');
+  }
+  return [];
+};

package/src/commands/get-access-token/get-access-token-options.ts

@@ -0,0 +1,9 @@
+export interface GetAccessTokenOptions {
+  authEndpoint: string;
+  clientId: string;
+  clientSecret: string;
+  permissionsFile: string;
+  userEmail?: string;
+  expiration?: number;
+  failOnUnknownPermission?: boolean;
+}

package/src/commands/get-access-token/get-dev-access-token.ts

@@ -0,0 +1,32 @@
+import {
+  devGenerateUserAccessTokenWithPermissions,
+  getServiceAccountToken,
+  TokenResult,
+} from '@axinom/mosaic-id-link-be';
+import { readFileSync } from 'fs';
+import { GetAccessTokenOptions } from './get-access-token-options';
+
+/**
+ * Returns a development ID JWT token based on passed options.
+ */
+export const getDevAccessToken = async (
+  options: GetAccessTokenOptions,
+): Promise<TokenResult> => {
+  const permissions = JSON.parse(
+    readFileSync(options.permissionsFile, 'utf-8'),
+  );
+
+  const serviceAccountToken = await getServiceAccountToken(
+    options.authEndpoint,
+    options.clientId,
+    options.clientSecret,
+  );
+  return devGenerateUserAccessTokenWithPermissions(
+    options.authEndpoint,
+    serviceAccountToken.accessToken,
+    permissions,
+    options.userEmail,
+    options.expiration,
+    options.failOnUnknownPermission,
+  );
+};

package/src/commands/get-access-token/index.ts

@@ -0,0 +1,66 @@
+import { assertError } from '@axinom/mosaic-service-common';
+import * as chalk from 'chalk';
+import { CommandModule } from 'yargs';
+import { GetAccessTokenOptions } from './get-access-token-options';
+import { getDevAccessToken } from './get-dev-access-token';
+
+export const getAccessToken: CommandModule<unknown, GetAccessTokenOptions> = {
+  command: 'get-access-token',
+  describe: 'Requests a long living access token for development purposes',
+  builder: (yargs) =>
+    yargs
+      .option('permissionsFile', {
+        alias: 'f',
+        describe:
+          'A JSON file containing the wanted permission structure.\nJSON Format:\n{"serviceId" : string, "permissions": string[]}[]',
+        string: true,
+        demandOption: true,
+      })
+      .option('clientId', {
+        alias: ['i', 'devServiceAccountClientId'],
+        describe:
+          "The service account client id.\nRequired permission:\nID SERVICE -> 'Dev Generate User Access Token With Permissions'",
+        string: true,
+        demandOption: true,
+      })
+      .option('clientSecret', {
+        alias: ['s', 'devServiceAccountClientSecret'],
+        describe: 'The service account client secret.',
+        string: true,
+        demandOption: true,
+      })
+      .option('authEndpoint', {
+        alias: ['a', 'idServiceAuthBaseUrl'],
+        describe: 'The authentication service endpoint url.',
+        string: true,
+        demandOption: true,
+      })
+      .option('userEmail', {
+        alias: ['e'],
+        describe:
+          'The email of a user that exists on the environment. If unspecified, a pseudo-user will be used to generate the token for.',
+        string: true,
+      })
+      .option('failOnUnknownPermission', {
+        alias: 'u',
+        describe: 'Fails if an unknown permission is requested.',
+        boolean: true,
+        default: false,
+      })
+      .option('expiration', {
+        alias: 'x',
+        describe: 'Token expiration time in seconds.',
+        number: true,
+        default: 2592000,
+      }),
+  handler: async (options: GetAccessTokenOptions): Promise<void> => {
+    try {
+      const result = await getDevAccessToken(options);
+
+      console.log(chalk.greenBright(result.accessToken));
+    } catch (err) {
+      assertError(err);
+      console.log(chalk.red('Command failed:'), err.message);
+    }
+  },
+};

package/src/commands/graphql-diff.ts

@@ -0,0 +1,143 @@
+/** Script to check graphql schemas for breaking changes
+ *  Uses: https://www.npmjs.com/package/@graphql-inspector/core
+ *  The associated CLI tool (https://www.npmjs.com/package/@graphql-inspector/cli)
+ *  is simple to use but inflexible for our use case.
+ */
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { CriticalityLevel, diff } from '@graphql-inspector/core';
+import { green, red } from 'chalk';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import { buildSchema, GraphQLSchema } from 'graphql';
+import * as path from 'path';
+import { CommandModule } from 'yargs';
+
+interface GraphqlDiffOptions {
+  files: (string | number)[];
+  branch: string;
+  verbose: boolean;
+}
+
+export const graphqlDiff: CommandModule<unknown, GraphqlDiffOptions> = {
+  command: 'graphql-diff',
+  describe: 'Compares graphql schema(s) with git for breaking changes.',
+  builder: (yargs) =>
+    yargs
+      .options('files', {
+        alias: 'f',
+        describe:
+          'The .graphql file(s) to check. Each will be checked against git.',
+        type: 'array',
+        demand: true,
+      })
+      .option('branch', {
+        alias: 'b',
+        description: 'Git branch or commit identifier to compare to.',
+        type: 'string',
+        default: 'origin/master',
+      })
+      .option('verbose', {
+        alias: 'v',
+        description: 'Verbose output including non-breaking changes',
+        type: 'boolean',
+        default: false,
+      }),
+  handler: async (argv) => {
+    let totalBreaking = 0;
+    try {
+      for (const file of argv.files) {
+        totalBreaking += await gqlDiff(
+          file.toString(),
+          argv.branch,
+          argv.verbose,
+        );
+      }
+    } catch (e) {
+      console.log(red(e));
+      process.exit(1);
+    }
+    if (totalBreaking > 0) {
+      process.exit(1);
+    }
+  },
+};
+
+async function gqlDiff(
+  file: string,
+  branch: string,
+  verbose: boolean,
+): Promise<number> {
+  const root = path.dirname(__dirname);
+  const relPath = path.relative(root, file);
+  console.log(`Comparing schema '${relPath}' with branch '${branch}':`);
+
+  let schema1: GraphQLSchema | undefined = undefined;
+  let schema2: GraphQLSchema | undefined = undefined;
+
+  // load schemas
+  try {
+    const buffer = await fs.promises.readFile(file);
+    schema2 = buildSchema(buffer.toString());
+  } catch (e: any) {
+    throw `Error reading ${file}: ${e.toString()}`;
+  }
+  try {
+    const text = readFileFromGit(branch, path.resolve(file));
+    schema1 = buildSchema(text);
+  } catch (e: any) {
+    if (e.toString().includes(`exists on disk, but not in '${branch}'`)) {
+      console.log(e.toString());
+      console.log(
+        `WARNING: Check will be skipped on the assumption that this is a new schema.`,
+      );
+      return 0;
+    }
+    throw `Error reading ${file} from branch ${branch}: ${e}`;
+  }
+
+  // generate diff
+  const diffResult = await diff(
+    schema1 as GraphQLSchema,
+    schema2 as GraphQLSchema,
+  );
+  const breaking = diffResult.filter(
+    (r) => r.criticality.level === CriticalityLevel.Breaking,
+  );
+
+  // log results
+  if (breaking.length > 0 || verbose) {
+    for (const item of diffResult) {
+      if (item.criticality.level === CriticalityLevel.Breaking) {
+        console.log(`  ✖ ${item.message}`);
+      } else {
+        console.log(`  ✔ ${item.message}`);
+      }
+    }
+  }
+  const color = breaking.length > 0 ? red : green;
+  console.log(
+    color(
+      `${breaking.length > 0 ? '❌ ' : ''}${breaking.length} breaking change${
+        breaking.length === 1 ? '' : 's'
+      }`,
+    ),
+  );
+
+  return breaking.length;
+}
+
+function readFileFromGit(branch: string, file: string): string {
+  const root = execSync(
+    `git -C ${path
+      .dirname(file)
+      .replace(/\\/g, '/')} rev-parse --show-toplevel`,
+  )
+    .toString()
+    .trim();
+  return execSync(
+    `git -C ${root} show ${branch}:${path
+      .relative(root, file)
+      .replace(/\\/g, '/')}`,
+  ).toString();
+}