@skmtc/core 0.0.983 → 0.16.1

package/script/dsl/Import.js

@@ -1,270 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportName = exports.Import = void 0;
-const mod_js_1 = require("../mod.js");
-/**
- * Represents a TypeScript import statement in the SKMTC DSL system.
- *
- * The `Import` class generates properly formatted import statements for TypeScript
- * files, handling named imports with optional aliases. It's used throughout the
- * code generation pipeline to manage module dependencies.
- *
- * This class supports both simple string imports and aliased imports, making it
- * easy to avoid naming conflicts and provide cleaner import statements.
- *
- * @example Basic named imports
- * ```typescript
- * import { Import } from '@skmtc/core';
- *
- * const basicImport = new Import({
- *   module: './types',
- *   importNames: ['User', 'Product', 'Order']
- * });
- *
- * console.log(basicImport.toString());
- * // import { User, Product, Order } from './types'
- * ```
- *
- * @example Imports with aliases
- * ```typescript
- * const aliasedImport = new Import({
- *   module: 'react',
- *   importNames: [
- *     'useState',
- *     'useEffect',
- *     { 'default': 'React' } // Import default as React
- *   ]
- * });
- *
- * console.log(aliasedImport.toString());
- * // import { useState, useEffect, default as React } from 'react'
- * ```
- *
- * @example Mixed imports
- * ```typescript
- * const mixedImport = new Import({
- *   module: './api/client',
- *   importNames: [
- *     'ApiClient',
- *     { 'RequestOptions': 'Options' }, // Alias to avoid conflicts
- *     'ResponseType'
- *   ]
- * });
- *
- * console.log(mixedImport.toString());
- * // import { ApiClient, RequestOptions as Options, ResponseType } from './api/client'
- * ```
- *
- * @example Using in File generation
- * ```typescript
- * import { File, Import } from '@skmtc/core';
- *
- * const file = new File({ path: './generated.ts', settings: undefined });
- *
- * // Add import to file
- * file.imports.set('./types', new Set(['User', 'Product']));
- *
- * // Or create Import directly for more control
- * const customImport = new Import({
- *   module: './helpers',
- *   importNames: [{ 'validateEmail': 'emailValidator' }]
- * });
- * ```
- */
-class Import {
-    /**
-     * Creates a new Import instance.
-     *
-     * @param args - Import configuration
-     * @param args.module - The module path to import from (e.g., './types', 'react')
-     * @param args.importNames - Array of import names, can be strings or alias objects
-     *
-     * @example
-     * ```typescript
-     * const importStatement = new Import({
-     *   module: './models/User',
-     *   importNames: [
-     *     'User',                           // Simple import
-     *     { 'UserType': 'IUser' },         // Aliased import
-     *     'createUser'                     // Another simple import
-     *   ]
-     * });
-     * ```
-     */
-    constructor({ module, importNames }) {
-        /** The module path to import from */
-        Object.defineProperty(this, "module", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Array of parsed import names with potential aliases */
-        Object.defineProperty(this, "importNames", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.module = module;
-        this.importNames = importNames.map(importName => new ImportName(importName));
-    }
-    /**
-     * Converts the import to a record format.
-     *
-     * This method creates a record representation where the module path is the key
-     * and the import names are the value. Useful for serialization or when working
-     * with import maps.
-     *
-     * @returns A record with module as key and import names as value
-     *
-     * @example
-     * ```typescript
-     * const importStatement = new Import({
-     *   module: './types',
-     *   importNames: ['User', { 'Product': 'IProduct' }]
-     * });
-     *
-     * const record = importStatement.toRecord();
-     * console.log(record);
-     * // {
-     * //   './types': ['User', { 'Product': 'IProduct' }]
-     * // }
-     * ```
-     */
-    toRecord() {
-        return {
-            [this.module]: this.importNames.map(({ name, alias }) => (alias ? { [name]: alias } : name))
-        };
-    }
-    /**
-     * Generates the TypeScript import statement string.
-     *
-     * This method produces a properly formatted ES6 import statement that can be
-     * written directly to a TypeScript file. It handles both simple and aliased
-     * imports correctly.
-     *
-     * @returns The formatted import statement string
-     *
-     * @example
-     * ```typescript
-     * const basicImport = new Import({
-     *   module: './utils',
-     *   importNames: ['formatDate', 'parseJson']
-     * });
-     *
-     * console.log(basicImport.toString());
-     * // import { formatDate, parseJson } from './utils'
-     *
-     * const aliasedImport = new Import({
-     *   module: 'lodash',
-     *   importNames: [{ 'isEqual': 'deepEqual' }, 'cloneDeep']
-     * });
-     *
-     * console.log(aliasedImport.toString());
-     * // import { isEqual as deepEqual, cloneDeep } from 'lodash'
-     * ```
-     *
-     * @todo Move syntax to typescript package to enable language-agnostic use
-     */
-    toString() {
-        const importAllAs = this.importNames.find(importName => importName.toString().startsWith('* as '));
-        const importNames = this.importNames.filter(importName => !importName.toString().startsWith('* as '));
-        // Only skip the braces if we have a namespace import and no named imports
-        const importObject = importNames.length > 0 || !importAllAs
-            ? mod_js_1.List.toObject(importNames)
-            : undefined;
-        const importItems = new mod_js_1.List([importAllAs, importObject], { separator: ', ', skipEmpty: true });
-        // @TODO move syntax to typescript package to enable
-        // language agnostic use
-        return `import ${importItems} from '${this.module}'`;
-    }
-}
-exports.Import = Import;
-/**
- * Represents a single import name with optional aliasing.
- *
- * This class handles the parsing and formatting of individual import specifiers,
- * supporting both simple imports and aliased imports. It's used internally by
- * the {@link Import} class to manage import statement components.
- *
- * @example Simple import name
- * ```typescript
- * const simple = new ImportName('useState');
- * console.log(simple.toString()); // 'useState'
- * ```
- *
- * @example Aliased import name
- * ```typescript
- * const aliased = new ImportName({ 'React': 'ReactLib' });
- * console.log(aliased.toString()); // 'React as ReactLib'
- * ```
- */
-class ImportName {
-    /**
-     * Creates a new ImportName instance.
-     *
-     * @param name - Either a string for simple imports or an object for aliased imports
-     *
-     * @example Simple import
-     * ```typescript
-     * const importName = new ImportName('User');
-     * // Results in: User
-     * ```
-     *
-     * @example Aliased import
-     * ```typescript
-     * const importName = new ImportName({ 'UserInterface': 'IUser' });
-     * // Results in: UserInterface as IUser
-     * ```
-     */
-    constructor(name) {
-        /** The original name being imported */
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The alias to use (if any) */
-        Object.defineProperty(this, "alias", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        if (typeof name === 'string') {
-            this.name = name;
-        }
-        else {
-            const [n, alias] = Object.entries(name)[0];
-            this.name = n;
-            this.alias = alias;
-        }
-    }
-    /**
-     * Generates the string representation of the import name.
-     *
-     * This method creates the appropriate import specifier syntax,
-     * either a simple name or an aliased import using TypeScript's
-     * 'as' keyword.
-     *
-     * @returns The formatted import specifier string
-     *
-     * @example Simple import
-     * ```typescript
-     * const simple = new ImportName('useState');
-     * console.log(simple.toString()); // 'useState'
-     * ```
-     *
-     * @example Aliased import
-     * ```typescript
-     * const aliased = new ImportName({ 'Component': 'ReactComponent' });
-     * console.log(aliased.toString()); // 'Component as ReactComponent'
-     * ```
-     */
-    toString() {
-        return this.alias ? `${this.name} as ${this.alias}` : this.name;
-    }
-}
-exports.ImportName = ImportName;

package/script/dsl/model/ModelBase.d.ts

@@ -1,285 +0,0 @@
-import type { BaseRegisterArgs, GenerateContextType } from '../../context/generateTypes.js';
-import type { InsertModelOptions, InsertNormalisedModelArgs, InsertNormalisedModelReturn } from '../../context/generateTypes.js';
-import type { GeneratedValue } from '../GeneratedValue.js';
-import type { GeneratorKey } from '../GeneratorKeys.js';
-import type { RefName } from '../../types/RefName.js';
-import type { ContentSettings } from '../ContentSettings.js';
-import type { ModelInsertable } from './types.js';
-import { ContentBase } from '../ContentBase.js';
-import type { Inserted } from '../Inserted.js';
-import type { OasSchema } from '../../oas/schema/Schema.js';
-import type { OasRef } from '../../oas/ref/Ref.js';
-import type { OasVoid } from '../../oas/void/Void.js';
-/**
- * Constructor arguments for {@link ModelBase}.
- *
- * @template EnrichmentType - Optional type for custom enrichment data
- */
-export type ModelBaseArgs<EnrichmentType = undefined> = {
-    /** The generation context providing access to the processing pipeline */
-    context: GenerateContextType;
-    /** Content settings including export path and enrichment configuration */
-    settings: ContentSettings<EnrichmentType>;
-    /** Unique identifier for this generator type */
-    generatorKey: GeneratorKey;
-    /** Reference name for the model being generated */
-    refName: RefName;
-};
-/**
- * Base class for model generators in the SKMTC DSL system.
- *
- * `ModelBase` extends {@link ContentBase} to provide specialized functionality for
- * generating code from OpenAPI schema models. It offers type-safe methods for
- * inserting related models, managing schema references, and handling enrichments.
- *
- * This class serves as the foundation for creating custom model generators that
- * transform OpenAPI schemas into various code artifacts like TypeScript interfaces,
- * validation schemas, or database models.
- *
- * ## Key Features
- *
- * - **Model Insertion**: Insert related models with automatic reference resolution
- * - **Schema Normalization**: Handle complex schema references and fallbacks
- * - **Export Management**: Control which models are exported from generated files
- * - **Enrichment Support**: Extend functionality with custom enrichment data
- * - **Type Safety**: Full TypeScript support with generic enrichment types
- *
- * @template EnrichmentType - Optional type for custom enrichment data
- *
- * @example Basic model generator
- * ```typescript
- * import { ModelBase, Definition } from '@skmtc/core';
- *
- * class TypeScriptInterface extends ModelBase {
- *   toDefinition(): Definition {
- *     const schema = this.context.getSchema(this.refName);
- *
- *     return new Definition({
- *       name: this.refName,
- *       content: `export interface ${this.refName} {
- *         ${this.generateProperties(schema)}
- *       }`
- *     });
- *   }
- *
- *   private generateProperties(schema: OasSchema): string {
- *     // Generate interface properties from schema
- *     return Object.entries(schema.properties || {})
- *       .map(([key, prop]) => `${key}: ${this.getPropertyType(prop)}`)
- *       .join(';\n  ');
- *   }
- * }
- * ```
- *
- * @example With enrichments
- * ```typescript
- * type ValidationEnrichment = {
- *   validators: string[];
- *   customRules: Record<string, string>;
- * };
- *
- * class ValidationModel extends ModelBase<ValidationEnrichment> {
- *   toDefinition(): Definition {
- *     const enrichment = this.settings.enrichment;
- *     const validators = enrichment?.validators || [];
- *
- *     return new Definition({
- *       name: `${this.refName}Validator`,
- *       content: this.generateValidator(validators)
- *     });
- *   }
- * }
- * ```
- *
- * @example Inserting related models
- * ```typescript
- * class ApiModel extends ModelBase {
- *   toDefinition(): Definition {
- *     const schema = this.context.getSchema(this.refName);
- *
- *     // Insert related models automatically
- *     if (schema.properties?.user) {
- *       this.insertNormalizedModel(
- *         new TypeScriptInterface({ ... }),
- *         { schema: schema.properties.user, fallbackName: 'User' }
- *       );
- *     }
- *
- *     return new Definition({
- *       name: this.refName,
- *       content: this.generateInterface(schema)
- *     });
- *   }
- * }
- * ```
- */
-export declare class ModelBase<EnrichmentType = undefined> extends ContentBase {
-    /** Content settings including export path and enrichment configuration */
-    settings: ContentSettings<EnrichmentType>;
-    /** Reference name for the model being generated */
-    refName: RefName;
-    /** Generator key identifying this generator type */
-    generatorKey: GeneratorKey;
-    /**
-     * Creates a new ModelBase instance.
-     *
-     * @param args - Model generator configuration
-     * @param args.context - The generation context providing pipeline access
-     * @param args.settings - Content settings with export path and enrichments
-     * @param args.generatorKey - Unique identifier for this generator type
-     * @param args.refName - Reference name for the model being generated
-     *
-     * @example
-     * ```typescript
-     * const model = new ModelBase({
-     *   context: generateContext,
-     *   settings: {
-     *     exportPath: './src/models.ts',
-     *     enrichment: customEnrichments
-     *   },
-     *   generatorKey: 'typescript-models',
-     *   refName: 'UserModel'
-     * });
-     * ```
-     */
-    constructor({ context, settings, generatorKey, refName }: ModelBaseArgs<EnrichmentType>);
-    /**
-     * Inserts a related model with forced generation.
-     *
-     * This method adds a related model to the current generation context, ensuring
-     * it will be generated regardless of whether it already exists. The inserted
-     * model will be exported to the same destination path as this model unless
-     * `noExport` is specified.
-     *
-     * @template V - Type of generated value returned by the insertable
-     * @template EnrichmentType - Type of enrichment data for the insertable
-     * @param insertable - The model generator to insert
-     * @param refName - Reference name for the inserted model
-     * @param options - Insertion options
-     * @param options.noExport - Whether to skip exporting the inserted model
-     * @returns Inserted model reference with generated value
-     *
-     * @example
-     * ```typescript
-     * class UserModel extends ModelBase {
-     *   toDefinition(): Definition {
-     *     // Insert an address model that's always generated
-     *     const address = this.insertModel(
-     *       new AddressModel({ ... }),
-     *       'Address',
-     *       { noExport: false }
-     *     );
-     *
-     *     return new Definition({
-     *       name: this.refName,
-     *       content: `export interface ${this.refName} {
-     *         address: ${address.value}
-     *       }`
-     *     });
-     *   }
-     * }
-     * ```
-     */
-    insertModel<V extends GeneratedValue, EnrichmentType = undefined>(insertable: ModelInsertable<V, EnrichmentType>, refName: RefName, options?: Pick<InsertModelOptions, 'noExport'>): Inserted<V, EnrichmentType>;
-    /**
-     * Inserts a related model with automatic schema normalization and reference resolution.
-     *
-     * This method intelligently handles schema references by automatically resolving
-     * them to appropriate model names. If the schema is a reference, it uses the
-     * referenced name; otherwise it falls back to the provided fallback name.
-     *
-     * This is particularly useful when working with complex nested schemas where
-     * you want to automatically generate models for referenced types.
-     *
-     * @template V - Type of generated value returned by the insertable
-     * @template Schema - Type of OpenAPI schema (schema object, reference, or void)
-     * @template EnrichmentType - Type of enrichment data for the insertable
-     * @param insertable - The model generator to insert
-     * @param args - Schema normalization arguments
-     * @param args.schema - The OpenAPI schema to normalize (can be reference or actual schema)
-     * @param args.fallbackName - Name to use if schema is not a reference
-     * @param options - Insertion options
-     * @param options.noExport - Whether to skip exporting the inserted model
-     * @returns Inserted model reference with normalized name and generated value
-     *
-     * @example Handling schema references
-     * ```typescript
-     * class OrderModel extends ModelBase {
-     *   toDefinition(): Definition {
-     *     const schema = this.context.getSchema(this.refName);
-     *
-     *     // Handle customer property - could be reference or inline schema
-     *     if (schema.properties?.customer) {
-     *       const customer = this.insertNormalizedModel(
-     *         new CustomerModel({ ... }),
-     *         {
-     *           schema: schema.properties.customer,
-     *           fallbackName: 'Customer'
-     *         }
-     *       );
-     *       // customer.refName will be 'Customer' or the referenced schema name
-     *     }
-     *
-     *     return new Definition({ ... });
-     *   }
-     * }
-     * ```
-     *
-     * @example With complex nested schemas
-     * ```typescript
-     * // If schema.properties.items is { $ref: '#/components/schemas/Product' }
-     * // Then the inserted model will use refName 'Product'
-     * const items = this.insertNormalizedModel(
-     *   new ProductModel({ ... }),
-     *   {
-     *     schema: schema.properties.items,
-     *     fallbackName: 'Item' // Won't be used since schema has $ref
-     *   }
-     * );
-     * ```
-     */
-    insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<'schema'> | OasVoid, EnrichmentType = undefined>(insertable: ModelInsertable<V, EnrichmentType>, { schema, fallbackName }: Omit<InsertNormalisedModelArgs<Schema>, 'destinationPath'>, options?: Pick<InsertModelOptions, 'noExport'>): InsertNormalisedModelReturn<V, Schema>;
-    /**
-     * Registers a file-level artifact with the generation context.
-     *
-     * This method allows the model generator to register additional content
-     * (like imports, exports, or file-level definitions) that should be included
-     * in the generated file. The registration is automatically scoped to this
-     * model's export path.
-     *
-     * @param args - Registration arguments
-     * @param args.content - The content to register (import, export, etc.)
-     * @param args.phase - When to register the content ('pre' or 'post')
-     *
-     * @example Registering imports
-     * ```typescript
-     * class ApiModel extends ModelBase {
-     *   toDefinition(): Definition {
-     *     // Register an import that all generated models need
-     *     this.register({
-     *       content: "import { BaseModel } from './base';",
-     *       phase: 'pre'
-     *     });
-     *
-     *     return new Definition({ ... });
-     *   }
-     * }
-     * ```
-     *
-     * @example Registering type exports
-     * ```typescript
-     * class TypeModel extends ModelBase {
-     *   toDefinition(): Definition {
-     *     this.register({
-     *       content: "export type * from './types';",
-     *       phase: 'post'
-     *     });
-     *
-     *     return new Definition({ ... });
-     *   }
-     * }
-     * ```
-     */
-    register(args: BaseRegisterArgs): void;
-}
-//# sourceMappingURL=ModelBase.d.ts.map

package/script/dsl/model/ModelBase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/ModelBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAC3F,OAAO,KAAK,EACV,kBAAkB,EAClB,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,gCAAgC,CAAA;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAErD;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,cAAc,GAAG,SAAS,IAAI;IACtD,yEAAyE;IACzE,OAAO,EAAE,mBAAmB,CAAA;IAC5B,0EAA0E;IAC1E,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,gDAAgD;IAChD,YAAY,EAAE,YAAY,CAAA;IAC1B,mDAAmD;IACnD,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,qBAAa,SAAS,CAAC,cAAc,GAAG,SAAS,CAAE,SAAQ,WAAW;IACpE,0EAA0E;IAC1E,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IAEzC,mDAAmD;IACnD,OAAO,EAAE,OAAO,CAAA;IAEhB,oDAAoD;IAC3C,YAAY,EAAE,YAAY,CAAA;IAEnC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE,aAAa,CAAC,cAAc,CAAC;IAQvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,WAAW,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,GAAG,SAAS,EAC9D,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,EAC9C,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAM,GACjD,QAAQ,CAAC,CAAC,EAAE,cAAc,CAAC;IAO9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,qBAAqB,CACnB,CAAC,SAAS,cAAc,EACxB,MAAM,SAAS,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,OAAO,EACrD,cAAc,GAAG,SAAS,EAE1B,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,EAC9C,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC,EACpF,OAAO,GAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAM,GACjD,2BAA2B,CAAC,CAAC,EAAE,MAAM,CAAC;IAYzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACM,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;CAMhD"}