;
}
diff --git a/src/generators/AbstractGenerator.ts b/src/generators/AbstractGenerator.ts
index 8eb722e606..57fc528795 100644
--- a/src/generators/AbstractGenerator.ts
+++ b/src/generators/AbstractGenerator.ts
@@ -1,62 +1,129 @@
-import { CommonInputModel, CommonModel, OutputModel, Preset, Presets, RenderOutput, ProcessorOptions } from '../models';
+import {
+ InputMetaModel,
+ OutputModel,
+ Preset,
+ Presets,
+ RenderOutput,
+ ProcessorOptions,
+ MetaModel,
+ ConstrainedMetaModel
+} from '../models';
import { InputProcessor } from '../processors';
import { IndentationTypes } from '../helpers';
-import { isPresetWithOptions } from '../utils';
-export interface CommonGeneratorOptions {
+import { DeepPartial, isPresetWithOptions } from '../utils';
+import { AbstractDependencyManager } from './AbstractDependencyManager';
+
+export interface CommonGeneratorOptions<
+ P extends Preset = Preset,
+ DependencyManager extends AbstractDependencyManager = AbstractDependencyManager
+> {
indentation?: {
type: IndentationTypes;
size: number;
};
defaultPreset?: P;
presets?: Presets
;
- processorOptions?: ProcessorOptions
+ processorOptions?: ProcessorOptions;
+ /**
+ * This dependency manager type serves two functions.
+ * 1. It can be used to provide a factory for generate functions
+ * 2. It can be used to provide a single instance of a dependency manager, to add all dependencies together
+ *
+ * This depends on context and where it's used.
+ */
+ dependencyManager?: (() => DependencyManager) | DependencyManager;
}
export const defaultGeneratorOptions: CommonGeneratorOptions = {
indentation: {
type: IndentationTypes.SPACES,
- size: 2,
+ size: 2
}
};
/**
* Abstract generator which must be implemented by each language
*/
-export abstract class AbstractGenerator {
- protected options: Options;
-
+export abstract class AbstractGenerator<
+ Options extends CommonGeneratorOptions,
+ RenderCompleteModelOptions
+> {
constructor(
public readonly languageName: string,
- defaultOptions?: Options,
- passedOptions?: Options,
- ) {
- this.options = this.mergeOptions(defaultOptions, passedOptions);
- }
+ public readonly options: Options
+ ) {}
- public abstract render(model: CommonModel, inputModel: CommonInputModel): Promise;
- public abstract renderCompleteModel(model: CommonModel, inputModel: CommonInputModel, options: RenderCompleteModelOptions): Promise;
+ public abstract render(
+ model: MetaModel,
+ inputModel: InputMetaModel,
+ options?: DeepPartial
+ ): Promise;
+ public abstract renderCompleteModel(
+ model: MetaModel,
+ inputModel: InputMetaModel,
+ completeOptions: Partial,
+ options?: DeepPartial
+ ): Promise;
+ public abstract constrainToMetaModel(
+ model: MetaModel,
+ options: DeepPartial
+ ): ConstrainedMetaModel;
+ public abstract getDependencyManager(
+ options: Options
+ ): AbstractDependencyManager;
+ public abstract splitMetaModel(model: MetaModel): MetaModel[];
- public process(input: Record): Promise {
- return InputProcessor.processor.process(input, this.options.processorOptions);
+ public process(input: Record): Promise {
+ return InputProcessor.processor.process(
+ input,
+ this.options.processorOptions
+ );
+ }
+
+ /**
+ * This function returns an instance of the dependency manager which is either a factory or an instance.
+ */
+ protected getDependencyManagerInstance(
+ options: Options
+ ): AbstractDependencyManager {
+ if (options.dependencyManager === undefined) {
+ throw new Error(
+ 'Internal error, could not find dependency manager instance'
+ );
+ }
+ if (typeof options.dependencyManager === 'function') {
+ return options.dependencyManager();
+ }
+ return options.dependencyManager;
}
/**
* Generates the full output of a model, instead of a scattered model.
- *
+ *
* OutputModels result is no longer the model itself, but including package, package dependencies and model dependencies.
- *
- * @param input
- * @param options to use for rendering full output
+ *
*/
- public async generateCompleteModels(input: Record | CommonInputModel, options: RenderCompleteModelOptions): Promise {
+ public async generateCompleteModels(
+ input: any | InputMetaModel,
+ completeOptions: Partial
+ ): Promise {
const inputModel = await this.processInput(input);
const renders = Object.values(inputModel.models).map(async (model) => {
- const renderedOutput = await this.renderCompleteModel(model, inputModel, options);
- return OutputModel.toOutputModel({
+ const dependencyManager = this.getDependencyManager(this.options);
+ const constrainedModel = this.constrainToMetaModel(model, {
+ dependencyManager
+ } as DeepPartial);
+ const renderedOutput = await this.renderCompleteModel(
+ constrainedModel,
+ inputModel,
+ completeOptions,
+ { dependencyManager } as DeepPartial
+ );
+ return OutputModel.toOutputModel({
result: renderedOutput.result,
- modelName: renderedOutput.renderedName,
+ modelName: renderedOutput.renderedName,
dependencies: renderedOutput.dependencies,
- model,
+ model: constrainedModel,
inputModel
});
});
@@ -64,19 +131,23 @@ export abstract class AbstractGenerator | CommonInputModel): Promise {
+ public async generate(input: any | InputMetaModel): Promise {
const inputModel = await this.processInput(input);
const renders = Object.values(inputModel.models).map(async (model) => {
- const renderedOutput = await this.render(model, inputModel);
- return OutputModel.toOutputModel({
+ const dependencyManager = this.getDependencyManager(this.options);
+ const constrainedModel = this.constrainToMetaModel(model, {
+ dependencyManager
+ } as DeepPartial);
+ const renderedOutput = await this.render(constrainedModel, inputModel, {
+ dependencyManager
+ } as DeepPartial);
+ return OutputModel.toOutputModel({
result: renderedOutput.result,
- modelName: renderedOutput.renderedName,
+ modelName: renderedOutput.renderedName,
dependencies: renderedOutput.dependencies,
- model,
+ model: constrainedModel,
inputModel
});
});
@@ -84,23 +155,38 @@ export abstract class AbstractGenerator | CommonInputModel): Promise {
- if (input instanceof CommonInputModel) {
- return Promise.resolve(input);
+ protected async processInput(
+ input: any | InputMetaModel
+ ): Promise {
+ const rawInputModel =
+ input instanceof InputMetaModel ? input : await this.process(input);
+
+ //Split out the models based on the language specific requirements of which models is rendered separately
+ const splitOutModels: { [key: string]: MetaModel } = {};
+ for (const model of Object.values(rawInputModel.models)) {
+ const splitModels = this.splitMetaModel(model);
+ for (const splitModel of splitModels) {
+ splitOutModels[splitModel.name] = splitModel;
+ }
}
- return this.process(input);
+ rawInputModel.models = splitOutModels;
+ return rawInputModel;
}
+ /**
+ * Get all presets (default and custom ones from options) for a given preset type (class, enum, etc).
+ */
protected getPresets(presetType: string): Array<[Preset, unknown]> {
const filteredPresets: Array<[Preset, unknown]> = [];
const defaultPreset = this.options.defaultPreset;
if (defaultPreset !== undefined) {
- filteredPresets.push([defaultPreset[String(presetType)], undefined]);
+ filteredPresets.push([defaultPreset[String(presetType)], this.options]);
}
const presets = this.options.presets || [];
@@ -120,12 +206,4 @@ export abstract class AbstractGenerator = AbstractGenerator,
+ RendererModelType extends ConstrainedMetaModel = ConstrainedMetaModel
> {
constructor(
protected readonly options: O,
readonly generator: G,
protected readonly presets: Array<[Preset, unknown]>,
- protected readonly model: CommonModel,
- protected readonly inputModel: CommonInputModel,
- public dependencies: string[] = []
+ protected readonly model: RendererModelType,
+ protected readonly inputModel: InputMetaModel
) {}
- /**
- * Adds a dependency while ensuring that only one dependency is preset at a time.
- *
- * @param dependency complete dependency string so it can be rendered as is.
- */
- addDependency(dependency: string): void {
- if (!this.dependencies.includes(dependency)) {
- this.dependencies.push(dependency);
- }
- }
-
renderLine(line: string): string {
return `${line}\n`;
}
@@ -38,11 +27,7 @@ export abstract class AbstractRenderer<
return lines.filter(Boolean).join(n);
}
- indent(
- content: string,
- size?: number,
- type?: IndentationTypes,
- ): string {
+ indent(content: string, size?: number, type?: IndentationTypes): string {
size = size || this.options.indentation?.size;
type = type || this.options.indentation?.type;
return FormatHelpers.indent(content, size, type);
@@ -51,24 +36,24 @@ export abstract class AbstractRenderer<
runSelfPreset(): Promise {
return this.runPreset('self');
}
-
+
runAdditionalContentPreset(): Promise {
return this.runPreset('additionalContent');
}
-
+
async runPreset(
functionName: string,
- params: Record = {},
+ params: Record = {}
): Promise {
let content = '';
for (const [preset, options] of this.presets) {
if (typeof preset[String(functionName)] === 'function') {
- const presetRenderedContent: any = await preset[String(functionName)]({
- ...params,
- renderer: this,
- content,
- options,
- model: this.model,
+ const presetRenderedContent: any = await preset[String(functionName)]({
+ ...params,
+ renderer: this,
+ content,
+ options,
+ model: this.model,
inputModel: this.inputModel
});
if (typeof presetRenderedContent === 'string') {
diff --git a/src/generators/csharp/CSharpConstrainer.ts b/src/generators/csharp/CSharpConstrainer.ts
new file mode 100644
index 0000000000..cc4ee0b766
--- /dev/null
+++ b/src/generators/csharp/CSharpConstrainer.ts
@@ -0,0 +1,108 @@
+import {
+ ConstrainedEnumValueModel,
+ ConstrainedObjectPropertyModel
+} from '../../models';
+import {
+ defaultEnumKeyConstraints,
+ defaultEnumValueConstraints
+} from './constrainer/EnumConstrainer';
+import { defaultModelNameConstraints } from './constrainer/ModelNameConstrainer';
+import { defaultPropertyKeyConstraints } from './constrainer/PropertyKeyConstrainer';
+import { CSharpTypeMapping } from './CSharpGenerator';
+
+function getFullTypeDefinition(
+ typeName: string,
+ partOfProperty: ConstrainedObjectPropertyModel | undefined
+) {
+ return partOfProperty?.required ?? true ? typeName : `${typeName}?`;
+}
+
+const fromEnumValueToType = (
+ enumValueModel: ConstrainedEnumValueModel
+): string => {
+ switch (typeof enumValueModel.value) {
+ case 'boolean':
+ return 'bool';
+ case 'number':
+ case 'bigint':
+ if (Number.isInteger(enumValueModel.value)) {
+ return 'int';
+ }
+ return 'double';
+ case 'string':
+ return 'string';
+ case 'object':
+ default:
+ return 'dynamic';
+ }
+};
+
+export const CSharpDefaultTypeMapping: CSharpTypeMapping = {
+ Object({ constrainedModel, partOfProperty }): string {
+ return getFullTypeDefinition(constrainedModel.name, partOfProperty);
+ },
+ Reference({ constrainedModel, partOfProperty }): string {
+ return getFullTypeDefinition(constrainedModel.name, partOfProperty);
+ },
+ Any({ partOfProperty }): string {
+ return getFullTypeDefinition('dynamic', partOfProperty);
+ },
+ Float({ partOfProperty }): string {
+ return getFullTypeDefinition('double', partOfProperty);
+ },
+ Integer({ partOfProperty }): string {
+ return getFullTypeDefinition('int', partOfProperty);
+ },
+ String({ partOfProperty }): string {
+ return getFullTypeDefinition('string', partOfProperty);
+ },
+ Boolean({ partOfProperty }): string {
+ return getFullTypeDefinition('bool', partOfProperty);
+ },
+ Tuple({ constrainedModel, partOfProperty }): string {
+ const tupleTypes = constrainedModel.tuple.map((constrainedType) => {
+ return constrainedType.value.type;
+ });
+ return getFullTypeDefinition(`(${tupleTypes.join(', ')})`, partOfProperty);
+ },
+ Array({ constrainedModel, options, partOfProperty }): string {
+ const typeString =
+ options.collectionType && options.collectionType === 'List'
+ ? `IEnumerable<${constrainedModel.valueModel.type}>`
+ : `${constrainedModel.valueModel.type}[]`;
+
+ return getFullTypeDefinition(typeString, partOfProperty);
+ },
+ Enum({ constrainedModel, partOfProperty }): string {
+ const typesForValues: Set = new Set();
+
+ for (const value of constrainedModel.values) {
+ const typeForValue = fromEnumValueToType(value);
+ typesForValues.add(typeForValue);
+ }
+ // If there exist more then 1 unique type, then default to dynamic
+ if (typesForValues.size > 1) {
+ return 'dynamic';
+ }
+ const [typeForValues] = typesForValues;
+ return getFullTypeDefinition(typeForValues, partOfProperty);
+ },
+ Union({ partOfProperty }): string {
+ //Because renderPrivateType( CSharp , partOfProperty) have no notion of unions (and no custom implementation), we have to render it as any value.
+
+ return getFullTypeDefinition('dynamic', partOfProperty);
+ },
+ Dictionary({ constrainedModel, partOfProperty }): string {
+ return getFullTypeDefinition(
+ `Dictionary<${constrainedModel.key.type}, ${constrainedModel.value.type}>`,
+ partOfProperty
+ );
+ }
+};
+
+export const CSharpDefaultConstraints = {
+ enumKey: defaultEnumKeyConstraints(),
+ enumValue: defaultEnumValueConstraints(),
+ modelName: defaultModelNameConstraints(),
+ propertyKey: defaultPropertyKeyConstraints()
+};
diff --git a/src/generators/csharp/CSharpDependencyManager.ts b/src/generators/csharp/CSharpDependencyManager.ts
new file mode 100644
index 0000000000..50d578606b
--- /dev/null
+++ b/src/generators/csharp/CSharpDependencyManager.ts
@@ -0,0 +1,8 @@
+import { AbstractDependencyManager } from '../AbstractDependencyManager';
+import { CSharpOptions } from './CSharpGenerator';
+
+export class CSharpDependencyManager extends AbstractDependencyManager {
+ constructor(public options: CSharpOptions, dependencies: string[] = []) {
+ super(dependencies);
+ }
+}
diff --git a/src/generators/csharp/CSharpFileGenerator.ts b/src/generators/csharp/CSharpFileGenerator.ts
index c8af7944d1..da32f8f90e 100644
--- a/src/generators/csharp/CSharpFileGenerator.ts
+++ b/src/generators/csharp/CSharpFileGenerator.ts
@@ -1,23 +1,43 @@
import { CSharpGenerator, CSharpRenderCompleteModelOptions } from './';
-import { CommonInputModel, OutputModel } from '../../models';
+import { InputMetaModel, OutputModel } from '../../models';
import * as path from 'path';
import { AbstractFileGenerator } from '../AbstractFileGenerator';
import { FileHelpers } from '../../helpers';
+import { DeepPartial } from '../../utils';
-export class CSharpFileGenerator extends CSharpGenerator implements AbstractFileGenerator {
+export class CSharpFileGenerator
+ extends CSharpGenerator
+ implements AbstractFileGenerator
+{
/**
- * Generates all the models to an output directory each model with their own separate files.
- *
+ * Generates all the models to an output directory each model with their own separate files.
+ *
* @param input
* @param outputDirectory where you want the models generated to
* @param options
+ * @param ensureFilesWritten verify that the files is completely written before returning, this can happen if the file system is swamped with write requests.
*/
- public async generateToFiles(input: Record | CommonInputModel, outputDirectory: string, options: CSharpRenderCompleteModelOptions): Promise {
+ public async generateToFiles(
+ input: Record | InputMetaModel,
+ outputDirectory: string,
+ options: DeepPartial,
+ ensureFilesWritten = false
+ ): Promise {
let generatedModels = await this.generateCompleteModels(input, options);
- generatedModels = generatedModels.filter((outputModel) => { return outputModel.modelName !== undefined; });
+ //Filter anything out that have not been successfully generated
+ generatedModels = generatedModels.filter((outputModel) => {
+ return outputModel.modelName !== '';
+ });
for (const outputModel of generatedModels) {
- const filePath = path.resolve(outputDirectory, `${outputModel.modelName}.cs`);
- await FileHelpers.writerToFileSystem(outputModel.result, filePath);
+ const filePath = path.resolve(
+ outputDirectory,
+ `${outputModel.modelName}.cs`
+ );
+ await FileHelpers.writerToFileSystem(
+ outputModel.result,
+ filePath,
+ ensureFilesWritten
+ );
}
return generatedModels;
}
diff --git a/src/generators/csharp/CSharpGenerator.ts b/src/generators/csharp/CSharpGenerator.ts
index bb930f4962..c0aab16663 100644
--- a/src/generators/csharp/CSharpGenerator.ts
+++ b/src/generators/csharp/CSharpGenerator.ts
@@ -3,95 +3,263 @@ import {
CommonGeneratorOptions,
defaultGeneratorOptions
} from '../AbstractGenerator';
-import { CommonModel, CommonInputModel, RenderOutput } from '../../models';
-import { TypeHelpers, ModelKind, CommonNamingConvention, CommonNamingConventionImplementation, FormatHelpers } from '../../helpers';
+import {
+ ConstrainedEnumModel,
+ ConstrainedMetaModel,
+ ConstrainedObjectModel,
+ InputMetaModel,
+ MetaModel,
+ RenderOutput
+} from '../../models';
+import {
+ FormatHelpers,
+ TypeMapping,
+ Constraints,
+ constrainMetaModel,
+ split,
+ SplitOptions
+} from '../../helpers';
import { CSharpPreset, CSHARP_DEFAULT_PRESET } from './CSharpPreset';
import { EnumRenderer } from './renderers/EnumRenderer';
import { ClassRenderer } from './renderers/ClassRenderer';
import { isReservedCSharpKeyword } from './Constants';
import { Logger } from '../../index';
+import {
+ CSharpDefaultConstraints,
+ CSharpDefaultTypeMapping
+} from './CSharpConstrainer';
+import { DeepPartial, mergePartialAndDefault } from '../../utils/Partials';
+import { CSharpDependencyManager } from './CSharpDependencyManager';
export interface CSharpOptions extends CommonGeneratorOptions {
- collectionType?: 'List' | 'Array';
- namingConvention?: CommonNamingConvention;
+ collectionType: 'List' | 'Array';
+ typeMapping: TypeMapping;
+ constraints: Constraints;
+ autoImplementedProperties: boolean;
}
+export type CSharpTypeMapping = TypeMapping<
+ CSharpOptions,
+ CSharpDependencyManager
+>;
export interface CSharpRenderCompleteModelOptions {
- namespace: string
+ namespace: string;
}
/**
* Generator for CSharp
*/
-export class CSharpGenerator extends AbstractGenerator {
+export class CSharpGenerator extends AbstractGenerator<
+ CSharpOptions,
+ CSharpRenderCompleteModelOptions
+> {
static defaultOptions: CSharpOptions = {
...defaultGeneratorOptions,
collectionType: 'Array',
defaultPreset: CSHARP_DEFAULT_PRESET,
- namingConvention: CommonNamingConventionImplementation
+ typeMapping: CSharpDefaultTypeMapping,
+ constraints: CSharpDefaultConstraints,
+ autoImplementedProperties: false,
+ // Temporarily set
+ dependencyManager: () => {
+ return {} as CSharpDependencyManager;
+ }
+ };
+
+ static defaultCompleteModelOptions: CSharpRenderCompleteModelOptions = {
+ namespace: 'Asyncapi.Models'
};
- constructor(
- options: CSharpOptions = CSharpGenerator.defaultOptions,
- ) {
- super('CSharp', CSharpGenerator.defaultOptions, options);
+ constructor(options?: DeepPartial) {
+ const realizedOptions = CSharpGenerator.getCSharpOptions(options);
+ super('CSharp', realizedOptions);
+ }
+
+ /**
+ * Returns the CSharp options by merging custom options with default ones.
+ */
+ static getCSharpOptions(options?: DeepPartial): CSharpOptions {
+ const optionsToUse = mergePartialAndDefault(
+ this.defaultOptions,
+ options
+ ) as CSharpOptions;
+ //Always overwrite the dependency manager unless user explicitly state they want it (ignore default temporary dependency manager)
+ if (options?.dependencyManager === undefined) {
+ optionsToUse.dependencyManager = () => {
+ return new CSharpDependencyManager(optionsToUse);
+ };
+ }
+ return optionsToUse;
+ }
+
+ /**
+ * Wrapper to get an instance of the dependency manager
+ */
+ getDependencyManager(options: CSharpOptions): CSharpDependencyManager {
+ return this.getDependencyManagerInstance(
+ options
+ ) as CSharpDependencyManager;
+ }
+
+ splitMetaModel(model: MetaModel): MetaModel[] {
+ //These are the models that we have separate renderers for
+ const metaModelsToSplit: SplitOptions = {
+ splitEnum: true,
+ splitObject: true
+ };
+ return split(model, metaModelsToSplit);
+ }
+
+ constrainToMetaModel(
+ model: MetaModel,
+ options: DeepPartial
+ ): ConstrainedMetaModel {
+ const optionsToUse = CSharpGenerator.getCSharpOptions({
+ ...this.options,
+ ...options
+ });
+ const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
+ return constrainMetaModel(
+ this.options.typeMapping,
+ this.options.constraints,
+ {
+ metaModel: model,
+ dependencyManager: dependencyManagerToUse,
+ options: this.options,
+ constrainedName: '' //This is just a placeholder, it will be constrained within the function,
+ }
+ );
}
/**
* Render a complete model result where the model code, library and model dependencies are all bundled appropriately.
- *
+ *
* For CSharp we need to specify which namespace the model is placed under.
- *
- * @param model
- * @param inputModel
+ *
+ * @param model
+ * @param inputModel
* @param options used to render the full output
*/
- async renderCompleteModel(model: CommonModel, inputModel: CommonInputModel, options: CSharpRenderCompleteModelOptions): Promise {
- if (isReservedCSharpKeyword(options.namespace)) {
- throw new Error(`You cannot use reserved CSharp keyword (${options.namespace}) as namespace, please use another.`);
+ async renderCompleteModel(
+ model: ConstrainedMetaModel,
+ inputModel: InputMetaModel,
+ completeModelOptions: DeepPartial,
+ options: DeepPartial
+ ): Promise {
+ const completeModelOptionsToUse = mergePartialAndDefault(
+ CSharpGenerator.defaultCompleteModelOptions,
+ completeModelOptions
+ ) as CSharpRenderCompleteModelOptions;
+ const optionsToUse = CSharpGenerator.getCSharpOptions({
+ ...this.options,
+ ...options
+ });
+ if (isReservedCSharpKeyword(completeModelOptionsToUse.namespace)) {
+ throw new Error(
+ `You cannot use reserved CSharp keyword (${completeModelOptionsToUse.namespace}) as namespace, please use another.`
+ );
}
const outputModel = await this.render(model, inputModel);
- const outputDependencies = outputModel.dependencies.length === 0 ? '' : `${outputModel.dependencies.join('\n')}\n\n`;
+ const outputDependencies =
+ outputModel.dependencies.length === 0
+ ? ''
+ : `${outputModel.dependencies.join('\n')}\n\n`;
- const outputContent = `namespace ${options.namespace}
+ const outputContent = `namespace ${completeModelOptionsToUse.namespace}
{
-${FormatHelpers.indent(outputDependencies + outputModel.result, this.options.indentation?.size, this.options.indentation?.type)}
+${FormatHelpers.indent(
+ outputDependencies + outputModel.result,
+ optionsToUse.indentation?.size,
+ optionsToUse.indentation?.type
+)}
}`;
- return RenderOutput.toRenderOutput({ result: outputContent, renderedName: outputModel.renderedName, dependencies: outputModel.dependencies });
+ return RenderOutput.toRenderOutput({
+ result: outputContent,
+ renderedName: outputModel.renderedName,
+ dependencies: outputModel.dependencies
+ });
}
- render(model: CommonModel, inputModel: CommonInputModel): Promise {
- const kind = TypeHelpers.extractKind(model);
- switch (kind) {
- case ModelKind.UNION:
- //We dont support union in Csharp generator, however, if union is an object, we render it as a class.
- if (!model.type?.includes('object')) { break; }
- return this.renderClass(model, inputModel);
- case ModelKind.OBJECT:
- return this.renderClass(model, inputModel);
- case ModelKind.ENUM:
- return this.renderEnum(model, inputModel);
+ render(
+ model: ConstrainedMetaModel,
+ inputModel: InputMetaModel,
+ options?: DeepPartial
+ ): Promise {
+ const optionsToUse = CSharpGenerator.getCSharpOptions({
+ ...this.options,
+ ...options
+ });
+ if (model instanceof ConstrainedObjectModel) {
+ return this.renderClass(model, inputModel, optionsToUse);
+ } else if (model instanceof ConstrainedEnumModel) {
+ return this.renderEnum(model, inputModel, optionsToUse);
}
- Logger.warn(`C# generator, cannot generate this type of model, ${model.$id}`);
- return Promise.resolve(RenderOutput.toRenderOutput({ result: '', renderedName: '', dependencies: [] }));
+ Logger.warn(
+ `C# generator, cannot generate this type of model, ${model.name}`
+ );
+ return Promise.resolve(
+ RenderOutput.toRenderOutput({
+ result: '',
+ renderedName: '',
+ dependencies: []
+ })
+ );
}
- async renderEnum(model: CommonModel, inputModel: CommonInputModel): Promise {
+ async renderEnum(
+ model: ConstrainedEnumModel,
+ inputModel: InputMetaModel,
+ options?: Partial
+ ): Promise {
+ const optionsToUse = CSharpGenerator.getCSharpOptions({
+ ...this.options,
+ ...options
+ });
+ const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
const presets = this.getPresets('enum');
- const renderer = new EnumRenderer(this.options, this, presets, model, inputModel);
+ const renderer = new EnumRenderer(
+ this.options,
+ this,
+ presets,
+ model,
+ inputModel,
+ dependencyManagerToUse
+ );
const result = await renderer.runSelfPreset();
- const renderedName = renderer.nameType(model.$id, model);
- return RenderOutput.toRenderOutput({ result, renderedName, dependencies: renderer.dependencies });
+ return RenderOutput.toRenderOutput({
+ result,
+ renderedName: model.name,
+ dependencies: dependencyManagerToUse.dependencies
+ });
}
- async renderClass(model: CommonModel, inputModel: CommonInputModel): Promise {
+ async renderClass(
+ model: ConstrainedObjectModel,
+ inputModel: InputMetaModel,
+ options?: Partial
+ ): Promise {
+ const optionsToUse = CSharpGenerator.getCSharpOptions({
+ ...this.options,
+ ...options
+ });
+ const dependencyManagerToUse = this.getDependencyManager(optionsToUse);
const presets = this.getPresets('class');
- const renderer = new ClassRenderer(this.options, this, presets, model, inputModel);
+ const renderer = new ClassRenderer(
+ this.options,
+ this,
+ presets,
+ model,
+ inputModel,
+ dependencyManagerToUse
+ );
const result = await renderer.runSelfPreset();
- const renderedName = renderer.nameType(model.$id, model);
- return RenderOutput.toRenderOutput({ result, renderedName, dependencies: renderer.dependencies });
+ return RenderOutput.toRenderOutput({
+ result,
+ renderedName: model.name,
+ dependencies: dependencyManagerToUse.dependencies
+ });
}
}
diff --git a/src/generators/csharp/CSharpPreset.ts b/src/generators/csharp/CSharpPreset.ts
index 8528ebb24e..e5b8e74940 100644
--- a/src/generators/csharp/CSharpPreset.ts
+++ b/src/generators/csharp/CSharpPreset.ts
@@ -1,19 +1,37 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { Preset, EnumPreset, ClassPreset, PresetArgs, PropertyArgs } from '../../models';
-import { ClassRenderer, CSHARP_DEFAULT_CLASS_PRESET } from './renderers/ClassRenderer';
-import { CSHARP_DEFAULT_ENUM_PRESET, EnumRenderer } from './renderers/EnumRenderer';
+import {
+ Preset,
+ EnumPreset,
+ ClassPreset,
+ PresetArgs,
+ PropertyArgs,
+ ConstrainedObjectModel
+} from '../../models';
+import { CSharpOptions } from './CSharpGenerator';
+import {
+ ClassRenderer,
+ CSHARP_DEFAULT_CLASS_PRESET
+} from './renderers/ClassRenderer';
+import {
+ CSHARP_DEFAULT_ENUM_PRESET,
+ EnumRenderer
+} from './renderers/EnumRenderer';
// Our class preset uses custom `accessor` hook to craft getter and setters.
-export interface CsharpClassPreset extends ClassPreset {
- accessor?: (args: PresetArgs & PropertyArgs) => Promise | string;
+export interface CsharpClassPreset extends ClassPreset {
+ accessor?: (
+ args: PresetArgs & PropertyArgs
+ ) => Promise | string;
}
-export type CSharpPreset = Preset<{
- class: CsharpClassPreset;
- enum: EnumPreset
+export type ClassPresetType = CsharpClassPreset;
+export type EnumPresetType = EnumPreset;
+
+export type CSharpPreset = Preset<{
+ class: CsharpClassPreset;
+ enum: EnumPreset;
}>;
-export const CSHARP_DEFAULT_PRESET: CSharpPreset = {
+export const CSHARP_DEFAULT_PRESET: CSharpPreset = {
class: CSHARP_DEFAULT_CLASS_PRESET,
- enum: CSHARP_DEFAULT_ENUM_PRESET,
+ enum: CSHARP_DEFAULT_ENUM_PRESET
};
diff --git a/src/generators/csharp/CSharpRenderer.ts b/src/generators/csharp/CSharpRenderer.ts
index 57363fbfa5..797d784eb1 100644
--- a/src/generators/csharp/CSharpRenderer.ts
+++ b/src/generators/csharp/CSharpRenderer.ts
@@ -1,123 +1,30 @@
import { AbstractRenderer } from '../AbstractRenderer';
import { CSharpGenerator, CSharpOptions } from './CSharpGenerator';
-import { CommonModel, CommonInputModel, Preset, PropertyType } from '../../models';
+import { Preset, ConstrainedMetaModel, InputMetaModel } from '../../models';
import { FormatHelpers } from '../../helpers/FormatHelpers';
-import { isReservedCSharpKeyword } from './Constants';
+import { CSharpDependencyManager } from './CSharpDependencyManager';
/**
* Common renderer for CSharp types
- *
+ *
* @extends AbstractRenderer
*/
-export abstract class CSharpRenderer extends AbstractRenderer {
+export abstract class CSharpRenderer<
+ RendererModelType extends ConstrainedMetaModel
+> extends AbstractRenderer {
constructor(
options: CSharpOptions,
generator: CSharpGenerator,
presets: Array<[Preset, unknown]>,
- model: CommonModel,
- inputModel: CommonInputModel,
+ model: RendererModelType,
+ inputModel: InputMetaModel,
+ public dependencyManager: CSharpDependencyManager
) {
super(options, generator, presets, model, inputModel);
}
- /**
- * Renders the name of a type based on provided generator option naming convention type function.
- *
- * This is used to render names of models and then later used if that class is referenced from other models.
- *
- * @param name
- * @param model
- */
- nameType(name: string | undefined, model?: CommonModel): string {
- return this.options?.namingConvention?.type
- ? this.options.namingConvention.type(name, { model: model || this.model, inputModel: this.inputModel, reservedKeywordCallback: isReservedCSharpKeyword })
- : name || '';
- }
-
- /**
- * Renders the name of a property based on provided generator option naming convention property function.
- *
- * @param propertyName
- * @param property
- */
- nameProperty(propertyName: string | undefined, property?: CommonModel): string {
- return this.options?.namingConvention?.property
- ? this.options.namingConvention.property(propertyName, { model: this.model, inputModel: this.inputModel, property, reservedKeywordCallback: isReservedCSharpKeyword })
- : propertyName || '';
- }
-
- runPropertyPreset(propertyName: string, property: CommonModel, options: any, type: PropertyType = PropertyType.property): Promise {
- return this.runPreset('property', { propertyName, property, options, type });
- }
-
- renderType(model: CommonModel, modelName?: string): string {
- if (model.$ref !== undefined) {
- return this.nameType(model.$ref);
- }
-
- const isRequired = modelName ? this.model.isRequired(modelName) || this.model.required?.map(x => this.nameProperty(x)).includes(modelName) : false;
-
- if (Array.isArray(model.type)) {
- return model.type.length > 1 ? 'dynamic' : `${this.toCSharpType(model.type[0], model, modelName, isRequired)}`;
- }
-
- return this.toCSharpType(model.type, model, modelName, isRequired);
- }
-
renderComments(lines: string | string[]): string {
lines = FormatHelpers.breakLines(lines);
- return lines.map(line => `// ${line}`).join('\n');
- }
-
- toCSharpType(type: string | undefined, model: CommonModel, modelName?: string, isRequired?: boolean): string {
- switch (type) {
- case 'integer':
- case 'int32':
- return `int${this.questionMark(isRequired)}`;
- case 'long':
- case 'int64':
- return `long${this.questionMark(isRequired)}`;
- case 'boolean':
- return `bool${this.questionMark(isRequired)}`;
- case 'date':
- case 'time':
- case 'dateTime':
- case 'date-time':
- return `System.DateTime${this.questionMark(isRequired)}`;
- case 'string':
- case 'password':
- case 'byte':
- return 'string';
- case 'float':
- return `float${this.questionMark(isRequired)}`;
- case 'double':
- case 'number':
- return `double${this.questionMark(isRequired)}`;
- case 'binary':
- return 'byte[]';
- case 'object':
- return 'object';
- case 'array': {
- let arrayItemModel = model.items;
- if (Array.isArray(model.items)) {
- arrayItemModel = model.items.reduce((prevModel, currentModel) => {
- return CommonModel.mergeCommonModels(CommonModel.toCommonModel(prevModel), CommonModel.toCommonModel(currentModel), {});
- });
- if (model.additionalItems !== undefined) {
- arrayItemModel = CommonModel.mergeCommonModels(arrayItemModel, model.additionalItems, {});
- }
- }
- const newType = arrayItemModel ? this.renderType(arrayItemModel as CommonModel, modelName) : 'dynamic';
- if (this.options.collectionType && this.options.collectionType === 'List') {
- return `IEnumerable<${newType}>`;
- }
- return `${newType}[]`;
- }
- default: return 'dynamic';
- }
- }
-
- private questionMark(isRequired?: boolean): string {
- return isRequired ? '' : '?';
+ return lines.map((line) => `// ${line}`).join('\n');
}
}
diff --git a/src/generators/csharp/Constants.ts b/src/generators/csharp/Constants.ts
index 8959d7ab07..92157914e8 100644
--- a/src/generators/csharp/Constants.ts
+++ b/src/generators/csharp/Constants.ts
@@ -1,3 +1,5 @@
+import { checkForReservedKeyword } from '../../helpers';
+
export const RESERVED_CSHARP_KEYWORDS = [
'abstract',
'as',
@@ -78,6 +80,13 @@ export const RESERVED_CSHARP_KEYWORDS = [
'while'
];
-export function isReservedCSharpKeyword(word: string): boolean {
- return RESERVED_CSHARP_KEYWORDS.includes(word);
+export function isReservedCSharpKeyword(
+ word: string,
+ forceLowerCase = true
+): boolean {
+ return checkForReservedKeyword(
+ word,
+ RESERVED_CSHARP_KEYWORDS,
+ forceLowerCase
+ );
}
diff --git a/src/generators/csharp/constrainer/EnumConstrainer.ts b/src/generators/csharp/constrainer/EnumConstrainer.ts
new file mode 100644
index 0000000000..fa22cc1a75
--- /dev/null
+++ b/src/generators/csharp/constrainer/EnumConstrainer.ts
@@ -0,0 +1,98 @@
+import { ConstrainedEnumModel, EnumModel } from '../../../models';
+import {
+ NO_NUMBER_START_CHAR,
+ NO_DUPLICATE_ENUM_KEYS,
+ NO_EMPTY_VALUE,
+ NO_RESERVED_KEYWORDS
+} from '../../../helpers/Constraints';
+import {
+ EnumKeyConstraint,
+ EnumValueConstraint,
+ FormatHelpers
+} from '../../../helpers';
+import { isReservedCSharpKeyword } from '../Constants';
+
+export type ModelEnumKeyConstraints = {
+ NO_SPECIAL_CHAR: (value: string) => string;
+ NO_NUMBER_START_CHAR: (value: string) => string;
+ NO_DUPLICATE_KEYS: (
+ constrainedEnumModel: ConstrainedEnumModel,
+ enumModel: EnumModel,
+ value: string,
+ namingFormatter: (value: string) => string
+ ) => string;
+ NO_EMPTY_VALUE: (value: string) => string;
+ NAMING_FORMATTER: (value: string) => string;
+ NO_RESERVED_KEYWORDS: (value: string) => string;
+};
+
+export const DefaultEnumKeyConstraints: ModelEnumKeyConstraints = {
+ NO_SPECIAL_CHAR: (value: string) => {
+ //Exclude '_', '$' because they are allowed as enum keys
+ return FormatHelpers.replaceSpecialCharacters(value, {
+ exclude: ['_', '$'],
+ separator: '_'
+ });
+ },
+ NO_NUMBER_START_CHAR,
+ NO_DUPLICATE_KEYS: NO_DUPLICATE_ENUM_KEYS,
+ NO_EMPTY_VALUE,
+ NAMING_FORMATTER: FormatHelpers.toConstantCase,
+ NO_RESERVED_KEYWORDS: (value: string) => {
+ return NO_RESERVED_KEYWORDS(value, (value) => {
+ // We don't care about comparing values in lowercase as we are using constant case
+ // This means the reserved keywords technically never clashes
+ return isReservedCSharpKeyword(value, false);
+ });
+ }
+};
+
+export function defaultEnumKeyConstraints(
+ customConstraints?: Partial
](https://github.com/asyncapi/modelina/commits/master)
[](https://github.com/asyncapi/modelina/discussions)
[](https://www.asyncapi.com/tools/modelina) <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[](#contributors-)
+[](#contributors-)
<!-- ALL-CONTRIBUTORS-BADGE:END -->
---
-## :loudspeaker: ATTENTION:
-
-This package is currently being prepared to reach version 1.0.0 and the development is therefore happening on the [`next` branch](https://github.com/asyncapi/modelina/tree/next), any features must be based and targetting that branch.
-
----
-
<!-- toc is generated with GitHub Actions do not remove toc markers -->
<!-- toc -->
-- [Requirements](#requirements)
-- [Installation](#installation)
+- [Installing Modelina](#installing-modelina)
- [Features](#features)
- [Roadmap](#roadmap)
+- [Requirements](#requirements)
- [Documentation](#documentation)
- [Examples](#examples)
+- [Versioning and maintenance](#versioning-and-maintenance)
- [Development](#development)
- [Contributing](#contributing)
- [Contributors ✨](#contributors-%E2%9C%A8)
<!-- tocstop -->
-## Requirements
-
-- [NodeJS](https://nodejs.org/en/) >= 14
-
-Feel free to submit an issue if you require this project in other use-cases.
-
-## Installation
+## Installing Modelina
Run this command to install Modelina in your project:
@@ -52,13 +39,138 @@ Run this command to install Modelina in your project:
npm install @asyncapi/modelina
```
-Once you've successfully installed Modelina in your project, it's time to select your generator. Check out the [examples](#examples) for the specific code.
+<h2 align=){kind=link}
+
+
+