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

package/src/commands/msg-codegen/index.ts

@@ -0,0 +1,48 @@
+import { CommandModule } from 'yargs';
+import { Codegen } from './codegen';
+import { lint } from './lint';
+import { MessageCodegenOptions } from './message-codegen-options';
+
+export const msgCodegen: CommandModule<unknown, MessageCodegenOptions> = {
+  command: 'msg-codegen',
+  describe: 'Generates code from AsyncAPI document.',
+  builder: (yargs) =>
+    yargs
+      .option('inputDir', {
+        alias: 'i',
+        describe: 'Path to input directory - AsyncAPI document root.',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('filePattern', {
+        alias: 'p',
+        describe: 'Regular expression that matches suitable input files.',
+        type: 'string',
+        default: '^.*(-asyncapi).(json|yaml|yml)$',
+      })
+      .option('outputDir', {
+        alias: 'o',
+        describe: 'Path to output directory - output root.',
+        type: 'string',
+        default: 'src/generated',
+      })
+      .option('lint', {
+        describe: 'Run the Spectral linter on message schemas.',
+        type: 'boolean',
+        default: false,
+      })
+      .option('rulesetPath', {
+        alias: 'r',
+        describe: 'Path to a Spectral ruleset file for linting.',
+        type: 'string',
+      }),
+  handler: async (argv) => {
+    if (argv.lint) {
+      await lint(argv);
+    } else {
+      const codegen = new Codegen(argv);
+      await codegen.run();
+    }
+    console.log('done.');
+  },
+};

package/src/commands/msg-codegen/lint.ts

@@ -0,0 +1,84 @@
+import {
+  Document,
+  isJSONSchemaDraft4,
+  isJSONSchemaLoose,
+  Parsers,
+  Spectral,
+} from '@stoplight/spectral';
+import * as fs from 'fs';
+import * as glob from 'glob';
+import * as path from 'path';
+import { MessageCodegenOptions } from './message-codegen-options';
+
+export async function lint(options: MessageCodegenOptions): Promise<void> {
+  console.log(`Linting schemas at ${options.inputDir}.`);
+
+  // Configure Spectral
+  const spectral = new Spectral({});
+  spectral.registerFormat('json-schema-loose', isJSONSchemaLoose);
+  spectral.registerFormat('json-schema-draft4', isJSONSchemaDraft4);
+  spectral.loadRuleset(getRuleset(options));
+
+  let lintingErrors = false;
+  // Find JSON schemas and lint
+  const schemas = glob.sync(path.join(options.inputDir, '/**/*.json'), {
+    absolute: true,
+  });
+
+  if (schemas.length === 0) {
+    console.log('Could not find any schemas, exiting.');
+    process.exit(1);
+  }
+
+  for (const schema of schemas) {
+    // console.log(schema);
+    const document = new Document(
+      fs.readFileSync(schema, 'utf-8'),
+      Parsers.Json,
+      schema,
+    );
+    const results = await spectral.run(document);
+    const errors = results.filter((r) => r.severity === 0);
+    if (errors.length > 0) {
+      lintingErrors = true;
+      console.log(`\nErrors in\n${schema}:`);
+      errors.forEach((e) => {
+        console.log(`* ${e.message}`);
+      });
+    }
+  }
+
+  if (lintingErrors) {
+    console.log('There were linting errors.');
+    process.exit(1);
+  } else {
+    console.log('No linting errors found.');
+  }
+}
+
+function getRuleset(options: MessageCodegenOptions): string {
+  // This has to be an abs path, otherwise Spectral will fall back to network resolution.
+  let ruleset: string;
+
+  if (!options.rulesetPath) {
+    console.log(
+      'No ruleset path provided, trying to find one in the input directory.',
+    );
+
+    const defaultRuleset = path.resolve(options.inputDir, '.spectral.yaml');
+
+    if (!fs.existsSync(defaultRuleset)) {
+      console.log(
+        `Could not find default ruleset at ${defaultRuleset}, exiting.`,
+      );
+      process.exit(1);
+    }
+    ruleset = defaultRuleset;
+  } else {
+    ruleset = path.resolve(options.rulesetPath);
+  }
+
+  console.log(`Using ruleset ${ruleset}`);
+
+  return ruleset;
+}

package/src/commands/msg-codegen/message-codegen-options.ts

@@ -0,0 +1,7 @@
+export interface MessageCodegenOptions {
+  inputDir: string;
+  filePattern: string;
+  outputDir: string;
+  lint: boolean;
+  rulesetPath?: string;
+}

package/src/commands/msg-diff/asyncapi-override.ts

@@ -0,0 +1,31 @@
+import { OverrideObject } from '@asyncapi/diff';
+
+const unclassified: OverrideObject[string] = {
+  add: 'unclassified',
+  remove: 'unclassified',
+  edit: 'unclassified',
+};
+
+/**
+ * Asyncapi classifier overrides. See: https://github.com/asyncapi/diff#standard-object.
+ * Standard defs (defaults) are here: https://github.com/asyncapi/diff/blob/master/src/standard.ts.
+ */
+export const override: OverrideObject = {
+  // Custom property used to name queues.
+  '/x-service-id': {
+    add: 'breaking',
+    remove: 'breaking',
+    edit: 'breaking',
+  },
+
+  // Changing or removing queue name is a breaking change.
+  '/channels/*/bindings/amqp/queue/name': {
+    add: 'non-breaking',
+    remove: 'breaking',
+    edit: 'breaking',
+  },
+  // (workaround) To find the rule above every subpath needs to be defined (if not already defined in standard defs)
+  //              see: https://github.com/asyncapi/diff/pull/19
+  '/channels/*/bindings/amqp/queue': unclassified,
+  '/channels/*/bindings/amqp': unclassified,
+};

package/src/commands/msg-diff/git-checkout-tmp.ts

@@ -0,0 +1,73 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as uuid from 'uuid';
+
+/*
+ * Checkout a copy of a git directory, from a specified commit/branch, to a temp location.
+ * This can be used to compare the current state of the directory to another commit.
+ * Ful paths from the git root are preserved in the temp checkout.
+ *
+ * @param localDir  A local directory path. Can be absolute or relative. Must be in a git repo.
+ * @param branch    A branch or commit directory to use for the checkout.
+ */
+export class GitCheckoutTmp {
+  private _gitRoot: string | undefined;
+  private _tmpDir: string | undefined;
+
+  public checkout(localDir: string, branch: string): void {
+    this._gitRoot = findGitRoot(localDir);
+    const gitRelDir = path
+      .relative(this._gitRoot, localDir)
+      .replace(/\\/g, '/');
+    if (!gitRelDir) {
+      throw `localDir for checkout cannot be the git root!`;
+    }
+    this._tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), uuid.v4()));
+    try {
+      execSync(
+        `git -C ${this._gitRoot} --work-tree=${this._tmpDir} checkout ${branch} -- ${gitRelDir}`,
+      );
+    } catch (e) {
+      this.cleanUp();
+      throw e;
+    }
+  }
+
+  /*
+   * Location of the temp directory. Root directory of the checked out files.
+   */
+  public get tmpDir(): string | undefined {
+    return this._tmpDir;
+  }
+
+  /*
+   * Location of the git root dir. Root directory of the original files.
+   */
+  public get gitRoot(): string | undefined {
+    return this._gitRoot;
+  }
+
+  /*
+   * Clean up temp files. This will remove the temp directory if it exists.
+   */
+  public cleanUp(): void {
+    try {
+      if (this._tmpDir !== undefined) {
+        fs.rmdirSync(this._tmpDir, { recursive: true });
+      }
+    } catch (e) {
+      console.error(`Failed to clean up tmp dir ${this._tmpDir}: ${e}`);
+    }
+    this._gitRoot = undefined;
+    this._tmpDir = undefined;
+  }
+}
+
+/*
+ * Finds the git root directory for a local path (relative or absolute).
+ */
+export function findGitRoot(dir: string): string {
+  return execSync(`git -C ${dir} rev-parse --show-toplevel`).toString().trim();
+}

package/src/commands/msg-diff/index.ts

@@ -0,0 +1,53 @@
+import * as yargs from 'yargs';
+import { CommandModule } from 'yargs';
+import { MessageDiffOptions } from './message-diff-options';
+import { MessageDiff } from './msg-diff';
+
+export const msgDiff: CommandModule<unknown, MessageDiffOptions> = {
+  command: 'msg-diff',
+  describe: 'Generates code from AsyncAPI document.',
+  builder: (yargs) =>
+    yargs
+      .option('inputDir', {
+        alias: 'i',
+        describe: 'Path to input directory - AsyncAPI document root.',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('filePattern', {
+        alias: 'p',
+        describe: 'Regular expression used to include suitable input files.',
+        type: 'string',
+        default: '^.*(-asyncapi).(json|yaml|yml)$',
+      })
+      .option('excludePattern', {
+        alias: 'e',
+        describe:
+          'Exclude input files matching a regular expression. Exclusion takes precedence over inclusion.',
+        type: 'string',
+        default: undefined,
+      })
+      .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) => {
+    const diff = new MessageDiff(argv);
+    await diff.run();
+    console.log('done.');
+  },
+};
+
+// Dev helper. Script can be run directly with command:
+//   ts-node libs/cli/src/commands/msg-diff/index.ts msg-diff -i libs/messages/schemas
+if (require.main === module) {
+  yargs.command(msgDiff).demandCommand().argv;
+}

package/src/commands/msg-diff/message-diff-options.ts

@@ -0,0 +1,7 @@
+export interface MessageDiffOptions {
+  inputDir: string;
+  filePattern: string;
+  excludePattern: string | undefined;
+  branch: string;
+  verbose: boolean;
+}