@apollo-annotation/cli 0.1.10

package/dist/commands/logout.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { BaseCommand } from '../baseCommand.js';
+import { Config, ConfigError, KEYS } from '../Config.js';
+import { basicCheckConfig, wrapLines } from '../utils.js';
+export default class Logout extends BaseCommand {
+    static summary = 'Logout of Apollo';
+    static description = wrapLines('Logout by removing the access token from the selected profile');
+    static examples = [
+        {
+            description: 'Logout default profile:',
+            command: '<%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: 'Logout selected profile',
+            command: '<%= config.bin %> <%= command.id %> --profile my-profile',
+        },
+    ];
+    async run() {
+        const { flags } = await this.parse(Logout);
+        let profileName = flags.profile;
+        if (profileName === undefined) {
+            profileName = process.env.APOLLO_PROFILE ?? 'default';
+        }
+        let configFile = flags['config-file'];
+        if (configFile === undefined) {
+            configFile = path.join(this.config.configDir, 'config.yaml');
+        }
+        try {
+            basicCheckConfig(configFile, profileName);
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+        const config = new Config(configFile);
+        config.set(KEYS.accessToken, '', profileName);
+        config.writeConfigFile();
+    }
+}

package/dist/commands/logout.test.d.ts

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

package/dist/commands/logout.test.js

@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import fs from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, test } from '@oclif/test';
+import YAML from 'yaml';
+import { CONFIG_FILE, TEST_DATA_DIR, VERBOSE, copyFile, } from '../test/fixtures.js';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe('apollo logout: Set token to empty string', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    let cmd = ['logout', '--profile', 'default'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.default.accessToken).to.equal('');
+    });
+    cmd = ['logout', '--profile', 'profile1'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.profile1.accessToken).to.equal('');
+    });
+    cmd = ['logout', '--profile', 'noAccessToken'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.profile1.accessToken).to.equal('');
+    });
+});
+describe('apollo logout: Config file does not exist', () => {
+    const cmd = ['logout', '--config-file', '_tmp.yaml'];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('apollo config'))
+        .it(cmd.join(' '));
+});
+describe('apollo logout: Profile does not exist', () => {
+    const cmd = [
+        'logout',
+        '--config-file',
+        'test_data/complete_config.yaml',
+        '--profile',
+        'notavailable',
+    ];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('apollo config'))
+        .do((output) => expect(output.stderr).to.contain('Profile'))
+        .do((output) => expect(output.stderr).to.contain('notavailable'))
+        .it(cmd.join(' '));
+});

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Get extends BaseCommand<typeof Get> {
+    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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/refseq/get.js

@@ -0,0 +1,44 @@
+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 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 examples = [
+        {
+            description: wrapLines('All sequences in the database:'),
+            command: '<%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: wrapLines('Only sequences for these assemblies:'),
+            command: '<%= config.bin %> <%= command.id %> -a mm9 mm10',
+        },
+    ];
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            multiple: true,
+            description: 'Get reference sequences for these assembly names or IDs; use - to read it from stdin',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        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 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/status.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../baseCommand.js';
+export default class Status extends BaseCommand<typeof Status> {
+    static summary: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/status.js

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import path from 'node:path';
+import { BaseCommand } from '../baseCommand.js';
+import { Config, ConfigError, KEYS } from '../Config.js';
+import { basicCheckConfig, wrapLines } 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.');
+    async run() {
+        const { flags } = await this.parse(Status);
+        let profileName = flags.profile;
+        if (profileName === undefined) {
+            profileName = process.env.APOLLO_PROFILE ?? 'default';
+        }
+        let configFile = flags['config-file'];
+        if (configFile === undefined) {
+            configFile = path.join(this.config.configDir, 'config.yaml');
+        }
+        try {
+            basicCheckConfig(configFile, profileName);
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+        const config = new Config(configFile);
+        const accessToken = config.get(KEYS.accessToken, profileName);
+        if (accessToken === undefined || accessToken.trim() === '') {
+            this.log(`${profileName}: Logged out`);
+        }
+        else {
+            this.log(`${profileName}: Logged in`);
+        }
+    }
+}

package/dist/commands/status.test.d.ts

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

package/dist/commands/status.test.js

@@ -0,0 +1,54 @@
+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';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe('apollo status: Check logged in', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    let cmd = ['status', '--profile', 'default'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout).contain('Logged in');
+    });
+    cmd = ['status', '--profile', 'noAccessToken'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout).contain('Logged out');
+    });
+});
+describe('apollo status: Config file does not exist', () => {
+    const cmd = ['status', '--config-file', '_tmp.yaml'];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('apollo config'))
+        .it(cmd.join(' '));
+});
+describe('apollo status: Profile does not exist', () => {
+    const cmd = [
+        'status',
+        '--config-file',
+        'test_data/complete_config.yaml',
+        '--profile',
+        'notavailable',
+    ];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('apollo config'))
+        .do((output) => expect(output.stderr).to.contain('Profile'))
+        .do((output) => expect(output.stderr).to.contain('notavailable'))
+        .it(cmd.join(' '));
+});

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

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

package/dist/commands/user/get.js

@@ -0,0 +1,46 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { queryApollo, wrapLines } 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 examples = [
+        {
+            description: 'By username:',
+            command: '<%= config.bin %> <%= command.id %> -u Guest',
+        },
+        {
+            description: 'By role:',
+            command: '<%= config.bin %> <%= command.id %> -r admin',
+        },
+        {
+            description: 'Use jq for more control:',
+            command: '<%= config.bin %> <%= command.id %> | jq \'.[] | select(.createdAt > "2024-03-18")\'',
+        },
+    ];
+    static flags = {
+        username: Flags.string({
+            char: 'u',
+            description: 'Find this username',
+        }),
+        role: Flags.string({
+            char: 'r',
+            description: 'Get users with this role',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const users = await queryApollo(access.address, access.accessToken, 'users');
+        const json = (await users.json());
+        const out = [];
+        for (const x of json) {
+            if ((flags.username === undefined ||
+                x['username'] === flags.username) &&
+                (flags.role === undefined || x['role'] === flags.role)) {
+                out.push(x);
+            }
+        }
+        this.log(JSON.stringify(out, null, 2));
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+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';
+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);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    const cmd = ['user:get'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (output) => {
+        const str = JSON.stringify(JSON.parse(output.stdout));
+        expect(str).contain('username');
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/test/fixtures.d.ts

@@ -0,0 +1,7 @@
+export declare const TEST_DATA_DIR: string;
+export declare const VERBOSE = false;
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare function copyFile(src: string, dest: string, verbose: boolean): void;
+export declare function mochaGlobalSetup(): void;
+export declare function mochaGlobalTeardown(): void;

package/dist/test/fixtures.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import os from 'node:os';
+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');
+function renameFile(src, dest, verbose = true) {
+    if (fs.existsSync(dest)) {
+        throw new Error(`File ${dest} already exists`);
+    }
+    let msg = '';
+    if (fs.existsSync(src)) {
+        fs.renameSync(src, dest);
+        msg = `mv ${src} ${dest}`;
+    }
+    else {
+        msg = `${src} does not exist`;
+    }
+    if (verbose) {
+        process.stdout.write(`${msg}\n`);
+    }
+}
+export function copyFile(src, dest, verbose) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    if (verbose) {
+        const msg = `cp ${src} ${dest}`;
+        process.stdout.write(`${msg} # Copied: ${fs.existsSync(dest)}\n`);
+    }
+}
+export function mochaGlobalSetup() {
+    process.stdout.write(`Temporarily remove config file ${CONFIG_FILE} if any`);
+    renameFile(CONFIG_FILE, CONFIG_BAK, VERBOSE);
+}
+export function mochaGlobalTeardown() {
+    process.stdout.write(`Putting back config file ${CONFIG_FILE} if any\n`);
+    renameFile(CONFIG_BAK, CONFIG_FILE, VERBOSE);
+}

package/dist/utils.d.ts

@@ -0,0 +1,54 @@
+import EventEmitter from 'node:events';
+import { Response } from 'undici';
+import { Config } from './Config.js';
+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 {
+}
+export interface UserCredentials {
+    accessToken: string;
+}
+export declare function createFetchErrorMessage(response: Response, additionalText?: string): Promise<string>;
+export declare function checkConfigfileExists(configFile: string): void;
+export declare function checkProfileExists(profileName: string, config: Config): void;
+export declare function basicCheckConfig(configFile: string, profileName: string): void;
+/**
+ * @deprecated Use this function while we wait to resolve the TypeError when using localhost in fetch.
+ */
+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 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>>;
+/** 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 {
+    assemblyName: string;
+    typeName: string;
+    fileId: string;
+}
+interface bodyExternalFile {
+    assemblyName: string;
+    typeName: string;
+    externalLocation: {
+        fa: string;
+        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 {};