@alagoni97/cli 0.72.1

package/dist/codegen/inputs/openapi/security.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSecuritySchemes = void 0;
+/**
+ * Extracts security schemes from an OpenAPI document.
+ * Handles both OpenAPI 3.x (components.securitySchemes) and
+ * Swagger 2.0 (securityDefinitions) formats.
+ */
+function extractSecuritySchemes(document) {
+    // Check if OpenAPI 3.x document
+    if ('openapi' in document) {
+        return extractOpenAPI3SecuritySchemes(document);
+    }
+    // Check if Swagger 2.0 document
+    if ('swagger' in document) {
+        return extractSwagger2SecuritySchemes(document);
+    }
+    return [];
+}
+exports.extractSecuritySchemes = extractSecuritySchemes;
+/**
+ * Extracts security schemes from OpenAPI 3.x documents.
+ */
+function extractOpenAPI3SecuritySchemes(document) {
+    const securitySchemes = document.components?.securitySchemes;
+    if (!securitySchemes) {
+        return [];
+    }
+    const schemes = [];
+    for (const [name, scheme] of Object.entries(securitySchemes)) {
+        // Skip $ref - should be dereferenced already
+        if ('$ref' in scheme) {
+            continue;
+        }
+        const securityScheme = scheme;
+        const extracted = extractOpenAPI3Scheme(name, securityScheme);
+        if (extracted) {
+            schemes.push(extracted);
+        }
+    }
+    return schemes;
+}
+/**
+ * Extracts a single OpenAPI 3.x security scheme.
+ */
+function extractOpenAPI3Scheme(name, scheme) {
+    switch (scheme.type) {
+        case 'apiKey':
+            return {
+                name,
+                type: 'apiKey',
+                apiKeyName: scheme.name,
+                apiKeyIn: scheme.in
+            };
+        case 'http':
+            return {
+                name,
+                type: 'http',
+                httpScheme: scheme.scheme,
+                bearerFormat: scheme.bearerFormat
+            };
+        case 'oauth2':
+            return {
+                name,
+                type: 'oauth2',
+                oauth2Flows: extractOAuth2Flows(scheme.flows)
+            };
+        case 'openIdConnect':
+            return {
+                name,
+                type: 'openIdConnect',
+                openIdConnectUrl: scheme.openIdConnectUrl
+            };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Extracts OAuth2 flows from OpenAPI 3.x OAuth2 security scheme.
+ */
+function extractOAuth2Flows(flows) {
+    const result = {};
+    if (flows.implicit) {
+        result.implicit = {
+            authorizationUrl: flows.implicit.authorizationUrl,
+            scopes: flows.implicit.scopes || {}
+        };
+    }
+    if (flows.password) {
+        result.password = {
+            tokenUrl: flows.password.tokenUrl,
+            scopes: flows.password.scopes || {}
+        };
+    }
+    if (flows.clientCredentials) {
+        result.clientCredentials = {
+            tokenUrl: flows.clientCredentials.tokenUrl,
+            scopes: flows.clientCredentials.scopes || {}
+        };
+    }
+    if (flows.authorizationCode) {
+        result.authorizationCode = {
+            authorizationUrl: flows.authorizationCode.authorizationUrl,
+            tokenUrl: flows.authorizationCode.tokenUrl,
+            scopes: flows.authorizationCode.scopes || {}
+        };
+    }
+    return result;
+}
+/**
+ * Extracts security definitions from Swagger 2.0 documents.
+ */
+function extractSwagger2SecuritySchemes(document) {
+    const securityDefinitions = document.securityDefinitions;
+    if (!securityDefinitions) {
+        return [];
+    }
+    const schemes = [];
+    for (const [name, definition] of Object.entries(securityDefinitions)) {
+        const extracted = extractSwagger2Scheme(name, definition);
+        if (extracted) {
+            schemes.push(extracted);
+        }
+    }
+    return schemes;
+}
+/**
+ * Extracts a single Swagger 2.0 security definition.
+ */
+function extractSwagger2Scheme(name, definition) {
+    switch (definition.type) {
+        case 'apiKey':
+            return {
+                name,
+                type: 'apiKey',
+                apiKeyName: definition.name,
+                apiKeyIn: definition.in
+            };
+        case 'basic':
+            // Swagger 2.0 has a separate 'basic' type which maps to http basic
+            return {
+                name,
+                type: 'http',
+                httpScheme: 'basic'
+            };
+        case 'oauth2':
+            return {
+                name,
+                type: 'oauth2',
+                oauth2Flows: extractSwagger2OAuth2Flow(definition)
+            };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Extracts OAuth2 flow from Swagger 2.0 format.
+ * Swagger 2.0 uses single 'flow' field instead of 'flows' object.
+ */
+function extractSwagger2OAuth2Flow(definition) {
+    const result = {};
+    const scopes = definition.scopes || {};
+    switch (definition.flow) {
+        case 'implicit':
+            result.implicit = {
+                authorizationUrl: definition.authorizationUrl || '',
+                scopes
+            };
+            break;
+        case 'password':
+            result.password = {
+                tokenUrl: definition.tokenUrl || '',
+                scopes
+            };
+            break;
+        case 'application':
+            // Swagger 2.0 'application' maps to OpenAPI 3.x 'clientCredentials'
+            result.clientCredentials = {
+                tokenUrl: definition.tokenUrl || '',
+                scopes
+            };
+            break;
+        case 'accessCode':
+            // Swagger 2.0 'accessCode' maps to OpenAPI 3.x 'authorizationCode'
+            result.authorizationCode = {
+                authorizationUrl: definition.authorizationUrl || '',
+                tokenUrl: definition.tokenUrl || '',
+                scopes
+            };
+            break;
+    }
+    return result;
+}

package/dist/codegen/modelina/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './presets';

package/dist/codegen/modelina/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export Zod types for TypeScript presets
+__exportStar(require("./types"), exports);
+// Export utility functions
+__exportStar(require("./presets"), exports);

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

@@ -0,0 +1,3 @@
+export { createValidationPreset, createUnionValidationPreset, safeStringify, type ValidationPresetOptions } from './validation';
+export { createUnionPreset, type UnionPresetOptions } from './union';
+export { createPrimitivesPreset, type PrimitivesPresetOptions } from './primitives';

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrimitivesPreset = exports.createUnionPreset = exports.safeStringify = exports.createUnionValidationPreset = exports.createValidationPreset = void 0;
+// Core validation presets
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "createValidationPreset", { enumerable: true, get: function () { return validation_1.createValidationPreset; } });
+Object.defineProperty(exports, "createUnionValidationPreset", { enumerable: true, get: function () { return validation_1.createUnionValidationPreset; } });
+Object.defineProperty(exports, "safeStringify", { enumerable: true, get: function () { return validation_1.safeStringify; } });
+// Core union marshalling/unmarshalling presets
+var union_1 = require("./union");
+Object.defineProperty(exports, "createUnionPreset", { enumerable: true, get: function () { return union_1.createUnionPreset; } });
+// Primitive and array type marshalling/unmarshalling presets
+var primitives_1 = require("./primitives");
+Object.defineProperty(exports, "createPrimitivesPreset", { enumerable: true, get: function () { return primitives_1.createPrimitivesPreset; } });

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

@@ -0,0 +1,34 @@
+import { ConstrainedMetaModel } from '@asyncapi/modelina';
+import { TypeScriptRenderer } from '@asyncapi/modelina/lib/types/generators/typescript/TypeScriptRenderer';
+import { BaseGeneratorContext } from './validation';
+/**
+ * Configuration options for the primitives preset
+ */
+export interface PrimitivesPresetOptions {
+    /** Whether to include validation methods in generated primitive types */
+    includeValidation: boolean;
+}
+/**
+ * Creates a preset that adds marshalling/unmarshalling and validation methods
+ * to primitive types (string, number, boolean) and array types
+ *
+ * @param options Configuration for primitive generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with primitive marshalling functionality
+ *
+ * @example
+ * ```typescript
+ * const preset = createPrimitivesPreset({
+ *   includeValidation: true
+ * }, context);
+ * ```
+ */
+export declare function createPrimitivesPreset(options: PrimitivesPresetOptions, context: BaseGeneratorContext): {
+    type: {
+        self({ model, content, renderer }: {
+            model: ConstrainedMetaModel;
+            content: string;
+            renderer: TypeScriptRenderer;
+        }): string;
+    };
+};

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

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrimitivesPreset = void 0;
+const modelina_1 = require("@asyncapi/modelina");
+const validation_1 = require("./validation");
+/**
+ * Check if the model is a primitive type (string, integer, float, boolean)
+ */
+function isPrimitiveModel(model) {
+    return (model instanceof modelina_1.ConstrainedStringModel ||
+        model instanceof modelina_1.ConstrainedIntegerModel ||
+        model instanceof modelina_1.ConstrainedFloatModel ||
+        model instanceof modelina_1.ConstrainedBooleanModel);
+}
+/**
+ * Check if the model is a null type (ConstrainedAnyModel with type: null in schema)
+ * Modelina converts null types to ConstrainedAnyModel
+ */
+function isNullModel(model) {
+    if (!(model instanceof modelina_1.ConstrainedAnyModel)) {
+        return false;
+    }
+    // Check if the original input schema has type: null
+    const originalInput = model.originalInput;
+    return originalInput && originalInput.type === 'null';
+}
+/**
+ * Check if the model is a date format string type (date or date-time)
+ * Note: 'time' format is NOT included because RFC 3339 time strings like "14:30:00"
+ * are not valid Date constructor arguments in JavaScript and would produce Invalid Date.
+ * Time values should remain as strings.
+ */
+function isDateFormatModel(model) {
+    if (!(model instanceof modelina_1.ConstrainedStringModel)) {
+        return false;
+    }
+    const format = model.originalInput?.format;
+    return format === 'date' || format === 'date-time';
+}
+/**
+ * Render marshal function for null type
+ */
+function renderNullMarshal(model) {
+    return `export function marshal(payload: null): string {
+  return JSON.stringify(payload);
+}`;
+}
+/**
+ * Render unmarshal function for null type
+ */
+function renderNullUnmarshal(model) {
+    return `export function unmarshal(json: string): null {
+  const parsed = JSON.parse(json);
+  if (parsed !== null) {
+    throw new Error('Expected null value');
+  }
+  return null;
+}`;
+}
+/**
+ * Render marshal function for primitive types
+ */
+function renderPrimitiveMarshal(model) {
+    return `export function marshal(payload: ${model.name}): string {
+  return JSON.stringify(payload);
+}`;
+}
+/**
+ * Render unmarshal function for primitive types
+ */
+function renderPrimitiveUnmarshal(model) {
+    // For string types, the input can be a JSON string (quoted) or the raw value
+    // We use 'any' for the json parameter since JSON.parse returns 'any'
+    return `export function unmarshal(json: string): ${model.name} {
+  return JSON.parse(json) as ${model.name};
+}`;
+}
+/**
+ * Render unmarshal function for date format types
+ * Converts JSON string to JavaScript Date object
+ */
+function renderDateUnmarshal(model) {
+    return `export function unmarshal(json: string): ${model.name} {
+  const parsed = JSON.parse(json);
+  return new Date(parsed);
+}`;
+}
+/**
+ * Render marshal function for date format types
+ * Note: JSON.stringify(Date) calls Date.toJSON() which returns ISO string
+ */
+function renderDateMarshal(model) {
+    return `export function marshal(payload: ${model.name}): string {
+  return JSON.stringify(payload);
+}`;
+}
+/**
+ * Render marshal function for array types
+ */
+function renderArrayMarshal(model) {
+    const valueModel = model.valueModel;
+    // Check if array items have a marshal method (object types)
+    const hasItemMarshal = valueModel.type !== 'string' &&
+        valueModel.type !== 'number' &&
+        valueModel.type !== 'boolean';
+    if (hasItemMarshal) {
+        return `export function marshal(payload: ${model.name}): string {
+  return JSON.stringify(payload.map((item) => {
+    if (item && typeof item === 'object' && 'marshal' in item && typeof item.marshal === 'function') {
+      return JSON.parse(item.marshal());
+    }
+    return item;
+  }));
+}`;
+    }
+    return `export function marshal(payload: ${model.name}): string {
+  return JSON.stringify(payload);
+}`;
+}
+/**
+ * Render unmarshal function for array types
+ */
+function renderArrayUnmarshal(model) {
+    const valueModel = model.valueModel;
+    // Check if array items have an unmarshal method (only object types do)
+    // Exclude primitives, nested arrays, and union types - they don't have unmarshal methods
+    // Union types are just type aliases without static unmarshal methods
+    const hasItemUnmarshal = valueModel.type !== 'string' &&
+        valueModel.type !== 'number' &&
+        valueModel.type !== 'boolean' &&
+        !(valueModel instanceof modelina_1.ConstrainedArrayModel) &&
+        !(valueModel instanceof modelina_1.ConstrainedUnionModel);
+    if (hasItemUnmarshal) {
+        const itemTypeName = valueModel.name;
+        return `export function unmarshal(json: string | any[]): ${model.name} {
+  const arr = typeof json === 'string' ? JSON.parse(json) : json;
+  return arr.map((item: any) => {
+    if (item && typeof item === 'object') {
+      return ${itemTypeName}.unmarshal(item);
+    }
+    return item;
+  }) as ${model.name};
+}`;
+    }
+    return `export function unmarshal(json: string | any[]): ${model.name} {
+  if (typeof json === 'string') {
+    return JSON.parse(json) as ${model.name};
+  }
+  return json as ${model.name};
+}`;
+}
+/**
+ * Creates a preset that adds marshalling/unmarshalling and validation methods
+ * to primitive types (string, number, boolean) and array types
+ *
+ * @param options Configuration for primitive generation
+ * @param context Generator context containing input type information
+ * @returns Modelina preset object with primitive marshalling functionality
+ *
+ * @example
+ * ```typescript
+ * const preset = createPrimitivesPreset({
+ *   includeValidation: true
+ * }, context);
+ * ```
+ */
+function createPrimitivesPreset(options, context) {
+    return {
+        type: {
+            self({ model, content, renderer }) {
+                // Handle primitive types (string, integer, float, boolean)
+                if (isPrimitiveModel(model)) {
+                    // Use date-specific marshal/unmarshal for date formats
+                    const isDate = isDateFormatModel(model);
+                    const unmarshalFunc = isDate
+                        ? renderDateUnmarshal(model)
+                        : renderPrimitiveUnmarshal(model);
+                    const marshalFunc = isDate
+                        ? renderDateMarshal(model)
+                        : renderPrimitiveMarshal(model);
+                    return `${content}
+
+${unmarshalFunc}
+${marshalFunc}
+${options.includeValidation ? (0, validation_1.generateTypescriptValidationCode)({ model, renderer, asClassMethods: false, context: context }) : ''}
+`;
+                }
+                // Handle array types
+                if (model instanceof modelina_1.ConstrainedArrayModel) {
+                    return `${content}
+
+${renderArrayUnmarshal(model)}
+${renderArrayMarshal(model)}
+${options.includeValidation ? (0, validation_1.generateTypescriptValidationCode)({ model, renderer, asClassMethods: false, context: context }) : ''}
+`;
+                }
+                // Handle null types (ConstrainedAnyModel with type: null in original schema)
+                if (isNullModel(model)) {
+                    return `${content}
+
+${renderNullUnmarshal(model)}
+${renderNullMarshal(model)}
+${options.includeValidation ? (0, validation_1.generateTypescriptValidationCode)({ model, renderer, asClassMethods: false, context: context }) : ''}
+`;
+                }
+                return content;
+            }
+        }
+    };
+}
+exports.createPrimitivesPreset = createPrimitivesPreset;

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

@@ -0,0 +1,33 @@
+import { ConstrainedMetaModel } from '@asyncapi/modelina';
+import { TypeScriptRenderer } from '@asyncapi/modelina/lib/types/generators/typescript/TypeScriptRenderer';
+import { BaseGeneratorContext } from './validation';
+/**
+ * Configuration options for the union preset
+ */
+export interface UnionPresetOptions {
+    /** Whether to include validation methods in generated union types */
+    includeValidation: boolean;
+}
+/**
+ * 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);
+ * ```
+ */
+export declare function createUnionPreset(options: UnionPresetOptions, context: BaseGeneratorContext): {
+    type: {
+        self({ model, content, renderer }: {
+            model: ConstrainedMetaModel;
+            content: string;
+            renderer: TypeScriptRenderer;
+        }): string;
+    };
+};