@dbs-portal/core-api/dist/mocks/factories/base-factory.js

HTTP client and API utilities for DBS Portal

/**
 * Base factory for creating mock data with type safety
 */
/**
 * Base factory class for creating mock data
 */
export class BaseFactory {
    /**
     * Create multiple instances
     */
    createMany(count, overrides) {
        return Array.from({ length: count }, () => this.create(overrides));
    }
    /**
     * Create instances with different overrides for each
     */
    createManyWithOverrides(overridesArray) {
        return overridesArray.map(overrides => this.create(overrides));
    }
    /**
     * Create a sequence of instances with incremental values
     */
    createSequence(count, sequenceFn) {
        return Array.from({ length: count }, (_, index) => this.create(sequenceFn(index)));
    }
    /**
     * Create instances with random variations
     */
    createVariations(count, variationFn) {
        return Array.from({ length: count }, () => this.create(variationFn()));
    }
}
/**
 * Simple factory function creator
 */
export function createFactory(factoryFn) {
    return factoryFn;
}
/**
 * Factory builder for creating complex factories
 */
export class FactoryBuilder {
    baseFn;
    traits = new Map();
    sequences = new Map();
    afterBuildHooks = [];
    constructor(baseFn) {
        this.baseFn = baseFn;
    }
    /**
     * Add a trait (named set of attributes)
     */
    trait(name, attributes) {
        this.traits.set(name, attributes);
        return this;
    }
    /**
     * Add a sequence for generating incremental values
     */
    sequence(key, sequenceFn) {
        let counter = 0;
        this.sequences.set(key, () => sequenceFn(counter++));
        return this;
    }
    /**
     * Add after-build hook
     */
    afterBuild(fn) {
        this.afterBuildHooks.push(fn);
        return this;
    }
    /**
     * Build the factory
     */
    build() {
        return new FactoryInstance(this.baseFn, this.traits, this.sequences, this.afterBuildHooks);
    }
}
/**
 * Factory instance with trait and sequence support
 */
export class FactoryInstance {
    baseFn;
    traits;
    sequences;
    afterBuildHooks;
    constructor(baseFn, traits, sequences, afterBuildHooks) {
        this.baseFn = baseFn;
        this.traits = traits;
        this.sequences = sequences;
        this.afterBuildHooks = afterBuildHooks;
    }
    /**
     * Create instance with optional traits and overrides
     */
    create(overrides, traitNames = []) {
        // Start with base instance
        let instance = this.baseFn();
        // Apply sequences
        for (const [key, sequenceFn] of this.sequences) {
            instance[key] = sequenceFn();
        }
        // Apply traits
        for (const traitName of traitNames) {
            const trait = this.traits.get(traitName);
            if (trait) {
                instance = { ...instance, ...trait };
            }
        }
        // Apply overrides
        if (overrides) {
            instance = { ...instance, ...overrides };
        }
        // Apply after-build hooks
        for (const hook of this.afterBuildHooks) {
            instance = hook(instance);
        }
        return instance;
    }
    /**
     * Create with specific traits
     */
    withTraits(...traitNames) {
        return {
            create: (overrides) => this.create(overrides, traitNames),
            createMany: (count, overrides) => Array.from({ length: count }, () => this.create(overrides, traitNames))
        };
    }
    /**
     * Create multiple instances
     */
    createMany(count, overrides, traitNames = []) {
        return Array.from({ length: count }, () => this.create(overrides, traitNames));
    }
}
/**
 * Create a factory builder
 */
export function defineFactory(baseFn) {
    return new FactoryBuilder(baseFn);
}
/**
 * Utility for creating factories with default values
 */
export function createFactoryWithDefaults(defaults, customizations) {
    return (overrides) => {
        const instance = { ...defaults };
        // Apply customizations
        if (customizations) {
            for (const [key, customFn] of Object.entries(customizations)) {
                if (customFn && typeof customFn === 'function') {
                    instance[key] = customFn();
                }
            }
        }
        // Apply overrides
        if (overrides) {
            Object.assign(instance, overrides);
        }
        return instance;
    };
}
//# sourceMappingURL=base-factory.js.map