@apollo-annotation/cli 0.1.10

package/dist/utils.js

@@ -0,0 +1,373 @@
+/* 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 { Config, ConfigError } from './Config.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 {
+}
+export async function createFetchErrorMessage(response, additionalText) {
+    let errorMessage;
+    try {
+        errorMessage = await response.text();
+    }
+    catch {
+        errorMessage = '';
+    }
+    const responseMessage = `${response.status} ${response.statusText}${errorMessage ? ` (${errorMessage})` : ''}`;
+    return `${additionalText ? `${additionalText} — ` : ''}${responseMessage}`;
+}
+export function checkConfigfileExists(configFile) {
+    if (!fs.existsSync(configFile)) {
+        throw new ConfigError(`Configuration file "${configFile}" does not exist. Please run "apollo config" first`);
+    }
+}
+export function checkProfileExists(profileName, config) {
+    if (!config.getProfileNames().includes(profileName)) {
+        throw new ConfigError(`Profile "${profileName}" does not exist. Please run "apollo config" to set this profile up or choose a different profile`);
+    }
+}
+export function basicCheckConfig(configFile, profileName) {
+    checkConfigfileExists(configFile);
+    const config = new Config(configFile);
+    checkProfileExists(profileName, config);
+}
+/**
+ * @deprecated Use this function while we wait to resolve the TypeError when using localhost in fetch.
+ */
+export function localhostToAddress(url) {
+    /** This is hacked function that should become redundant: On my MacOS (?)
+     * localhost must be converted to address otherwise fetch throws TypeError
+     * */
+    return url.replace('//localhost', '127.0.0.1');
+}
+export async function deleteAssembly(address, accessToken, assemblyId) {
+    const body = {
+        typeName: 'DeleteAssemblyChange',
+        assembly: assemblyId,
+    };
+    const auth = {
+        method: 'POST',
+        body: JSON.stringify(body),
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const url = new URL(localhostToAddress(`${address}/changes`));
+    const response = await fetch(url, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'deleteAssembly failed');
+        throw new Error(errorMessage);
+    }
+}
+export async function getAssembly(address, accessToken, assemblyNameOrId) {
+    const assemblyId = await convertAssemblyNameToId(address, accessToken, [assemblyNameOrId]);
+    if (assemblyId.length === 0) {
+        return {};
+    }
+    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;
+        }
+    }
+    return assemblyObj;
+}
+export async function getRefseqId(address, accessToken, refseqNameOrId, inAssemblyNameOrId) {
+    if (refseqNameOrId === undefined && inAssemblyNameOrId === undefined) {
+        throw new Error('Please provide refseq and/or assembly');
+    }
+    if (inAssemblyNameOrId === undefined) {
+        inAssemblyNameOrId = '';
+    }
+    let assemblyId = [];
+    if (inAssemblyNameOrId !== '') {
+        assemblyId = await convertAssemblyNameToId(address, accessToken, [
+            inAssemblyNameOrId,
+        ]);
+        if (assemblyId.length !== 1) {
+            throw new Error(`Assembly name or assembly id returned ${assemblyId.length} assemblies instead of just one`);
+        }
+    }
+    const res = await queryApollo(address, accessToken, 'refSeqs');
+    const refSeqs = (await res.json());
+    const refseqIds = [];
+    const nAssemblies = new Set();
+    for (const x of refSeqs) {
+        const aid = x['assembly'];
+        const rid = x['_id'];
+        const rname = x['name'];
+        if (refseqNameOrId === rid ||
+            refseqNameOrId === rname ||
+            refseqNameOrId === undefined) {
+            if (inAssemblyNameOrId === '' || assemblyId.includes(aid)) {
+                refseqIds.push(rid);
+                nAssemblies.add(aid);
+            }
+            else {
+                //
+            }
+        }
+        if (nAssemblies.size > 1) {
+            throw new Error(`Sequence name "${refseqNameOrId}" found in more than one assembly`);
+        }
+    }
+    return refseqIds;
+}
+async function checkNameToIdDict(address, accessToken) {
+    const asm = await queryApollo(address, accessToken, 'checks/types');
+    const ja = (await asm.json());
+    const nameToId = {};
+    for (const x of ja) {
+        const name = x['name'];
+        nameToId[name] = x['_id'];
+    }
+    return nameToId;
+}
+export async function convertCheckNameToId(address, accessToken, namesOrIds) {
+    const nameToId = await checkNameToIdDict(address, accessToken);
+    const ids = [];
+    for (const x of namesOrIds) {
+        if (nameToId[x] !== undefined) {
+            ids.push(nameToId[x]);
+        }
+        else if (Object.values(nameToId).includes(x)) {
+            ids.push(x);
+        }
+        else {
+            throw new CheckError(`Check name or id "${x}" not found`);
+        }
+    }
+    return ids;
+}
+export async function assemblyNameToIdDict(address, accessToken) {
+    const asm = await queryApollo(address, accessToken, 'assemblies');
+    const ja = (await asm.json());
+    const nameToId = {};
+    for (const x of ja) {
+        nameToId[x['name']] = x['_id'];
+    }
+    return nameToId;
+}
+/** In input array namesOrIds, substitute common names with internal IDs */
+export async function convertAssemblyNameToId(address, accessToken, namesOrIds, verbose = true, removeDuplicates = true) {
+    const nameToId = await assemblyNameToIdDict(address, accessToken);
+    let ids = [];
+    for (const x of namesOrIds) {
+        if (nameToId[x] !== undefined) {
+            ids.push(nameToId[x]);
+        }
+        else if (Object.values(nameToId).includes(x)) {
+            ids.push(x);
+        }
+        else if (verbose) {
+            process.stderr.write(`Warning: Omitting unknown assembly: "${x}"\n`);
+        }
+    }
+    if (removeDuplicates) {
+        ids = [...new Set(ids)];
+    }
+    return ids;
+}
+export async function getFeatureById(address, accessToken, id) {
+    const url = new URL(localhostToAddress(`${address}/features/${id}`));
+    const auth = {
+        headers: {
+            authorization: `Bearer ${accessToken}`,
+        },
+    };
+    const response = await fetch(url, auth);
+    return response;
+}
+export async function getAssemblyFromRefseq(address, accessToken, refSeq) {
+    const refSeqs = await queryApollo(address, accessToken, 'refSeqs');
+    const refJson = filterJsonList((await refSeqs.json()), [refSeq], '_id');
+    return refJson[0]['assembly'];
+}
+export async function queryApollo(address, accessToken, endpoint) {
+    const auth = {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const url = new URL(localhostToAddress(`${address}/${endpoint}`));
+    const response = await fetch(url, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'queryApollo failed');
+        throw new ConfigError(errorMessage);
+    }
+    return response;
+}
+export function filterJsonList(json, keep, key) {
+    const unique = new Set(keep);
+    const results = [];
+    for (const x of json) {
+        if (Object.keys(x).includes(key) && unique.has(x[key])) {
+            results.push(x);
+        }
+    }
+    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
+        .createHash('sha256')
+        .update(codeVerifier)
+        .digest('base64')
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replaceAll('=', '');
+    return {
+        state: crypto.randomBytes(32).toString('hex'),
+        codeVerifier,
+        codeChallenge,
+    };
+};
+export const waitFor = (eventName, emitter) => {
+    const promise = new Promise((resolve, reject) => {
+        const handleEvent = (eventData) => {
+            eventData instanceof Error ? reject(eventData) : resolve(eventData);
+            emitter.removeListener(eventName, handleEvent);
+        };
+        emitter.addListener(eventName, handleEvent);
+    });
+    return promise;
+};
+export async function submitAssembly(address, accessToken, body, force) {
+    const assemblies = await queryApollo(address, accessToken, 'assemblies');
+    for (const x of (await assemblies.json())) {
+        if (x['name'] === body.assemblyName) {
+            if (force) {
+                await deleteAssembly(address, accessToken, x['_id']);
+            }
+            else {
+                throw new Error(`Error: Assembly "${body.assemblyName}" already exists`);
+            }
+        }
+    }
+    const controller = new AbortController();
+    setTimeout(() => {
+        controller.abort();
+    }, 24 * 60 * 60 * 1000);
+    const auth = {
+        method: 'POST',
+        body: JSON.stringify(body),
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+        signal: controller.signal,
+    };
+    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);
+    }
+    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`));
+    try {
+        const response = await fetch(url, auth);
+        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;
+    }
+}
+/* Wrap text to max `length` per line */
+export function wrapLines(s, length) {
+    if (length === undefined) {
+        length = 80;
+    }
+    // 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;
+}
+export function idReader(input, removeDuplicates = true) {
+    let ids = [];
+    for (const xin of input) {
+        let data;
+        if (xin == '-') {
+            data = fs.readFileSync('/dev/stdin').toString();
+        }
+        else if (fs.existsSync(xin)) {
+            data = fs.readFileSync(xin).toString();
+        }
+        else {
+            data = xin;
+        }
+        try {
+            data = JSON.parse(data);
+            if (data.length === undefined) {
+                data = [data];
+            }
+            for (const x of data) {
+                const id = x['_id'];
+                if (id !== undefined) {
+                    ids.push(id);
+                }
+            }
+        }
+        catch {
+            for (let x of data.split('\n')) {
+                x = x.trim();
+                if (x !== '') {
+                    ids.push(x);
+                }
+            }
+        }
+    }
+    if (removeDuplicates) {
+        ids = [...new Set(ids)];
+    }
+    return ids;
+}