@apollo-annotation/cli 0.1.18 → 0.1.20

package/dist/commands/refseq/add-alias.js

@@ -0,0 +1,72 @@
+import * as fs from 'node:fs';
+import { Agent, fetch } from 'undici';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, localhostToAddress, queryApollo, } from '../../utils.js';
+import { ConfigError } from '../../ApolloConf.js';
+export default class AddRefNameAlias extends BaseCommand {
+    static summary = 'Add reference name aliases from a file';
+    static description = 'Reference name aliasing is a process to make chromosomes that are named slightly differently but which refer to the same thing render properly. This command reads a file with reference name aliases and adds them to the database.';
+    static examples = [
+        {
+            description: 'Add reference name aliases:',
+            command: '<%= config.bin %> <%= command.id %> -i alias.txt -a myAssembly',
+        },
+    ];
+    static flags = {
+        'input-file': Flags.string({
+            char: 'i',
+            description: 'Input refname alias file',
+            required: true,
+        }),
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Name for this assembly.',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AddRefNameAlias);
+        if (!fs.existsSync(flags['input-file'])) {
+            this.error(`File ${flags['input-file']} does not exist`);
+        }
+        const access = await this.getAccess();
+        const filehandle = await fs.promises.open(flags['input-file']);
+        const fileContent = await filehandle.readFile({ encoding: 'utf8' });
+        await filehandle.close();
+        const lines = fileContent.split('\n');
+        const refNameAliases = [];
+        for (const line of lines) {
+            const [refName, ...aliases] = line.split('\t');
+            refNameAliases.push({ refName, aliases });
+        }
+        const assemblies = await queryApollo(access.address, access.accessToken, 'assemblies');
+        const json = (await assemblies.json());
+        const assembly = json.find((x) => 'name' in x && x.name === flags.assembly);
+        const assemblyId = assembly && '_id' in assembly ? assembly._id : undefined;
+        if (!assemblyId) {
+            this.error(`Assembly ${flags.assembly} not found`);
+        }
+        const change = {
+            typeName: 'AddRefSeqAliasesChange',
+            assembly: assemblyId,
+            refSeqAliases: refNameAliases,
+        };
+        const auth = {
+            method: 'POST',
+            body: JSON.stringify(change),
+            headers: {
+                Authorization: `Bearer ${access.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
+        };
+        const url = new URL(localhostToAddress(`${access.address}/changes`));
+        const response = await fetch(url, auth);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'Failed to add reference name aliases');
+            throw new ConfigError(errorMessage);
+        }
+        this.log(`Reference name aliases added successfully to assembly ${flags.assembly}`);
+    }
+}

package/dist/commands/refseq/get.js

@@ -1,18 +1,18 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../baseCommand.js';
-import { convertAssemblyNameToId, idReader, queryApollo, wrapLines, } from '../../utils.js';
+import { convertAssemblyNameToId, idReader, queryApollo } from '../../utils.js';
 export default class Get extends BaseCommand {
     static summary = 'Get reference sequences';
-    static description = wrapLines('Output the reference sequences in one or more assemblies in json format. \
-    This command returns the sequence characteristics (e.g., name, ID, etc), not the DNA sequences. \
-    Use `assembly sequence` for that.');
+    static description = 'Output the reference sequences in one or more assemblies in json format. \
+This command returns the sequence characteristics (e.g., name, ID, etc), not the DNA sequences. \
+Use `assembly sequence` for that.';
     static examples = [
         {
-            description: wrapLines('All sequences in the database:'),
+            description: 'All sequences in the database:',
             command: '<%= config.bin %> <%= command.id %>',
         },
         {
-            description: wrapLines('Only sequences for these assemblies:'),
+            description: 'Only sequences for these assemblies:',
             command: '<%= config.bin %> <%= command.id %> -a mm9 mm10',
         },
     ];
@@ -25,13 +25,13 @@ export default class Get extends BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(Get);
-        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const access = await this.getAccess();
         const refSeqs = await queryApollo(access.address, access.accessToken, 'refSeqs');
         const json = (await refSeqs.json());
         let keep = json;
         if (flags.assembly !== undefined) {
             keep = [];
-            const assembly = idReader(flags.assembly);
+            const assembly = await idReader(flags.assembly);
             const assemblyIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
             for (const x of json) {
                 if (assemblyIds.includes(x['assembly'])) {

package/dist/commands/status.js

@@ -2,11 +2,12 @@
 import path from 'node:path';
 import { ApolloConf, KEYS } from '../ApolloConf.js';
 import { BaseCommand } from '../baseCommand.js';
-import { basicCheckConfig, wrapLines } from '../utils.js';
+import { basicCheckConfig } from '../utils.js';
 export default class Status extends BaseCommand {
     static summary = 'View authentication status';
-    static description = wrapLines('This command returns "<profile>: Logged in" if the selected profile has an access token and "<profile>: Logged out" otherwise.\
-    Note that this command does not check the validity of the access token.');
+    static description = 'This command returns "<profile>: Logged in" if the selected profile \
+has an access token and "<profile>: Logged out" otherwise.\
+Note that this command does not check the validity of the access token.';
     async run() {
         const { flags } = await this.parse(Status);
         let profileName = flags.profile;
@@ -15,7 +16,7 @@ export default class Status extends BaseCommand {
         }
         let configFile = flags['config-file'];
         if (configFile === undefined) {
-            configFile = path.join(this.config.configDir, 'config.yaml');
+            configFile = path.join(this.config.configDir, 'config.yml');
         }
         basicCheckConfig(configFile, profileName);
         const config = new ApolloConf(configFile);

package/dist/commands/user/get.js

@@ -1,9 +1,9 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../baseCommand.js';
-import { queryApollo, wrapLines } from '../../utils.js';
+import { queryApollo } from '../../utils.js';
 export default class Get extends BaseCommand {
     static summary = 'Get list of users';
-    static description = wrapLines('If set, filters username and role must be both satisfied to return an entry');
+    static description = 'If set, filters username and role must be both satisfied to return an entry';
     static examples = [
         {
             description: 'By username:',
@@ -30,7 +30,7 @@ export default class Get extends BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(Get);
-        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const access = await this.getAccess();
         const users = await queryApollo(access.address, access.accessToken, 'users');
         const json = (await users.json());
         const out = [];

package/dist/commands/user/get.test.js

@@ -7,7 +7,7 @@ const __dirname = fileURLToPath(new URL('.', import.meta.url));
 // TODO: Need valid token
 describe.skip('apollo user get: Get users as YAML string', () => {
     before(() => {
-        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+        copyFile(`${TEST_DATA_DIR}/complete_config.yml`, CONFIG_FILE, VERBOSE);
     });
     after(() => {
         fs.rmSync(CONFIG_FILE);

package/dist/fileCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './baseCommand.js';
+export declare abstract class FileCommand extends BaseCommand<typeof FileCommand> {
+    init(): Promise<void>;
+    uploadFile(address: string, accessToken: string, file: string, type: string, isGzip: boolean): Promise<string>;
+}

package/dist/fileCommand.js

@@ -0,0 +1,76 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Transform, pipeline, } from 'node:stream';
+import { SingleBar } from 'cli-progress';
+import { Agent, fetch } from 'undici';
+import { ConfigError } from './ApolloConf.js';
+import { BaseCommand } from './baseCommand.js';
+import { createFetchErrorMessage, localhostToAddress } from './utils.js';
+class ProgressTransform extends Transform {
+    size = 0;
+    progressBar;
+    constructor(opts) {
+        super(opts);
+        this.progressBar = opts.progressBar;
+    }
+    _transform(chunk, _encoding, callback) {
+        this.size += chunk.length;
+        this.progressBar.update(this.size);
+        callback(null, chunk);
+    }
+}
+export class FileCommand extends BaseCommand {
+    async init() {
+        await super.init();
+    }
+    async uploadFile(address, accessToken, file, type, isGzip) {
+        const filehandle = await fs.promises.open(file);
+        const { size } = await filehandle.stat();
+        const stream = filehandle.createReadStream();
+        const progressBar = new SingleBar({ etaBuffer: 100_000_000 });
+        const progressTransform = new ProgressTransform({ progressBar });
+        const body = pipeline(stream, progressTransform, (error) => {
+            if (error) {
+                progressBar.stop();
+                console.error('Error processing file.', error);
+                throw error;
+            }
+        });
+        const headers = new Headers({
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': type,
+            'Content-Length': String(size),
+        });
+        if (isGzip) {
+            headers.append('Content-Encoding', 'gzip');
+        }
+        const init = {
+            method: 'POST',
+            body,
+            duplex: 'half',
+            dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
+            headers,
+        };
+        const fileName = path.basename(file);
+        const url = new URL(localhostToAddress(`${address}/files`));
+        url.searchParams.set('name', fileName);
+        url.searchParams.set('type', type);
+        progressBar.start(size, 0);
+        try {
+            const response = await fetch(url, init);
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, 'uploadFile failed');
+                throw new ConfigError(errorMessage);
+            }
+            const json = (await response.json());
+            return json['_id'];
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+        finally {
+            progressBar.stop();
+        }
+    }
+}

package/dist/test/fixtures.js

@@ -4,8 +4,8 @@ import path from 'node:path';
 export const TEST_DATA_DIR = path.resolve('test_data');
 export const VERBOSE = false;
 export const CONFIG_DIR = path.join(os.homedir(), '.config', 'apollo-cli');
-export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.yaml');
-const CONFIG_BAK = path.join(TEST_DATA_DIR, 'original.config.yaml.bak');
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.yml');
+const CONFIG_BAK = path.join(TEST_DATA_DIR, 'original.config.yml.bak');
 function renameFile(src, dest, verbose = true) {
     if (fs.existsSync(dest)) {
         throw new Error(`File ${dest} already exists`);

package/dist/utils.d.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'node:events';
 import { Response } from 'undici';
 import { ApolloConf } from './ApolloConf.js';
+import { ApolloAssemblySnapshot } from '@apollo-annotation/mst';
 export declare const CLI_SERVER_ADDRESS = "http://127.0.0.1:5657";
 export declare const CLI_SERVER_ADDRESS_CALLBACK = "http://127.0.0.1:5657/auth/callback";
 export declare class CheckError extends Error {
@@ -17,27 +18,38 @@ export declare function basicCheckConfig(configFile: string, profileName: string
  */
 export declare function localhostToAddress(url: string): string;
 export declare function deleteAssembly(address: string, accessToken: string, assemblyId: string): Promise<void>;
-export declare function getAssembly(address: string, accessToken: string, assemblyNameOrId: string): Promise<object>;
+export declare function getAssembly(address: string, accessToken: string, assemblyNameOrId: string): Promise<ApolloAssemblySnapshot>;
 export declare function getRefseqId(address: string, accessToken: string, refseqNameOrId?: string, inAssemblyNameOrId?: string): Promise<string[]>;
 export declare function convertCheckNameToId(address: string, accessToken: string, namesOrIds: string[]): Promise<string[]>;
-export declare function assemblyNameToIdDict(address: string, accessToken: string): Promise<Record<string, string>>;
+export declare function assemblyNameToIdDict(address: string, accessToken: string): Promise<Record<string, string | undefined>>;
 /** In input array namesOrIds, substitute common names with internal IDs */
 export declare function convertAssemblyNameToId(address: string, accessToken: string, namesOrIds: string[], verbose?: boolean, removeDuplicates?: boolean): Promise<string[]>;
 export declare function getFeatureById(address: string, accessToken: string, id: string): Promise<Response>;
 export declare function getAssemblyFromRefseq(address: string, accessToken: string, refSeq: string): Promise<string>;
 export declare function queryApollo(address: string, accessToken: string, endpoint: string): Promise<Response>;
 export declare function filterJsonList(json: object[], keep: string[], key: string): object[];
-export declare const getUserCredentials: () => UserCredentials | null;
 export declare const generatePkceChallenge: () => {
     state: string;
     codeVerifier: string;
     codeChallenge: string;
 };
 export declare const waitFor: <T>(eventName: string, emitter: EventEmitter) => Promise<T>;
-interface bodyLocalFile {
+interface bodyFastaFile {
     assemblyName: string;
     typeName: string;
-    fileId: string;
+    fileIds: {
+        fa: string;
+    };
+    assembly: string;
+}
+interface bodyIndexedFiles {
+    assemblyName: string;
+    typeName: string;
+    fileIds: {
+        fa: string;
+        fai: string;
+        gzi: string;
+    };
 }
 interface bodyExternalFile {
     assemblyName: string;
@@ -47,8 +59,7 @@ interface bodyExternalFile {
         fai: string;
     };
 }
-export declare function submitAssembly(address: string, accessToken: string, body: bodyLocalFile | bodyExternalFile, force: boolean): Promise<Response>;
-export declare function uploadFile(address: string, accessToken: string, file: string, type: string): Promise<string>;
-export declare function wrapLines(s: string, length?: number): string;
-export declare function idReader(input: string[], removeDuplicates?: boolean): string[];
+export declare function submitAssembly(address: string, accessToken: string, body: bodyFastaFile | bodyExternalFile | bodyIndexedFiles, force: boolean): Promise<object>;
+export declare function readStdin(): Promise<string>;
+export declare function idReader(input: string[], removeDuplicates?: boolean): Promise<string[]>;
 export {};

package/dist/utils.js

@@ -1,15 +1,8 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { Agent, FormData, Response, fetch } from 'undici';
+import { stdin, stderr } from 'node:process';
+import { Agent, fetch } from 'undici';
 import { ApolloConf, ConfigError } from './ApolloConf.js';
-const CONFIG_PATH = path.resolve(os.homedir(), '.clirc');
 export const CLI_SERVER_ADDRESS = 'http://127.0.0.1:5657';
 export const CLI_SERVER_ADDRESS_CALLBACK = `${CLI_SERVER_ADDRESS}/auth/callback`;
 export class CheckError extends Error {
@@ -61,6 +54,7 @@ export async function deleteAssembly(address, accessToken, assemblyId) {
             Authorization: `Bearer ${accessToken}`,
             'Content-Type': 'application/json',
         },
+        dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
     };
     const url = new URL(localhostToAddress(`${address}/changes`));
     const response = await fetch(url, auth);
@@ -72,18 +66,16 @@ export async function deleteAssembly(address, accessToken, assemblyId) {
 export async function getAssembly(address, accessToken, assemblyNameOrId) {
     const assemblyId = await convertAssemblyNameToId(address, accessToken, [assemblyNameOrId]);
     if (assemblyId.length === 0) {
-        return {};
+        throw new Error(`Assembly "${assemblyNameOrId}" not found`);
     }
     const res = await queryApollo(address, accessToken, 'assemblies');
     const assemblies = (await res.json());
-    let assemblyObj = {};
     for (const x of assemblies) {
-        if (x['_id'] === assemblyId[0]) {
-            assemblyObj = JSON.parse(JSON.stringify(x));
-            break;
+        if (x._id === assemblyId[0]) {
+            return JSON.parse(JSON.stringify(x));
         }
     }
-    return assemblyObj;
+    throw new Error(`Assembly "${assemblyNameOrId}" not found`);
 }
 export async function getRefseqId(address, accessToken, refseqNameOrId, inAssemblyNameOrId) {
     if (refseqNameOrId === undefined && inAssemblyNameOrId === undefined) {
@@ -128,11 +120,11 @@ export async function getRefseqId(address, accessToken, refseqNameOrId, inAssemb
 }
 async function checkNameToIdDict(address, accessToken) {
     const asm = await queryApollo(address, accessToken, 'checks/types');
-    const ja = (await asm.json());
+    const ja = (await asm.json()); // Not sure if CheckResultSnapshot is the right interface
     const nameToId = {};
     for (const x of ja) {
-        const name = x['name'];
-        nameToId[name] = x['_id'];
+        const { _id, name } = x; // x['name' as keyof typeof x]
+        nameToId[name] = _id; // x['_id' as keyof typeof x]
     }
     return nameToId;
 }
@@ -173,7 +165,7 @@ export async function convertAssemblyNameToId(address, accessToken, namesOrIds,
             ids.push(x);
         }
         else if (verbose) {
-            process.stderr.write(`Warning: Omitting unknown assembly: "${x}"\n`);
+            stderr.write(`Warning: Omitting unknown assembly: "${x}"\n`);
         }
     }
     if (removeDuplicates) {
@@ -221,15 +213,6 @@ export function filterJsonList(json, keep, key) {
     }
     return results;
 }
-export const getUserCredentials = () => {
-    try {
-        const content = fs.readFileSync(CONFIG_PATH, { encoding: 'utf8' });
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-};
 export const generatePkceChallenge = () => {
     const codeVerifier = crypto.randomBytes(64).toString('hex');
     const codeChallenge = crypto
@@ -256,7 +239,7 @@ export const waitFor = (eventName, emitter) => {
     return promise;
 };
 export async function submitAssembly(address, accessToken, body, force) {
-    const assemblies = await queryApollo(address, accessToken, 'assemblies');
+    let assemblies = await queryApollo(address, accessToken, 'assemblies');
     for (const x of (await assemblies.json())) {
         if (x['name'] === body.assemblyName) {
             if (force) {
@@ -267,10 +250,6 @@ export async function submitAssembly(address, accessToken, body, force) {
             }
         }
     }
-    const controller = new AbortController();
-    setTimeout(() => {
-        controller.abort();
-    }, 24 * 60 * 60 * 1000);
     const auth = {
         method: 'POST',
         body: JSON.stringify(body),
@@ -278,60 +257,35 @@ export async function submitAssembly(address, accessToken, body, force) {
             Authorization: `Bearer ${accessToken}`,
             'Content-Type': 'application/json',
         },
-        signal: controller.signal,
+        dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
     };
     const url = new URL(localhostToAddress(`${address}/changes`));
     const response = await fetch(url, auth);
     if (!response.ok) {
         const errorMessage = await createFetchErrorMessage(response, 'submitAssembly failed');
-        throw new ConfigError(errorMessage);
+        throw new Error(errorMessage);
     }
-    return response;
-}
-export async function uploadFile(address, accessToken, file, type) {
-    const stream = fs.createReadStream(file, 'utf8');
-    const fileStream = new Response(stream);
-    const fileBlob = await fileStream.blob();
-    const formData = new FormData();
-    formData.append('type', type);
-    formData.append('file', fileBlob);
-    const auth = {
-        method: 'POST',
-        body: formData,
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-        },
-        dispatcher: new Agent({
-            keepAliveTimeout: 10 * 60 * 1000,
-            keepAliveMaxTimeout: 10 * 60 * 1000, // 10 minutes
-        }),
-    };
-    const url = new URL(localhostToAddress(`${address}/files`));
-    const response = await fetch(url, auth);
-    if (!response.ok) {
-        const errorMessage = await createFetchErrorMessage(response, 'uploadFile failed');
-        throw new ConfigError(errorMessage);
+    assemblies = await queryApollo(address, accessToken, 'assemblies');
+    for (const x of (await assemblies.json())) {
+        if (x['name'] === body.assemblyName) {
+            return x;
+        }
     }
-    const json = (await response.json());
-    return json['_id'];
+    throw new Error(`Failed to retrieve assembly ${body.assemblyName}`);
 }
-/* Wrap text to max `length` per line */
-export function wrapLines(s, length) {
-    if (length === undefined) {
-        length = 80;
+export async function readStdin() {
+    const chunks = [];
+    for await (const chunk of stdin) {
+        chunks.push(Buffer.from(chunk));
     }
-    // Credit: https://stackoverflow.com/questions/14484787/wrap-text-in-javascript
-    const re = new RegExp(`(?![^\\n]{1,${length}}$)([^\\n]{1,${length}})\\s`, 'g');
-    s = s.replaceAll(/ +/g, ' ');
-    const wr = s.replace(re, '$1\n');
-    return wr;
+    return Buffer.concat(chunks).toString('utf8');
 }
-export function idReader(input, removeDuplicates = true) {
+export async function idReader(input, removeDuplicates = true) {
     let ids = [];
     for (const xin of input) {
         let data;
         if (xin == '-') {
-            data = fs.readFileSync('/dev/stdin').toString();
+            data = await readStdin();
         }
         else if (fs.existsSync(xin)) {
             data = fs.readFileSync(xin).toString();
@@ -340,14 +294,13 @@ export function idReader(input, removeDuplicates = true) {
             data = xin;
         }
         try {
-            data = JSON.parse(data);
-            if (data.length === undefined) {
-                data = [data];
+            let parsedData = JSON.parse(data);
+            if (!Array.isArray(parsedData)) {
+                parsedData = [parsedData];
             }
-            for (const x of data) {
-                const id = x['_id'];
-                if (id !== undefined) {
-                    ids.push(id);
+            for (const x of parsedData) {
+                if ('_id' in x && typeof x._id === 'string') {
+                    ids.push(x._id);
                 }
             }
         }