@skmtc/core 0.0.984 → 0.16.1

package/script/dsl/operation/types.d.ts

@@ -1,125 +0,0 @@
-import type { OasOperation } from '../../oas/operation/Operation.js';
-import type { ContentSettings } from '../ContentSettings.js';
-import type { GenerateContextType } from '../../context/generateTypes.js';
-import type { Identifier } from '../Identifier.js';
-import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
-import type * as v from 'valibot';
-import type { MappingModule, PreviewModule } from '../../types/Preview.js';
-/**
- * Arguments passed to operation insertable constructors.
- *
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type OperationInsertableArgs<EnrichmentType = undefined> = {
-    context: GenerateContextType;
-    settings: ContentSettings<EnrichmentType>;
-    operation: OasOperation;
-};
-/**
- * Arguments passed to operation transformation functions.
- *
- * @template Acc - Accumulator type for collecting transformation results
- */
-export type TransformOperationArgs<Acc> = {
-    context: GenerateContextType;
-    operation: OasOperation;
-    acc: Acc | undefined;
-};
-/**
- * Interface for objects that provide operation transformation capabilities.
- *
- * Used by generator configurations to transform operation definitions
- * during the code generation process.
- */
-export type WithTransformOperation = {
-    transformOperation: (operation: OasOperation) => void;
-};
-/**
- * Arguments for checking if an operation is supported with enrichment configuration.
- *
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type IsSupportedOperationConfigArgs<EnrichmentType = undefined> = {
-    context: GenerateContextType;
-    operation: OasOperation;
-    enrichments: EnrichmentType;
-};
-/**
- * Arguments for checking if an operation is supported for code generation.
- */
-export type IsSupportedOperationArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Arguments for generating enrichment data for operations.
- */
-export type ToOperationEnrichmentsArgs = {
-    operation: OasOperation;
-    context: GenerateContextType;
-};
-/**
- * Arguments for generating operation preview modules.
- *
- * Preview modules provide quick insights into generated operations
- * without full code generation.
- */
-export type ToOperationPreviewModuleArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Arguments for generating operation mapping information.
- *
- * Mappings track relationships between OAS operations and generated code,
- * enabling cross-references and dependency analysis.
- */
-export type ToOperationMappingArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Configuration object for insertable operation generators.
- *
- * Defines the contract for operation generator classes that can be inserted
- * into the generation context to produce type-safe operation definitions.
- *
- * @template V - Generated value type produced by the operation generator
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type OperationInsertable<V, EnrichmentType = undefined> = {
-    prototype: V;
-} & {
-    new ({ context, settings, operation }: OperationInsertableArgs<EnrichmentType>): V;
-    id: string;
-    type: 'operation';
-    toIdentifier: (operation: OasOperation) => Identifier;
-    toExportPath: (operation: OasOperation) => string;
-    toEnrichments: ({ operation, context }: ToOperationEnrichmentsArgs) => EnrichmentType;
-} & Function;
-/**
- * Arguments for checking if an operation is supported for generation.
- */
-export type IsSupportedArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Configuration object for operation generators.
- *
- * Defines the behavior and capabilities of operation generators including
- * support detection, transformation logic, and enrichment handling.
- *
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type OperationConfig<EnrichmentType = undefined> = {
-    id: string;
-    type: 'operation';
-    transform: <Acc = void>({ context, operation, acc }: TransformOperationArgs<Acc>) => Acc;
-    toEnrichmentSchema?: () => v.GenericSchema<EnrichmentType>;
-    isSupported: ({ context, operation }: IsSupportedArgs) => boolean;
-    toPreviewModule?: ({ context, operation }: ToOperationPreviewModuleArgs) => PreviewModule;
-    toMappingModule?: ({ context, operation }: ToOperationMappingArgs) => MappingModule;
-    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: OasOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
-};
-//# sourceMappingURL=types.d.ts.map

package/script/dsl/operation/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/types.ts"],"names":[],"mappings":"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"}

package/script/helpers/protectedKeywords.d.ts

@@ -1,2 +0,0 @@
-export declare const protectedKeywords: Record<string, string>;
-//# sourceMappingURL=protectedKeywords.d.ts.map

package/script/helpers/protectedKeywords.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protectedKeywords.d.ts","sourceRoot":"","sources":["../../src/helpers/protectedKeywords.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoEpD,CAAA"}

package/script/helpers/protectedKeywords.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.protectedKeywords = void 0;
-exports.protectedKeywords = {
-    abstract: 'abstractValue',
-    arguments: 'argumentsValue',
-    'async *': 'asyncStarValue',
-    'await *': 'awaitStarValue',
-    boolean: 'booleanValue',
-    break: 'breakValue',
-    byte: 'byteValue',
-    case: 'caseValue',
-    catch: 'catchValue',
-    char: 'charValue',
-    'class *': 'classStarValue',
-    'const *': 'constStarValue',
-    continue: 'continueValue',
-    debugger: 'debuggerValue',
-    default: 'defaultValue',
-    delete: 'deleteValue',
-    do: 'doValue',
-    double: 'doubleValue',
-    else: 'elseValue',
-    'enum *': 'enumStarValue',
-    eval: 'evalValue',
-    export: 'exportValue',
-    'export *': 'exportStarValue',
-    'extends *': 'extendsStarValue',
-    false: 'falseValue',
-    final: 'finalValue',
-    finally: 'finallyValue',
-    float: 'floatValue',
-    for: 'forValue',
-    goto: 'gotoValue',
-    if: 'ifValue',
-    implements: 'implementsValue',
-    function: 'functionValue',
-    'import *': 'importStarValue',
-    in: 'inValue',
-    instanceof: 'instanceofValue',
-    int: 'intValue',
-    interface: 'interfaceValue',
-    'let *': 'letStarValue',
-    long: 'longValue',
-    native: 'nativeValue',
-    new: 'newValue',
-    null: 'nullValue',
-    package: 'packageValue',
-    private: 'privateValue',
-    protected: 'protectedValue',
-    public: 'publicValue',
-    return: 'returnValue',
-    short: 'shortValue',
-    static: 'staticValue',
-    'super *': 'superStarValue',
-    switch: 'switchValue',
-    synchronized: 'synchronizedValue',
-    this: 'thisValue',
-    throw: 'throwValue',
-    throws: 'throwsValue',
-    transient: 'transientValue',
-    true: 'trueValue',
-    try: 'tryValue',
-    typeof: 'typeofValue',
-    'using *': 'usingStarValue',
-    var: 'varValue',
-    void: 'voidValue',
-    volatile: 'volatileValue',
-    while: 'whileValue',
-    with: 'withValue',
-    yield: 'yieldValue'
-};

package/script/helpers/sanitizePropertyName.d.ts

@@ -1,3 +0,0 @@
-import type { Stringable } from '../dsl/Stringable.js';
-export declare const sanitizePropertyName: (propertyName: string) => string | Stringable;
-//# sourceMappingURL=sanitizePropertyName.d.ts.map

package/script/helpers/sanitizePropertyName.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizePropertyName.d.ts","sourceRoot":"","sources":["../../src/helpers/sanitizePropertyName.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEtD,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,UAYpE,CAAA"}

package/script/helpers/sanitizePropertyName.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizePropertyName = void 0;
-const helper_validator_identifier_1 = require("@babel/helper-validator-identifier");
-const List_js_1 = require("../typescript/List.js");
-const strings_js_1 = require("./strings.js");
-const protectedKeywords_js_1 = require("./protectedKeywords.js");
-const sanitizePropertyName = (propertyName) => {
-    const sanitizedKeyword = protectedKeywords_js_1.protectedKeywords[propertyName];
-    if (sanitizedKeyword) {
-        return List_js_1.List.toKeyValue(propertyName, sanitizedKeyword);
-    }
-    if (!(0, helper_validator_identifier_1.isIdentifierName)(propertyName)) {
-        return List_js_1.List.toKeyValue(`'${propertyName}'`, (0, strings_js_1.camelCase)(propertyName));
-    }
-    return propertyName;
-};
-exports.sanitizePropertyName = sanitizePropertyName;

package/script/helpers/tracer.d.ts

@@ -1,127 +0,0 @@
-import type { StackTrail } from '../context/StackTrail.js';
-/**
- * Executes a function with distributed tracing support and stack trail management.
- *
- * This utility function provides distributed tracing capabilities for the SKMTC
- * generation pipeline. It manages stack trail tokens that help track execution
- * context across complex nested operations, making debugging and performance
- * analysis much easier.
- *
- * The tracer ensures proper cleanup of stack trail tokens even if the wrapped
- * function throws an error, maintaining the integrity of the tracing system.
- * This is essential for accurate debugging and performance monitoring in
- * complex code generation scenarios.
- *
- * @template T - The return type of the traced function
- * @param stackTrail - The stack trail instance for tracking execution context
- * @param token - Token(s) to identify this execution step in traces
- * @param fn - The function to execute with tracing
- * @param log - Logger instance for error reporting
- * @returns The result of the wrapped function execution
- *
- * @throws Re-throws any error from the wrapped function after cleanup
- *
- * @example Basic tracing usage
- * ```typescript
- * import { tracer } from '@skmtc/core';
- *
- * class ModelGenerator {
- *   generateModel(stackTrail: StackTrail, logger: Logger) {
- *     return tracer(stackTrail, 'generate-model', () => {
- *       // Complex model generation logic here
- *       return this.createModelDefinition();
- *     }, logger);
- *   }
- * }
- * ```
- *
- * @example Nested tracing
- * ```typescript
- * class ComplexProcessor {
- *   processSchema(stackTrail: StackTrail, logger: Logger) {
- *     return tracer(stackTrail, 'process-schema', () => {
- *       const parsed = tracer(stackTrail, 'parse', () => {
- *         return this.parseSchema();
- *       }, logger);
- *
- *       const validated = tracer(stackTrail, 'validate', () => {
- *         return this.validateSchema(parsed);
- *       }, logger);
- *
- *       return tracer(stackTrail, 'transform', () => {
- *         return this.transformSchema(validated);
- *       }, logger);
- *     }, logger);
- *   }
- * }
- *
- * // Stack trail will show: ['process-schema', 'parse'] -> ['process-schema', 'validate'] -> ['process-schema', 'transform']
- * ```
- *
- * @example Multiple token tracing
- * ```typescript
- * const result = tracer(
- *   stackTrail,
- *   ['file-generation', 'models.ts'], // Multiple tokens for detailed context
- *   () => {
- *     return generateModelsFile();
- *   },
- *   logger
- * );
- * ```
- *
- * @example Error handling with tracing
- * ```typescript
- * class SafeGenerator {
- *   generateWithTracing(stackTrail: StackTrail, logger: Logger) {
- *     try {
- *       return tracer(stackTrail, 'risky-operation', () => {
- *         // This might throw an error
- *         return this.complexGeneration();
- *       }, logger);
- *     } catch (error) {
- *       // Stack trail is automatically cleaned up
- *       logger.error(`Generation failed: ${error.message}`);
- *       return this.fallbackGeneration();
- *     }
- *   }
- * }
- * ```
- *
- * @example Performance monitoring
- * ```typescript
- * class PerformanceAwareGenerator {
- *   timedGeneration(stackTrail: StackTrail, logger: Logger) {
- *     const startTime = Date.now();
- *
- *     const result = tracer(stackTrail, 'timed-generation', () => {
- *       return this.heavyComputation();
- *     }, logger);
- *
- *     const duration = Date.now() - startTime;
- *     logger.info(`Generation completed in ${duration}ms`);
- *
- *     return result;
- *   }
- * }
- * ```
- *
- * @example Integration with context classes
- * ```typescript
- * // Typically used within context classes like this:
- * class GenerateContext {
- *   trace<T>(token: string | string[], fn: () => T): T {
- *     return tracer(this.stackTrail, token, fn, this.logger);
- *   }
- *
- *   processModel(schema: OasSchema) {
- *     return this.trace(['model', schema.type], () => {
- *       // Model processing logic
- *       return this.createModel(schema);
- *     });
- *   }
- * }
- * ```
- */
-export declare const tracer: <T>(stackTrail: StackTrail, token: string, fn: () => T) => T;
-//# sourceMappingURL=tracer.d.ts.map

package/script/helpers/tracer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../src/helpers/tracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2HG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,YAAY,UAAU,EAAE,OAAO,MAAM,EAAE,IAAI,MAAM,CAAC,MAe3E,CAAA"}

package/script/helpers/tracer.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tracer = void 0;
-/**
- * Executes a function with distributed tracing support and stack trail management.
- *
- * This utility function provides distributed tracing capabilities for the SKMTC
- * generation pipeline. It manages stack trail tokens that help track execution
- * context across complex nested operations, making debugging and performance
- * analysis much easier.
- *
- * The tracer ensures proper cleanup of stack trail tokens even if the wrapped
- * function throws an error, maintaining the integrity of the tracing system.
- * This is essential for accurate debugging and performance monitoring in
- * complex code generation scenarios.
- *
- * @template T - The return type of the traced function
- * @param stackTrail - The stack trail instance for tracking execution context
- * @param token - Token(s) to identify this execution step in traces
- * @param fn - The function to execute with tracing
- * @param log - Logger instance for error reporting
- * @returns The result of the wrapped function execution
- *
- * @throws Re-throws any error from the wrapped function after cleanup
- *
- * @example Basic tracing usage
- * ```typescript
- * import { tracer } from '@skmtc/core';
- *
- * class ModelGenerator {
- *   generateModel(stackTrail: StackTrail, logger: Logger) {
- *     return tracer(stackTrail, 'generate-model', () => {
- *       // Complex model generation logic here
- *       return this.createModelDefinition();
- *     }, logger);
- *   }
- * }
- * ```
- *
- * @example Nested tracing
- * ```typescript
- * class ComplexProcessor {
- *   processSchema(stackTrail: StackTrail, logger: Logger) {
- *     return tracer(stackTrail, 'process-schema', () => {
- *       const parsed = tracer(stackTrail, 'parse', () => {
- *         return this.parseSchema();
- *       }, logger);
- *
- *       const validated = tracer(stackTrail, 'validate', () => {
- *         return this.validateSchema(parsed);
- *       }, logger);
- *
- *       return tracer(stackTrail, 'transform', () => {
- *         return this.transformSchema(validated);
- *       }, logger);
- *     }, logger);
- *   }
- * }
- *
- * // Stack trail will show: ['process-schema', 'parse'] -> ['process-schema', 'validate'] -> ['process-schema', 'transform']
- * ```
- *
- * @example Multiple token tracing
- * ```typescript
- * const result = tracer(
- *   stackTrail,
- *   ['file-generation', 'models.ts'], // Multiple tokens for detailed context
- *   () => {
- *     return generateModelsFile();
- *   },
- *   logger
- * );
- * ```
- *
- * @example Error handling with tracing
- * ```typescript
- * class SafeGenerator {
- *   generateWithTracing(stackTrail: StackTrail, logger: Logger) {
- *     try {
- *       return tracer(stackTrail, 'risky-operation', () => {
- *         // This might throw an error
- *         return this.complexGeneration();
- *       }, logger);
- *     } catch (error) {
- *       // Stack trail is automatically cleaned up
- *       logger.error(`Generation failed: ${error.message}`);
- *       return this.fallbackGeneration();
- *     }
- *   }
- * }
- * ```
- *
- * @example Performance monitoring
- * ```typescript
- * class PerformanceAwareGenerator {
- *   timedGeneration(stackTrail: StackTrail, logger: Logger) {
- *     const startTime = Date.now();
- *
- *     const result = tracer(stackTrail, 'timed-generation', () => {
- *       return this.heavyComputation();
- *     }, logger);
- *
- *     const duration = Date.now() - startTime;
- *     logger.info(`Generation completed in ${duration}ms`);
- *
- *     return result;
- *   }
- * }
- * ```
- *
- * @example Integration with context classes
- * ```typescript
- * // Typically used within context classes like this:
- * class GenerateContext {
- *   trace<T>(token: string | string[], fn: () => T): T {
- *     return tracer(this.stackTrail, token, fn, this.logger);
- *   }
- *
- *   processModel(schema: OasSchema) {
- *     return this.trace(['model', schema.type], () => {
- *       // Model processing logic
- *       return this.createModel(schema);
- *     });
- *   }
- * }
- * ```
- */
-const tracer = (stackTrail, token, fn) => {
-    stackTrail.append(token);
-    try {
-        const result = fn();
-        stackTrail.remove(token);
-        return result;
-    }
-    catch (error) {
-        // log.error(error)
-        stackTrail.remove(token);
-        throw error;
-    }
-};
-exports.tracer = tracer;

package/script/oas/_helpers/parseEnum.d.ts

@@ -1,14 +0,0 @@
-import type { ParseContextType } from '../../context/parseTypes.js';
-import type { StackTrail } from '../../context/StackTrail.js';
-type ParseEnumArgs = {
-    value: unknown;
-    nullable: boolean | undefined;
-    parent: unknown;
-    check: (item: unknown) => boolean;
-    toMessage: (item: unknown) => string;
-    context: ParseContextType;
-    stackTrail: StackTrail;
-};
-export declare const parseEnum: ({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseEnumArgs) => any[] | undefined;
-export {};
-//# sourceMappingURL=parseEnum.d.ts.map

package/script/oas/_helpers/parseEnum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseEnum.d.ts","sourceRoot":"","sources":["../../../src/oas/_helpers/parseEnum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAA;IACjC,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,oEAQvB,aAAa,sBA2Bf,CAAA"}

package/script/oas/_helpers/parseEnum.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEnum = void 0;
-const parseEnum = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            if (nullable && item === null) {
-                continue;
-            }
-            if (check(item)) {
-                continue;
-            }
-            context.logIssue({
-                key: 'default',
-                level: 'warning',
-                message: toMessage(item),
-                parent,
-                stackTrail,
-                type: 'INVALID_DEFAULT'
-            });
-            return undefined;
-        }
-        return value;
-    }
-    return undefined;
-};
-exports.parseEnum = parseEnum;