@tolinax/ayoune-cli 2024.2.1

package/data/defaultActions.js

@@ -0,0 +1,9 @@
+const defaultActions = [
+    "describe",
+    "edit",
+    "edit raw",
+    "download",
+    "copy",
+    "delete",
+];
+export { defaultActions };

package/data/operations.js

@@ -0,0 +1,5 @@
+const operations = [
+    'list',
+    'get',
+];
+export { operations };

package/index.js

@@ -0,0 +1,34 @@
+#! /usr/bin/env node
+import { Command } from "commander";
+import { createSpinner } from "nanospinner";
+import { initializeSettings } from "./lib/helpers/initializeSettings.js";
+import { createProgram } from "./lib/commands/createProgram.js";
+import autoupdater from "cli-autoupdater";
+import path from "path";
+import { readFile } from "fs/promises";
+import * as process from "process";
+//Create new command instance
+//@ts-ignore
+const pkg = JSON.parse(await readFile(path.join(process.cwd(), "package.json"), "utf8"));
+const program = new Command();
+initializeSettings();
+//Setup spinner
+export const spinner = createSpinner("Getting data...");
+console.log(pkg);
+autoupdater(pkg)
+    .then((updated) => {
+    if (updated) {
+        // The application was updated, so exit
+        console.log("You may rerun the last command");
+        process.exit();
+    }
+    else {
+        // No update occurred, so just run the application
+        createProgram(program);
+    }
+})
+    .catch((e) => {
+    // An error has occurred so
+    console.log(e);
+    process.exit();
+});

package/lib/api/apiCallHandler.js

@@ -0,0 +1,42 @@
+import { api } from "./apiClient.js";
+import { spinner } from "../../index.js";
+import * as process from "process";
+import { login } from "./login.js";
+import { localStorage } from "../helpers/localStorage.js";
+export const apiCallHandler = async (url, method = "get", data = null, params = {}) => {
+    var _a, _b, _c;
+    try {
+        const response = await api({
+            method,
+            url,
+            data,
+            params: { ...params, ref: `ayoune-cli@${process.env.AYOUNE_VERSION}` },
+            headers: {
+                Authorization: `Bearer ${localStorage.getItem("token")}`,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        const apiError = error.response;
+        if (apiError.status === 400) {
+            spinner.error({
+                text: `Bad Request: ${apiError.data.meta.message}`,
+            });
+        }
+        if (apiError.status === 401) {
+            await login();
+        }
+        if (apiError.status === 403) {
+            spinner.error({
+                text: `You are not allowed to access this ressource... Required rights are [${(_c = (_b = (_a = apiError.data) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.requiredRights) === null || _c === void 0 ? void 0 : _c.join(",")}]`,
+            });
+        }
+        else {
+            spinner.error({
+                text: `Status ${apiError.status}: ${apiError.statusText} | ${apiError.data.meta.message}`,
+            });
+        }
+        return apiError.data;
+    }
+};

package/lib/api/apiClient.js

@@ -0,0 +1,16 @@
+import axios from "axios";
+import axiosRetry from "axios-retry";
+const hosts = {
+    api: "https://api.ayoune.app",
+    api_dev: "http://localhost:3000",
+    audit: "https://audit.ayoune.app",
+};
+const api = axios.create({
+    baseURL: hosts.api_dev,
+});
+const audit = axios.create({
+    baseURL: hosts.audit,
+});
+axiosRetry(api, { retries: 3 });
+axiosRetry(audit, { retries: 3 });
+export { api, audit };

package/lib/api/auditCallHandler.js

@@ -0,0 +1,42 @@
+import { audit } from "./apiClient.js";
+import { spinner } from "../../index.js";
+import * as process from "process";
+import { login } from "./login.js";
+import { localStorage } from "../helpers/localStorage.js";
+export const auditCallHandler = async (url, method = "get", data = null, params = {}) => {
+    var _a, _b, _c;
+    try {
+        const response = await audit({
+            method,
+            url,
+            data,
+            params: { ...params, ref: `ayoune-cli@${process.env.AYOUNE_VERSION}` },
+            headers: {
+                Authorization: `Bearer ${localStorage.getItem("token")}`,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        const apiError = error.response;
+        if (apiError.status === 400) {
+            spinner.error({
+                text: `Bad Request: ${apiError.data.meta.message}`,
+            });
+        }
+        if (apiError.status === 401) {
+            await login();
+        }
+        if (apiError.status === 403) {
+            spinner.error({
+                text: `You are not allowed to access this ressource... Required rights are [${(_c = (_b = (_a = apiError.data) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.requiredRights) === null || _c === void 0 ? void 0 : _c.join(",")}]`,
+            });
+        }
+        else {
+            spinner.error({
+                text: `Status ${apiError.status}: ${apiError.statusText} | ${apiError.data.meta.message}`,
+            });
+        }
+        return apiError.data;
+    }
+};

package/lib/api/login.js

@@ -0,0 +1,33 @@
+import { socket } from "../socket/socketClient.js";
+import { randomAsciiString } from "@tolinax/ayoune-models/utils/makeRandomToken.js";
+import { spinner } from "../../index.js";
+import { localStorage } from "../helpers/localStorage.js";
+export const login = async () => {
+    spinner.start({ text: "Waiting for login\n" });
+    const token = randomAsciiString();
+    console.log(`___________________________________________________`);
+    console.log(`Visit: https://login.ayoune.app/ayoune?cli=${token}`);
+    console.log(`___________________________________________________`);
+    const credentials = await waitForCredentials(token);
+    return credentials;
+};
+const waitForCredentials = async (token) => {
+    return new Promise(function (resolve, reject) {
+        const _socket = socket(token);
+        _socket.on("join:cli:confirmed", async (data) => {
+            spinner.update({ text: `Session active` });
+        });
+        _socket.on("cli-token", async (data) => {
+            spinner.success({ text: `Received auth credentials` });
+            localStorage.setItem("token", data.token);
+            localStorage.setItem("refreshToken", data.refreshToken);
+            resolve(data);
+        });
+        _socket.on("connect_error", async (err) => {
+            spinner.error({ text: err.message });
+        });
+        _socket.on("connect", async () => {
+            spinner.update({ text: "Tunnel established. Waiting for credentials" });
+        });
+    });
+};

package/lib/commands/createAuditCommand.js

@@ -0,0 +1,28 @@
+import { Argument } from "commander";
+import { localStorage } from "../helpers/localStorage.js";
+import { handleAuditOperation } from "../operations/handleAuditOperation.js";
+import { promptAudits } from "../prompts/promptAudits.js";
+import { handleSingleAuditOperation } from "../operations/handleSingleAuditOperation.js";
+export function createAuditCommand(program) {
+    program
+        .command("audit")
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), "The last used collection"))
+        .addArgument(new Argument("[id]", "The id to get the audit from").default(localStorage.getItem("lastId"), "The last used id"))
+        .alias("history")
+        .description("Get the history of <id> in <collection>")
+        .action(async (collection, id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const { data, content, result, meta } = await handleAuditOperation(collection, id, {
+                ...opts,
+            });
+            const selectedAudit = await promptAudits(result);
+            const { singleData, singleContent, singleResult, singleMeta } = await handleSingleAuditOperation(collection, id, selectedAudit, {
+                ...opts,
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createCopyCommand.js

@@ -0,0 +1,24 @@
+import { Argument } from "commander";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleCopySingleOperation } from "../operations/handleCopySingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createCopyCommand(program) {
+    program
+        .command("copy")
+        .addArgument(new Argument("[collection]", "The collection to use").default(localStorage.getItem("lastCollection"), "The last used collection"))
+        .addArgument(new Argument("[id]", "The id to copy").default(localStorage.getItem("lastId"), "The last used id"))
+        .alias("cp")
+        .description("Copy entry with  <id> in <collection>")
+        .action(async (collection, id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            await handleCopySingleOperation(module.module, collection, id, {
+                ...opts,
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createCreateCommand.js

@@ -0,0 +1,29 @@
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { handleCreateSingleOperation } from "../operations/handleCreateSingleOperation.js";
+import { promptName } from "../prompts/promptName.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createCreateCommand(program) {
+    program
+        .command("create [collection]")
+        .alias("c")
+        .description("Create entry in <collection>")
+        .action(async (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collection) {
+                collection = await promptCollectionWithModule();
+            }
+            const module = getModuleFromCollection(collection);
+            const name = await promptName();
+            await handleCreateSingleOperation(module.module, collection, name, {
+                ...opts,
+            });
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createDescribeCommand.js

@@ -0,0 +1,24 @@
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleDescribeSingleOperation } from "../operations/handleDescribeSingleOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createDescribeCommand(program) {
+    program
+        .command("describe <collection> <id>")
+        .alias("d")
+        .description("Describe entry with  <id> in <collection>")
+        .action(async (collection, id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            localStorage.setItem("lastId", id);
+            await handleDescribeSingleOperation(module.module, collection, id, {
+                ...opts,
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createEditCommand.js

@@ -0,0 +1,25 @@
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleGetSingleOperation } from "../operations/handleGetSingleOperation.js";
+import { handleEditOperation } from "../operations/handleEditOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createEditCommand(program) {
+    program
+        .command("edit <collection> <id>")
+        .alias("e")
+        .description("Edit entry with  <id> in <collection>")
+        .action(async (collection, id, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            localStorage.setItem("lastId", id);
+            let result = {};
+            result = await handleGetSingleOperation(module.module, collection, id, opts);
+            await handleEditOperation(module.module, collection, result.content);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createEventsCommand.js

@@ -0,0 +1,54 @@
+import { Option } from "commander";
+import { localStorage } from "../helpers/localStorage.js";
+import { decodeToken } from "@tolinax/ayoune-core/lib/auth/decodeToken.js";
+import { customerSocket } from "../socket/customerSocketClient.js";
+import { spinner } from "../../index.js";
+import yaml from "js-yaml";
+export function createEventsCommand(program) {
+    program
+        .command("events")
+        .alias("sub")
+        .description("Attach to the live event bus")
+        .addOption(new Option("-f, --format <format>", "Set the output format")
+        .choices(["json", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-c, --category <category>", "Set the category to listen").default("*"))
+        .addOption(new Option("-a, --action <action>", "Set the action to listen").default("*"))
+        .addOption(new Option("-l, --label <label>", "Set the label to listen").default("*"))
+        .addOption(new Option("-v, --value <value>", "Set the value to listen").default("*"))
+        .action(async (options) => {
+        try {
+            const tokenPayload = decodeToken(localStorage.getItem("token"));
+            const user = tokenPayload.payload;
+            spinner.start({ text: `Starting stream with [${user._customerID}]` });
+            const socket = customerSocket(user);
+            spinner.update({ text: "Stream active" });
+            socket.on("event", (data) => {
+                if (options.category !== "*" && options.category !== data.category)
+                    return;
+                if (options.action !== "*" && options.action !== data.action)
+                    return;
+                if (options.label !== "*" && options.label !== data.label)
+                    return;
+                if (options.value !== "*" && options.value !== data.value)
+                    return;
+                spinner.update({
+                    text: `Received [${data.category}.${data.action}.${data.label}.${data.value}]`,
+                });
+                if (options.format === "table") {
+                    console.table(data.evt_data);
+                }
+                if (options.format === "yaml") {
+                    console.log(yaml.dump(data.evt_data));
+                }
+                if (options.format === "json") {
+                    console.log(JSON.stringify(data.evt_data, null, 2));
+                }
+            });
+        }
+        catch (e) {
+            spinner.error({ text: e.message });
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createGetCommand.js

@@ -0,0 +1,36 @@
+import { parseInteger } from "../helpers/parseInt.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { handleGetOperation } from "../operations/handleGetOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createGetCommand(program) {
+    program
+        .command("get [collection]")
+        .alias("g")
+        .description("Get Data in collection")
+        .option("-p, --page <number>", "Page", parseInteger, 1)
+        .option("-l, --limit <number>", "Limit", parseInteger, 20)
+        .option("-f, --from <date>", "From date")
+        .option("-i, --fields <fields...>", "Fields to get")
+        .action(async (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collection) {
+                collection = await promptCollectionWithModule();
+            }
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            let result = {};
+            let entry = "";
+            result = await handleGetOperation(module.module, collection, opts);
+            if (opts.save) {
+                await saveFile("get", opts, result);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createListCommand.js

@@ -0,0 +1,35 @@
+import { parseInteger } from "../helpers/parseInt.js";
+import { promptCollectionWithModule } from "../prompts/promptCollectionWithModule.js";
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { handleListOperation } from "../operations/handleListOperation.js";
+import { saveFile } from "../helpers/saveFile.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createListCommand(program) {
+    program
+        .command("list [collection]")
+        .alias("l")
+        .description("List entries in collection")
+        .option("-p, --page <number>", "Page", parseInteger, 1)
+        .option("-l, --limit <number>", "Limit", parseInteger, 20)
+        .option("-f, --from <date>", "From date")
+        .action(async (collection, options) => {
+        try {
+            const opts = { ...program.opts(), ...options };
+            if (!collection) {
+                collection = await promptCollectionWithModule();
+            }
+            const module = getModuleFromCollection(collection);
+            localStorage.setItem("lastModule", module.module);
+            localStorage.setItem("lastCollection", collection);
+            let result = {};
+            let entry = "";
+            result = await handleListOperation(module.module, collection, opts);
+            if (opts.save) {
+                await saveFile("list", opts, result);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createLoginCommand.js

@@ -0,0 +1,17 @@
+import { login } from "../api/login.js";
+import * as process from "process";
+export function createLoginCommand(program) {
+    program
+        .command("login")
+        .alias("auth")
+        .description("Login to your aYOUne account")
+        .action(async () => {
+        try {
+            await login();
+            process.exit();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createModulesCommand.js

@@ -0,0 +1,33 @@
+import { promptModule } from "../prompts/promptModule.js";
+import { promptCollectionInModule } from "../prompts/promptCollectionInModule.js";
+import { promptOperation } from "../prompts/promptOperation.js";
+import { handleListOperation } from "../operations/handleListOperation.js";
+import { promptEntry } from "../prompts/promptEntry.js";
+import { handleCollectionOperation } from "../operations/handleCollectionOperation.js";
+import { localStorage } from "../helpers/localStorage.js";
+export function createModulesCommand(program) {
+    program
+        .command("modules")
+        .alias("m")
+        .description("List modules")
+        .action(async (message) => {
+        try {
+            console.log(message);
+            const module = await promptModule();
+            const collection = await promptCollectionInModule(module);
+            const operation = await promptOperation();
+            localStorage.setItem("lastModule", module);
+            localStorage.setItem("lastCollection", collection);
+            let result = {};
+            let entry = "";
+            if (operation === "list") {
+                result = await handleListOperation(module, collection);
+                entry = await promptEntry(result);
+            }
+            await handleCollectionOperation(module, collection, entry, operation);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createProgram.js

@@ -0,0 +1,63 @@
+//Defines the main program structure for command line interface
+import { Option } from "commander";
+import path from "path";
+import os from "os";
+import { createModulesCommand } from "./createModulesCommand.js";
+import { createListCommand } from "./createListCommand.js";
+import { createGetCommand } from "./createGetCommand.js";
+import { createEditCommand } from "./createEditCommand.js";
+import { createLoginCommand } from "./createLoginCommand.js";
+import { createDescribeCommand } from "./createDescribeCommand.js";
+import { createCopyCommand } from "./createCopyCommand.js";
+import { createCreateCommand } from "./createCreateCommand.js";
+import { createStorageCommand } from "./createStorageCommand.js";
+import { createAuditCommand } from "./createAuditCommand.js";
+import { createStreamCommand } from "./createStreamCommand.js";
+import { createEventsCommand } from "./createEventsCommand.js";
+export function createProgram(program) {
+    program
+        .version("2024.2.0")
+        .addOption(new Option("-r, --responseFormat <format>", "Set the output format")
+        .choices(["json", "csv", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-v, --verbosity <level>", "Set the verbosity level of the returned meta information")
+        .choices(["default", "extended", "minimal"])
+        .default("default")
+        .conflicts("hideMeta"))
+        .addOption(new Option("-m, --hideMeta", "Returns only the payload without meta information. ")
+        .default(false)
+        .conflicts("verbosity"))
+        .addOption(new Option("-s, --save", "Saves the response as file"))
+        .addOption(new Option("-d, --debug", "Saves the meta information as file"))
+        .addOption(new Option("-o, --outPath [filePath]", "Lets you set a path").default(path.join(os.homedir(), "aYOUne")))
+        .addOption(new Option("-n, --name [fileName]", "Lets you set a filename"))
+        .description("aYOUne - Business as a Service Command Line Interface");
+    program.showHelpAfterError();
+    createModulesCommand(program);
+    createListCommand(program);
+    createGetCommand(program);
+    createEditCommand(program);
+    createCopyCommand(program);
+    createDescribeCommand(program);
+    createCreateCommand(program);
+    createStorageCommand(program);
+    createAuditCommand(program);
+    createStreamCommand(program);
+    createEventsCommand(program);
+    createLoginCommand(program);
+    program.addHelpText("beforeAll", `
+     __     ______  _    _            
+     \\ \\   / / __ \\| |  | |           
+   __ \\ \\_/ / |  | | |  | |_ __   ___ 
+  / _\` \\   /| |  | | |  | | '_ \\ / _ \\
+ | (_| || | | |__| | |__| | | | |  __/
+  \\__,_||_|  \\____/ \\____/|_| |_|\\___|
+`);
+    program.configureHelp({
+        sortOptions: true,
+        sortSubcommands: true,
+        showGlobalOptions: true,
+    });
+    //Parse command line arguments
+    program.parse(process.argv);
+}

package/lib/commands/createStorageCommand.js

@@ -0,0 +1,16 @@
+import { localStorage } from "../helpers/localStorage.js";
+export function createStorageCommand(program) {
+    program
+        .command("storage")
+        .alias("s")
+        .description("Show current local storage")
+        .action(async () => {
+        try {
+            const storage = { ...localStorage };
+            console.table(storage);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}

package/lib/commands/createStreamCommand.js

@@ -0,0 +1,45 @@
+import { Option } from "commander";
+import { localStorage } from "../helpers/localStorage.js";
+import { decodeToken } from "@tolinax/ayoune-core/lib/auth/decodeToken.js";
+import { customerSocket } from "../socket/customerSocketClient.js";
+import { spinner } from "../../index.js";
+import yaml from "js-yaml";
+export function createStreamCommand(program) {
+    program
+        .command("stream")
+        .alias("listen")
+        .description("Attach to the live data stream")
+        .addOption(new Option("-f, --format <format>", "Set the output format")
+        .choices(["json", "yaml", "table"])
+        .default("json"))
+        .addOption(new Option("-l, --level <level>", "Set the detail level")
+        .choices(["default", "minimal", "extended"])
+        .default("default"))
+        .action(async (options) => {
+        try {
+            const tokenPayload = decodeToken(localStorage.getItem("token"));
+            const user = tokenPayload.payload;
+            console.log(user);
+            console.log(`Starting stream with [${user._customerID}]`);
+            spinner.start({ text: `Starting stream with [${user._customerID}]` });
+            const socket = customerSocket(user);
+            spinner.update({ text: "Stream active" });
+            socket.onAny((channel, data) => {
+                spinner.update({ text: `Received [${channel}]` });
+                if (options.format === "table") {
+                    console.table(data);
+                }
+                if (options.format === "yaml") {
+                    console.log(yaml.dump(data));
+                }
+                if (options.format === "json") {
+                    console.log(JSON.stringify(data, null, 2));
+                }
+            });
+        }
+        catch (e) {
+            spinner.error({ text: e.message });
+            console.error(e);
+        }
+    });
+}

package/lib/helpers/addSpacesToCamelCase.js

@@ -0,0 +1,5 @@
+export const addSpacesToCamelCase = (str) => {
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1 $2") // add space between lower & upper case letters
+        .replace(/^./, (str) => str.toUpperCase()); // capitalize the first letter
+};