@alagoni97/cli 0.72.1

package/dist/codegen/modelina/presets/union.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnionPreset = void 0;
+const modelina_1 = require("@asyncapi/modelina");
+const LoggingInterface_1 = require("../../../LoggingInterface");
+const validation_1 = require("./validation");
+/**
+ * Find the best possible discriminator value along side the properties using;
+ * - Enum value
+ * - Constant
+ */
+function findBestDiscriminatorOption(model, renderer) {
+    //find first const or enum value since no explicit discriminator property found
+    const firstFound = Object.values(model.properties)
+        .map((property) => {
+        const enumModel = property.property instanceof modelina_1.ConstrainedReferenceModel &&
+            property.property.ref instanceof modelina_1.ConstrainedEnumModel
+            ? property.property.ref
+            : undefined;
+        const constValue = property.property.options.const
+            ? property.property.options.const.value
+            : undefined;
+        return {
+            isEnumModel: enumModel !== undefined,
+            isConst: constValue !== undefined,
+            constValue,
+            enumModel,
+            property
+        };
+    })
+        .filter(({ isConst, isEnumModel }) => {
+        return isConst || isEnumModel;
+    });
+    if (firstFound.length > 1) {
+        const potentialProperties = firstFound
+            .map(({ property }) => {
+            return property.propertyName;
+        })
+            .join(', ');
+        LoggingInterface_1.Logger.warn(`More then one property could be discriminator for union model ${model.name}, found property ${potentialProperties}`);
+    }
+    if (firstFound.length >= 1) {
+        const firstIsBest = firstFound[0];
+        const discriminatorValue = firstIsBest.property.unconstrainedPropertyName;
+        if (firstIsBest.isEnumModel) {
+            const enumModel = firstIsBest.enumModel;
+            renderer.dependencyManager.addTypeScriptDependency(`{${enumModel.type}}`, `./${enumModel.type}`);
+            return {
+                objCheck: `if(json.${discriminatorValue} === ${enumModel.type}.${enumModel.values[0].key}) {
+  return ${model.name}.unmarshal(json);
+  }`
+            };
+        }
+        else if (firstIsBest.isConst) {
+            return {
+                objCheck: `if(json.${discriminatorValue} === ${firstIsBest.constValue}) {
+  return ${model.name}.unmarshal(json);
+  }`
+            };
+        }
+        LoggingInterface_1.Logger.warn(`Could not determine discriminator for ${model.name}, as part of ${model.name}, will not be able to serialize or deserialize messages with this payload`);
+        return {};
+    }
+}
+function findDiscriminatorChecks(model, renderer) {
+    if (model instanceof modelina_1.ConstrainedReferenceModel &&
+        model.ref instanceof modelina_1.ConstrainedObjectModel) {
+        const discriminatorValue = model.options.discriminator?.type;
+        if (!discriminatorValue) {
+            return findBestDiscriminatorOption(model.ref, renderer);
+        }
+        // Use discriminatorValue to figure out if we unmarshal it
+        return {
+            objCheck: `if(json.${model.options.discriminator?.discriminator} === ${discriminatorValue}}) {
+return ${model.type}.unmarshal(json);
+}`
+        };
+    }
+    return {};
+}
+function renderUnionMarshal(model) {
+    const unmarshalChecks = model.union.map((unionModel) => {
+        if (unionModel instanceof modelina_1.ConstrainedReferenceModel &&
+            unionModel.ref instanceof modelina_1.ConstrainedObjectModel) {
+            return `if(payload instanceof ${unionModel.type}) {
+return payload.marshal();
+}`;
+        }
+    });
+    return `export function marshal(payload: ${model.name}) {
+  ${unmarshalChecks.join('\n')}
+  return JSON.stringify(payload);
+}`;
+}
+function renderUnionUnmarshal(model, renderer) {
+    const discriminatorChecks = model.union.map((model) => {
+        return findDiscriminatorChecks(model, renderer);
+    });
+    const hasObjValues = discriminatorChecks.filter((value) => value?.objCheck).length >= 1;
+    return `export function unmarshal(json: any): ${model.name} {
+  ${hasObjValues
+        ? `if(typeof json === 'object') {
+    ${discriminatorChecks
+            .filter((value) => value?.objCheck)
+            .map((value) => value?.objCheck)
+            .join('\n  ')}
+  }`
+        : ''}
+  return JSON.parse(json);
+}`;
+}
+/**
+ * Extract status code value from union member
+ */
+function extractStatusCodeValue(unionMember) {
+    if (!(unionMember instanceof modelina_1.ConstrainedReferenceModel &&
+        unionMember.ref instanceof modelina_1.ConstrainedObjectModel)) {
+        return null;
+    }
+    const memberOriginalInput = unionMember.ref.originalInput;
+    const statusCode = memberOriginalInput?.['x-modelina-status-codes'];
+    if (!statusCode) {
+        return null;
+    }
+    if (typeof statusCode === 'object' && statusCode.code !== undefined) {
+        return statusCode.code;
+    }
+    if (typeof statusCode === 'number') {
+        return statusCode;
+    }
+    return null;
+}
+/**
+ * Generate status code check string for a union member
+ */
+function generateStatusCodeCheck(unionMember, codeValue) {
+    return `  if (statusCode === ${codeValue}) {
+    return ${unionMember.type}.unmarshal(json);
+  }`;
+}
+/**
+ * Render status code based unmarshal function for union models
+ */
+function renderUnionUnmarshalByStatusCode(model) {
+    if (!model.originalInput?.['x-modelina-has-status-codes']) {
+        return '';
+    }
+    const statusCodeChecks = model.union
+        .map((unionMember) => {
+        const codeValue = extractStatusCodeValue(unionMember);
+        return codeValue !== null
+            ? generateStatusCodeCheck(unionMember, codeValue)
+            : null;
+    })
+        .filter((check) => check !== null);
+    if (statusCodeChecks.length === 0) {
+        return '';
+    }
+    return `
+export function unmarshalByStatusCode(json: any, statusCode: number): ${model.name} {
+${statusCodeChecks.join('\n')}
+  throw new Error(\`No matching type found for status code: \${statusCode}\`);
+}`;
+}
+/**
+ * Creates a union preset that adds marshalling/unmarshalling methods to union types
+ *
+ * @param options Configuration for union generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with union marshalling functionality
+ *
+ * @example
+ * ```typescript
+ * const preset = createUnionPreset({
+ *   includeValidation: true
+ * }, context);
+ * ```
+ */
+function createUnionPreset(options, context) {
+    return {
+        type: {
+            self({ model, content, renderer }) {
+                if (model instanceof modelina_1.ConstrainedUnionModel) {
+                    return `${content}
+
+${renderUnionUnmarshal(model, renderer)}
+${renderUnionMarshal(model)}
+${renderUnionUnmarshalByStatusCode(model)}
+${options.includeValidation ? (0, validation_1.generateTypescriptValidationCode)({ model, renderer, asClassMethods: false, context: context }) : ''}
+`;
+                }
+                return content;
+            }
+        }
+    };
+}
+exports.createUnionPreset = createUnionPreset;

package/dist/codegen/modelina/presets/validation.d.ts

@@ -0,0 +1,66 @@
+import { ConstrainedMetaModel } from '@asyncapi/modelina';
+import { TypeScriptRenderer } from '@asyncapi/modelina/lib/types/generators/typescript/TypeScriptRenderer';
+import { TypescriptHeadersContext, TypeScriptPayloadContext } from '../../generators';
+/**
+ * Safe stringify that removes x- properties and circular references by assuming true
+ */
+export declare function safeStringify(value: any): string;
+export declare function generateTypescriptValidationCode({ model, renderer, asClassMethods, context }: {
+    model: ConstrainedMetaModel;
+    renderer: TypeScriptRenderer;
+    asClassMethods?: boolean;
+    context: TypeScriptPayloadContext | TypescriptHeadersContext;
+}): string;
+export interface BaseGeneratorContext {
+    inputType: 'asyncapi' | 'openapi';
+    generator: {
+        includeValidation?: boolean;
+    };
+}
+/**
+ * Configuration options for the validation preset
+ */
+export interface ValidationPresetOptions {
+    /** Whether to include validation methods in generated models */
+    includeValidation: boolean;
+    /** Whether to generate as class methods (true) or standalone functions (false) */
+    asClassMethods?: boolean;
+}
+/**
+ * Creates a validation preset that adds AJV validation methods to generated TypeScript models
+ *
+ * @param options Configuration for validation generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with validation functionality
+ *
+ * @example
+ * ```typescript
+ * const preset = createValidationPreset({
+ *   includeValidation: true,
+ *   asClassMethods: true
+ * }, context);
+ * ```
+ */
+export declare function createValidationPreset(options: ValidationPresetOptions, context: BaseGeneratorContext): {
+    class: {
+        additionalContent: ({ content, model, renderer }: {
+            content: string;
+            model: ConstrainedMetaModel;
+            renderer: TypeScriptRenderer;
+        }) => string;
+    };
+};
+/**
+ * Creates a validation preset for union types (generates standalone functions)
+ *
+ * @param options Configuration for validation generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with validation functionality for union types
+ */
+export declare function createUnionValidationPreset(options: ValidationPresetOptions, context: BaseGeneratorContext): {
+    type?: undefined;
+} | {
+    type: {
+        additionalValidation: (model: ConstrainedMetaModel, renderer: TypeScriptRenderer) => string;
+    };
+};

package/dist/codegen/modelina/presets/validation.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnionValidationPreset = exports.createValidationPreset = exports.generateTypescriptValidationCode = exports.safeStringify = void 0;
+/**
+ * Safe stringify that removes x- properties and circular references by assuming true
+ */
+function safeStringify(value) {
+    let depth = 0;
+    const maxDepth = 255;
+    const maxRepetitions = 5; // Allow up to 5 repetitions of the same object
+    let isRoot = true;
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    function stringify(val, currentPath = []) {
+        // Check depth limit
+        if (depth > maxDepth) {
+            return true;
+        }
+        switch (typeof val) {
+            case 'function':
+                return true;
+            case 'boolean':
+            case 'number':
+            case 'string':
+                return val;
+            case 'object': {
+                if (val === null) {
+                    return null;
+                }
+                // Check for immediate circular reference (direct self-reference)
+                if (currentPath.length > 0 &&
+                    currentPath[currentPath.length - 1] === val) {
+                    return true;
+                }
+                // Count how many times this object appears in the current path
+                const repetitionCount = currentPath.filter((obj) => obj === val).length;
+                // If we've seen this object too many times in the current path, cut it off
+                if (repetitionCount >= maxRepetitions) {
+                    return true;
+                }
+                depth++;
+                const newPath = [...currentPath, val];
+                const atRoot = isRoot;
+                isRoot = false;
+                let result;
+                if (Array.isArray(val)) {
+                    result = val.map((item) => stringify(item, newPath));
+                }
+                else {
+                    result = {};
+                    // Check if this is a root-level schema with oneOf/anyOf that has conflicting type:object
+                    // Modelina adds type:object to union models, but this conflicts with primitive oneOf/anyOf
+                    const hasCompositionKeyword = val.oneOf !== undefined || val.anyOf !== undefined;
+                    const hasConflictingObjectType = val.type === 'object' && hasCompositionKeyword;
+                    for (const [key, value] of Object.entries(val)) {
+                        // Skip extension properties
+                        if (key.startsWith('x-modelina') ||
+                            key.startsWith('x-the-codegen-project') ||
+                            key.startsWith('x-parser-') ||
+                            key.startsWith('x-modelgen-') ||
+                            key.startsWith('discriminator')) {
+                            continue;
+                        }
+                        // Skip type:object at root level when there's oneOf/anyOf with primitives
+                        if (atRoot && key === 'type' && hasConflictingObjectType) {
+                            continue;
+                        }
+                        // eslint-disable-next-line security/detect-object-injection
+                        result[key] = stringify(value, newPath);
+                    }
+                }
+                depth--;
+                return result;
+            }
+            case 'undefined':
+                return undefined;
+            default:
+                return true;
+        }
+    }
+    return JSON.stringify(stringify(value));
+}
+exports.safeStringify = safeStringify;
+function generateTypescriptValidationCode({ model, renderer, asClassMethods = true, context }) {
+    renderer.dependencyManager.addTypeScriptDependency('{Ajv, Options as AjvOptions, ErrorObject, ValidateFunction}', 'ajv');
+    // Use named import with default alias for compatibility without esModuleInterop
+    // This works with both esModuleInterop: true and verbatimModuleSyntax: true
+    renderer.dependencyManager.addTypeScriptDependency('{default as addFormats}', 'ajv-formats');
+    const schemaProperty = asClassMethods
+        ? 'public static theCodeGenSchema'
+        : 'export const theCodeGenSchema';
+    const methodPrefix = asClassMethods ? 'public static ' : 'export function ';
+    const createValidatorCall = asClassMethods
+        ? 'this.createValidator(context)'
+        : 'createValidator(context)';
+    const compileCall = asClassMethods
+        ? 'this.theCodeGenSchema'
+        : 'theCodeGenSchema';
+    const vocabularies = context.inputType === 'openapi'
+        ? 'ajvInstance.addVocabulary(["xml", "example"])'
+        : '';
+    return `${schemaProperty} = ${safeStringify(model.originalInput)};
+${methodPrefix}validate(context?: {data: any, ajvValidatorFunction?: ValidateFunction, ajvInstance?: Ajv, ajvOptions?: AjvOptions}): { valid: boolean; errors?: ErrorObject[]; } {
+  const {data, ajvValidatorFunction} = context ?? {};
+  // Intentionally parse JSON strings to support validation of marshalled output.
+  // Example: validate({data: marshal(obj)}) works because marshal returns JSON string.
+  // Note: String 'true' will be coerced to boolean true due to JSON.parse.
+  const parsedData = typeof data === 'string' ? JSON.parse(data) : data;
+  const validate = ajvValidatorFunction ?? ${createValidatorCall}
+  return {
+    valid: validate(parsedData),
+    errors: validate.errors ?? undefined,
+  };
+}
+${methodPrefix}createValidator(context?: {ajvInstance?: Ajv, ajvOptions?: AjvOptions}): ValidateFunction {
+  const {ajvInstance} = {...context ?? {}, ajvInstance: new Ajv(context?.ajvOptions ?? {})};
+  addFormats(ajvInstance);
+  ${vocabularies}
+  const validate = ajvInstance.compile(${compileCall});
+  return validate;
+}
+`;
+}
+exports.generateTypescriptValidationCode = generateTypescriptValidationCode;
+/**
+ * Creates a validation preset that adds AJV validation methods to generated TypeScript models
+ *
+ * @param options Configuration for validation generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with validation functionality
+ *
+ * @example
+ * ```typescript
+ * const preset = createValidationPreset({
+ *   includeValidation: true,
+ *   asClassMethods: true
+ * }, context);
+ * ```
+ */
+function createValidationPreset(options, context) {
+    return {
+        class: {
+            additionalContent: ({ content, model, renderer }) => {
+                if (!options.includeValidation) {
+                    return content;
+                }
+                return `${content}
+${generateTypescriptValidationCode({
+                    model,
+                    renderer,
+                    asClassMethods: options.asClassMethods ?? true,
+                    context: context
+                })}`;
+            }
+        }
+    };
+}
+exports.createValidationPreset = createValidationPreset;
+/**
+ * Creates a validation preset for union types (generates standalone functions)
+ *
+ * @param options Configuration for validation generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with validation functionality for union types
+ */
+function createUnionValidationPreset(options, context) {
+    if (!options.includeValidation) {
+        return {};
+    }
+    return {
+        type: {
+            // This will be used in the union preset to add validation functions
+            additionalValidation: (model, renderer) => {
+                return generateTypescriptValidationCode({
+                    model,
+                    renderer,
+                    asClassMethods: false,
+                    context: context
+                });
+            }
+        }
+    };
+}
+exports.createUnionValidationPreset = createUnionValidationPreset;