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

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

@@ -0,0 +1,891 @@
+/* eslint-disable no-console */
+
+import {
+  CommonNamingConvention,
+  FormatHelpers,
+  OutputModel,
+  PropertyType,
+  TypeScriptGenerator,
+} from '@asyncapi/modelina';
+import { AsyncAPIDocument, Message, parse } from '@asyncapi/parser';
+import endent from 'endent';
+import * as fs from 'fs';
+import * as path from 'path';
+import { MessageCodegenOptions } from './message-codegen-options';
+
+/**
+ * Processes AsyncAPI document and generates Typescript classes from it.
+ * Generated output:
+ *  - message payloads will be transformed into Typescript types and bundled JSON schemas
+ *  - channels information will be used to generate MessagingSettings, that can be used to configure RabbitMQ connection.
+ * @param inputDir - Path to input directory - AsyncAPI document root.
+ * @param filePattern - Regular expression that matches suitable input files.
+ * @param outputDir - Path to output directory - output root.
+ */
+export class Codegen {
+  private readonly schemaRoot: string;
+  private readonly filePattern: RegExp;
+  private readonly outputRoot: string;
+  private readonly typesOutputRoot: string;
+  private readonly schemasOutputRoot: string;
+  private readonly messagingSettingsOutputRoot: string;
+
+  constructor(options: MessageCodegenOptions) {
+    this.schemaRoot = path.resolve(options.inputDir);
+    try {
+      this.filePattern = new RegExp(options.filePattern);
+    } catch (error) {
+      console.error(
+        `${options.filePattern} is not a valid regular expression.`,
+      );
+      process.exit(1);
+    }
+
+    this.outputRoot = path.resolve(options.outputDir);
+    this.typesOutputRoot = path.join(this.outputRoot, 'types');
+    this.schemasOutputRoot = path.join(this.outputRoot, 'schemas');
+    this.messagingSettingsOutputRoot = path.join(this.outputRoot, 'config');
+  }
+
+  public async run(): Promise<void> {
+    console.log('Running message codegen.');
+    console.log(`* schema root: ${this.schemaRoot}`);
+    console.log(`* output root: ${this.outputRoot}`);
+
+    await this.walk(this.schemaRoot);
+    await this.barrelExportTs(
+      [],
+      [
+        this.typesOutputRoot,
+        this.schemasOutputRoot,
+        this.messagingSettingsOutputRoot,
+      ],
+      path.join(this.outputRoot, 'index.ts'),
+    );
+  }
+
+  /**
+   * Recursively walks a schemas directory and generates TS + bundled JSON schema files.
+   * @param dir - Directory to walk.
+   */
+  async walk(dir: string): Promise<void> {
+    const items = await fs.promises.readdir(dir);
+
+    const fullPathItems = items.map((i) => path.join(dir, i));
+    const dirs = fullPathItems.filter((i) => fs.statSync(i).isDirectory());
+    const files = fullPathItems.filter(
+      (i) => fs.statSync(i).isFile() && this.filePattern.test(i),
+    );
+
+    if ([...files, ...dirs].length === 0) {
+      return;
+    }
+
+    for (const asyncApiFile of files) {
+      console.log(`Processing ${asyncApiFile}.`);
+      await this.processAsyncAPIDocument(asyncApiFile);
+    }
+
+    for (const directory of dirs) {
+      await this.walk(directory);
+    }
+
+    if (files.length === 0) {
+      //Calculate correct TS output related directories for barrel exports.
+      const tsDirs = dirs.map((d) =>
+        path.join(this.typesOutputRoot, path.relative(this.schemaRoot, d)),
+      );
+      const tsIndexOutPath = path.join(
+        this.typesOutputRoot,
+        getRelativeDir(this.schemaRoot, dir),
+        'index.ts',
+      );
+      await this.barrelExportTs([], tsDirs, tsIndexOutPath);
+
+      // Calculate correct JSON schema output related directories for barrel exports.
+      const schemaDirs = dirs.map((d) =>
+        path.join(this.schemasOutputRoot, path.relative(this.schemaRoot, d)),
+      );
+      const schemaIndexOutPath = path.join(
+        this.schemasOutputRoot,
+        getRelativeDir(this.schemaRoot, dir),
+        'index.ts',
+      );
+      await this.barrelExportSchema([], schemaDirs, schemaIndexOutPath);
+
+      // Calculate correct Message Settings output related directories for barrel exports.
+      const settingsDirs = dirs.map((d) =>
+        path.join(
+          this.messagingSettingsOutputRoot,
+          path.relative(this.schemaRoot, d),
+        ),
+      );
+      const messagingIndexOutPath = path.join(
+        this.messagingSettingsOutputRoot,
+        getRelativeDir(this.schemaRoot, dir),
+        'index.ts',
+      );
+      await this.barrelExportSettings([], settingsDirs, messagingIndexOutPath);
+    }
+  }
+
+  /**
+   * Builds a path for the generated TS file from an input JSON schema path, retains directory structure.
+   * @param outputPath - output directory.
+   * @param typeName - Name of the type.
+   */
+  buildTsOutPath(outputPath: string, typeName: string): string {
+    return path.join(outputPath, `${FormatHelpers.toParamCase(typeName)}.ts`);
+  }
+
+  /**
+   * Builds a path for the bundled JSON schema file from an input JSON schema path, retains directory structure.
+   * @param outputPath - output directory.
+   * @param typeName - Name of the type.
+   */
+  buildSchemaOutPath(outputPath: string, typeName: string): string {
+    return path.join(outputPath, `${FormatHelpers.toParamCase(typeName)}.json`);
+  }
+
+  /**
+   * Generates TS interfaces and JSON schemas from AsyncAPI schema.
+   * @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 });
+
+    //export Typescript models
+    const tsModelsOutputPath = path.join(
+      this.typesOutputRoot,
+      getRelativeDir(this.schemaRoot, asyncApiFile),
+    );
+    await this.exportTsModels(asyncApiDocument, tsModelsOutputPath);
+
+    //export JSON Schemas
+    const schemasOutputPath = path.join(
+      this.schemasOutputRoot,
+      getRelativeDir(this.schemaRoot, asyncApiFile),
+    );
+    await this.exportSchemas(asyncApiDocument, schemasOutputPath);
+
+    //export message settings
+    const messagingSettingsOutputPath = path.join(
+      this.messagingSettingsOutputRoot,
+      getRelativeDir(this.schemaRoot, asyncApiFile),
+    );
+    await this.exportSettings(asyncApiDocument, messagingSettingsOutputPath);
+  }
+
+  /**
+   * Export all TS models from AsyncAPI document
+   * @param asyncAPIDocument - AsyncAPI Document object
+   * @param outputPath - output path for generated files
+   */
+  async exportTsModels(
+    asyncAPIDocument: AsyncAPIDocument,
+    outputPath: string,
+  ): Promise<void> {
+    const generator = new TypeScriptGenerator({
+      modelType: 'interface',
+      namingConvention: CustomNamingConvention,
+      enumType: 'union',
+      presets: [
+        ADDITIONAL_PROPERTIES_PRESET,
+        NULLABLE_PROPERTY_TO_UNION_PRESET,
+        EXPORT_UNION_TYPE_PRESET,
+        EXPORT_INTERFACE_PRESET,
+        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(),
+      );
+      outputModels = outputModels.map(
+        (om) =>
+          referencedModels.find((rm) => om.modelName === rm.modelName) || om,
+      );
+    }
+
+    const groupedModels: { [key: string]: OutputModel[] } = {};
+    outputModels.map((outModel) => {
+      const modelPathPrefix = getModelPathPrefix(outModel.modelName);
+      if (groupedModels[modelPathPrefix] === undefined) {
+        groupedModels[modelPathPrefix] = [];
+      }
+      groupedModels[modelPathPrefix].push(outModel);
+    });
+
+    const tsDirs: string[] = [];
+    for (const pathPrefix in groupedModels) {
+      const models = groupedModels[pathPrefix];
+      const groupOutPutPath = path.join(outputPath, pathPrefix);
+      if (pathPrefix) {
+        tsDirs.push(groupOutPutPath);
+      }
+      await fs.promises.mkdir(groupOutPutPath, {
+        recursive: true,
+      });
+      const tsFiles: string[] = [];
+      for (const outputModel of models) {
+        const outputFilePath = this.buildTsOutPath(
+          groupOutPutPath,
+          outputModel.modelName,
+        );
+        await fs.promises.writeFile(outputFilePath, outputModel.result);
+        tsFiles.push(outputFilePath);
+      }
+      //generate barrel export for all model in AsyncAPI document
+      const tsIndexOutPath = path.join(groupOutPutPath, 'index.ts');
+      await this.barrelExportTs(tsFiles, [], tsIndexOutPath);
+    }
+    if (tsDirs.length > 0) {
+      const tsIndexOutPath = path.join(outputPath, 'index.ts');
+      await this.barrelExportTs([], tsDirs, tsIndexOutPath);
+    }
+  }
+
+  /**
+   * Export all JSON Schemas from AsyncAPI document
+   * @param asyncAPIDocument - AsyncAPI Document object
+   * @param outputPath - output path for generated files
+   */
+  async exportSchemas(
+    asyncAPIDocument: AsyncAPIDocument,
+    outputPath: string,
+  ): Promise<void> {
+    const groupedSchemas: { [key: string]: Message[] } = {};
+
+    for (const [, message] of asyncAPIDocument.allMessages()) {
+      const schemaPathPrefix = getModelPathPrefix(getMessageTitle(message));
+      if (groupedSchemas[schemaPathPrefix] === undefined) {
+        groupedSchemas[schemaPathPrefix] = [];
+      }
+      groupedSchemas[schemaPathPrefix].push(message);
+    }
+    const schemaDirs: string[] = [];
+    for (const pathPrefix in groupedSchemas) {
+      const messages = groupedSchemas[pathPrefix];
+      const schemaFiles: string[] = [];
+      const groupOutPutPath = path.join(outputPath, pathPrefix);
+      if (pathPrefix) {
+        schemaDirs.push(groupOutPutPath);
+      }
+      await fs.promises.mkdir(groupOutPutPath, {
+        recursive: true,
+      });
+      for (const msg of messages) {
+        const outputSchemaPath = this.buildSchemaOutPath(
+          groupOutPutPath,
+          getMessageTitle(msg),
+        );
+        await this.bundleSchema(msg.originalPayload(), outputSchemaPath);
+        schemaFiles.push(outputSchemaPath);
+      }
+
+      //generate barrel export for all model in AsyncAPI document
+      const schemasIndexOutPath = path.join(groupOutPutPath, 'index.ts');
+      await this.barrelExportSchema(schemaFiles, [], schemasIndexOutPath);
+    }
+
+    const schemaIndexOutPath = path.join(outputPath, 'index.ts');
+    await this.barrelExportSchema([], schemaDirs, schemaIndexOutPath);
+  }
+
+  /**
+   * Export all AsyncAPI document channels to Messaging Settings
+   * @param asyncAPIDocument - AsyncAPI Document object
+   * @param outputPath - output path for generated files
+   */
+  async exportSettings(
+    asyncAPIDocument: AsyncAPIDocument,
+    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';
+
+        channelsData.push({
+          routingKey: routingKey,
+          queueName: queueName,
+          payloadName: payloadName,
+          acceptedAction: channel.hasSubscribe() ? 'subscribe' : `publish`,
+          isMultiTenant: routingKey.includes('*.*'),
+        });
+      }
+    }
+    await this.generateMessagingSettings(
+      serviceId,
+      serviceTitle,
+      channelsData,
+      outputPath,
+    );
+  }
+
+  /**
+   * Generate Messaging Settings based on Channels data.
+   * @param serviceId - service identifier
+   * @param serviceTitle - service title
+   * @param channelsData - AsyncAPI channels information
+   * @param outputPath - output path for generated files
+   */
+  async generateMessagingSettings(
+    serviceId: string,
+    serviceTitle: string,
+    channelsData: ChannelData[],
+    outputPath: string,
+  ): Promise<void> {
+    const messagingSettingFiles: string[] = [];
+
+    messagingSettingFiles.push(
+      await this.createMessagingSettingFile(
+        true,
+        serviceId,
+        serviceTitle,
+        channelsData.filter((data) => data.isMultiTenant === true),
+        outputPath,
+      ),
+    );
+    messagingSettingFiles.push(
+      await this.createMessagingSettingFile(
+        false,
+        serviceId,
+        serviceTitle,
+        channelsData.filter((data) => data.isMultiTenant === false),
+        outputPath,
+      ),
+    );
+
+    //barrel export for messaging settings
+    const schemaIndexOutPath = path.join(outputPath, 'index.ts');
+    await this.barrelExportSettings(
+      messagingSettingFiles.filter((f) => f),
+      [],
+      schemaIndexOutPath,
+    );
+  }
+
+  /**
+   * Create new Messaging Settings file.
+   * @param isMultiTenant - is file with multi tenant settings, or not
+   * @param serviceId - service Identifier
+   * @param serviceTitle - service Title
+   * @param channelsData - AsyncAPI channels information
+   * @param outputPath - output path for generated files
+   */
+  async createMessagingSettingFile(
+    isMultiTenant: boolean,
+    serviceId: string,
+    serviceTitle: string,
+    channelsData: ChannelData[],
+    outputPath: string,
+  ): Promise<string> {
+    if (channelsData.length === 0) {
+      return ``;
+    }
+    const baseClass = isMultiTenant
+      ? `MultiTenantMessagingSettings`
+      : `MessagingSettings`;
+    const className = `${FormatHelpers.toPascalCase(serviceTitle)}${baseClass}`;
+    const action = isMultiTenant ? `extends` : `implements`;
+    const constructor = endent`private constructor(
+      public readonly messageType: string,
+      public readonly queue: string,
+      public readonly routingKey: string,
+    ) {
+      ${
+        isMultiTenant
+          ? `super('${serviceId}', messageType, queue, routingKey);`
+          : ``
+      }
+    }`;
+
+    const properties = channelsData.map((data) =>
+      this.createMessagingSettingProperty(data, className),
+    );
+    const content = endent`import { ${baseClass} } from '@axinom/mosaic-message-bus-abstractions';
+
+    export class ${className} ${action} ${baseClass} {
+      ${properties.join(`\n`)}
+      ${isMultiTenant ? `` : `\npublic readonly serviceId = '${serviceId}';\n`}
+      ${constructor}
+
+      public toString = (): string => {
+        return this.messageType;
+      };
+    }`;
+
+    const filePath = path.join(
+      outputPath,
+      `${FormatHelpers.toParamCase(className)}.ts`,
+    );
+    await fs.promises.mkdir(path.dirname(filePath), {
+      recursive: true,
+    });
+    await fs.promises.writeFile(filePath, content);
+
+    return filePath;
+  }
+  /**
+   * Create Messaging Settings property from Channel Data.
+   * @param channelData - AsyncAPI channel information
+   * @param settingsClassName - class name of messaging setting
+   */
+  createMessagingSettingProperty(
+    channelData: ChannelData,
+    settingsClassName: string,
+  ): string {
+    const messageType = FormatHelpers.toPascalCase(
+      channelData.payloadName.replace('command', '').replace('event', ''),
+    );
+    return endent`
+    public static ${messageType} = new ${settingsClassName}(
+      '${messageType}', 
+      '${channelData.queueName}', 
+      '${channelData.routingKey}'
+      );`;
+  }
+
+  /**
+   * Bundles a JSON schema into a self-contained file by including all external refs.
+   * @param jsonSchema - Schema object.
+   * @param outPath - Output JSON schema path.
+   */
+  async bundleSchema(jsonSchema: unknown, outPath: string): Promise<void> {
+    await fs.promises.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.promises.writeFile(outPath, JSON.stringify(jsonSchema, null, 2));
+  }
+
+  // TODO: Consider doing named exports based on message groups to not just put all messages in one namespace.
+  // TODO: Maybe some templating engine would be better than just building strings.
+  /**
+   * Generates a barrel index.ts for all modules inside `outPath`.
+   * In addition it generates a schemas enum for the included modules to make it easier to map them to bundled JSON schemas.
+   * @param files - Files to roll up.
+   * @param dirs - Directories to roll up.
+   * @param outPath - Path where to write `index.ts`.
+   */
+  async barrelExportTs(
+    files: string[],
+    dirs: string[],
+    outPath: string,
+  ): Promise<void> {
+    console.log(`Rolling up TS exports to ${outPath}.`);
+    const items = [
+      ...files.map((f) => path.basename(f, '.ts')),
+      ...dirs.filter((d) => fs.existsSync(d)).map((d) => path.basename(d)),
+    ];
+
+    if (items.length < 1) {
+      return;
+    }
+
+    const exports = `${items
+      .sort()
+      .map((p) => `export * from './${p}';`)
+      .join('\n')}`;
+    let schemaEnum = '';
+    let typeNamesEnum = '';
+
+    // TODO: Break this up into smaller pieces.
+    // TODO: Consider adding docstring to generated enums.
+    if (files.length > 0) {
+      const sortedFiles = files.sort();
+      // TODO: Message envelope is handled separately, we could remove this entirely.
+      // If message-envelope requires some special handling.
+      if (files.length === 1 && files[0].endsWith('message-envelope.ts')) {
+        const file = files[0];
+        schemaEnum = endent`
+        export enum MessageEnvelopeSchema {
+          MessageEnvelope = '${toPosixPath(this.tsPathToSchemaPath(file))}'
+        }
+        `;
+      } else {
+        let enumNameBase = FormatHelpers.toPascalCase(
+          getRelativeDir(this.typesOutputRoot, path.dirname(outPath)),
+        );
+        if (!enumNameBase.includes('Types')) {
+          enumNameBase = enumNameBase.replace('Payloads', ''); // Remove the Payloads prefix to reduce noise
+          schemaEnum = endent`
+        export enum ${enumNameBase}Schemas {
+          ${sortedFiles
+            .map(
+              (f) =>
+                `${FormatHelpers.toPascalCase(
+                  path.basename(f, '.ts'),
+                )} = '${toPosixPath(this.tsPathToSchemaPath(f))}'`,
+            )
+            .join(',\n')}
+        }`;
+          typeNamesEnum = endent`
+        export enum ${enumNameBase}Types {
+          ${sortedFiles
+            .sort()
+            .map(
+              (f) =>
+                `${FormatHelpers.toPascalCase(
+                  path.basename(f, '.ts'),
+                )} = '${FormatHelpers.toPascalCase(path.basename(f, '.ts'))}'`,
+            )
+            .join(',\n')}
+        }`;
+        }
+      }
+    }
+
+    const contents = endent`
+    ${exports}
+
+    ${schemaEnum}
+
+    ${typeNamesEnum}
+    `;
+
+    await fs.promises.writeFile(outPath, contents);
+  }
+
+  /**
+   * Generates a barrel index.ts for all Messaging Settings inside `outPath`.
+   * @param files - Files to roll up.
+   * @param dirs - Directories to roll up.
+   * @param outPath - Path where to write `index.ts`.
+   */
+  async barrelExportSettings(
+    files: string[],
+    dirs: string[],
+    outPath: string,
+  ): Promise<void> {
+    console.log(`Rolling up Messaging Settings exports to ${outPath}.`);
+    const items = [
+      ...files.map((f) => path.basename(f, '.ts')),
+      ...dirs.filter((d) => fs.existsSync(d)).map((d) => path.basename(d)),
+    ];
+
+    const dirExports = dirs
+      .sort()
+      .filter((d) => fs.existsSync(d))
+      .map((d) => path.basename(d));
+
+    if (items.length < 1) {
+      return;
+    }
+
+    let contents = '';
+
+    if (files.length > 0) {
+      const baseNames = files.map((f) => path.basename(f, '.ts')).sort();
+      const messagingImports = baseNames.map((n) => `export * from './${n}';`);
+      contents = endent`
+        ${messagingImports.join('\n')}
+        `;
+    }
+
+    contents += endent`\n
+      ${dirExports.map((d) => `export * from './${d}';`).join('\n')}`;
+
+    await fs.promises.writeFile(outPath, contents);
+  }
+  /**
+   * Generates a barrel index.ts for all JSON schemas inside `outPath`.
+   * @param files - Files to roll up.
+   * @param dirs - Directories to roll up.
+   * @param outPath - Path where to write `index.ts`.
+   */
+  async barrelExportSchema(
+    files: string[],
+    dirs: string[],
+    outPath: string,
+  ): Promise<void> {
+    console.log(`Rolling up JSON exports to ${outPath}.`);
+    const items = [
+      ...files.map((f) => path.basename(f, '.json')),
+      ...dirs.filter((d) => fs.existsSync(d)).map((d) => path.basename(d)),
+    ];
+
+    const dirExports = dirs
+      .sort()
+      .filter((d) => fs.existsSync(d))
+      .map((d) => path.basename(d));
+
+    if (items.length < 1) {
+      return;
+    }
+
+    let contents = '';
+
+    if (files.length > 0) {
+      const baseNames = files.map((f) => path.basename(f, '.json')).sort();
+      const schemaImports = baseNames.map(
+        (n) =>
+          `import * as ${FormatHelpers.toPascalCase(n)} from './${n}.json';`,
+      );
+      const schemaExports = baseNames.map(
+        (n) =>
+          `export const ${FormatHelpers.toPascalCase(
+            n,
+          )}Schema = ${FormatHelpers.toPascalCase(n)};`,
+      );
+      contents = endent`
+      ${schemaImports.join('\n')}
+
+      ${schemaExports.join('\n')}
+      `;
+    }
+
+    contents += endent`\n
+    ${dirExports.map((d) => `export * from './${d}';`).join('\n')}`;
+
+    await fs.promises.writeFile(outPath, contents);
+  }
+
+  /**
+   * Converts a generated TS path to a corresponding JSON schema path.
+   * @param tsFile - Path to a generated TS file.
+   */
+  tsPathToSchemaPath(tsFile: string): string {
+    return path.join(
+      getRelativeDir(this.typesOutputRoot, tsFile),
+      `${path.basename(tsFile, '.ts')}.json`,
+    );
+  }
+}
+
+/**
+ * Metadata of channels for settings generation.
+ */
+interface ChannelData {
+  /** Channel routing key */
+  routingKey: string;
+
+  /** Channel queue */
+  queueName: string;
+
+  /** Channel model */
+  payloadName: string;
+
+  /** Accepted Action*/
+  acceptedAction: 'subscribe' | 'publish';
+
+  /** 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);
+  },
+};