@apollo-annotation/cli 0.3.9 → 0.3.11

package/dist/commands/feature/add.js

@@ -0,0 +1,323 @@
+import { readFile } from 'node:fs/promises';
+import { Args, Flags } from '@oclif/core';
+import { ObjectId } from 'bson';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, localhostToAddress } from '../../utils.js';
+export default class Add extends BaseCommand {
+    static summary = 'Add one or more features to Apollo';
+    static description = `A single simple feature can be added using the --min, --max, etc. flags.
+
+To add multiple features, features with more details, or features with children, you can pass in JSON via argument or stdin or use the --feature-json-file options.
+`;
+    static examples = [
+        {
+            description: 'Add a single feature by specifying its location and type',
+            command: '<%= config.bin %> <%= command.id %> --assembly hg19 --refSeq chr3 --min 1000 --max 5000 --type remark',
+        },
+        {
+            description: 'Add a single feature from inline JSON',
+            command: '<%= config.bin %> <%= command.id %> \'{"assembly":"<assemblyNameOrId>","refseq":"<refSeqNameOrId>","min":1,"max":100,"type":"<featureType>"}\'',
+        },
+        {
+            description: 'Add mutilple features from stdin JSON',
+            command: 'echo \'[{"assembly":"<assemblyNameOrId>","refseq":"<refSeqNameOrId>","min":1,"max":100,"type":"<featureType>"},{"assembly":"<assemblyNameOrId>","refseq":"<refSeqNameOrId>","min":101,"max":200,"type":"<featureType>"}]\' | <%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: 'Add a feature with children from inline JSON',
+            command: '<%= config.bin %> <%= command.id %> \'{"assembly":"<assemblyNameOrId>","refseq":"<refSeqNameOrId>","min":1,"max":100,"type":"<featureType>","children":[{"min":1,"max":50,"type":"<featureType>"}]}\'',
+        },
+    ];
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Name or ID of target assembly. Not required if refseq is unique in the database',
+        }),
+        refSeq: Flags.string({
+            char: 'r',
+            description: 'Name or ID of target reference sequence',
+            dependsOn: ['min', 'max', 'type'],
+            exclusive: ['feature-json-file'],
+        }),
+        min: Flags.integer({
+            char: 's',
+            description: 'Start position in target reference sequence',
+            dependsOn: ['refSeq', 'max', 'type'],
+            exclusive: ['feature-json-file'],
+        }),
+        max: Flags.integer({
+            char: 'e',
+            description: 'End position in target reference sequence',
+            dependsOn: ['refSeq', 'min', 'type'],
+            exclusive: ['feature-json-file'],
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Type of child feature',
+            dependsOn: ['refSeq', 'min', 'max'],
+            exclusive: ['feature-json-file'],
+        }),
+        'feature-json-file': Flags.file({
+            char: 'F',
+            description: 'File with JSON describing the feature(s) to add',
+            exists: true,
+        }),
+    };
+    static args = {
+        'feature-json': Args.string({
+            description: 'Inline JSON describing the feature(s) to add. Can also be provided via stdin.',
+        }),
+    };
+    async run() {
+        const { args, flags } = this;
+        const { 'feature-json': featureJSONString } = args;
+        const { assembly, refSeq, min, max, type, 'feature-json-file': featureJSONFile, } = flags;
+        if (featureJSONString) {
+            if (assembly !== undefined ||
+                refSeq !== undefined ||
+                min !== undefined ||
+                max !== undefined ||
+                type !== undefined ||
+                featureJSONFile !== undefined) {
+                this.error('Cannot use the following flags when providing a feature JSON: --assembly, --refSeq, --min, --max, --type, --feature-json-file');
+            }
+            await this.addFeatureFromJSON(featureJSONString);
+            return;
+        }
+        if (featureJSONFile) {
+            const fileText = await readFile(featureJSONFile, 'utf8');
+            await this.addFeatureFromJSON(fileText);
+            return;
+        }
+        if (refSeq === undefined ||
+            min === undefined ||
+            max === undefined ||
+            type === undefined) {
+            this.error('Must provide all of: --refSeq, --min, --max, and --type');
+        }
+        await this.addFeatureFromFlags(refSeq, min, max, type, assembly);
+    }
+    async addFeatureFromJSON(featureJSONString) {
+        let featureJSON;
+        try {
+            featureJSON = parseFeatureJSON(featureJSONString);
+        }
+        catch (error) {
+            this.logToStderr('Error: feature JSON is not valid');
+            if (error instanceof Error || typeof error === 'string') {
+                this.error(error);
+            }
+            throw error;
+        }
+        if (Array.isArray(featureJSON)) {
+            const firstFeature = featureJSON.at(0);
+            if (!firstFeature) {
+                throw new Error('Feature array is empty');
+            }
+            const { assembly, refSeq } = firstFeature;
+            if (!featureJSON.every((feature) => feature.assembly === assembly)) {
+                throw new Error('Cannot add features to multiple assemblies at the same time');
+            }
+            const [assemblyId] = await this.getAssemblyAndRefSeqIds(refSeq, assembly);
+            const changedIds = [];
+            const changes = await Promise.all(featureJSON.map(async (singleFeatureJSON) => {
+                const { children, assembly, refSeq, ...rest } = singleFeatureJSON;
+                const refSeqDocument = await this.getRefSeq(refSeq);
+                return {
+                    addedFeature: this.makeFeatureSnapshot({
+                        assembly: assemblyId,
+                        refSeq: refSeqDocument._id,
+                        ...rest,
+                    }, changedIds),
+                };
+            }));
+            const change = {
+                changedIds,
+                typeName: 'AddFeatureChange',
+                assembly: assemblyId,
+                changes,
+            };
+            return this.submitChange(change);
+        }
+        const { assembly, refSeq, ...rest } = featureJSON;
+        const [assemblyId, refSeqId] = await this.getAssemblyAndRefSeqIds(refSeq, assembly);
+        const changedIds = [];
+        const details = {
+            addedFeature: this.makeFeatureSnapshot({
+                assembly: assemblyId,
+                refSeq: refSeqId,
+                ...rest,
+            }, changedIds),
+        };
+        const change = {
+            changedIds,
+            typeName: 'AddFeatureChange',
+            assembly: assemblyId,
+            ...details,
+        };
+        return this.submitChange(change);
+    }
+    makeFeatureSnapshot(details, ids) {
+        const { children, ...rest } = details;
+        let childrenDetails = undefined;
+        if (children) {
+            childrenDetails = {};
+            const { refSeq } = rest;
+            for (const child of children) {
+                const childDetails = this.makeFeatureSnapshot({ refSeq, ...child }, ids);
+                childrenDetails[childDetails._id] = childDetails;
+            }
+        }
+        const _id = new ObjectId().toHexString();
+        ids.push(_id);
+        return {
+            _id,
+            ...rest,
+            ...(childrenDetails ? { children: childrenDetails } : {}),
+        };
+    }
+    async addFeatureFromFlags(refSeqNameOrId, min, max, type, assemblyNameOrId) {
+        const [assemblyId, refSeqId] = await this.getAssemblyAndRefSeqIds(refSeqNameOrId, assemblyNameOrId);
+        const changedIds = [];
+        const details = {
+            addedFeature: this.makeFeatureSnapshot({ refSeq: refSeqId, min: min - 1, max, type }, changedIds),
+        };
+        const change = {
+            changedIds,
+            typeName: 'AddFeatureChange',
+            assembly: assemblyId,
+            ...details,
+        };
+        return this.submitChange(change);
+    }
+    async getAssemblyAndRefSeqIds(refSeqNameOrId, assemblyNameOrId) {
+        const refSeqIsObjectId = ObjectId.isValid(refSeqNameOrId);
+        const assemblyIsObjectId = assemblyNameOrId
+            ? ObjectId.isValid(assemblyNameOrId)
+            : false;
+        if (assemblyNameOrId && assemblyIsObjectId && refSeqIsObjectId) {
+            return [assemblyNameOrId, refSeqNameOrId];
+        }
+        if (refSeqIsObjectId) {
+            if (assemblyNameOrId) {
+                this.warn('Ignoring provided --assembly because it is not an ID');
+            }
+            const refSeqDocument = await this.getRefSeq(refSeqNameOrId);
+            return [refSeqDocument.assembly, refSeqNameOrId];
+        }
+        if (!assemblyNameOrId) {
+            this.error(`If provided refSeq (${refSeqNameOrId}) is not an ID, assembly must also be provided`);
+        }
+        const assemblyDocument = await this.getAssembly(assemblyNameOrId);
+        const refSeqDocument = await this.getRefSeq(refSeqNameOrId, assemblyDocument._id);
+        return [assemblyDocument._id, refSeqDocument._id];
+    }
+    async getAssembly(assemblyNameOrId) {
+        if (ObjectId.isValid(assemblyNameOrId)) {
+            const response = await this.fetch(`assemblies/${assemblyNameOrId}`);
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, `Could not find assembly: "${assemblyNameOrId}"`);
+                this.error(errorMessage);
+            }
+            return response.json();
+        }
+        const response = await this.fetch('assemblies');
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, `Could not find assembly: "${assemblyNameOrId}"`);
+            this.error(errorMessage);
+        }
+        const assemblies = (await response.json());
+        for (const assembly of assemblies) {
+            if (assembly.name === assemblyNameOrId ||
+                assembly.aliases?.includes(assemblyNameOrId)) {
+                return assembly;
+            }
+        }
+        throw new Error(`Could not find assembly: "${assemblyNameOrId}"`);
+    }
+    async getRefSeq(refSeqNameOrId, assemblyId) {
+        if (ObjectId.isValid(refSeqNameOrId)) {
+            const response = await this.fetch(`refSeqs/${refSeqNameOrId}`);
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, `Could not find refSeq: "${refSeqNameOrId}"`);
+                this.error(errorMessage);
+            }
+            return response.json();
+        }
+        let endpoint = 'refSeqs';
+        if (assemblyId) {
+            const searchParams = new URLSearchParams({ assembly: assemblyId });
+            endpoint = `${endpoint}?${searchParams.toString()}`;
+        }
+        const response = await this.fetch(endpoint);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, `Could not find refSeq: "${refSeqNameOrId}"`);
+            this.error(errorMessage);
+        }
+        const refSeqs = (await response.json());
+        for (const refSeq of refSeqs) {
+            if (refSeq.name === refSeqNameOrId ||
+                refSeq.aliases?.includes(refSeqNameOrId)) {
+                return refSeq;
+            }
+        }
+        throw new Error(`Could not find refSeq: "${refSeqNameOrId}"`);
+    }
+    async submitChange(change) {
+        const options = { method: 'POST', body: JSON.stringify(change) };
+        const response = await this.fetch('changes', options);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'Could not add feature');
+            this.error(errorMessage);
+        }
+        this.log(await response.text());
+    }
+    async fetch(endpoint, options) {
+        const { address, accessToken } = await this.getAccess();
+        const url = new URL(localhostToAddress(`${address}/${endpoint}`));
+        const optionsWithAuth = {
+            ...options,
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+                ...options?.headers,
+            },
+        };
+        return fetch(url, optionsWithAuth);
+    }
+}
+function parseFeatureJSON(featureJSONString) {
+    const featureJSON = JSON.parse(featureJSONString);
+    if (Array.isArray(featureJSON)) {
+        return featureJSON.map((feature) => {
+            assertFeatureIsValid(feature, true);
+            return feature;
+        });
+    }
+    assertFeatureIsValid(featureJSON, true);
+    return featureJSON;
+}
+function assertFeatureIsValid(feature, topLevel = false) {
+    if (typeof feature !== 'object' ||
+        feature === null ||
+        Array.isArray(feature)) {
+        throw new TypeError(`Feature is not a key-value record: '${JSON.stringify(feature)}'`);
+    }
+    for (const attribute of ['min', 'max', 'type']) {
+        if (!(attribute in feature)) {
+            throw new Error(`Feature does not contain "${attribute}": '${JSON.stringify(feature)}'`);
+        }
+    }
+    if (topLevel && !('refSeq' in feature)) {
+        throw new Error(`Top-level feature does not contain "refSeq": '${JSON.stringify(feature)}'`);
+    }
+    if ('children' in feature) {
+        const { children } = feature;
+        if (!Array.isArray(children)) {
+            throw new TypeError(`"children" is not an array of features '${JSON.stringify(feature)}'`);
+        }
+        for (const child of children) {
+            assertFeatureIsValid(child);
+        }
+    }
+}

package/dist/commands/feature/get-indexed-id.d.ts

@@ -0,0 +1,17 @@
+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 args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        topLevel: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/get-indexed-id.js

@@ -0,0 +1,66 @@
+import { Args, Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { convertAssemblyNameToId, createFetchErrorMessage, idReader, localhostToAddress, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Get features given an indexed identifier';
+    static description = 'Get features that match a given indexed identifier, such as the ID of a feature from an imported GFF3 file';
+    static examples = [
+        {
+            description: 'Get features for this indexed identifier:',
+            command: '<%= config.bin %> <%= command.id %> -i abc...zyz def...foo',
+        },
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Indexed identifier to search for',
+            required: true,
+        }),
+    };
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            multiple: true,
+            description: 'Assembly names or IDs to search; use "-" to read it from stdin. If omitted search all assemblies',
+        }),
+        topLevel: Flags.boolean({
+            description: 'Return the top-level parent of the feature instead of the feature itself',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Get);
+        const access = await this.getAccess();
+        const { topLevel } = flags;
+        const { id } = args;
+        const assembly = flags.assembly && (await idReader(flags.assembly));
+        const assemblyIds = assembly &&
+            (await convertAssemblyNameToId(access.address, access.accessToken, assembly));
+        if (assemblyIds?.length === 0) {
+            this.log(JSON.stringify([], null, 2));
+            this.exit(0);
+        }
+        const url = new URL(localhostToAddress(`${access.address}/features/getByIndexedId`));
+        const searchParams = new URLSearchParams({ id });
+        if (assemblyIds) {
+            searchParams.append('assemblies', assemblyIds.join(','));
+        }
+        if (topLevel) {
+            searchParams.append('topLevel', 'true');
+        }
+        url.search = searchParams.toString();
+        const uri = url.toString();
+        const auth = {
+            headers: {
+                authorization: `Bearer ${access.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        const response = await fetch(uri, auth);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'Failed to access Apollo with the current address and/or access token\nThe server returned:\n');
+            throw new Error(errorMessage);
+        }
+        const results = (await response.json());
+        this.log(JSON.stringify(results, null, 2));
+    }
+}

package/dist/test/test.js

@@ -18,14 +18,19 @@
 import assert from 'node:assert';
 import * as crypto from 'node:crypto';
 import fs from 'node:fs';
-import { afterEach, before, beforeEach, describe } from 'node:test';
+import { after, afterEach, before, beforeEach, describe } from 'node:test';
+import { MongoClient } from 'mongodb';
 import { Shell, deleteAllChecks } from './utils.js';
 const apollo = 'yarn dev';
 const P = '--profile testAdmin';
+// let client = MongoClient
+let client;
 let configFile = '';
 let configFileBak = '';
 void describe('Test CLI', () => {
     before(() => {
+        const uri = 'mongodb://localhost:27017/apolloTestCliDb?directConnection=true';
+        client = new MongoClient(uri);
         configFile = new Shell(`${apollo} config --get-config-file`).stdout.trim();
         configFileBak = `${configFile}.bak`;
         if (fs.existsSync(configFileBak)) {
@@ -36,11 +41,24 @@ void describe('Test CLI', () => {
         new Shell(`${apollo} config ${P} rootPassword pass`);
         new Shell(`${apollo} login ${P} -f`);
     });
+    after(async () => {
+        await client.close();
+    });
     beforeEach(() => {
         // Backup starting config file
         fs.copyFileSync(configFile, configFileBak);
     });
-    afterEach(() => {
+    afterEach(async () => {
+        const database = client.db('apolloTestCliDb');
+        await Promise.all([
+            'assemblies',
+            'changes',
+            'counters',
+            'features',
+            'files',
+            'refseqchunks',
+            'refseqs',
+        ].map((collectionName) => database.collection(collectionName).deleteMany({})));
         // Put back starting config file
         fs.renameSync(configFileBak, configFile);
     });
@@ -501,6 +519,111 @@ void describe('Test CLI', () => {
         p = new Shell(`${apollo} feature search ${P} -a vv1 -t Q`);
         assert.ok(p.stdout.includes('"Q"'));
     });
+    void globalThis.itName('Get feature by indexed ID', () => {
+        new Shell(`${apollo} assembly add-from-gff ${P} test_data/tiny.fasta.gff3 -a vv1 -f`);
+        new Shell(`${apollo} assembly add-from-gff ${P} test_data/tiny.fasta.gff3 -a vv2 -f`);
+        // Search multiple assemblies
+        let p = new Shell(`${apollo} feature get-indexed-id ${P} MyGene -a vv1 vv2`);
+        let out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 2);
+        assert.ok(p.stdout.includes('MyGene'));
+        // Specifying no assembly defaults to searching all assemblies
+        p = new Shell(`${apollo} feature get-indexed-id ${P} MyGene`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 2);
+        assert.ok(p.stdout.includes('MyGene'));
+        // Search single assembly
+        p = new Shell(`${apollo} feature get-indexed-id ${P} MyGene -a vv1`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(p.stdout.includes('MyGene'));
+        // Warn on unknown assembly
+        p = new Shell(`${apollo} feature get-indexed-id ${P} EDEN -a foobar`);
+        assert.strictEqual('[]', p.stdout.trim());
+        assert.ok(p.stderr.includes('Warning'));
+        // Return empty array with no matches
+        p = new Shell(`${apollo} feature get-indexed-id ${P} foobarspam -a vv1`);
+        assert.deepStrictEqual(p.stdout.trim(), '[]');
+        // Gets subfeature
+        p = new Shell(`${apollo} feature get-indexed-id ${P} myCDS.1 -a vv1`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(out.at(0)?.type === 'CDS');
+        // Gets top-level feature from subfeature id
+        p = new Shell(`${apollo} feature get-indexed-id ${P} myCDS.1 -a vv1 --topLevel`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(out.at(0)?.type === 'gene');
+        // Gets feature and child feature that were added manually (not imported)
+        p = new Shell(`${apollo} feature add ${P} <<EOF
+{
+  "assembly": "vv1",
+  "refSeq": "ctgA",
+  "min": 301,
+  "max": 310,
+  "type": "match",
+  "attributes": {"gff_id": ["match1"]},
+  "children": [
+    {
+      "min": 301,
+      "max": 305,
+      "type": "match_part",
+      "attributes": {"gff_id": ["matchPart1"]}
+    }
+  ]
+}
+EOF`);
+        p = new Shell(`${apollo} feature get-indexed-id ${P} match1 -a vv1`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(p.stdout.includes('match1'));
+        p = new Shell(`${apollo} feature get-indexed-id ${P} matchPart1 -a vv1`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(p.stdout.includes('matchPart1'));
+        // Doesn't get child feature after it was deleted
+        const idToDelete = out[0]._id;
+        new Shell(`${apollo} feature delete ${P} -i ${idToDelete}`);
+        p = new Shell(`${apollo} feature get-indexed-id ${P} matchPart1 -a vv1`);
+        assert.deepStrictEqual(p.stdout.trim(), '[]');
+        // Gets feature after ID was manually added
+        p = new Shell(`${apollo} feature add ${P} <<EOF
+{
+  "assembly": "vv1",
+  "refSeq": "ctgA",
+  "min": 311,
+  "max": 320,
+  "type": "match"
+}
+EOF`);
+        out = JSON.parse(p.stdout);
+        const { assembly, changes } = out;
+        const { _id, refSeq } = changes[0].addedFeature;
+        new Shell(`${apollo} feature edit-attribute ${P} -i ${_id} -a gff_id -v match2`);
+        p = new Shell(`${apollo} feature get-indexed-id ${P} match2 -a vv1`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(p.stdout.includes('match2'));
+        // Gets child featuer after it was added with an ID
+        // add-child CLI command doesn't support adding attributes yet, so we'll
+        // manually do it with curl for testing for neow
+        p = new Shell(`${apollo} config ${P} accessToken`);
+        const token = p.stdout.trim();
+        const newChildFeatureID = '69408088d502fc21aea1bb0a';
+        new Shell(`curl -X POST http://127.0.0.1:3999/changes -d '{"typeName":"AddFeatureChange","changedIds":["${newChildFeatureID}"],"assembly":"${assembly}","addedFeature":{"_id":"${newChildFeatureID}","refSeq":"${refSeq}","min":311,"max":315,"type":"match_part","attributes":{"gff_id":["matchPart2"]}},"parentFeatureId":"${_id}"}' -H "Content-Type: application/json" -H "Authorization: Bearer ${token}"`);
+        p = new Shell(`${apollo} feature get-indexed-id ${P} matchPart2 -a vv1`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        assert.ok(p.stdout.includes('matchPart2'));
+        // Doesn't get feature or child after IDs were manually removed
+        new Shell(`${apollo} feature edit-attribute ${P} -i ${_id} -a gff_id -d`);
+        const childId = out[0]._id;
+        new Shell(`${apollo} feature edit-attribute ${P} -i ${childId} -a gff_id -d`);
+        p = new Shell(`${apollo} feature get-indexed-id ${P} match2 -a vv1`);
+        assert.deepStrictEqual(p.stdout.trim(), '[]');
+        p = new Shell(`${apollo} feature get-indexed-id ${P} matchPart2 -a vv1`);
+        assert.deepStrictEqual(p.stdout.trim(), '[]');
+    });
     void globalThis.itName('Delete features', () => {
         new Shell(`${apollo} assembly add-from-gff ${P} test_data/tiny.fasta.gff3 -a vv1 -f`);
         let p = new Shell(`${apollo} feature search ${P} -a vv1 -t EDEN`);
@@ -516,6 +639,75 @@ void describe('Test CLI', () => {
         p = new Shell(`${apollo} feature delete ${P} --force -i ${fid}`);
         assert.strictEqual(p.returncode, 0);
     });
+    void globalThis.itName('Add features', () => {
+        let p = new Shell(`${apollo} assembly add-from-fasta ${P} test_data/tiny.fasta.gz -a tiny -f`);
+        let out = JSON.parse(p.stdout);
+        const assemblyId = out._id;
+        p = new Shell(`${apollo} feature get ${P} -a tiny`);
+        assert.deepStrictEqual(p.stdout.trim(), '[]');
+        // Can add a feature using flags
+        p = new Shell(`${apollo} feature add ${P} -a tiny -r ctgA -s 1 -e 10 -t remark`);
+        out = JSON.parse(p.stdout);
+        p = new Shell(`${apollo} feature get ${P} -a tiny`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 1);
+        const refSeqId = out[0].refSeq;
+        // Can add a feature using assembly and refSeq ids
+        p = new Shell(`${apollo} feature add ${P} -a ${assemblyId} -r ${refSeqId} -s 11 -e 20 -t remark`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId}`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 2);
+        // Can add a feature using JSON arg
+        p = new Shell(`${apollo} feature add ${P} '{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":21,"max":30,"type":"remark"}'`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId}`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 3);
+        // Can add a feature using JSON from stdin
+        p = new Shell(`${apollo} feature add ${P} <<EOF
+{
+  "assembly": "${assemblyId}",
+  "refSeq": "${refSeqId}",
+  "min": 31,
+  "max": 40,
+  "type": "remark"
+}
+EOF`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId}`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 4);
+        // Can add a feature using JSON from a file
+        fs.writeFileSync('test_data/tmp.json', `{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":41,"max":50,"type":"remark"}\n`);
+        p = new Shell(`${apollo} feature add ${P} --feature-json-file test_data/tmp.json`);
+        fs.unlinkSync('test_data/tmp.json');
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId}`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 5);
+        // Can add multiple features using JSON
+        p = new Shell(`${apollo} feature add ${P} '[{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":51,"max":60,"type":"remark"},{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":61,"max":70,"type":"remark"}]'`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId}`);
+        out = JSON.parse(p.stdout);
+        assert.strictEqual(out.length, 7);
+        // Can add a feature with children from JSON
+        p = new Shell(`${apollo} feature add ${P} '{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":71,"max":80,"type":"match","children":[{"min":71,"max":75,"type":"match_part"}]}'`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId} -r ${refSeqId} -s 71 -e 80`);
+        out = JSON.parse(p.stdout);
+        let feature = out.at(0);
+        assert.strictEqual(Object.keys(feature?.children).length, 1);
+        // Can add a feature with attributes from JSON
+        p = new Shell(`${apollo} feature add ${P} '{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":81,"max":90,"type":"remark","attributes":{"key1":["val1"]}}'`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId} -r ${refSeqId} -s 81 -e 90`);
+        out = JSON.parse(p.stdout);
+        feature = out.at(0);
+        assert.strictEqual(feature?.attributes?.key1?.[0], 'val1');
+        // Can add a feature with children from JSON
+        p = new Shell(`${apollo} feature add ${P} '{"assembly":"${assemblyId}","refSeq":"${refSeqId}","min":91,"max":100,"type":"match","children":[{"min":91,"max":95,"type":"match_part","attributes":{"key2":["val2"]}}]}'`);
+        p = new Shell(`${apollo} feature get ${P} -a ${assemblyId} -r ${refSeqId} -s 91 -e 100`);
+        out = JSON.parse(p.stdout);
+        feature = out.at(0);
+        const keys = Object.keys(feature?.children);
+        assert.strictEqual(keys.length, 1);
+        assert.strictEqual(feature.children[keys[0]].attributes.key2[0], 'val2');
+    });
     void globalThis.itName('Add child features', () => {
         new Shell(`${apollo} assembly add-from-gff ${P} test_data/tiny.fasta.gff3 -a vv1 -f`);
         let p = new Shell(`${apollo} feature search ${P} -a vv1 -t contig`);