@oada/cli/dist/commands/get.js

CLI OADA client

import { Flags } from '@oclif/core';
import { json, shell } from '../highlight.js';
import Command from '../BaseCommand.js';
import { _id, _meta, oadaify, } from '@oada/oadaify';
import { expandPath, loadFile, output } from '../io.js';
import getConn from '../connections.js';
function isArray(oadaified) {
    return Array.isArray(oadaified);
}
const examples = [
    `${shell `$ oada get /bookmarks`}
${json `{
  "_id": "resources/default:resources_bookmarks_321",
  "_rev": 45,
  "_type": "application/vnd.oada.bookmarks.1+json",
  "_meta": {
    "_id": "resources/default:resources_bookmarks_321/_meta",
    "_rev": 45
  },
  "foo": "bar",
  "baz": 700
}`}`,
    `${shell `$ oada get /bookmarks/*`}
${json `"bar"`}
${json `700`}`,
];
class Get extends Command {
    async run() {
        const { argv: paths, flags: { out, meta, tree: treefile }, } = await this.parse(Get);
        const conn = getConn(this.iconfig);
        const tree = treefile ? (await loadFile(treefile)) : undefined;
        await output(out, async function* () {
            for (const p of paths) {
                const pp = expandPath(conn, `${p}`);
                for await (const path of pp) {
                    const { data } = await conn.get({ path, tree });
                    if (Buffer.isBuffer(data)) {
                        yield data;
                        return;
                    }
                    const oadaified = oadaify(data);
                    if (meta) {
                        await getMeta(conn, oadaified);
                    }
                    yield oadaified;
                }
            }
        }, this.iconfig);
    }
}
Get.description = 'perform an OADA GET (read)';
Get.aliases = ['g', 'GET'];
Get.examples = examples;
Get.flags = {
    tree: Flags.string({
        char: 'T',
        description: 'file containing an OADA tree to use for a tree GET',
    }),
    recursive: Flags.boolean({ char: 'R', default: false }),
    meta: Flags.boolean({ char: 'm', default: false }),
    out: Flags.string({ char: 'o', default: '-' }),
};
Get.strict = false;
export default Get;
async function getMeta(conn, oadaified) {
    if (!oadaified ||
        typeof oadaified !== 'object' ||
        Buffer.isBuffer(oadaified)) {
        return oadaified;
    }
    if (isArray(oadaified)) {
        return Promise.all(oadaified.map(async (element) => getMeta(conn, element)));
    }
    const out = Object.fromEntries(await Promise.all(Object.entries(oadaified).map(async ([k, v]) => [
        k,
        await getMeta(conn, v),
    ])));
    const meta = out[_meta];
    if (meta) {
        const { data } = await conn.get({
            path: meta[_id],
        });
        if (!data || Buffer.isBuffer(data)) {
            throw new TypeError(`Meta ${meta[_id]} is not a valid OADA meta resource`);
        }
        out[_meta] = oadaify(data);
    }
    return out;
}
//# sourceMappingURL=get.js.map