typeorm-fixtures-cli/dist/Resolver.js

[](https://circleci.com/gh/RobinCK/typeorm-fixtures)  [![OpenCollective](https

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Resolver = void 0;
const lodash_1 = require("lodash");
class Resolver {
    constructor() {
        this.stack = [];
        this.resolved = {};
    }
    /**
     * @param fixtureConfigs
     * @return {IFixture[]}
     */
    resolve(fixtureConfigs) {
        for (const { entity, items, parameters, processor, resolvedFields } of fixtureConfigs) {
            for (const [mainReferenceName, propertyList] of Object.entries(items)) {
                const rangeRegExp = /^([\w-_]+)\{(\d+)\.\.(\d+)}$/gm;
                let referenceNames = [];
                if (rangeRegExp.test(mainReferenceName)) {
                    const result = mainReferenceName.split(rangeRegExp);
                    /* istanbul ignore else */
                    if (result) {
                        referenceNames = (0, lodash_1.range)(+result[2], +(+result[3]) + 1).map((rangeNumber) => `${result[1]}${rangeNumber}`);
                    }
                }
                else {
                    referenceNames = [mainReferenceName];
                }
                for (const name of referenceNames) {
                    const data = { ...propertyList };
                    this.stack.push({
                        parameters: parameters || {},
                        processor,
                        entity: entity,
                        name: name,
                        resolvedFields,
                        data,
                        dependencies: this.resolveDependencies(name, data),
                    });
                }
            }
        }
        return this.stack
            .map((s) => ({ ...s, dependencies: this.resolveDeepDependencies(s) }))
            .sort((a, b) => a.dependencies.length - b.dependencies.length);
    }
    /**
     * @param {string} parentReferenceName
     * @param {any[] | object} propertyList
     * @return {any[]}
     */
    resolveDependencies(parentReferenceName, propertyList) {
        const dependencies = [];
        const currentRegExp = /\(\$current(([+\-/*])\d+)?\)/g;
        for (const [key, value] of Object.entries(propertyList)) {
            if (typeof value === 'string' && value.indexOf('@') === 0) {
                const reference = this.resolveReference(parentReferenceName, value.substring(1));
                propertyList[key] = `@${reference}`;
                dependencies.push(reference);
            }
            else if (typeof value === 'string' && currentRegExp.test(value)) {
                propertyList[key] = value.replace(currentRegExp, this.resolveCurrent(parentReferenceName, value));
            }
            else if (typeof value === 'object' && value !== null) {
                dependencies.push(...this.resolveDependencies(parentReferenceName, value));
            }
        }
        return dependencies;
    }
    /**
     * @param {string} fixtureIdentify
     * @param {string} reference
     * @return {any}
     */
    resolveReference(fixtureIdentify, reference) {
        const currentRegExp = /^([\w-_]+)\(\$current(([+\-/*])\d+)?\)$/gm;
        const rangeRegExp = /^([\w-_]+)\{(\d+)\.\.(\d+)}$/gm;
        if (currentRegExp.test(reference)) {
            const index = this.resolveCurrent(fixtureIdentify, reference);
            /* istanbul ignore else */
            if (!index) {
                throw new Error(`Error parsed index in reference: "${reference}" and fixture identify: ${fixtureIdentify}`);
            }
            return reference.replace(/\(\$current(([+\-/*])\d+)?\)/g, index);
        }
        else if (rangeRegExp.test(reference)) {
            const splitting = reference.split(rangeRegExp);
            (0, lodash_1.sample)((0, lodash_1.range)(+splitting[2], +(+splitting[3]) + 1));
            return `${splitting[1]}${(0, lodash_1.sample)((0, lodash_1.range)(+splitting[2], +(+splitting[3]) + 1))}`;
        }
        return reference;
    }
    /**
     * @param {string} fixtureIdentify
     * @param {string} value
     */
    resolveCurrent(fixtureIdentify, value) {
        const currentIndexRegExp = /^[a-z_-]+(\d+)$/gi;
        const currentRegExp = /\(\$current(([+\-/*])\d+)\)/gi;
        const splitting = fixtureIdentify.split(currentIndexRegExp);
        if (currentRegExp.test(value)) {
            const calc = String(value.match(/([+\-/*])\d+/gi));
            return eval(splitting[1].concat(calc));
        }
        return splitting[1];
    }
    /**
     * @param {string[]} dependencies
     * @return {string[]} filtered dependencies
     */
    filterUnique(dependencies) {
        return dependencies.filter((value, index, self) => self.indexOf(value) === index);
    }
    /**
     * @param item
     * @return {any[]}
     */
    resolveDeepDependencies(item) {
        const dependencies = [];
        for (const dependencyName of item.dependencies) {
            const dependencyElement = this.stack.find((s) => s.name === dependencyName);
            if (!dependencyElement) {
                /* istanbul ignore else */
                if (dependencyName.substr(dependencyName.length - 1) !== '*') {
                    throw new Error(`Reference "${dependencyName}" not found`);
                }
                if (this.resolved[dependencyName]) {
                    dependencies.push(...this.resolved[dependencyName]);
                }
                else {
                    const prefix = dependencyName.substr(0, dependencyName.length - 1);
                    const regex = new RegExp(`^${prefix}([0-9]+)$`);
                    for (const dependencyMaskElement of this.stack.filter((s) => regex.test(s.name))) {
                        dependencies.push(dependencyMaskElement.name, ...this.resolveDeepDependencies(dependencyMaskElement));
                    }
                    this.resolved[dependencyName] = this.filterUnique(dependencies);
                }
            }
            else {
                dependencies.push(dependencyName, ...this.resolveDeepDependencies(dependencyElement));
            }
        }
        return this.filterUnique(dependencies);
    }
}
exports.Resolver = Resolver;
//# sourceMappingURL=Resolver.js.map