@skmtc/core 0.0.983 → 0.16.1

package/esm/dsl/model/ModelBase.js

@@ -1,294 +0,0 @@
-import { ContentBase } from '../ContentBase.js';
-/**
- * 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 class ModelBase extends ContentBase {
-    /**
-     * 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 }) {
-        super({ context });
-        /** Content settings including export path and enrichment configuration */
-        Object.defineProperty(this, "settings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Reference name for the model being generated */
-        Object.defineProperty(this, "refName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Generator key identifying this generator type */
-        Object.defineProperty(this, "generatorKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.generatorKey = generatorKey;
-        this.refName = refName;
-        this.settings = settings;
-    }
-    /**
-     * 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(insertable, refName, options = {}) {
-        return this.context.insertModel(insertable, refName, {
-            destinationPath: this.settings.exportPath,
-            noExport: options.noExport
-        });
-    }
-    /**
-     * 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(insertable, { schema, fallbackName }, options = {}) {
-        return this.context.insertNormalisedModel(insertable, {
-            schema,
-            fallbackName,
-            destinationPath: this.settings.exportPath
-        }, options);
-    }
-    /**
-     * 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) {
-        this.context.register({
-            ...args,
-            destinationPath: this.settings.exportPath
-        });
-    }
-}

package/esm/dsl/model/toModelBase.d.ts

@@ -1,106 +0,0 @@
-import type { GenerateContextType } from '../../context/generateTypes.js';
-import type { RefName } from '../../types/RefName.js';
-import type { ContentSettings } from '../ContentSettings.js';
-import type { Identifier } from '../Identifier.js';
-import * as v from 'valibot';
-/**
- * Arguments for creating a model insertable instance.
- *
- * @template EnrichmentType - Type of enrichments to apply to the model
- */
-export type ModelInsertableArgs<EnrichmentType = undefined> = {
-    /** The generation context providing access to OAS objects and utilities */
-    context: GenerateContextType;
-    /** Content settings for customizing model generation behavior */
-    settings: ContentSettings<EnrichmentType>;
-    /** Reference name identifying the model schema */
-    refName: RefName;
-};
-type ToEnrichmentsArgs = {
-    refName: RefName;
-    context: GenerateContextType;
-};
-/**
- * Configuration for creating a base model class.
- *
- * Defines the structure and behavior for model generators, including
- * identifier generation, export path resolution, and enrichment schemas.
- *
- * @template EnrichmentType - Type of enrichments to apply to generated models
- */
-export type BaseModelConfig<EnrichmentType = undefined> = {
-    /** Unique identifier for the model generator */
-    id: string;
-    /** Function to generate identifiers from reference names */
-    toIdentifier: (refName: RefName) => Identifier;
-    /** Function to generate export paths from reference names */
-    toExportPath: (refName: RefName) => string;
-    /** Optional function to provide enrichment validation schema */
-    toEnrichmentSchema?: () => v.BaseSchema<EnrichmentType, EnrichmentType, v.BaseIssue<unknown>>;
-};
-/**
- * Creates a base model class constructor for generating type-safe model artifacts.
- *
- * This factory function creates a specialized ModelBase class that implements
- * the provided configuration for identifier generation, export paths, and
- * enrichment handling. The resulting class can be instantiated to generate
- * model artifacts from OpenAPI schemas.
- *
- * @template EnrichmentType - Type of enrichments to apply to generated models
- * @param config - Configuration defining the model generation behavior
- * @returns Constructor function for creating model instances
- *
- * @example Creating a TypeScript interface generator
- * ```typescript
- * import { toModelBase } from '@skmtc/core';
- *
- * const TypeScriptModelBase = toModelBase({
- *   id: 'typescript-interfaces',
- *   toIdentifier: (refName) => new Identifier(pascalCase(refName)),
- *   toExportPath: (refName) => `./models/${kebabCase(refName)}.ts`,
- *   toEnrichmentSchema: () => v.object({
- *     includeValidation: v.optional(v.boolean()),
- *     readonly: v.optional(v.boolean())
- *   })
- * });
- *
- * class TypeScriptModelGenerator extends TypeScriptModelBase {
- *   generate() {
- *     const enrichments = this.enrichments;
- *     const interface = generateInterface(this.schema, {
- *       readonly: enrichments?.readonly ?? false
- *     });
- *     this.register({ file: this.createFile(interface) });
- *   }
- * }
- * ```
- *
- * @example Creating a validation schema generator
- * ```typescript
- * const ValidationModelBase = toModelBase({
- *   id: 'zod-schemas',
- *   toIdentifier: (refName) => new Identifier(`${pascalCase(refName)}Schema`),
- *   toExportPath: (refName) => `./schemas/${kebabCase(refName)}.schema.ts`
- * });
- * ```
- */
-export declare const toModelBase: <EnrichmentType = undefined>(config: BaseModelConfig<EnrichmentType>) => {
-    new (args: ModelInsertableArgs<EnrichmentType>): {
-        settings: ContentSettings<EnrichmentType>;
-        refName: RefName;
-        generatorKey: import("../GeneratorKeys.js").GeneratorKey;
-        insertModel<V extends import("../GeneratedValue.js").GeneratedValue, EnrichmentType_1 = undefined>(insertable: import("./types.js").ModelInsertable<V, EnrichmentType_1>, refName: RefName, options?: Pick<import("../../mod.js").InsertModelOptions, "noExport">): import("../Inserted.js").Inserted<V, EnrichmentType_1>;
-        insertNormalizedModel<V extends import("../GeneratedValue.js").GeneratedValue, Schema extends import("../../mod.js").OasSchema | import("../../mod.js").OasRef<"schema"> | import("../../mod.js").OasVoid, EnrichmentType_2 = undefined>(insertable: import("./types.js").ModelInsertable<V, EnrichmentType_2>, { schema, fallbackName }: Omit<import("../../mod.js").InsertNormalisedModelArgs<Schema>, "destinationPath">, options?: Pick<import("../../mod.js").InsertModelOptions, "noExport">): import("../../mod.js").InsertNormalisedModelReturn<V, Schema>;
-        register(args: import("../../mod.js").BaseRegisterArgs): void;
-        context: GenerateContextType;
-        skipped: boolean;
-    };
-    id: string;
-    type: "model";
-    toIdentifier: (refName: RefName) => Identifier;
-    toExportPath: (refName: RefName) => string;
-    toEnrichments: ({ refName, context }: ToEnrichmentsArgs) => EnrichmentType;
-    isSupported: () => boolean;
-};
-export {};
-//# sourceMappingURL=toModelBase.d.ts.map

package/esm/dsl/model/toModelBase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toModelBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/toModelBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAEzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,2EAA2E;IAC3E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,iEAAiE;IACjE,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,mBAAmB,CAAA;CAC7B,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAAI;IACxD,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAA;IACV,4DAA4D;IAC5D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,UAAU,CAAA;IAC9C,6DAA6D;IAC7D,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAA;IAC1C,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,GAAI,cAAc,GAAG,SAAS,EACpD,QAAQ,eAAe,CAAC,cAAc,CAAC;eAiBnB,mBAAmB,CAAC,cAAc,CAAC;;;;;;;;;;;UAbvC,OAAO;4BA1DC,OAAO,KAAK,UAAU;4BAEtB,OAAO,KAAK,MAAM;oBA4DhB,sBAAsB,iBAAiB,KAAG,cAAc;;CAmBnF,CAAA"}

package/esm/dsl/model/toModelBase.js

@@ -1,105 +0,0 @@
-import { toModelGeneratorKey } from '../GeneratorKeys.js';
-import { ModelBase } from './ModelBase.js';
-import * as v from 'valibot';
-import get from 'lodash-es/get.js';
-/**
- * Creates a base model class constructor for generating type-safe model artifacts.
- *
- * This factory function creates a specialized ModelBase class that implements
- * the provided configuration for identifier generation, export paths, and
- * enrichment handling. The resulting class can be instantiated to generate
- * model artifacts from OpenAPI schemas.
- *
- * @template EnrichmentType - Type of enrichments to apply to generated models
- * @param config - Configuration defining the model generation behavior
- * @returns Constructor function for creating model instances
- *
- * @example Creating a TypeScript interface generator
- * ```typescript
- * import { toModelBase } from '@skmtc/core';
- *
- * const TypeScriptModelBase = toModelBase({
- *   id: 'typescript-interfaces',
- *   toIdentifier: (refName) => new Identifier(pascalCase(refName)),
- *   toExportPath: (refName) => `./models/${kebabCase(refName)}.ts`,
- *   toEnrichmentSchema: () => v.object({
- *     includeValidation: v.optional(v.boolean()),
- *     readonly: v.optional(v.boolean())
- *   })
- * });
- *
- * class TypeScriptModelGenerator extends TypeScriptModelBase {
- *   generate() {
- *     const enrichments = this.enrichments;
- *     const interface = generateInterface(this.schema, {
- *       readonly: enrichments?.readonly ?? false
- *     });
- *     this.register({ file: this.createFile(interface) });
- *   }
- * }
- * ```
- *
- * @example Creating a validation schema generator
- * ```typescript
- * const ValidationModelBase = toModelBase({
- *   id: 'zod-schemas',
- *   toIdentifier: (refName) => new Identifier(`${pascalCase(refName)}Schema`),
- *   toExportPath: (refName) => `./schemas/${kebabCase(refName)}.schema.ts`
- * });
- * ```
- */
-export const toModelBase = (config) => {
-    var _a;
-    return _a = class extends ModelBase {
-            constructor(args) {
-                super({
-                    ...args,
-                    generatorKey: toModelGeneratorKey({
-                        generatorId: config.id,
-                        refName: args.refName
-                    })
-                });
-            }
-        },
-        Object.defineProperty(_a, "id", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config.id
-        }),
-        Object.defineProperty(_a, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'model'
-        }),
-        Object.defineProperty(_a, "toIdentifier", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config.toIdentifier.bind(config)
-        }),
-        Object.defineProperty(_a, "toExportPath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config.toExportPath.bind(config)
-        }),
-        Object.defineProperty(_a, "toEnrichments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ({ refName, context }) => {
-                const modelEnrichments = get(context.settings, `enrichments.${config.id}.${refName}`);
-                const enrichmentSchema = config.toEnrichmentSchema?.() ?? v.undefined();
-                return v.parse(enrichmentSchema, modelEnrichments);
-            }
-        }),
-        Object.defineProperty(_a, "isSupported", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: () => true
-        }),
-        _a;
-};