@terascope/job-components/dist/src/operation-loader.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.OperationLoader = void 0;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const utils_1 = require("@terascope/utils");
const shims_1 = require("./operations/shims");
class OperationLoader {
    constructor(options = {}) {
        this.options = utils_1.cloneDeep(options);
        this.availableExtensions = availableExtensions();
    }
    find(name, assetIds) {
        let filePath = null;
        const findCodeFn = this.findCode(name);
        const findCodeByConvention = (basePath, subfolders) => {
            if (!basePath)
                return;
            if (!fs_1.default.existsSync(basePath))
                return;
            if (!subfolders || !subfolders.length)
                return;
            subfolders.forEach((folder) => {
                const folderPath = path_1.default.join(basePath, folder);
                if (!filePath && fs_1.default.existsSync(folderPath)) {
                    filePath = findCodeFn(folderPath);
                }
            });
        };
        findCodeByConvention(this.options.assetPath, assetIds);
        if (!filePath) {
            findCodeByConvention(this.getBuiltinDir(), ['.']);
        }
        if (!filePath) {
            findCodeByConvention(this.options.terasliceOpPath, ['readers', 'processors']);
        }
        if (!filePath) {
            filePath = this.resolvePath(name);
        }
        return filePath;
    }
    /**
     * Load any LegacyOperation
     * DEPRECATED to accommadate for new Job APIs,
     * use loadReader, or loadProcessor
     */
    load(name, assetIds) {
        const codePath = this.findOrThrow(name, assetIds);
        try {
            return this.require(codePath);
        }
        catch (err) {
            throw new Error(`Failure loading module: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
    }
    loadProcessor(name, assetIds) {
        const codePath = this.findOrThrow(name, assetIds);
        if (this.isLegacyProcessor(codePath)) {
            return this.shimLegacyProcessor(name, codePath);
        }
        let Processor;
        let Schema;
        let API;
        try {
            Processor = this.require(codePath, 'processor');
        }
        catch (err) {
            throw new Error(`Failure loading processor from module: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
        try {
            Schema = this.require(codePath, 'schema');
        }
        catch (err) {
            throw new Error(`Failure loading schema from module: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
        try {
            API = this.require(codePath, 'api');
        }
        catch (err) {
            // do nothing
        }
        return {
            // @ts-expect-error
            Processor,
            // @ts-expect-error
            Schema,
            API,
        };
    }
    loadReader(name, assetIds) {
        const codePath = this.findOrThrow(name, assetIds);
        if (this.isLegacyReader(codePath)) {
            return this.shimLegacyReader(name, codePath);
        }
        let Fetcher;
        let Slicer;
        let Schema;
        let API;
        try {
            Slicer = this.require(codePath, 'slicer');
        }
        catch (err) {
            throw new Error(`Failure loading slicer from module: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
        try {
            Fetcher = this.require(codePath, 'fetcher');
        }
        catch (err) {
            throw new Error(`Failure loading fetcher from module: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
        try {
            Schema = this.require(codePath, 'schema');
        }
        catch (err) {
            throw new Error(`Failure loading schema from module: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
        try {
            API = this.require(codePath, 'api');
        }
        catch (err) {
            // do nothing
        }
        return {
            // @ts-expect-error
            Slicer,
            // @ts-expect-error
            Fetcher,
            // @ts-expect-error
            Schema,
            API,
        };
    }
    loadAPI(name, assetIds) {
        const [apiName] = name.split(':');
        const codePath = this.findOrThrow(apiName, assetIds);
        let API;
        try {
            API = this.require(codePath, 'api');
        }
        catch (err) {
            // do nothing
        }
        let Observer;
        try {
            Observer = this.require(codePath, 'observer');
        }
        catch (err) {
            // do nothing
        }
        let Schema;
        try {
            Schema = this.require(codePath, 'schema');
        }
        catch (err) {
            throw new Error(`Failure loading schema from module: ${apiName}, error: ${utils_1.parseError(err, true)}`);
        }
        if (Observer == null && API == null) {
            throw new Error(`Failure to load api module: ${apiName}, requires at least an api.js or observer.js`);
        }
        else if (Observer != null && API != null) {
            throw new Error(`Failure to load api module: ${apiName}, required only one api.js or observer.js`);
        }
        const type = API != null ? 'api' : 'observer';
        return {
            // @ts-expect-error
            API: API || Observer,
            // @ts-expect-error
            Schema,
            type,
        };
    }
    findOrThrow(name, assetIds) {
        this.verifyOpName(name);
        const codePath = this.find(name, assetIds);
        if (!codePath) {
            throw new Error(`Unable to find module for operation: ${name}`);
        }
        return codePath;
    }
    isLegacyReader(codePath) {
        return !this.fileExists(codePath, 'fetcher') && !this.fileExists(codePath, 'slicer');
    }
    shimLegacyReader(name, codePath) {
        try {
            return shims_1.readerShim(this.require(codePath));
        }
        catch (err) {
            throw new Error(`Failure loading reader: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
    }
    isLegacyProcessor(codePath) {
        return !this.fileExists(codePath, 'processor');
    }
    shimLegacyProcessor(name, codePath) {
        try {
            return shims_1.processorShim(this.require(codePath));
        }
        catch (err) {
            throw new Error(`Failure loading processor: ${name}, error: ${utils_1.parseError(err, true)}`);
        }
    }
    fileExists(dir, name) {
        const filePaths = this.availableExtensions.map((ext) => path_1.default.format({
            dir,
            name,
            ext,
        }));
        return filePaths.some((filePath) => fs_1.default.existsSync(filePath));
    }
    require(dir, name) {
        const filePaths = name
            ? this.availableExtensions.map((ext) => path_1.default.format({
                dir,
                name,
                ext,
            }))
            : [dir];
        let err;
        for (const filePath of filePaths) {
            try {
                const mod = require(filePath);
                return mod.default || mod;
            }
            catch (_err) {
                err = _err;
            }
        }
        if (err) {
            throw err;
        }
        else {
            throw new Error(`Unable to find module at paths: ${filePaths.join(', ')}`);
        }
    }
    resolvePath(filePath) {
        if (!filePath)
            return null;
        if (fs_1.default.existsSync(filePath))
            return filePath;
        try {
            return require.resolve(filePath);
        }
        catch (err) {
            for (const ext of this.availableExtensions) {
                try {
                    return path_1.default.dirname(require.resolve(path_1.default.format({
                        dir: filePath,
                        name: 'schema',
                        ext,
                    })));
                }
                catch (_err) {
                    // do nothing
                }
            }
            return null;
        }
    }
    verifyOpName(name) {
        if (!utils_1.isString(name)) {
            throw new TypeError('Please verify that the "_op" name exists for each operation');
        }
    }
    findCode(name) {
        let filePath = null;
        const codeNames = this.availableExtensions.map((ext) => path_1.default.format({
            name,
            ext,
        }));
        const allowedNames = utils_1.uniq([name, ...codeNames]);
        const invalid = ['node_modules', ...ignoreDirectories()];
        const findCode = (rootDir) => {
            const fileNames = fs_1.default.readdirSync(rootDir)
                .filter((fileName) => !invalid.includes(fileName));
            for (const fileName of fileNames) {
                if (filePath)
                    break;
                const nextPath = path_1.default.join(rootDir, fileName);
                // if name is same as fileName/dir then we found it
                if (allowedNames.includes(fileName)) {
                    filePath = this.resolvePath(nextPath);
                }
                if (!filePath && this.isDir(nextPath)) {
                    filePath = findCode(nextPath);
                }
            }
            return filePath;
        };
        return findCode;
    }
    isDir(filePath) {
        return fs_1.default.statSync(filePath).isDirectory();
    }
    getBuiltinDir() {
        if (this.availableExtensions.includes('.ts')) {
            return path_1.default.join(__dirname, 'builtin');
        }
        return path_1.default.join(__dirname, '..', '..', 'dist', 'src', 'builtin');
    }
}
exports.OperationLoader = OperationLoader;
function availableExtensions() {
    // populated by teraslice Jest configuration
    // @ts-expect-error
    return global.availableExtensions ? global.availableExtensions : ['.js'];
}
function ignoreDirectories() {
    // populated by teraslice Jest configuration
    // @ts-expect-error
    return global.ignoreDirectories || [];
}
//# sourceMappingURL=operation-loader.js.map