@jbrowse/cli 4.3.0 → 5.0.0-beta.10

package/dist/commands/add-assembly/utils.js

@@ -1,10 +1,35 @@
-import fs from 'fs';
-import path from 'path';
-import { isURL } from "../../types/common.js";
-import { debug, readInlineOrFileJson, readJsonFile, resolveFileLocation, } from "../../utils.js";
-import { findAndUpdateOrAdd, saveConfigAndReport as saveConfigAndReportBase, } from "../shared/config-operations.js";
-const { rename, copyFile, symlink } = fs.promises;
-export function isValidJSON(string) {
+import fs from 'node:fs';
+import path from 'node:path';
+import { isURL } from '../../types/common.js';
+import { STDIN_ARG, debug, ignoreNotFound, isRecord, parseCommaSeparatedString, readInlineOrFileJson, readJsonFile, } from '../../utils.js';
+import { mapLocationForFiles } from '../add-track-utils/track-config.js';
+import { parseConfigFlag, validateLoadAndLocation, } from '../add-track-utils/validators.js';
+import { findAndUpdateOrAdd } from '../shared/config-operations.js';
+const sequenceTypes = new Set([
+    'indexedFasta',
+    'bgzipFasta',
+    'twoBit',
+    'chromSizes',
+    'custom',
+]);
+function isSequenceType(t) {
+    return sequenceTypes.has(t);
+}
+// parseArgs does not enforce the `choices` declared on --type, so an
+// unrecognized value would otherwise be silently dropped and the type guessed
+// from the file extension, masking a user typo. Returning the narrowed value
+// (rather than validating and leaving the caller to re-test the same string)
+// keeps the check and the narrowing in one place.
+export function parseSequenceType(type) {
+    if (type === undefined) {
+        return undefined;
+    }
+    if (!isSequenceType(type)) {
+        throw new Error(`--type must be one of: ${[...sequenceTypes].join(', ')}`);
+    }
+    return type;
+}
+function isValidJSON(string) {
     try {
         JSON.parse(string);
         return true;
@@ -13,299 +38,197 @@ export function isValidJSON(string) {
         return false;
     }
 }
-export function guessSequenceType(sequence) {
-    if (sequence.endsWith('.fa') ||
-        sequence.endsWith('.fna') ||
-        sequence.endsWith('.fasta')) {
-        return 'indexedFasta';
-    }
-    if (sequence.endsWith('.fa.gz') ||
-        sequence.endsWith('.fna.gz') ||
-        sequence.endsWith('.fasta.gz')) {
-        return 'bgzipFasta';
-    }
-    if (sequence.endsWith('.2bit')) {
-        return 'twoBit';
-    }
-    if (sequence.endsWith('.chrom.sizes')) {
-        return 'chromSizes';
-    }
-    if (sequence.endsWith('.json')) {
-        return 'custom';
+// recognized FASTA extensions, shared by sequence-type guessing and basename
+// stripping so the list lives in one place
+const fastaExts = 'fa|fna|fasta|mfa';
+const fastaRegex = new RegExp(`\\.(${fastaExts})$`, 'i');
+const bgzipFastaRegex = new RegExp(`\\.(${fastaExts})\\.gz$`, 'i');
+const fastaExtRegex = new RegExp(`\\.(${fastaExts})(\\.gz)?$`, 'i');
+function basenameWithoutFastaExt(p) {
+    return path.basename(p).replace(fastaExtRegex, '');
+}
+// extension → sequence type, tried in order. The plain-fasta pattern is anchored
+// at the end so it cannot claim a .fa.gz out from under the bgzip one.
+const seqTypeByExtension = [
+    [fastaRegex, 'indexedFasta'],
+    [bgzipFastaRegex, 'bgzipFasta'],
+    [/\.2bit$/i, 'twoBit'],
+    [/\.chrom\.sizes$/i, 'chromSizes'],
+    [/\.json$/i, 'custom'],
+];
+function guessSequenceType(sequence) {
+    const byExtension = seqTypeByExtension.find(([regex]) => regex.test(sequence))?.[1];
+    if (byExtension) {
+        return byExtension;
     }
+    // a custom adapter can also be given as inline JSON, which has no extension
     if (isValidJSON(sequence)) {
         return 'custom';
     }
     throw new Error('Could not determine sequence type automatically, add --type to specify it');
 }
-export function needLoadData(location) {
-    return !isURL(location);
-}
-export async function loadData({ load, filePaths, destination, }) {
-    if (isURL(filePaths[0])) {
-        return false;
-    }
-    if (load === 'inPlace') {
-        return false;
+const seqSpecs = {
+    indexedFasta: {
+        adapterType: 'IndexedFastaAdapter',
+        locField: 'fastaLocation',
+        sidecars: [{ field: 'faiLocation', suffix: '.fai' }],
+        defaultName: basenameWithoutFastaExt,
+    },
+    bgzipFasta: {
+        adapterType: 'BgzipFastaAdapter',
+        locField: 'fastaLocation',
+        sidecars: [
+            { field: 'faiLocation', suffix: '.fai' },
+            { field: 'gziLocation', suffix: '.gzi' },
+        ],
+        defaultName: basenameWithoutFastaExt,
+    },
+    twoBit: {
+        adapterType: 'TwoBitAdapter',
+        locField: 'twoBitLocation',
+        sidecars: [],
+        defaultName: p => path.basename(p, '.2bit'),
+    },
+    chromSizes: {
+        adapterType: 'ChromSizesAdapter',
+        locField: 'chromSizesLocation',
+        sidecars: [],
+        defaultName: p => path.basename(p, '.chrom.sizes'),
+    },
+};
+async function customSequenceAdapter(argsSequence, name) {
+    const adapter = await readInlineOrFileJson(argsSequence);
+    debug(`Custom adapter: ${JSON.stringify(adapter)}`);
+    if (!name) {
+        // neither inline JSON nor stdin carries a filename to name the assembly
+        // after, and "-" is not a name
+        if (isValidJSON(argsSequence) || argsSequence === STDIN_ARG) {
+            throw new Error('Must provide --name when using custom inline JSON sequence');
+        }
+        name = path.basename(argsSequence, '.json');
     }
-    const destDir = path.dirname(destination);
-    const validPaths = filePaths.filter(f => !!f);
-    const operations = {
-        copy: copyFile,
-        symlink: (src, dest) => symlink(path.resolve(src), dest),
-        move: rename,
-    };
-    const operation = operations[load];
-    if (operation) {
-        await Promise.all(validPaths.map(filePath => operation(filePath, path.join(destDir, path.basename(filePath)))));
-        return true;
+    if (!adapter.type) {
+        throw new Error(`No "type" specified in sequence adapter "${JSON.stringify(adapter)}"`);
     }
-    return false;
+    return { adapter, name };
 }
-export async function getAssembly({ runFlags, argsSequence, target, }) {
-    let sequence;
-    if (needLoadData(argsSequence) && !runFlags.load) {
-        throw new Error('Please specify the loading operation for this file with --load copy|symlink|move|inPlace');
-    }
-    else if (!needLoadData(argsSequence) && runFlags.load) {
-        throw new Error('URL detected with --load flag. Please rerun the function without the --load flag');
-    }
-    let { name } = runFlags;
-    let { type } = runFlags;
-    if (type) {
-        debug(`Type is: ${type}`);
-    }
-    else {
-        type = guessSequenceType(argsSequence);
-        debug(`No type specified, guessing type: ${type}`);
-    }
-    if (name) {
-        debug(`Name is: ${name}`);
-    }
-    switch (type) {
-        case 'indexedFasta': {
-            const { skipCheck, force, load, faiLocation } = runFlags;
-            let sequenceLocation = await resolveFileLocation(argsSequence, !(skipCheck || force), load === 'inPlace');
-            debug(`FASTA location resolved to: ${sequenceLocation}`);
-            let indexLocation = await resolveFileLocation(faiLocation || `${argsSequence}.fai`, !(skipCheck || force), load === 'inPlace');
-            debug(`FASTA index location resolved to: ${indexLocation}`);
-            if (!name) {
-                name = path.basename(sequenceLocation, sequenceLocation.endsWith('.fasta') ? '.fasta' : '.fa');
-                debug(`Guessing name: ${name}`);
-            }
-            const loaded = load
-                ? await loadData({
-                    load,
-                    filePaths: [sequenceLocation, indexLocation],
-                    destination: target,
-                })
-                : false;
-            if (loaded) {
-                sequenceLocation = path.basename(sequenceLocation);
-                indexLocation = path.basename(indexLocation);
-            }
-            sequence = {
-                type: 'ReferenceSequenceTrack',
-                trackId: `${name}-ReferenceSequenceTrack`,
-                adapter: {
-                    type: 'IndexedFastaAdapter',
-                    fastaLocation: {
-                        uri: sequenceLocation,
-                        locationType: 'UriLocation',
-                    },
-                    faiLocation: { uri: indexLocation, locationType: 'UriLocation' },
-                },
-            };
-            break;
-        }
-        case 'bgzipFasta': {
-            let sequenceLocation = await resolveFileLocation(argsSequence, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
-            debug(`compressed FASTA location resolved to: ${sequenceLocation}`);
-            let indexLocation = await resolveFileLocation(runFlags.faiLocation || `${sequenceLocation}.fai`, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
-            debug(`compressed FASTA index location resolved to: ${indexLocation}`);
-            let bgzipIndexLocation = await resolveFileLocation(runFlags.gziLocation || `${sequenceLocation}.gzi`, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
-            debug(`bgzip index location resolved to: ${bgzipIndexLocation}`);
-            if (!name) {
-                name = path.basename(sequenceLocation, sequenceLocation.endsWith('.fasta.gz') ? '.fasta.gz' : '.fa.gz');
-                debug(`Guessing name: ${name}`);
-            }
-            const loaded = runFlags.load
-                ? await loadData({
-                    load: runFlags.load,
-                    filePaths: [sequenceLocation, indexLocation, bgzipIndexLocation],
-                    destination: target,
-                })
-                : false;
-            if (loaded) {
-                sequenceLocation = path.basename(sequenceLocation);
-                indexLocation = path.basename(indexLocation);
-                bgzipIndexLocation = path.basename(bgzipIndexLocation);
-            }
-            sequence = {
-                type: 'ReferenceSequenceTrack',
-                trackId: `${name}-ReferenceSequenceTrack`,
-                adapter: {
-                    type: 'BgzipFastaAdapter',
-                    fastaLocation: {
-                        uri: sequenceLocation,
-                        locationType: 'UriLocation',
-                    },
-                    faiLocation: { uri: indexLocation, locationType: 'UriLocation' },
-                    gziLocation: {
-                        uri: bgzipIndexLocation,
-                        locationType: 'UriLocation',
-                    },
-                },
-            };
-            break;
-        }
-        case 'twoBit': {
-            let sequenceLocation = await resolveFileLocation(argsSequence, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
-            debug(`2bit location resolved to: ${sequenceLocation}`);
-            if (!name) {
-                name = path.basename(sequenceLocation, '.2bit');
-                debug(`Guessing name: ${name}`);
-            }
-            const loaded = runFlags.load
-                ? await loadData({
-                    load: runFlags.load,
-                    filePaths: [sequenceLocation],
-                    destination: target,
-                })
-                : false;
-            if (loaded) {
-                sequenceLocation = path.basename(sequenceLocation);
-            }
-            sequence = {
-                type: 'ReferenceSequenceTrack',
-                trackId: `${name}-ReferenceSequenceTrack`,
-                adapter: {
-                    type: 'TwoBitAdapter',
-                    twoBitLocation: {
-                        uri: sequenceLocation,
-                        locationType: 'UriLocation',
-                    },
-                },
-            };
-            break;
-        }
-        case 'chromSizes': {
-            let sequenceLocation = await resolveFileLocation(argsSequence, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
-            debug(`chrom.sizes location resolved to: ${sequenceLocation}`);
-            if (!name) {
-                name = path.basename(sequenceLocation, '.chrom.sizes');
-                debug(`Guessing name: ${name}`);
-            }
-            const loaded = runFlags.load
-                ? await loadData({
-                    load: runFlags.load,
-                    filePaths: [sequenceLocation],
-                    destination: target,
-                })
-                : false;
-            if (loaded) {
-                sequenceLocation = path.basename(sequenceLocation);
-            }
-            sequence = {
-                type: 'ReferenceSequenceTrack',
-                trackId: `${name}-ReferenceSequenceTrack`,
-                adapter: {
-                    type: 'ChromSizesAdapter',
-                    chromSizesLocation: {
-                        uri: sequenceLocation,
-                        locationType: 'UriLocation',
-                    },
-                },
-            };
-            break;
-        }
-        case 'custom': {
-            const adapter = await readInlineOrFileJson(argsSequence);
-            debug(`Custom adapter: ${JSON.stringify(adapter)}`);
-            if (!name) {
-                if (isValidJSON(argsSequence)) {
-                    throw new Error('Must provide --name when using custom inline JSON sequence');
-                }
-                else {
-                    name = path.basename(argsSequence, '.json');
-                }
-                debug(`Guessing name: ${name}`);
-            }
-            if (!('type' in adapter)) {
-                throw new Error(`No "type" specified in sequence adapter "${JSON.stringify(adapter)}"`);
-            }
-            sequence = {
-                type: 'ReferenceSequenceTrack',
-                trackId: `${name}-ReferenceSequenceTrack`,
-                adapter,
-            };
-            break;
-        }
+export async function getAssembly({ runFlags, argsSequence, }) {
+    validateLoadAndLocation(argsSequence, runFlags.load);
+    const type = runFlags.type ?? guessSequenceType(argsSequence);
+    debug(runFlags.type ? `Type is: ${type}` : `No type specified, guessed: ${type}`);
+    const uri = (p) => ({
+        uri: mapLocationForFiles(p, runFlags.load),
+        locationType: 'UriLocation',
+    });
+    if (type === 'custom') {
+        const { adapter, name } = await customSequenceAdapter(argsSequence, runFlags.name);
+        return {
+            assembly: { name, sequence: makeSequence(name, adapter) },
+            filesToLoad: [],
+        };
     }
-    return { name, sequence };
+    const spec = seqSpecs[type];
+    const sidecars = spec.sidecars.map(s => ({
+        field: s.field,
+        path: runFlags[s.field] ?? `${argsSequence}${s.suffix}`,
+    }));
+    const name = runFlags.name || spec.defaultName(argsSequence);
+    const adapter = {
+        type: spec.adapterType,
+        [spec.locField]: uri(argsSequence),
+        ...Object.fromEntries(sidecars.map(s => [s.field, uri(s.path)])),
+    };
+    return {
+        assembly: { name, sequence: makeSequence(name, adapter) },
+        filesToLoad: [argsSequence, ...sidecars.map(s => s.path)],
+    };
 }
-export async function exists(s) {
-    try {
-        await fs.promises.access(s, fs.constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
+function makeSequence(name, adapter) {
+    return {
+        type: 'ReferenceSequenceTrack',
+        trackId: `${name}-ReferenceSequenceTrack`,
+        adapter,
+    };
 }
 export async function resolveTargetPath(output) {
-    if (!(await exists(output))) {
+    const stat = await ignoreNotFound(fs.promises.stat(output));
+    if (!stat) {
         const dir = output.endsWith('.json') ? path.dirname(output) : output;
         await fs.promises.mkdir(dir, { recursive: true });
     }
-    let isDir = false;
-    try {
-        isDir = fs.statSync(output).isDirectory();
-    }
-    catch (e) { }
-    return isDir ? path.join(output, 'config.json') : output;
+    const finalStat = stat ?? (await ignoreNotFound(fs.promises.stat(output)));
+    return finalStat?.isDirectory() ? path.join(output, 'config.json') : output;
 }
-export async function enhanceAssembly(assembly, runFlags) {
-    const enhancedAssembly = { ...assembly };
-    if (runFlags.alias?.length) {
-        debug(`Adding assembly aliases: ${runFlags.alias}`);
-        enhancedAssembly.aliases = runFlags.alias;
+async function resolveRefNameAliasAdapter(refNameAliases, runFlags) {
+    if (runFlags.refNameAliasesType === 'custom') {
+        const config = await readInlineOrFileJson(refNameAliases);
+        if (!config.type) {
+            throw new Error(`No "type" specified in refNameAliases adapter "${JSON.stringify(config)}"`);
+        }
+        debug(`Adding custom refNameAliases config: ${JSON.stringify(config)}`);
+        return config;
     }
-    if (runFlags.refNameColors) {
-        enhancedAssembly.refNameColors = runFlags.refNameColors
-            .split(',')
-            .map((color) => color.trim());
+    // rewriting the path to a bare basename is only right when a load mode is
+    // going to copy the file next to config.json. With no --load — which a URL
+    // sequence forces, since --load with a URL is an error — the file stays where
+    // the user pointed at it, rather than the config naming a basename that
+    // nothing ever put there
+    const location = mapLocationForFiles(refNameAliases, runFlags.load ?? 'inPlace');
+    debug(`refName aliases file location: ${location}`);
+    return {
+        type: 'RefNameAliasAdapter',
+        location: { uri: location, locationType: 'UriLocation' },
+    };
+}
+// --config is merged shallowly, except for `sequence`: the generated
+// ReferenceSequenceTrack already holds the adapter built from the sequence
+// file, so a `sequence` hunk layers onto it (e.g. formatAbout) rather than
+// replacing it and dropping the adapter
+function applyExtraConfig(assembly, config) {
+    if (config === undefined) {
+        return assembly;
     }
-    if (runFlags.refNameAliases) {
-        if (runFlags.refNameAliasesType &&
-            runFlags.refNameAliasesType === 'custom') {
-            const refNameAliasesConfig = await readInlineOrFileJson(runFlags.refNameAliases);
-            if (!refNameAliasesConfig.type) {
-                throw new Error(`No "type" specified in refNameAliases adapter "${JSON.stringify(refNameAliasesConfig)}"`);
-            }
-            debug(`Adding custom refNameAliases config: ${JSON.stringify(refNameAliasesConfig)}`);
-            enhancedAssembly.refNameAliases = {
-                adapter: refNameAliasesConfig,
-            };
-        }
-        else {
-            const refNameAliasesLocation = await resolveFileLocation(runFlags.refNameAliases, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
-            debug(`refName aliases file location resolved to: ${refNameAliasesLocation}`);
-            enhancedAssembly.refNameAliases = {
-                adapter: {
-                    type: 'RefNameAliasAdapter',
-                    location: {
-                        uri: refNameAliasesLocation,
-                        locationType: 'UriLocation',
-                    },
-                },
-            };
-        }
+    const { sequence, name, ...rest } = parseConfigFlag(config);
+    if (sequence !== undefined && !isRecord(sequence)) {
+        throw new Error('--config "sequence" must be an object');
     }
-    if (runFlags.displayName) {
-        enhancedAssembly.displayName = runFlags.displayName;
+    if (name !== undefined) {
+        throw new Error('use --name rather than "name" in --config');
     }
-    return enhancedAssembly;
+    return {
+        ...assembly,
+        ...rest,
+        name: assembly.name,
+        sequence: { ...assembly.sequence, ...sequence },
+    };
+}
+export async function enhanceAssembly(assembly, runFlags) {
+    const { refNameAliases, refNameAliasesType } = runFlags;
+    // a non-custom refNameAliases points at a local aliases file; under a --load
+    // mode its location is rewritten to a bare basename, so the file itself must
+    // be loaded into the config dir alongside the sequence. Custom aliases are
+    // embedded inline (no file), and URLs are referenced in place.
+    const filesToLoad = refNameAliases && refNameAliasesType !== 'custom' && !isURL(refNameAliases)
+        ? [refNameAliases]
+        : [];
+    // typed flags layer over --config, so the most specific flag a user reaches
+    // for wins
+    return {
+        assembly: {
+            ...applyExtraConfig(assembly, runFlags.config),
+            ...(runFlags.alias?.length && { aliases: runFlags.alias }),
+            ...(runFlags.refNameColors && {
+                refNameColors: parseCommaSeparatedString(runFlags.refNameColors),
+            }),
+            ...(runFlags.displayName && { displayName: runFlags.displayName }),
+            ...(refNameAliases && {
+                refNameAliases: {
+                    adapter: await resolveRefNameAliasAdapter(refNameAliases, runFlags),
+                },
+            }),
+        },
+        filesToLoad,
+    };
 }
 export function createDefaultConfig() {
     return {
@@ -334,11 +257,11 @@ export async function loadOrCreateConfig(target) {
 }
 export async function addAssemblyToConfig({ config, assembly, runFlags, }) {
     const { updatedItems, wasOverwritten } = findAndUpdateOrAdd({
-        items: config.assemblies || [],
+        items: config.assemblies ?? [],
         newItem: assembly,
         idField: 'name',
         getId: item => item.name,
-        allowOverwrite: runFlags.overwrite || runFlags.force || false,
+        force: runFlags.force ?? false,
         itemType: 'assembly',
     });
     return {
@@ -346,12 +269,3 @@ export async function addAssemblyToConfig({ config, assembly, runFlags, }) {
         wasOverwritten,
     };
 }
-export async function saveConfigAndReport({ config, target, assembly, wasOverwritten, }) {
-    await saveConfigAndReportBase({
-        config,
-        target,
-        itemType: 'assembly',
-        itemName: assembly.name,
-        wasOverwritten,
-    });
-}