@apollo-annotation/cli 0.1.10

package/dist/commands/assembly/check.js

@@ -0,0 +1,148 @@
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { CheckError, convertCheckNameToId, createFetchErrorMessage, getAssembly, idReader, localhostToAddress, wrapLines, } from '../../utils.js';
+async function setChecks(address, accessToken, assembly, checkId) {
+    const check = {
+        _id: assembly,
+        checks: checkId,
+        name: '',
+    };
+    const auth = {
+        method: 'POST',
+        body: JSON.stringify(check),
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const url = new URL(localhostToAddress(`${address}/assemblies/checks`));
+    const response = await fetch(url, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'setChecks failed');
+        throw new Error(errorMessage);
+    }
+    return response;
+}
+async function getCheckTypes(address, accessToken) {
+    const auth = {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const url = new URL(localhostToAddress(`${address}/checks/types`));
+    const response = await fetch(url, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'getCheckTypes failed');
+        throw new Error(errorMessage);
+    }
+    const chk = (await response.json());
+    return chk;
+}
+function getCheckTypesForAssembly(checkTypes, assembly) {
+    const checks = [];
+    for (const chkType of checkTypes) {
+        for (const chk of assembly['checks']) {
+            if (chkType['_id'] === chk) {
+                checks.push(chkType);
+            }
+        }
+    }
+    return checks;
+}
+export default class Check extends BaseCommand {
+    static summary = 'Add, view, or delete checks to assembly';
+    static description = wrapLines('Manage checks, i.e. the rules ensuring features in an assembly are plausible. \
+    This command only sets the check to apply, to retrieve features flagged by these checks use `apollo feature check`.');
+    static examples = [
+        {
+            description: 'View available check types:',
+            command: '<%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: 'View checks set for assembly hg19:',
+            command: '<%= config.bin %> <%= command.id %> -a hg19',
+        },
+        {
+            description: 'Add checks to assembly:',
+            command: '<%= config.bin %> <%= command.id %> -a hg19 -c CDSCheck',
+        },
+        {
+            description: 'Delete checks from assembly:',
+            command: '<%= config.bin %> <%= command.id %> -a hg19 -c CDSCheck --delete',
+        },
+    ];
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Manage checks in this assembly',
+        }),
+        check: Flags.string({
+            char: 'c',
+            description: 'Add these check names or IDs. If unset, print the checks set for assembly',
+            multiple: true,
+        }),
+        delete: Flags.boolean({
+            char: 'd',
+            description: 'Delete (instead of adding) checks',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Check);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const checkTypes = await getCheckTypes(access.address, access.accessToken);
+        if (flags.check === undefined && flags.assembly === undefined) {
+            this.log(JSON.stringify(checkTypes, null, 2));
+            this.exit(0);
+        }
+        if (flags.assembly === undefined) {
+            this.logToStderr('Please specify the assembly to manage for checks');
+            this.exit(1);
+        }
+        const asm = idReader([flags.assembly]);
+        const assembly = await getAssembly(access.address, access.accessToken, asm[0]);
+        if (Object.keys(assembly).length === 0) {
+            this.logToStderr(`Assembly ${flags.assembly} not found`);
+            this.exit(1);
+        }
+        const currentChecks = getCheckTypesForAssembly(checkTypes, assembly);
+        if (flags.check === undefined) {
+            this.log(JSON.stringify(currentChecks, null, 2));
+            this.exit(0);
+        }
+        let inputCheckIds = [];
+        try {
+            inputCheckIds = await convertCheckNameToId(access.address, access.accessToken, flags.check);
+        }
+        catch (error) {
+            if (error instanceof CheckError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+        const newChecks = new Set();
+        if (flags.delete) {
+            const currentCheckIds = new Set();
+            for (const chk of currentChecks) {
+                currentCheckIds.add(chk['_id']);
+            }
+            for (const id of inputCheckIds) {
+                if (!currentCheckIds.has(id)) {
+                    newChecks.add(id);
+                }
+            }
+        }
+        else {
+            for (const chk of inputCheckIds) {
+                newChecks.add(chk);
+            }
+            for (const chk of currentChecks) {
+                newChecks.add(chk['_id']);
+            }
+        }
+        await setChecks(access.address, access.accessToken, assembly['_id'], [...newChecks.values()]);
+        this.exit(0);
+    }
+}

package/dist/commands/assembly/delete.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Delete extends BaseCommand<typeof Delete> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/assembly/delete.js

@@ -0,0 +1,43 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { convertAssemblyNameToId, deleteAssembly, getAssembly, idReader, wrapLines, } from '../../utils.js';
+export default class Delete extends BaseCommand {
+    static summary = 'Delete assemblies';
+    static description = wrapLines('Assemblies to delete may be names or IDs');
+    static examples = [
+        {
+            description: 'Delete multiple assemblies using name or ID:',
+            command: '<%= config.bin %> <%= command.id %> -a mouse 6605826fbd0eee691f83e73f',
+        },
+    ];
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Assembly names or IDs to delete',
+            multiple: true,
+            required: true,
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            description: 'Print to stdout the array of assemblies deleted',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Delete);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const assembly = idReader(flags.assembly);
+        const deleteIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
+        let i = 0;
+        const deleted = [];
+        for (const x of deleteIds) {
+            const asm = await getAssembly(access.address, access.accessToken, x);
+            await deleteAssembly(access.address, access.accessToken, x);
+            deleted.push(asm);
+            i += 1;
+        }
+        if (flags.verbose) {
+            this.log(JSON.stringify(deleted, null, 2));
+        }
+        this.logToStderr(`${i} assemblies deleted`);
+    }
+}

package/dist/commands/assembly/get.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Get extends BaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/assembly/get.js

@@ -0,0 +1,33 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { convertAssemblyNameToId, idReader, queryApollo, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Get available assemblies';
+    static description = wrapLines('Print to stdout the list of assemblies in json format');
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Get assemblies in this list of names or IDs',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const assemblies = await queryApollo(access.address, access.accessToken, 'assemblies');
+        let assemblyIds = [];
+        if (flags.assembly !== undefined) {
+            const assembly = idReader(flags.assembly);
+            assemblyIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
+        }
+        const json = (await assemblies.json());
+        const keep = [];
+        for (const x of json) {
+            if (flags.assembly === undefined ||
+                assemblyIds.includes(x['_id'])) {
+                keep.push(x);
+            }
+        }
+        this.log(JSON.stringify(keep, null, 2));
+    }
+}

package/dist/commands/assembly/get.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, test } from '@oclif/test';
+import { CONFIG_FILE, TEST_DATA_DIR, VERBOSE, copyFile, } from '../../test/fixtures.js';
+// import nock from 'nock'
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe.skip('apollo assembly get: Fail without token', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/guest.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    const cmd = ['assembly:get'];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('Profile "default" has no access token'))
+        .do((output) => expect(output.stderr).to.not.contain(' at async ')) // Don't print error stack
+        .it(cmd.join(' '));
+});
+// TODO: Need valid token
+describe.skip('apollo assembly get: Get assemblies as YAML string', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    const cmd = ['assembly:get'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (output) => {
+        JSON.parse(output.stdout);
+    });
+});
+describe.skip('apollo assembly get: Test nock', () => {
+    const cmd = ['assembly:get', '--config-file', 'tmp.yaml'];
+    test
+        .stdout()
+        .nock('http://127.0.0.1:3999', (api) => api.persist().get('/assemblies').reply(200, { stuff: 'foo' }))
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (output) => {
+        console.error(output.stdout);
+        // const out = JSON.parse(output.stdout)
+    });
+});

package/dist/commands/assembly/sequence.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class ApolloCmd extends BaseCommand<typeof ApolloCmd> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        refseq: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        start: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        end: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/assembly/sequence.js

@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getRefseqId, idReader, localhostToAddress, queryApollo, wrapLines, } from '../../utils.js';
+async function getSequence(address, accessToken, refSeq, start, end) {
+    const url = new URL(localhostToAddress(`${address}/sequence`));
+    const searchParams = new URLSearchParams({
+        refSeq,
+        start: start.toString(),
+        end: end.toString(),
+    });
+    url.search = searchParams.toString();
+    const uri = url.toString();
+    const controller = new AbortController();
+    setTimeout(() => {
+        controller.abort();
+    }, 24 * 60 * 60 * 1000);
+    const auth = {
+        headers: {
+            authorization: `Bearer ${accessToken}`,
+        },
+        signal: controller.signal,
+    };
+    const response = await fetch(uri, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'getSequence failed');
+        throw new Error(errorMessage);
+    }
+    return response;
+}
+export default class ApolloCmd extends BaseCommand {
+    static summary = 'Get reference sequence in fasta format';
+    static description = wrapLines('Return the reference sequence for a given assembly and coordinates');
+    static examples = [
+        {
+            description: 'Get all sequences in myAssembly:',
+            command: '<%= config.bin %> <%= command.id %> -a myAssembly',
+        },
+        {
+            description: 'Get sequence in coordinates chr1:1..1000:',
+            command: '<%= config.bin %> <%= command.id %> -a myAssembly -r chr1 -s 1 -e 1000',
+        },
+    ];
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Find input reference sequence in this assembly',
+        }),
+        refseq: Flags.string({
+            char: 'r',
+            description: 'Reference sequence. If unset, get all sequences',
+        }),
+        start: Flags.integer({
+            char: 's',
+            description: 'Start coordinate (1-based)',
+            default: 1,
+        }),
+        end: Flags.integer({
+            char: 'e',
+            description: 'End coordinate',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ApolloCmd);
+        const endCoord = flags.end ?? Number.MAX_SAFE_INTEGER;
+        if (flags.start <= 0 || endCoord <= 0) {
+            this.logToStderr('Start and end coordinates must be greater than 0.');
+            this.exit(1);
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        let assembly = undefined;
+        if (flags.assembly !== undefined) {
+            ;
+            [assembly] = idReader([flags.assembly]);
+        }
+        let refseqIds = [];
+        try {
+            refseqIds = await getRefseqId(access.address, access.accessToken, flags.refseq, assembly);
+        }
+        catch (error) {
+            this.logToStderr(error.message);
+            this.exit(1);
+        }
+        if (refseqIds.length === 0) {
+            this.logToStderr('No reference sequence found');
+            this.exit(1);
+        }
+        const refs = await queryApollo(access.address, access.accessToken, 'refSeqs');
+        const refSeqs = (await refs.json());
+        for (const rid of refseqIds) {
+            const res = await getSequence(access.address, access.accessToken, rid, flags.start - 1, endCoord);
+            const seqObj = await res.body?.getReader().read();
+            const seq = new TextDecoder().decode(seqObj?.value);
+            let header = '';
+            for (const x of refSeqs) {
+                if (x['_id'] === rid) {
+                    const rname = x['name'];
+                    header = `>${rname}:${flags.start}..${flags.start + seq.length - 1}`;
+                    break;
+                }
+            }
+            this.log(header);
+            this.log(splitStringIntoChunks(seq, 80).join('\n'));
+        }
+        this.exit(0);
+    }
+}
+function splitStringIntoChunks(input, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < input.length; i += chunkSize) {
+        const chunk = input.slice(i, i + chunkSize);
+        chunks.push(chunk);
+    }
+    return chunks;
+}

package/dist/commands/change/get.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Get extends BaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/change/get.js

@@ -0,0 +1,35 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { convertAssemblyNameToId, idReader, queryApollo, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Get list of changes';
+    static description = wrapLines('Return the change log in json format. Note \
+  that when an assembly is deleted the link between common name and ID is lost \
+  (it can still be recovered by inspecting the change log but at present this task is left to the user). \
+  In such cases you need to use the assembly ID.');
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            multiple: true,
+            description: 'Get changes only for these assembly names or IDs (but see description)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const changes = await queryApollo(access.address, access.accessToken, 'changes');
+        const json = (await changes.json());
+        let keep = json;
+        if (flags.assembly !== undefined) {
+            keep = [];
+            const assembly = idReader(flags.assembly);
+            const assemblyIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
+            for (const x of json) {
+                if (assemblyIds.includes(x['assembly'])) {
+                    keep.push(x);
+                }
+            }
+        }
+        this.log(JSON.stringify(keep, null, 2));
+    }
+}

package/dist/commands/change/get.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import fs from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { test } from '@oclif/test';
+import { CONFIG_FILE, TEST_DATA_DIR, VERBOSE, copyFile, } from '../../test/fixtures.js';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+// TODO: Need valid token
+describe.skip('apollo change get: Get changes as YAML string', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    const cmd = ['change:get'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (output) => {
+        JSON.parse(output.stdout);
+    });
+});

package/dist/commands/config.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../baseCommand.js';
+export default class ApolloConfig extends BaseCommand<typeof ApolloConfig> {
+    static summary: string;
+    static description: string;
+    static args: {
+        key: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        profile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'get-config-file': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    run(): Promise<void>;
+    private interactiveSetup;
+    private askProfileName;
+    private askPassword;
+    private askUsername;
+    private askAddress;
+    private selectAccessType;
+    private getLoginTypes;
+}