@axinom/mosaic-cli 0.18.4 → 0.18.5-rc.0

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

@@ -1,17 +1,39 @@
 /* eslint-disable no-console */
 
 import {
-  CommonNamingConvention,
   FormatHelpers,
   OutputModel,
-  PropertyType,
+  TS_DESCRIPTION_PRESET,
+  typeScriptDefaultPropertyKeyConstraints,
   TypeScriptGenerator,
 } from '@asyncapi/modelina';
-import { AsyncAPIDocument, Message, parse } from '@asyncapi/parser';
+import Parser, {
+  AsyncAPIDocumentInterface,
+  fromFile,
+  MessageInterface,
+} from '@asyncapi/parser';
 import endent from 'endent';
 import * as fs from 'fs';
 import * as path from 'path';
 import { MessageCodegenOptions } from './message-codegen-options';
+import {
+  ADDITIONAL_PROPERTIES_PRESET,
+  ANY_TO_UNKNOWN_PRESET,
+  EXPORT_TYPES_PRESET,
+  IMPORTS_PRESET,
+  NULLABLE_PROPERTY_TO_UNION_PRESET,
+} from './presets';
+import {
+  getChannelAction,
+  getMessageTitle,
+  getModelPathPrefix,
+  getPayloadTitle,
+  getRelativeDir,
+  getServiceId,
+  getServiceTitle,
+  removeXParserProperties,
+  toPosixPath,
+} from './utils';
 
 /**
  * Processes AsyncAPI document and generates Typescript classes from it.
@@ -152,30 +174,38 @@ export class Codegen {
    * @param asyncApiFile - path to AsyncAPI document
    */
   async processAsyncAPIDocument(asyncApiFile: string): Promise<void> {
-    const schemaContent = fs.readFileSync(asyncApiFile, 'utf8');
-
-    const asyncApiDocument = await parse(schemaContent, { path: asyncApiFile });
+    const parser = new Parser();
+    const { document, diagnostics } = await fromFile(
+      parser,
+      asyncApiFile,
+    ).parse();
+
+    if (document === undefined) {
+      console.error(`Failed to parse ${asyncApiFile}.`);
+      console.error(diagnostics);
+      process.exit(1);
+    }
 
     //export Typescript models
     const tsModelsOutputPath = path.join(
       this.typesOutputRoot,
       getRelativeDir(this.schemaRoot, asyncApiFile),
     );
-    await this.exportTsModels(asyncApiDocument, tsModelsOutputPath);
+    await this.exportTsModels(document, tsModelsOutputPath);
 
     //export JSON Schemas
     const schemasOutputPath = path.join(
       this.schemasOutputRoot,
       getRelativeDir(this.schemaRoot, asyncApiFile),
     );
-    await this.exportSchemas(asyncApiDocument, schemasOutputPath);
+    await this.exportSchemas(document, schemasOutputPath);
 
     //export message settings
     const messagingSettingsOutputPath = path.join(
       this.messagingSettingsOutputRoot,
       getRelativeDir(this.schemaRoot, asyncApiFile),
     );
-    await this.exportSettings(asyncApiDocument, messagingSettingsOutputPath);
+    await this.exportSettings(document, messagingSettingsOutputPath);
   }
 
   /**
@@ -184,28 +214,37 @@ export class Codegen {
    * @param outputPath - output path for generated files
    */
   async exportTsModels(
-    asyncAPIDocument: AsyncAPIDocument,
+    asyncAPIDocument: AsyncAPIDocumentInterface,
     outputPath: string,
   ): Promise<void> {
     const generator = new TypeScriptGenerator({
       modelType: 'interface',
-      namingConvention: CustomNamingConvention,
       enumType: 'union',
+      mapType: 'indexedObject',
+      constraints: {
+        propertyKey: typeScriptDefaultPropertyKeyConstraints({
+          NAMING_FORMATTER: (name) => FormatHelpers.toSnakeCase(name),
+          NO_RESERVED_KEYWORDS: (name) => {
+            // TODO: This is a hack to avoid reserved keywords in property names.
+            // Currently many non-reserved keywords are also being replaced: https://github.com/asyncapi/modelina/issues/1053
+            return name;
+          },
+        }),
+      },
+      // Order of presets matters!
       presets: [
-        ADDITIONAL_PROPERTIES_PRESET,
         NULLABLE_PROPERTY_TO_UNION_PRESET,
-        EXPORT_UNION_TYPE_PRESET,
-        EXPORT_INTERFACE_PRESET,
-        DESCRIPTION_PRESET,
+        ANY_TO_UNKNOWN_PRESET,
+        ADDITIONAL_PROPERTIES_PRESET,
+        EXPORT_TYPES_PRESET,
+        TS_DESCRIPTION_PRESET,
         IMPORTS_PRESET,
       ],
     });
 
-    let outputModels = await await generator.generate(asyncAPIDocument as any);
-    for (const key in asyncAPIDocument.components().schemas()) {
-      const referencedModels = await generator.generate(
-        asyncAPIDocument.components().schemas()[key].json(),
-      );
+    let outputModels = await generator.generate(asyncAPIDocument);
+    for (const schema of asyncAPIDocument.components().schemas()) {
+      const referencedModels = await generator.generate(schema.json());
       outputModels = outputModels.map(
         (om) =>
           referencedModels.find((rm) => om.modelName === rm.modelName) || om,
@@ -256,12 +295,12 @@ export class Codegen {
    * @param outputPath - output path for generated files
    */
   async exportSchemas(
-    asyncAPIDocument: AsyncAPIDocument,
+    asyncAPIDocument: AsyncAPIDocumentInterface,
     outputPath: string,
   ): Promise<void> {
-    const groupedSchemas: { [key: string]: Message[] } = {};
+    const groupedSchemas: { [key: string]: MessageInterface[] } = {};
 
-    for (const [, message] of asyncAPIDocument.allMessages()) {
+    for (const message of asyncAPIDocument.messages()) {
       const schemaPathPrefix = getModelPathPrefix(getMessageTitle(message));
       if (groupedSchemas[schemaPathPrefix] === undefined) {
         groupedSchemas[schemaPathPrefix] = [];
@@ -280,12 +319,16 @@ export class Codegen {
         recursive: true,
       });
       for (const msg of messages) {
-        const outputSchemaPath = this.buildSchemaOutPath(
-          groupOutPutPath,
-          getMessageTitle(msg),
-        );
-        await this.bundleSchema(msg.originalPayload(), outputSchemaPath);
-        schemaFiles.push(outputSchemaPath);
+        const payload = msg.payload();
+        if (payload !== undefined && payload.json() !== undefined) {
+          const filteredPayload = removeXParserProperties(payload.json());
+          const outputSchemaPath = this.buildSchemaOutPath(
+            groupOutPutPath,
+            getMessageTitle(msg),
+          );
+          await this.bundleSchema(filteredPayload, outputSchemaPath);
+          schemaFiles.push(outputSchemaPath);
+        }
       }
 
       //generate barrel export for all model in AsyncAPI document
@@ -303,33 +346,30 @@ export class Codegen {
    * @param outputPath - output path for generated files
    */
   async exportSettings(
-    asyncAPIDocument: AsyncAPIDocument,
+    asyncAPIDocument: AsyncAPIDocumentInterface,
     outputPath: string,
   ): Promise<void> {
     const serviceTitle = getServiceTitle(asyncAPIDocument);
     const serviceId = getServiceId(asyncAPIDocument);
     const channelsData: ChannelData[] = [];
 
-    for (const routingKey of asyncAPIDocument.channelNames()) {
-      const channel = asyncAPIDocument.channel(routingKey);
-      if (channel.hasBinding('amqp')) {
-        const queueName = channel.binding('amqp')['queue']['name'];
-
-        const payloadName = channel.hasSubscribe()
-          ? channel.subscribe().message().payload().title()
-          : channel.hasPublish()
-          ? channel.publish().message().payload().title()
-          : 'undefined';
+    for (const channel of asyncAPIDocument.channels()) {
+      const queueName = channel.bindings().get('amqp')?.value().queue.name;
 
+      if (queueName !== undefined) {
+        const routingKey = channel.address();
+        const action = getChannelAction(channel);
+        const payloadName = getPayloadTitle(channel) ?? 'undefined';
         channelsData.push({
-          routingKey: routingKey,
-          queueName: queueName,
-          payloadName: payloadName,
-          acceptedAction: channel.hasSubscribe() ? 'subscribe' : `publish`,
+          routingKey,
+          queueName,
+          payloadName,
+          acceptedAction: action,
           isMultiTenant: routingKey.includes('*.*'),
         });
       }
     }
+
     await this.generateMessagingSettings(
       serviceId,
       serviceTitle,
@@ -685,207 +725,3 @@ interface ChannelData {
   /** Channel multi tenancy */
   isMultiTenant: boolean;
 }
-
-function getRelativeDir(from: string, to: string): string {
-  return fs.statSync(to).isFile()
-    ? path.dirname(path.relative(from, to))
-    : path.relative(from, to);
-}
-
-function getMessageTitle(message: Message): string {
-  return (
-    message.payload().title() ??
-    message.extension('x-parser-message-name') ??
-    message.payload().extension('x-parser-schema-id')
-  );
-}
-
-/**
- * Retrieve Service Title from AsyncAPI document.
- * As Title returned value set in info.title property of document.
- * @param asyncAPIDocument - AsyncAPI document.
- */
-function getServiceTitle(asyncAPIDocument: AsyncAPIDocument): string {
-  return asyncAPIDocument.info().title();
-}
-
-/**
- * Retrieve Service Id from AsyncAPI document.
- * As Id returned value set in extension property `x-service-id`.
- * If extension property is not set - returned Service Title in lower-kebab-case.
- * @param asyncAPIDocument - AsyncAPI document.
- */
-function getServiceId(asyncAPIDocument: AsyncAPIDocument): string {
-  return (
-    (asyncAPIDocument.extension('x-service-id') as string) ??
-    FormatHelpers.toParamCase(getServiceTitle(asyncAPIDocument))
-  );
-}
-
-/**
- * Converts a path into a POSIX path by replacing current path separator with `/`.
- * @param p - Path to convert.
- */
-function toPosixPath(p: string): string {
-  return path.posix.join(...p.split(path.sep));
-}
-
-/**
- * Generating the path prefix for model.
- * model name ends with "command" - prefix "commands"
- * model name ends with "event" - prefix "events"
- * default prefix "types"
- * @param modelName - name of the model, defined in json schema, or AsyncAPI document
- */
-function getModelPathPrefix(modelName: string): string {
-  return modelName
-    ? modelName.toLowerCase().endsWith('command')
-      ? 'commands'
-      : modelName.toLowerCase().endsWith('event')
-      ? 'events'
-      : 'types'
-    : 'types';
-}
-
-/**
- * Adding 'export' for interfaces
- */
-const EXPORT_INTERFACE_PRESET = {
-  interface: {
-    self({ content }) {
-      return `export ${content}`;
-    },
-    property({ content }) {
-      return content;
-    },
-  },
-};
-
-/**
- * Adding 'export' for union enumeration types
- */
-const EXPORT_UNION_TYPE_PRESET = {
-  type: {
-    async self({ renderer }) {
-      return `export ${await renderer.defaultSelf()}`;
-    },
-  },
-};
-
-/**
- * Preset for TypeScriptGenerator, adds descriptions to types and properties.
- */
-const DESCRIPTION_PRESET = {
-  interface: {
-    self({ renderer, content, model }) {
-      const desc = model.getFromOriginalInput('description');
-      if (desc) {
-        const renderedDesc = renderer.renderComments(desc);
-        return `${renderedDesc}\n${content}`;
-      }
-      return content;
-    },
-    property({ renderer, model, content, propertyName }) {
-      if (model.getFromOriginalInput('properties') !== undefined) {
-        const property = model.getFromOriginalInput('properties')[propertyName];
-        if (property !== undefined) {
-          const desc = property['description'];
-          if (desc) {
-            const renderedDesc = renderer.renderComments(desc);
-            return `${renderedDesc}\n${content}`;
-          }
-        }
-      }
-      return content;
-    },
-  },
-};
-
-/**
- * Preset for TypeScriptGenerator, additionalProperties added to models as "[k: string]: unknown;"
- */
-const ADDITIONAL_PROPERTIES_PRESET = {
-  interface: {
-    self({ content }) {
-      return content;
-    },
-    property({ renderer, propertyName, property, type }) {
-      if (type === PropertyType.additionalProperty) {
-        return property.originalInput === true
-          ? `\n[k: string]: unknown;`
-          : renderer
-              .renderProperty(propertyName, property)
-              .replace('additionalProperties?:', '[k: string]:');
-      }
-      return renderer.renderProperty(propertyName, property, type);
-    },
-  },
-};
-
-/**
- * Preset for TypeScriptGenerator, adds imports to resulting model.
- */
-const IMPORTS_PRESET = {
-  interface: {
-    self({ content, model }) {
-      const interfaceName = model.getFromOriginalInput('title');
-      const interfacePrefix = getModelPathPrefix(interfaceName);
-      const dependencies = model.getNearestDependencies(model);
-      const imports = dependencies.map((dep) => ({
-        class: FormatHelpers.toPascalCase(dep),
-        location:
-          interfacePrefix !== getModelPathPrefix(dep)
-            ? `../${getModelPathPrefix(dep)}/${FormatHelpers.toParamCase(dep)}`
-            : `./${FormatHelpers.toParamCase(dep)}`,
-      }));
-      return endent`
-      ${imports
-        .sort((a, b) => a.location.localeCompare(b.location))
-        .map((i) => `import { ${i.class} } from '${i.location}';`)
-        .join('\n')}
-      ${content}`;
-    },
-    property({ content }) {
-      return content;
-    },
-  },
-};
-
-/**
- * Preset for TypeScriptGenerator, sets nullable properties as unions in resulted models(compatibility with zapatos generated models).
- */
-const NULLABLE_PROPERTY_TO_UNION_PRESET = {
-  interface: {
-    self({ content }) {
-      return content;
-    },
-    property({ renderer, model, content, propertyName }) {
-      if (model.getFromOriginalInput('properties') !== undefined) {
-        const property = model.getFromOriginalInput('properties')[propertyName];
-        if (property !== undefined) {
-          if (Array.isArray(property['type'])) {
-            const renderProp = renderer.renderProperty(propertyName, property);
-            return renderProp.replace(
-              'object',
-              content.split(':')[1].replace(';', ''),
-            );
-          }
-        }
-      }
-
-      return content;
-    },
-  },
-};
-
-/**
- * Extension for @asyncapi/modelina, to make sure that the type name is in pascal.
- */
-const CustomNamingConvention: CommonNamingConvention = {
-  type: (name) => {
-    if (!name) {
-      return '';
-    }
-    return FormatHelpers.toPascalCase(name);
-  },
-};

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

@@ -0,0 +1,138 @@
+import { FormatHelpers, TypeScriptPreset } from '@asyncapi/modelina';
+import endent from 'endent';
+import {
+  ensureNullable,
+  getModelPathPrefix,
+  indexOfNullArrayProperty,
+  indexOfNullObjectProperty,
+  replaceAnyType,
+} from './utils';
+
+/**
+ * Exports types.
+ */
+export const EXPORT_TYPES_PRESET: TypeScriptPreset = {
+  interface: {
+    self({ content }) {
+      return `export ${content}`;
+    },
+  },
+  enum: {
+    self({ content }) {
+      return `export ${content}`;
+    },
+  },
+  type: {
+    self({ content }) {
+      return `export ${content}`;
+    },
+  },
+};
+
+/**
+ * Preset for TypeScriptGenerator, additionalProperties added to models as "[k: string]: unknown;"
+ */
+export const ADDITIONAL_PROPERTIES_PRESET: TypeScriptPreset = {
+  interface: {
+    self({ content }) {
+      return content;
+    },
+    property({ property, content }) {
+      if (property.unconstrainedPropertyName === 'additionalProperties') {
+        return `\n[k: string]: unknown;`;
+      }
+      return content;
+    },
+  },
+};
+
+/**
+ * Preset for TypeScriptGenerator, adds imports to resulting model.
+ */
+export const IMPORTS_PRESET: TypeScriptPreset = {
+  interface: {
+    self({ content, model }) {
+      const interfacePrefix = getModelPathPrefix(model.name);
+      const dependencies = model.getNearestDependencies();
+
+      const imports = dependencies.map((dep) => ({
+        class: FormatHelpers.toPascalCase(dep.name),
+        location:
+          interfacePrefix !== getModelPathPrefix(dep.name)
+            ? `../${getModelPathPrefix(dep.name)}/${FormatHelpers.toParamCase(
+                dep.name,
+              )}`
+            : `./${FormatHelpers.toParamCase(dep.name)}`,
+      }));
+      return endent`
+      ${imports
+        .sort((a, b) => a.location.localeCompare(b.location))
+        .map((i) => `import { ${i.class} } from '${i.location}';`)
+        .join('\n')}
+      ${content}`;
+    },
+    property({ content }) {
+      return content;
+    },
+  },
+};
+
+/**
+ * Preset for TypeScriptGenerator, sets nullable properties as unions in resulted models(compatibility with zapatos generated models).
+ */
+export const NULLABLE_PROPERTY_TO_UNION_PRESET: TypeScriptPreset = {
+  interface: {
+    self({ content }) {
+      return content;
+    },
+    property({ renderer, property, content }) {
+      let index = indexOfNullObjectProperty(property);
+
+      // Regular object property, not array.
+      if (index > -1) {
+        property.property.type = ensureNullable(property.property.type, index);
+        return renderer.renderProperty(property);
+      }
+
+      // Array property.
+      index = indexOfNullArrayProperty(property);
+      if (index > -1) {
+        // This pattern is not perfect but it's good enough for this use case.
+        const regex = /((?<single>\w+)|\((?<multiple>[\w\s|]+)\))\[\]/;
+        const match = regex.exec(property.property.type);
+        if (match && (match?.groups?.single || match?.groups?.multiple)) {
+          const newType = ensureNullable(
+            match.groups.single ?? match.groups.multiple,
+            index,
+          );
+          // At this point we assume that the type will be a union of at least two types - null and something else.
+          property.property.type = `(${newType})[]`;
+          return renderer.renderProperty(property);
+        }
+      }
+
+      return content;
+    },
+  },
+};
+
+/**
+ * Converts all occurrences of 'any' to 'unknown'.
+ */
+export const ANY_TO_UNKNOWN_PRESET: TypeScriptPreset = {
+  interface: {
+    property({ renderer, property }) {
+      property.property.type = replaceAnyType(
+        property.property.type,
+        'unknown',
+      );
+      return renderer.renderProperty(property);
+    },
+  },
+  type: {
+    self({ content }) {
+      // TODO: This is inconsistent with interface but not sure how to use type renderer.
+      return replaceAnyType(content, 'unknown');
+    },
+  },
+};