From a0d868d4386ccee8f6fcc8481137338fe590b770 Mon Sep 17 00:00:00 2001 From: Karl von Randow Date: Thu, 22 Aug 2024 18:43:28 +1200 Subject: [PATCH] Add info to CodegenNativeType to support generators to augment native types as required --- .changeset/honest-starfishes-beam.md | 6 ++++ packages/core/src/native-type.ts | 50 +++++++++++++++++++++++++++- packages/types/src/native-types.ts | 12 ++++++- packages/types/src/types.ts | 10 ++++++ 4 files changed, 76 insertions(+), 2 deletions(-) create mode 100644 .changeset/honest-starfishes-beam.md diff --git a/.changeset/honest-starfishes-beam.md b/.changeset/honest-starfishes-beam.md new file mode 100644 index 00000000..b42b8b0a --- /dev/null +++ b/.changeset/honest-starfishes-beam.md @@ -0,0 +1,6 @@ +--- +"@openapi-generator-plus/types": minor +"@openapi-generator-plus/core": minor +--- + +Add info to CodegenNativeType to support generators to augment native types as required diff --git a/packages/core/src/native-type.ts b/packages/core/src/native-type.ts index 816a26f7..bd338e6a 100644 --- a/packages/core/src/native-type.ts +++ b/packages/core/src/native-type.ts @@ -1,5 +1,5 @@ /* eslint-disable @typescript-eslint/explicit-module-boundary-types */ -import { CodegenNativeType, CodegenNativeTypeTransformers, CodegenNativeTypeComposers, CodegenNativeTypeComposer } from '@openapi-generator-plus/types' +import { CodegenNativeType, CodegenNativeTypeTransformers, CodegenNativeTypeComposers, CodegenNativeTypeComposer, CodegenNativeTypeInfo } from '@openapi-generator-plus/types' export class CodegenNativeTypeImpl implements CodegenNativeType { @@ -9,6 +9,7 @@ export class CodegenNativeTypeImpl implements CodegenNativeType { public concreteType: string public parentType: string public componentType: CodegenNativeType | null + private infoValue: CodegenNativeTypeInfo | null public constructor(nativeType: string, additionalTypes?: { serializedType?: string @@ -16,6 +17,7 @@ export class CodegenNativeTypeImpl implements CodegenNativeType { concreteType?: string parentType?: string componentType?: CodegenNativeType | null + info?: CodegenNativeTypeInfo }) { this.nativeType = nativeType if (additionalTypes) { @@ -24,12 +26,23 @@ export class CodegenNativeTypeImpl implements CodegenNativeType { this.concreteType = additionalTypes.concreteType !== undefined ? additionalTypes.concreteType : nativeType this.parentType = additionalTypes.parentType !== undefined ? additionalTypes.parentType : nativeType this.componentType = additionalTypes.componentType !== undefined ? additionalTypes.componentType : null + this.infoValue = additionalTypes.info !== undefined ? additionalTypes.info : null } else { this.serializedType = nativeType this.literalType = nativeType this.concreteType = nativeType this.parentType = nativeType this.componentType = null + this.infoValue = null + } + } + + public get info() { + /* We provide this getter to ensure that our info remains immutable */ + if (this.infoValue) { + return { ...this.infoValue } + } else { + return null } } @@ -107,6 +120,16 @@ export class CodegenTransformingNativeTypeImpl implements CodegenNativeType { } } + public get info(): CodegenNativeTypeInfo | null { + const transformer = this.transformers.info !== undefined ? this.transformers.info : (nativeType: CodegenNativeType) => nativeType.info + if (transformer) { + /* We must create a new object to prevent modifications to the wrapped info */ + return transformer(this.wrapped) + } else { + return this.wrapped.info + } + } + private get wrapped(): CodegenNativeType { return this.actualWrapped } @@ -160,6 +183,18 @@ export class CodegenComposingNativeTypeImpl implements CodegenNativeType { return null } } + + + /** + * The default composing of `info` is to combine left to right. + */ + public get info(): CodegenNativeTypeInfo | null { + if (this.composers.info) { + return this.composers.info(this.wrapped, defaultCodegenNativeTypeInfoComposer) + } else { + return defaultCodegenNativeTypeInfoComposer(this.wrapped) + } + } private get wrapped(): CodegenNativeType[] { return this.actualWrapped @@ -179,6 +214,19 @@ export class CodegenComposingNativeTypeImpl implements CodegenNativeType { } +function defaultCodegenNativeTypeInfoComposer(nativeTypes: CodegenNativeType[]): CodegenNativeTypeInfo | null { + let result: CodegenNativeTypeInfo | null = null + for (const nativeType of nativeTypes) { + if (nativeType.info) { + if (!result) { + result = {} + } + Object.assign(result, nativeType.info) + } + } + return result +} + function equalNativeType(a: CodegenNativeType, b: CodegenNativeType | undefined): boolean { if (!b) { return false diff --git a/packages/types/src/native-types.ts b/packages/types/src/native-types.ts index 03bc1f1a..35d0b73f 100644 --- a/packages/types/src/native-types.ts +++ b/packages/types/src/native-types.ts @@ -1,7 +1,9 @@ -import { CodegenNativeType } from './types' +import { CodegenNativeType, CodegenNativeTypeInfo } from './types' export type CodegenNativeTypeStringComposer = (nativeTypeStrings: string[]) => string export type CodegenNativeTypeComposer = (nativeTypes: CodegenNativeType[]) => string +type DefaultCodegenNativeTypeInfoComposer = (nativeTypes: CodegenNativeType[]) => CodegenNativeTypeInfo | null +export type CodegenNativeTypeInfoComposer = (nativeTypes: CodegenNativeType[], defaultComposer: DefaultCodegenNativeTypeInfoComposer) => CodegenNativeTypeInfo | null /** * Transform the given native type. @@ -11,6 +13,12 @@ export type CodegenNativeTypeComposer = (nativeTypes: CodegenNativeType[]) => st */ export type CodegenNativeTypeTransformer = (nativeType: CodegenNativeType, nativeTypeString: string) => string +/** + * Transform the native type info + * @param nativeType the native type + */ +export type CodegenNativeTypeInfoTransformer = (nativeType: CodegenNativeType) => CodegenNativeTypeInfo | null + export interface CodegenNativeTypeTransformers { /** * Implement the default transformer if you don't need to know which CodegenNativeType property is being transformed, @@ -29,6 +37,7 @@ export interface CodegenNativeTypeTransformers { * If undefined, the component type is transformed using this set of transformers. */ componentType?: CodegenNativeTypeTransformers | null + info?: CodegenNativeTypeInfoTransformer | null } export interface CodegenTransformingNativeTypeConstructor { @@ -42,6 +51,7 @@ export interface CodegenNativeTypeComposers { literalType?: CodegenNativeTypeComposer parentType?: CodegenNativeTypeComposer concreteType?: CodegenNativeTypeComposer + info?: CodegenNativeTypeInfoComposer } export interface CodegenComposingNativeTypeConstructor { diff --git a/packages/types/src/types.ts b/packages/types/src/types.ts index f2249935..b878eede 100644 --- a/packages/types/src/types.ts +++ b/packages/types/src/types.ts @@ -418,6 +418,7 @@ export interface CodegenNativeTypeConstructor { literalType?: string concreteType?: string componentType?: CodegenNativeType + info?: CodegenNativeTypeInfo }): CodegenNativeType } @@ -449,12 +450,21 @@ export interface CodegenNativeType { */ componentType: CodegenNativeType | null + /** + * Any extra information that a generator template might provide to help with code generation. + */ + info: CodegenNativeTypeInfo | null + toString(): string equals(other: CodegenNativeType | undefined): boolean } +export interface CodegenNativeTypeInfo { + [key: string]: unknown +} + export enum CodegenSchemaType { OBJECT = 'OBJECT', INTERFACE = 'INTERFACE',