ts-class-to-openapi 1.0.5 → 1.1.0

package/dist/__test__/entities/additional-test-classes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Additional test classes for pure TypeScript classes tests
+ * These classes are used in the pure-classes.test.ts file
+ */
+export declare class OptionalOnlyClass {
+    optionalProp?: string;
+    anotherOptional?: number;
+}
+export declare class UnionTypeClass {
+    stringOrNumber: string | number;
+    optionalUnion?: boolean | string;
+}

package/dist/__test__/entities/circular-reference-classes.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Test classes for circular reference scenarios
+ * These classes are designed to test the handling of recursive references
+ */
+/**
+ * Self-referencing class through direct property
+ */
+export declare class SelfReferenceDirectClass {
+    id: number;
+    name: string;
+    parent?: SelfReferenceDirectClass;
+    children: SelfReferenceDirectClass[];
+}
+/**
+ * Metadata class for nested circular references
+ */
+export declare class NestedMetadata {
+    createdBy?: SelfReferenceNestedClass;
+    modifiedBy?: SelfReferenceNestedClass;
+}
+/**
+ * Self-referencing class through nested property
+ */
+export declare class SelfReferenceNestedClass {
+    id: number;
+    metadata: NestedMetadata;
+}
+/**
+ * Second class in indirect circular reference
+ */
+export declare class NodeDataClass {
+    description: string;
+    parentNode: NodeClass;
+}
+/**
+ * First class in indirect circular reference
+ */
+export declare class NodeClass {
+    id: number;
+    name: string;
+    nodeData: NodeDataClass;
+}
+/**
+ * Third class in deep circular chain
+ */
+export declare class ClassC {
+    id: number;
+    value: number;
+    nextRef: ClassA;
+}
+/**
+ * Second class in deep circular chain
+ */
+export declare class ClassB {
+    id: number;
+    description: string;
+    nextRef: ClassC;
+}
+/**
+ * First class in deep circular chain
+ */
+export declare class ClassA {
+    id: number;
+    name: string;
+    nextRef: ClassB;
+}
+/**
+ * Multiple circular paths in the same class
+ */
+export declare class MultiPathCircularClass {
+    id: number;
+    selfRef1?: MultiPathCircularClass;
+    selfRef2?: MultiPathCircularClass;
+    manyRefs: MultiPathCircularClass[];
+}
+/**
+ * Base generic class that can create circular references
+ */
+export declare class GenericContainer {
+    value: any;
+    metadata: Record<string, any>;
+    related?: GenericContainer;
+}
+/**
+ * Concrete implementation with self-reference
+ */
+export declare class SelfReferencingGenericClass extends GenericContainer {
+    id: number;
+    name: string;
+    children: SelfReferencingGenericClass;
+}
+/**
+ * Classes for deeply nested circular references
+ */
+export declare class Level3 {
+    data: boolean;
+    refToRoot?: DeepNestedProperClasses;
+}
+export declare class Level2 {
+    data: number;
+    level3: Level3;
+}
+export declare class Level1 {
+    data: string;
+    level2: Level2;
+}
+export declare class DeepNestedProperClasses {
+    id: number;
+    level1: Level1;
+}

package/dist/__test__/entities/complex-circular-dependencies.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Complex inter-dependent classes with multiple circular references
+ */
+/**
+ * Core entity with relationships to other classes
+ */
+export declare class User {
+    id: number;
+    name: string;
+    email: string;
+    posts: Post[];
+    comments: Comment[];
+    profile: Profile;
+    primaryGroup?: Group;
+    manager?: User;
+    directReports: User[];
+}
+/**
+ * Entity with back-reference to User
+ */
+export declare class Post {
+    id: number;
+    title: string;
+    content: string;
+    author: User;
+    comments: Comment[];
+    categories: Category[];
+    relatedPosts: Post[];
+}
+/**
+ * Entity with multiple back-references creating complex circular dependencies
+ */
+export declare class Comment {
+    id: number;
+    content: string;
+    author: User;
+    post: Post;
+    parentComment?: Comment;
+    replies: Comment[];
+}
+/**
+ * Entity with 1:1 relationship with User
+ */
+export declare class Profile {
+    id: number;
+    bio: string;
+    avatar: string;
+    user: User;
+}
+/**
+ * Entity with many-to-many relationship with User
+ */
+export declare class Group {
+    id: number;
+    name: string;
+    description: string;
+    members: User[];
+    admin: User;
+    parentGroup?: Group;
+    subGroups: Group[];
+}
+/**
+ * Entity with many-to-many relationship with Post
+ */
+export declare class Category {
+    id: number;
+    name: string;
+    posts: Post[];
+    parentCategory?: Category;
+    subcategories: Category[];
+}

package/dist/__test__/entities/decorated-classes.d.ts

@@ -0,0 +1,54 @@
+export declare enum UserStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    PENDING = "pending",
+    SUSPENDED = "suspended"
+}
+export declare enum Priority {
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3,
+    CRITICAL = 4
+}
+export declare class DecoratedAddress {
+    street: string;
+    city: string;
+    state: string;
+    zipCode: string;
+    country: string;
+}
+export declare class DecoratedUser {
+    id: number;
+    name: string;
+    email: string;
+    age: number;
+    status: UserStatus;
+    isActive?: boolean;
+    tags: string[];
+    address: DecoratedAddress;
+    createdAt: Date;
+    updatedAt?: Date;
+}
+export declare class DecoratedProduct {
+    id: number;
+    name: string;
+    description: string;
+    price: number;
+    currency: string;
+    categories: string[];
+    inStock: boolean;
+    quantity?: number;
+    images?: string[];
+}
+export declare class DecoratedTask {
+    id: number;
+    title: string;
+    description: string;
+    priority: Priority;
+    completed: boolean;
+    dueDate: Date;
+    assignedTo?: DecoratedUser;
+    tags?: string[];
+    createdAt: Date;
+    completedAt?: Date;
+}

package/dist/__test__/entities/generic-circular-classes.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Interfaces and classes for handling generic circular references
+ */
+/**
+ * Interface defining the contract for metadata properties
+ */
+export interface IMetadata {
+    createdAt?: Date;
+    updatedAt?: Date;
+    version?: number;
+    [key: string]: any;
+}
+/**
+ * Interface defining the contract for entities with circular references
+ */
+export interface ICircularReference<T> {
+    getReference(): T | undefined;
+    setReference(ref: T): void;
+}
+/**
+ * Interface for entities that can contain related items
+ */
+export interface IRelatable<T> {
+    related?: T;
+}
+/**
+ * Base class for containers that hold generic values with metadata
+ */
+export declare abstract class BaseContainer<T> implements IRelatable<BaseContainer<T>> {
+    abstract value: T;
+    metadata: IMetadata;
+    related?: BaseContainer<T>;
+    constructor();
+    protected abstract validateValue(value: T): boolean;
+}
+/**
+ * Generic container implementation with basic value validation
+ */
+export declare class GenericContainer<T> extends BaseContainer<T> {
+    value: T;
+    metadata: IMetadata & {
+        additionalInfo?: string;
+    };
+    constructor(value: T);
+    protected validateValue(value: T): boolean;
+}
+/**
+ * Self-referencing class that extends GenericContainer
+ */
+export declare class SelfReferencingGenericClass extends GenericContainer<SelfReferencingGenericClass> implements ICircularReference<SelfReferencingGenericClass> {
+    id: number;
+    name: string;
+    constructor(id: number, name: string);
+    getReference(): SelfReferencingGenericClass | undefined;
+    setReference(ref: SelfReferencingGenericClass): void;
+    protected validateValue(value: SelfReferencingGenericClass): boolean;
+}

package/dist/__test__/entities/nested-classes.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Nested TypeScript classes to test object relationships
+ */
+export declare class Address {
+    street: string;
+    city: string;
+    state: string;
+    zipCode: string;
+    country: string;
+}
+export declare class Role {
+    id: number;
+    name: string;
+    permissions: string[];
+    level: number;
+}
+export declare class Company {
+    name: string;
+    industry: string;
+    foundedYear: number;
+    employees: number;
+}
+export declare class EmergencyContact {
+    name: string;
+    phone: string;
+    relationship: string;
+}
+export declare class NestedUser {
+    id: number;
+    name: string;
+    email: string;
+    address: Address;
+    roles: Role[];
+    company: Company;
+    alternativeAddresses: Address[];
+    emergencyContact?: EmergencyContact;
+}
+/**
+ * Deep nesting example
+ */
+export declare class Department {
+    id: number;
+    name: string;
+    budget: number;
+}
+export declare class Team {
+    id: number;
+    name: string;
+    department: Department;
+    members: TeamMember[];
+}
+export declare class TeamMember {
+    id: number;
+    name: string;
+    email: string;
+    role: string;
+    startDate: Date;
+}
+export declare class Subsidiary {
+    name: string;
+    location: Address;
+    established: Date;
+}
+export declare class Organization {
+    id: number;
+    name: string;
+    teams: Team[];
+    headquarters: Address;
+    subsidiaries: Subsidiary[];
+}

package/dist/__test__/entities/pure-classes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Pure TypeScript class without any decorators
+ * Used to test basic type inference and transformation
+ */
+export declare class PureUser {
+    id: number;
+    name: string;
+    email: string;
+    age: number;
+    isActive: boolean;
+    tags: string[];
+    metadata: Record<string, any>;
+    createdAt: Date;
+    phone?: string;
+    bio?: string;
+}
+/**
+ * Pure TypeScript class with primitive types only
+ */
+export declare class SimplePerson {
+    firstName: string;
+    lastName: string;
+    age: number;
+    isEmployed: boolean;
+}
+/**
+ * Pure TypeScript class with arrays
+ */
+export declare class Product {
+    id: number;
+    name: string;
+    price: number;
+    categories: string[];
+    scores: number[];
+    isAvailable: boolean;
+    description?: string;
+}

package/dist/__test__/entities/schema-validation-classes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Classes for testing schema validation
+ */
+export declare class TypeMappingTest {
+    stringProp: string;
+    numberProp: number;
+    booleanProp: boolean;
+    arrayProp: string[];
+    objectProp: Record<string, any>;
+    dateProp: Date;
+}
+export declare class NestedSchema {
+    id: number;
+    name: string;
+    nested: {
+        prop1: string;
+        prop2: number;
+    };
+}
+export declare class CircularA {
+    id: number;
+    name: string;
+    refToB: CircularB;
+}
+export declare class CircularB {
+    id: number;
+    description: string;
+    refToA: CircularA;
+}
+export declare class RequiredFieldsTest {
+    required1: string;
+    required2: number;
+    optional1?: string;
+    optional2?: number;
+}

package/dist/__test__/index.d.ts

@@ -1,9 +1,3 @@
-import './main.test';
-import './integration.test';
-import './plain.test';
-import './optional-properties.test';
-import './generic-types.test';
-import './enum.test';
-import './circular-reference.test';
-import './ref-pattern.test';
-import './singleton-behavior.test';
+import './testCases/pure-classes.test';
+import './testCases/decorated-classes.test';
+import './testCases/nested-classes.test';

package/dist/__test__/testCases/schema-validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { transform, SchemaTransformer } from './transformer';
+import { transform } from './transformer';
 import { SchemaType, TransformerOptions } from './types';
-export { transform, SchemaTransformer, type SchemaType, type TransformerOptions, };
+export { transform, type SchemaType, type TransformerOptions };