@apollo-annotation/cli 0.1.10

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+
+// eslint-disable-next-line node/shebang
+async function main() {
+  const {execute} = await import('@oclif/core')
+  await execute({development: true, dir: import.meta.url})
+}
+
+await main()

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+async function main() {
+  const {execute} = await import('@oclif/core')
+  await execute({dir: import.meta.url})
+}
+
+await main()

package/dist/Config.d.ts

@@ -0,0 +1,43 @@
+import Joi from 'joi';
+export declare class ConfigError extends Error {
+}
+interface BaseProfile {
+    address: string;
+    accessType: 'google' | 'microsoft' | 'guest';
+    accessToken: string;
+}
+interface RootProfile extends Omit<BaseProfile, 'accessType'> {
+    accessType: 'root';
+    rootCredentials: {
+        username: string;
+        password: string;
+    };
+}
+export type Profile = BaseProfile | RootProfile;
+export declare enum KEYS {
+    address = "address",
+    accessType = "accessType",
+    accessToken = "accessToken",
+    rootCredentials_username = "rootCredentials.username",
+    rootCredentials_password = "rootCredentials.password"
+}
+export declare function optionDesc(): string[];
+export declare class Config {
+    private configFile;
+    private profiles;
+    constructor(configFile: string);
+    private index;
+    private addProps;
+    private checkKey;
+    get(key: string, profileName: string): string;
+    set(key: string, value: string, profileName: string): void;
+    writeConfigFile(): void;
+    getProfileNames(): string[];
+    validate(): Joi.ValidationResult;
+    getAccess(profileName: string): Promise<{
+        address: string;
+        accessToken: string;
+    }>;
+    toString(): string;
+}
+export {};

package/dist/Config.js

@@ -0,0 +1,233 @@
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import fs from 'node:fs';
+import path from 'node:path';
+import Joi from 'joi';
+import YAML, { YAMLParseError } from 'yaml';
+import { checkProfileExists, queryApollo } from './utils.js';
+export class ConfigError extends Error {
+}
+export var KEYS;
+(function (KEYS) {
+    KEYS["address"] = "address";
+    KEYS["accessType"] = "accessType";
+    KEYS["accessToken"] = "accessToken";
+    KEYS["rootCredentials_username"] = "rootCredentials.username";
+    KEYS["rootCredentials_password"] = "rootCredentials.password";
+})(KEYS || (KEYS = {}));
+function optionDocs() {
+    const docs = [];
+    for (const v of Object.values(KEYS)) {
+        switch (v) {
+            case 'address': {
+                docs.push({
+                    key: v,
+                    description: 'Address and port e.g http://localhost:3999',
+                });
+                break;
+            }
+            case 'accessType': {
+                docs.push({
+                    key: v,
+                    description: 'How to access Apollo. accessType is typically one of: google, microsoft, guest, root. Allowed types depend on your Apollo setup',
+                });
+                break;
+            }
+            case 'accessToken': {
+                docs.push({
+                    key: v,
+                    description: 'Access token. Usually inserted by `apollo login`',
+                });
+                break;
+            }
+            case 'rootCredentials.username': {
+                docs.push({
+                    key: v,
+                    description: 'Username of root account. Only set this for "root" access type',
+                });
+                break;
+            }
+            case 'rootCredentials.password': {
+                docs.push({
+                    key: v,
+                    description: 'Password for root account. Only set this for "root" access type',
+                });
+                break;
+            }
+            default: {
+                throw new ConfigError(`Unexpected key: ${v}`);
+            }
+        }
+    }
+    return docs;
+}
+export function optionDesc() {
+    const docs = [];
+    for (const x of optionDocs()) {
+        docs.push(`- ${x.key}:\n${x.description}`);
+    }
+    return docs;
+}
+function isValidAddress(address) {
+    // const port: string | undefined = address.split(':').pop()
+    // if (port === undefined || /^\d+$/.test(port) === false) {
+    //   return false
+    // }
+    let url;
+    try {
+        url = new URL(address);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return false;
+    }
+    return true;
+}
+const profileSchema = Joi.object({
+    address: Joi.string()
+        .uri({ scheme: /https?/ })
+        .required(),
+    accessType: Joi.string()
+        .valid('google', 'microsoft', 'root', 'guest')
+        .required(),
+    accessToken: Joi.string(),
+    rootCredentials: Joi.object({
+        username: Joi.string().required(),
+        password: Joi.string().required(),
+    }).when('accessType', {
+        is: Joi.string().valid('root'),
+        // eslint-disable-next-line unicorn/no-thenable
+        then: Joi.required(),
+        otherwise: Joi.forbidden(),
+    }),
+});
+const configSchema = Joi.object().pattern(Joi.string(), profileSchema);
+export class Config {
+    configFile;
+    profiles = {};
+    constructor(configFile) {
+        this.configFile = configFile;
+        if (fs.existsSync(configFile)) {
+            const data = fs.readFileSync(configFile, 'utf8').trim();
+            if (data !== '') {
+                let config;
+                try {
+                    config = YAML.parse(data);
+                }
+                catch (error) {
+                    if (error instanceof YAMLParseError) {
+                        process.stderr.write('Error: Configuration file is probably invalid yaml format:\n');
+                        process.stderr.write(error.message);
+                    }
+                    else if (error instanceof Error) {
+                        process.stderr.write('Unexpected error:');
+                        process.stderr.write(error.message);
+                    }
+                    // eslint-disable-next-line unicorn/no-process-exit
+                    process.exit(1);
+                }
+                this.profiles = config;
+            }
+        }
+    }
+    index(obj, arr, value) {
+        if (typeof arr == 'string') {
+            return this.index(obj, arr.split('.'), value);
+        }
+        if (arr.length == 1 && value !== undefined) {
+            return (obj[arr[0]] = value);
+        }
+        if (arr.length === 0) {
+            return obj;
+        }
+        return this.index(obj[arr[0]], arr.slice(1), value);
+    }
+    addProps(obj, arr, value) {
+        // credit https://stackoverflow.com/questions/17643965/how-to-automatically-add-properties-to-an-object-that-is-undefined
+        if (typeof arr == 'string') {
+            arr = arr.split('.');
+        }
+        obj[arr[0]] = obj[arr[0]] || {};
+        const tmpObj = obj[arr[0]];
+        if (arr.length > 1) {
+            arr.shift();
+            this.addProps(tmpObj, arr, value);
+        }
+        else if (value !== undefined) {
+            obj[arr[0]] = value;
+        }
+        return obj;
+    }
+    checkKey(key) {
+        for (const x of Object.values(KEYS)) {
+            if (x === key) {
+                return;
+            }
+        }
+        throw new ConfigError(`Invalid configuration key: "${key}". Valid keys are:\n${Object.values('\n')}`);
+    }
+    get(key, profileName) {
+        this.checkKey(key);
+        const profile = this.profiles[profileName];
+        if (!profile) {
+            // throw new Error(`No profile name "${profileName}" found`)
+            return '';
+        }
+        this.addProps(profile, key);
+        const value = this.index(profile, key);
+        if (typeof value === 'object' && Object.keys(value).length === 0) {
+            // The key is valid but missing from config
+            return '';
+        }
+        return value;
+    }
+    set(key, value, profileName) {
+        this.checkKey(key);
+        if (key === KEYS[KEYS.address] && !isValidAddress(value)) {
+            throw new ConfigError(`"${value}" is not a valid value for "${key}"`);
+        }
+        const profile = this.profiles[profileName] ?? {};
+        this.profiles[profileName] = profile;
+        this.addProps(profile, key, value);
+    }
+    writeConfigFile() {
+        let APOLLO_DISABLE_CONFIG_CREATE = false;
+        if (process.env.APOLLO_DISABLE_CONFIG_CREATE !== undefined &&
+            process.env.APOLLO_DISABLE_CONFIG_CREATE !== '0') {
+            APOLLO_DISABLE_CONFIG_CREATE = true;
+        }
+        if (APOLLO_DISABLE_CONFIG_CREATE && !fs.existsSync(this.configFile)) {
+            throw new ConfigError('Configuration file does not exist yet, please create it as an empty file first.');
+        }
+        const yml = YAML.stringify(this.profiles);
+        fs.mkdirSync(path.dirname(this.configFile), { recursive: true });
+        fs.writeFileSync(this.configFile, yml);
+    }
+    getProfileNames() {
+        return Object.keys(this.profiles);
+    }
+    validate() {
+        return configSchema.validate(this.profiles);
+    }
+    async getAccess(profileName) {
+        checkProfileExists(profileName, this);
+        const address = this.get('address', profileName);
+        if (address === undefined || address.trim() === '') {
+            throw new ConfigError(`Profile "${profileName}" has no address. Please run "apollo config" to set it up.`);
+        }
+        const accessToken = this.get('accessToken', profileName);
+        if (accessToken === undefined || accessToken.trim() === '') {
+            throw new ConfigError(`Profile "${profileName}" has no access token. Please run "apollo login" to set it up.`);
+        }
+        await queryApollo(address, accessToken, 'assemblies');
+        return { address, accessToken };
+    }
+    toString() {
+        return YAML.stringify(this.profiles);
+    }
+}

package/dist/baseCommand.d.ts

@@ -0,0 +1,21 @@
+import { Command, Interfaces } from '@oclif/core';
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BaseCommand)['baseFlags'] & T['flags']>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    static baseFlags: {
+        profile: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'config-file': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    };
+    protected flags: Flags<T>;
+    protected args: Args<T>;
+    init(): Promise<void>;
+    private getConfig;
+    getAccess(configFile: string | undefined, profileName: string | undefined): Promise<{
+        address: string;
+        accessToken: string;
+    }>;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<unknown>;
+    protected finally(_: Error | undefined): Promise<unknown>;
+}

package/dist/baseCommand.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { Command, Flags } from '@oclif/core';
+import { Config, ConfigError } from './Config.js';
+import { checkConfigfileExists } from './utils.js';
+export class BaseCommand extends Command {
+    static baseFlags = {
+        profile: Flags.string({
+            description: 'Use credentials from this profile',
+        }),
+        'config-file': Flags.string({
+            description: 'Use this config file (mostly for testing)',
+        }),
+    };
+    flags;
+    args;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+    }
+    getConfig(configFile) {
+        if (configFile === undefined) {
+            configFile = path.join(this.config.configDir, 'config.yaml');
+        }
+        checkConfigfileExists(configFile);
+        const config = new Config(configFile);
+        return config;
+    }
+    async getAccess(configFile, profileName) {
+        const config = this.getConfig(configFile);
+        if (profileName === undefined) {
+            profileName = process.env.APOLLO_PROFILE ?? 'default';
+        }
+        try {
+            return await config.getAccess(profileName);
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async catch(err) {
+        // add any custom logic to handle errors from the command
+        // or simply return the parent class error handling
+        return super.catch(err);
+    }
+    async finally(_) {
+        // called after run and catch regardless of whether or not the command errored
+        return super.finally(_);
+    }
+}

package/dist/commands/assembly/add-fasta.d.ts

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

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

@@ -0,0 +1,98 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Flags } from '@oclif/core';
+import { ObjectId } from 'bson';
+import { BaseCommand } from '../../baseCommand.js';
+import { submitAssembly, uploadFile, wrapLines } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static description = 'Add new assembly from local or external fasta file';
+    static examples = [
+        {
+            description: wrapLines('From local file:'),
+            command: '<%= config.bin %> <%= command.id %> -i genome.fa -a myAssembly',
+        },
+        {
+            description: wrapLines('From external source we also need the URL of the index:'),
+            command: '<%= config.bin %> <%= command.id %> -i https://.../genome.fa -x https://.../genome.fa.fai -a myAssembly',
+        },
+    ];
+    static flags = {
+        'input-file': Flags.string({
+            char: 'i',
+            description: 'Input fasta file',
+            required: true,
+        }),
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Name for this assembly. Use the file name if omitted',
+        }),
+        index: Flags.string({
+            char: 'x',
+            description: 'URL of the index. Required if input is an external source and ignored if input is a local file',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Delete existing assembly, if it exists',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const assemblyName = flags.assembly ?? path.basename(flags['input-file']);
+        const isExternal = isValidHttpUrl(flags['input-file']);
+        let response;
+        if (isExternal) {
+            if (flags.index === undefined) {
+                this.logToStderr('Please provide the URL to the index of the external fasta file');
+                this.exit(1);
+            }
+            const body = {
+                assemblyName,
+                typeName: 'AddAssemblyFromExternalChange',
+                externalLocation: {
+                    fa: flags['input-file'],
+                    fai: flags.index,
+                },
+            };
+            response = (await submitAssembly(access.address, access.accessToken, body, flags.force));
+        }
+        else {
+            if (!isExternal && !fs.existsSync(flags['input-file'])) {
+                this.logToStderr(`File ${flags['input-file']} does not exist`);
+                this.exit(1);
+            }
+            try {
+                const fileId = await uploadFile(access.address, access.accessToken, flags['input-file'], 'text/x-fasta');
+                const body = {
+                    assemblyName,
+                    fileId,
+                    typeName: 'AddAssemblyFromFileChange',
+                    assembly: new ObjectId().toHexString(),
+                };
+                response = (await submitAssembly(access.address, access.accessToken, body, flags.force));
+            }
+            catch (error) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+        if (!response.ok) {
+            const json = JSON.parse(await response.text());
+            this.logToStderr(JSON.stringify(json, null, 2));
+            this.exit(1);
+        }
+        this.exit(0);
+    }
+}
+function isValidHttpUrl(x) {
+    let url;
+    try {
+        url = new URL(x);
+    }
+    catch {
+        return false;
+    }
+    return url.protocol === 'http:' || url.protocol === 'https:';
+}

package/dist/commands/assembly/add-gff.d.ts

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

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

@@ -0,0 +1,76 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Flags } from '@oclif/core';
+import { ObjectId } from 'bson';
+import { BaseCommand } from '../../baseCommand.js';
+import { submitAssembly, uploadFile, wrapLines } from '../../utils.js';
+export default class AddGff extends BaseCommand {
+    static summary = 'Add new assembly from gff or gft file';
+    static description = wrapLines('The gff file is expected to contain sequences as per gff specifications. Features are also imported by default.');
+    static examples = [
+        {
+            description: 'Import sequences and features:',
+            command: '<%= config.bin %> <%= command.id %> -i genome.gff -a myAssembly',
+        },
+        {
+            description: 'Import sequences only:',
+            command: '<%= config.bin %> <%= command.id %> -i genome.gff -a myAssembly -o',
+        },
+    ];
+    static flags = {
+        'input-file': Flags.string({
+            char: 'i',
+            description: 'Input gff or gtf file',
+            required: true,
+        }),
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Name for this assembly. Use the file name if omitted',
+        }),
+        'omit-features': Flags.boolean({
+            char: 'o',
+            description: 'Do not import features, only upload the sequences',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Delete existing assembly, if it exists',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AddGff);
+        if (!fs.existsSync(flags['input-file'])) {
+            this.logToStderr(`File ${flags['input-file']} does not exist`);
+            this.exit(1);
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const fileId = await uploadFile(access.address, access.accessToken, flags['input-file'], 'text/x-gff3');
+        let typeName = 'AddAssemblyAndFeaturesFromFileChange';
+        if (flags['omit-features']) {
+            typeName = 'AddAssemblyFromFileChange';
+        }
+        const assemblyName = flags.assembly ?? path.basename(flags['input-file']);
+        let res;
+        try {
+            const body = {
+                assemblyName,
+                fileId,
+                typeName,
+                assembly: new ObjectId().toHexString(),
+            };
+            res = await submitAssembly(access.address, access.accessToken, body, flags.force);
+        }
+        catch (error) {
+            this.logToStderr(error.message);
+            this.exit(1);
+        }
+        if (!res.ok) {
+            const json = JSON.parse(await res.text());
+            const message = json['message'];
+            this.logToStderr(message);
+            this.exit(1);
+        }
+        this.exit(0);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Check extends BaseCommand<typeof Check> {
+    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>;
+        check: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        delete: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}