@tolinax/ayoune-cli 2026.2.0 → 2026.2.2

package/lib/commands/createStorageCommand.js

@@ -0,0 +1,54 @@
+import chalk from "chalk";
+import { localStorage } from "../helpers/localStorage.js";
+import { loadConfig } from "../helpers/configLoader.js";
+import { spinner } from "../../index.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+const REDACT_KEYS = new Set(["token", "refreshToken"]);
+function redact(value) {
+    if (value.length <= 8)
+        return "••••";
+    return value.slice(0, 4) + "••••" + value.slice(-4);
+}
+export function createStorageCommand(program) {
+    program
+        .command("storage")
+        .alias("s")
+        .description("Display stored session data and preferences")
+        .action(async () => {
+        var _a, _b;
+        try {
+            const storage = {};
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key) {
+                    const value = (_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : "";
+                    storage[key] = REDACT_KEYS.has(key) ? redact(value) : value;
+                }
+            }
+            console.log();
+            console.log(chalk.bold("  Session Storage"));
+            console.log(chalk.dim(`  ${"─".repeat(44)}`));
+            const maxKey = Math.max(...Object.keys(storage).map((k) => k.length), 0);
+            for (const [key, value] of Object.entries(storage)) {
+                console.log(`  ${chalk.dim(key.padEnd(maxKey + 2))} ${chalk.white(value)}`);
+            }
+            const config = loadConfig();
+            const defaults = (_b = config.defaults) !== null && _b !== void 0 ? _b : {};
+            const defaultEntries = Object.entries(defaults).filter(([, v]) => v !== undefined && v !== null);
+            if (defaultEntries.length > 0) {
+                console.log();
+                console.log(chalk.bold("  Config Defaults"));
+                console.log(chalk.dim(`  ${"─".repeat(44)}`));
+                const maxDefault = Math.max(...defaultEntries.map(([k]) => k.length));
+                for (const [key, value] of defaultEntries) {
+                    console.log(`  ${chalk.dim(key.padEnd(maxDefault + 2))} ${chalk.white(String(value))}`);
+                }
+            }
+            console.log();
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createStreamCommand.js

@@ -0,0 +1,50 @@
+import { Option } from "commander";
+import { localStorage } from "../helpers/localStorage.js";
+import { decodeToken } from "../api/decodeToken.js";
+import { customerSocket } from "../socket/customerSocketClient.js";
+import { spinner } from "../../index.js";
+import yaml from "js-yaml";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+export function createStreamCommand(program) {
+    program
+        .command("stream")
+        .alias("listen")
+        .description("Subscribe to real-time data changes via WebSocket")
+        .addHelpText("after", `
+Examples:
+  ay stream                     Stream all data changes as JSON
+  ay stream -f yaml             Stream changes in YAML format
+  ay listen -l minimal          Stream with minimal detail`)
+        .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(`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 || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/createWhoAmICommand.js

@@ -0,0 +1,88 @@
+import chalk from "chalk";
+import moment from "moment";
+import { localStorage } from "../helpers/localStorage.js";
+import { decodeToken } from "../api/decodeToken.js";
+import { spinner } from "../../index.js";
+import { login } from "../api/login.js";
+import { EXIT_GENERAL_ERROR } from "../exitCodes.js";
+const LABEL_MAP = {
+    _id: "User ID",
+    _customerID: "Customer",
+    _resellerID: "Reseller",
+    _agencyID: "Agency",
+    email: "Email",
+    name: "Name",
+    username: "Username",
+    role: "Role",
+    type: "Type",
+    language: "Language",
+    iat: "Issued",
+    exp: "Expires",
+};
+const SKIP_FIELDS = new Set(["password", "hash", "salt", "__v"]);
+function formatValue(key, value) {
+    if ((key === "iat" || key === "exp") && typeof value === "number") {
+        const m = moment.unix(value);
+        const relative = m.fromNow();
+        const formatted = m.format("YYYY-MM-DD HH:mm:ss");
+        if (key === "exp" && m.isBefore(moment())) {
+            return chalk.red(`${formatted} (expired ${relative})`);
+        }
+        return `${formatted} ${chalk.dim(`(${relative})`)}`;
+    }
+    if (typeof value === "object" && value !== null) {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+function displayUser(user) {
+    const name = user.name || user.username || user.email || "User";
+    const greeting = getGreeting();
+    console.log();
+    console.log(chalk.bold(`  ${greeting}, ${chalk.cyan(name)}!`));
+    console.log(chalk.dim(`  ${"─".repeat(44)}`));
+    const maxLabel = Math.max(...Object.keys(user)
+        .filter((k) => !SKIP_FIELDS.has(k))
+        .map((k) => (LABEL_MAP[k] || k).length));
+    for (const [key, value] of Object.entries(user)) {
+        if (SKIP_FIELDS.has(key) || value == null || value === "")
+            continue;
+        const label = LABEL_MAP[key] || key;
+        const formatted = formatValue(key, value);
+        console.log(`  ${chalk.dim(label.padEnd(maxLabel + 2))} ${chalk.white(formatted)}`);
+    }
+    console.log();
+}
+function getGreeting() {
+    const hour = new Date().getHours();
+    if (hour < 12)
+        return "Good morning";
+    if (hour < 18)
+        return "Good afternoon";
+    return "Good evening";
+}
+export function createWhoAmICommand(program) {
+    program
+        .command("whoami")
+        .alias("who")
+        .description("Display the currently authenticated user")
+        .action(async (options) => {
+        try {
+            const tokenPayload = decodeToken(localStorage.getItem("token"));
+            if (tokenPayload) {
+                displayUser(tokenPayload.payload);
+            }
+            else {
+                await login();
+                const newPayload = decodeToken(localStorage.getItem("token"));
+                if (newPayload) {
+                    displayUser(newPayload.payload);
+                }
+            }
+        }
+        catch (e) {
+            spinner.error({ text: e.message || "An unexpected error occurred" });
+            process.exit(EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/exitCodes.js

@@ -0,0 +1,6 @@
+export const EXIT_SUCCESS = 0;
+export const EXIT_GENERAL_ERROR = 1;
+export const EXIT_MISUSE = 2;
+export const EXIT_AUTH_REQUIRED = 4;
+export const EXIT_PERMISSION_DENIED = 5;
+export const EXIT_CONFIG_ERROR = 6;

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
+};

package/lib/helpers/config.js

@@ -0,0 +1,6 @@
+export const config = {
+    apiUrl: process.env.AYOUNE_API_URL || "https://api.ayoune.app",
+    auditUrl: process.env.AYOUNE_AUDIT_URL || "https://audit.ayoune.app",
+    notifierUrl: process.env.AYOUNE_NOTIFIER_URL || "https://notifier.ayoune.app",
+    loginUrl: process.env.AYOUNE_LOGIN_URL || "https://login.ayoune.app",
+};

package/lib/helpers/configLoader.js

@@ -0,0 +1,60 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+const CONFIG_PATHS = [
+    path.join(os.homedir(), ".config", "ayoune", "config.json"),
+    path.join(os.homedir(), ".ayounerc"),
+];
+function findConfigFile() {
+    for (const configPath of CONFIG_PATHS) {
+        if (existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+export function loadConfig() {
+    const configPath = findConfigFile();
+    if (!configPath) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (_a) {
+        return {};
+    }
+}
+export function getConfigPath() {
+    return path.join(os.homedir(), ".config", "ayoune", "config.json");
+}
+export function saveConfig(config) {
+    const configPath = getConfigPath();
+    const dir = path.dirname(configPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+export function getActiveProfile(config) {
+    var _a, _b;
+    const profileName = process.env.AYOUNE_PROFILE || config.profile || "production";
+    return (_b = (_a = config.profiles) === null || _a === void 0 ? void 0 : _a[profileName]) !== null && _b !== void 0 ? _b : {};
+}
+export function getApiUrl(config) {
+    const profile = getActiveProfile(config);
+    return (process.env.AYOUNE_API_URL || profile.apiUrl || "https://api.ayoune.app");
+}
+export function getAuditUrl(config) {
+    const profile = getActiveProfile(config);
+    return (process.env.AYOUNE_AUDIT_URL ||
+        profile.auditUrl ||
+        "https://audit.ayoune.app");
+}
+export function getNotifierUrl(config) {
+    const profile = getActiveProfile(config);
+    return (process.env.AYOUNE_NOTIFIER_URL ||
+        profile.notifierUrl ||
+        "https://notifier.ayoune.app");
+}

package/lib/helpers/formatDocument.js

@@ -0,0 +1,176 @@
+import chalk from 'chalk';
+import moment from 'moment';
+import { addSpacesToCamelCase } from './addSpacesToCamelCase.js';
+const SKIP_FIELDS = new Set(['__v', 'password', 'hash', 'salt']);
+function isDateField(key, value) {
+    if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(value))
+        return true;
+    if (key.endsWith('At') || key.endsWith('Date'))
+        return true;
+    return false;
+}
+function formatDate(value) {
+    const m = moment(value);
+    if (!m.isValid())
+        return String(value);
+    const formatted = m.format('YYYY-MM-DD HH:mm:ss');
+    const relative = m.fromNow();
+    return `${formatted} ${chalk.dim(`(${relative})`)}`;
+}
+function formatValue(key, value) {
+    if (value == null || value === '')
+        return '';
+    if (typeof value === 'boolean') {
+        return value ? chalk.green('yes') : chalk.red('no');
+    }
+    if (isDateField(key, value)) {
+        return formatDate(value);
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '';
+        if (value.every((v) => typeof v !== 'object' || v === null)) {
+            return value.join(', ');
+        }
+        return '';
+    }
+    if (typeof value === 'object')
+        return '';
+    const str = String(value);
+    if ((key.endsWith('ID') || key.endsWith('Id') || key === '_id') && str.length > 10) {
+        return chalk.dim(str);
+    }
+    return str;
+}
+function getEntryName(obj) {
+    return (obj === null || obj === void 0 ? void 0 : obj.name) || (obj === null || obj === void 0 ? void 0 : obj.title) || (obj === null || obj === void 0 ? void 0 : obj.subject) || (obj === null || obj === void 0 ? void 0 : obj.originalname) || '';
+}
+function renderHeader(obj, ctx) {
+    const name = getEntryName(obj);
+    const contextParts = [];
+    if (ctx.module)
+        contextParts.push(ctx.module);
+    if (ctx.collection)
+        contextParts.push(ctx.collection);
+    if (ctx.id)
+        contextParts.push(ctx.id);
+    const contextLine = contextParts.join(chalk.dim(' · '));
+    const contentWidth = Math.max(name ? name.length : 0, contextLine ? contextParts.join(' · ').length : 0, 30);
+    const boxWidth = contentWidth + 4;
+    const lines = [];
+    lines.push(chalk.dim(`╭${'─'.repeat(boxWidth)}╮`));
+    if (name) {
+        lines.push(chalk.dim('│') + `  ${chalk.bold.white(name)}${' '.repeat(boxWidth - name.length - 2)}` + chalk.dim('│'));
+    }
+    if (contextLine) {
+        const plainLen = contextParts.join(' · ').length;
+        lines.push(chalk.dim('│') + `  ${chalk.dim(contextLine)}${' '.repeat(boxWidth - plainLen - 2)}` + chalk.dim('│'));
+    }
+    lines.push(chalk.dim(`╰${'─'.repeat(boxWidth)}╯`));
+    return lines.join('\n');
+}
+function collectFields(obj) {
+    const flat = [];
+    const nested = [];
+    const arrayOfObjects = [];
+    for (const [key, value] of Object.entries(obj)) {
+        if (SKIP_FIELDS.has(key) || value == null || value === '')
+            continue;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                continue;
+            if (value.some((v) => typeof v === 'object' && v !== null)) {
+                arrayOfObjects.push([key, value]);
+            }
+            else {
+                flat.push([key, value]);
+            }
+        }
+        else if (typeof value === 'object' && !isDateField(key, value)) {
+            nested.push([key, value]);
+        }
+        else {
+            flat.push([key, value]);
+        }
+    }
+    return { flat, nested, arrayOfObjects };
+}
+function renderFields(fields, indent, labelWidth) {
+    const pad = ' '.repeat(indent);
+    const lines = [];
+    for (const [key, value] of fields) {
+        const formatted = formatValue(key, value);
+        if (!formatted)
+            continue;
+        const label = addSpacesToCamelCase(key);
+        lines.push(`${pad}${chalk.dim(label.padEnd(labelWidth))} ${chalk.white(formatted)}`);
+    }
+    return lines;
+}
+function getLabelWidth(fields) {
+    if (fields.length === 0)
+        return 16;
+    return Math.max(...fields.map(([k]) => addSpacesToCamelCase(k).length)) + 2;
+}
+function renderSection(title, obj, indent) {
+    const pad = ' '.repeat(indent);
+    const lines = [];
+    const { flat, nested, arrayOfObjects } = collectFields(obj);
+    lines.push('');
+    lines.push(`${pad}${chalk.dim('── ' + addSpacesToCamelCase(title) + ' ' + '─'.repeat(Math.max(0, 36 - title.length)))}`);
+    const labelWidth = getLabelWidth(flat);
+    lines.push(...renderFields(flat, indent + 2, labelWidth));
+    for (const [key, value] of nested) {
+        lines.push(...renderSection(key, value, indent + 2));
+    }
+    for (const [key, items] of arrayOfObjects) {
+        lines.push('');
+        lines.push(`${pad}  ${chalk.dim('── ' + addSpacesToCamelCase(key) + ' ' + '─'.repeat(Math.max(0, 34 - key.length)))}`);
+        items.forEach((item, i) => {
+            if (typeof item === 'object' && item !== null) {
+                lines.push(`${pad}    ${chalk.dim(`[${i + 1}]`)}`);
+                const itemFields = collectFields(item);
+                const itemLabelWidth = getLabelWidth(itemFields.flat);
+                lines.push(...renderFields(itemFields.flat, indent + 6, itemLabelWidth));
+            }
+            else {
+                lines.push(`${pad}    ${chalk.dim(`[${i + 1}]`)} ${String(item)}`);
+            }
+        });
+    }
+    return lines;
+}
+export function formatDocument(obj, ctx = {}) {
+    if (!obj || typeof obj !== 'object')
+        return String(obj !== null && obj !== void 0 ? obj : '');
+    const lines = [];
+    lines.push('');
+    lines.push(renderHeader(obj, ctx));
+    const { flat, nested, arrayOfObjects } = collectFields(obj);
+    const labelWidth = getLabelWidth(flat);
+    lines.push('');
+    lines.push(...renderFields(flat, 2, labelWidth));
+    for (const [key, value] of nested) {
+        lines.push(...renderSection(key, value, 2));
+    }
+    for (const [key, items] of arrayOfObjects) {
+        lines.push('');
+        lines.push(`  ${chalk.dim('── ' + addSpacesToCamelCase(key) + ' ' + '─'.repeat(Math.max(0, 36 - key.length)))}`);
+        items.forEach((item, i) => {
+            if (typeof item === 'object' && item !== null) {
+                lines.push(`    ${chalk.dim(`[${i + 1}]`)}`);
+                const itemFields = collectFields(item);
+                const itemLabelWidth = getLabelWidth(itemFields.flat);
+                lines.push(...renderFields(itemFields.flat, 6, itemLabelWidth));
+            }
+            else {
+                lines.push(`    ${chalk.dim(`[${i + 1}]`)} ${String(item)}`);
+            }
+        });
+    }
+    lines.push('');
+    return lines.join('\n');
+}

package/lib/helpers/handleResponseFormatOptions.js

@@ -0,0 +1,85 @@
+import yaml from "js-yaml";
+import jmespath from "jmespath";
+function filterColumns(data, columns) {
+    const fields = columns.split(",").map((c) => c.trim());
+    if (Array.isArray(data)) {
+        return data.map((item) => {
+            const filtered = {};
+            for (const f of fields) {
+                if (item[f] !== undefined)
+                    filtered[f] = item[f];
+            }
+            return filtered;
+        });
+    }
+    if (typeof data === "object" && data !== null) {
+        const filtered = {};
+        for (const f of fields) {
+            if (data[f] !== undefined)
+                filtered[f] = data[f];
+        }
+        return filtered;
+    }
+    return data;
+}
+export function handleResponseFormatOptions(opts, res) {
+    let plainResult;
+    let result;
+    let meta = {};
+    let content;
+    if (opts.responseFormat && opts.responseFormat === "yaml") {
+        plainResult = yaml.load(res);
+        result = plainResult.payload;
+        meta = plainResult.meta;
+    }
+    if (opts.responseFormat && opts.responseFormat === "csv") {
+        plainResult = res;
+        result = res.payload;
+        meta = res.meta;
+    }
+    if (opts.responseFormat && opts.responseFormat === "table") {
+        plainResult = res;
+        result = res.payload;
+        meta = res.meta;
+    }
+    if (opts.responseFormat && opts.responseFormat === "json") {
+        plainResult = res;
+        result = res.payload;
+        meta = res.meta;
+    }
+    // Apply --columns filter
+    if (opts.columns && result) {
+        result = filterColumns(result, opts.columns);
+    }
+    // Apply --jq (JMESPath) filter
+    if (opts.jq && result) {
+        try {
+            result = jmespath.search(result, opts.jq);
+        }
+        catch (e) {
+            console.error(`JMESPath error: ${e.message}`);
+        }
+    }
+    // Generate content string after filtering
+    if (opts.responseFormat === "yaml") {
+        content = yaml.dump(result);
+    }
+    else if (opts.responseFormat === "csv") {
+        content = result;
+    }
+    else if (opts.responseFormat === "table") {
+        content = result;
+    }
+    else {
+        content = JSON.stringify(result, null, 4);
+    }
+    if (!opts.quiet) {
+        if (opts.responseFormat === "table") {
+            console.table(result);
+        }
+        else if (content !== undefined) {
+            console.log(content);
+        }
+    }
+    return { plainResult, result, meta, content };
+}

package/lib/helpers/initializeSettings.js

@@ -0,0 +1,14 @@
+//Initializes settings for system environment and inquirer
+import inquirer from "inquirer";
+import inquirerFuzzyPath from "inquirer-fuzzy-path";
+import inquirerSearchList from "inquirer-search-list";
+import inquirerFileTreeSelection from "inquirer-file-tree-selection-prompt";
+import inquirerTableInput from "inquirer-table-input";
+import InterruptedPrompt from "inquirer-interrupted-prompt";
+export function initializeSettings() {
+    inquirer.registerPrompt("fuzzypath", inquirerFuzzyPath);
+    inquirer.registerPrompt("search-list", inquirerSearchList);
+    inquirer.registerPrompt("file-tree-selection", inquirerFileTreeSelection);
+    inquirer.registerPrompt("table-input", inquirerTableInput);
+    InterruptedPrompt.fromAll(inquirer);
+}

package/lib/helpers/localStorage.js

@@ -0,0 +1,4 @@
+import { LocalStorage } from "node-localstorage";
+import path from "path";
+import os from "os";
+export const localStorage = new LocalStorage(path.join(os.homedir(), "aYOUne", "storage"));

package/lib/helpers/makeRandomToken.js

@@ -0,0 +1,27 @@
+import { randomBytes } from "crypto";
+/** Sync */
+const randomString = (length, chars) => {
+    if (!chars) {
+        throw new Error("Argument 'chars' is undefined");
+    }
+    const charsLength = chars.length;
+    if (charsLength > 256) {
+        throw new Error("Argument 'chars' should not have more than 256 characters" +
+            ", otherwise unpredictability will be broken");
+    }
+    const _randomBytes = randomBytes(length);
+    let result = new Array(length);
+    let cursor = 0;
+    for (let i = 0; i < length; i++) {
+        cursor += _randomBytes[i];
+        result[i] = chars[cursor % charsLength];
+    }
+    return result.join("");
+};
+/** Sync */
+export const randomAsciiString = (length = 32, alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") => {
+    if (typeof length === "undefined") {
+        length = 32;
+    }
+    return randomString(length, alphabet);
+};

package/lib/helpers/parseInt.js

@@ -0,0 +1,7 @@
+export function parseInteger(value, dummyPrevious) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new Error("Not a number.");
+    }
+    return parsedValue;
+}

package/lib/helpers/requireArg.js

@@ -0,0 +1,9 @@
+import { spinner } from "../../index.js";
+export function requireArg(value, name) {
+    if (value)
+        return true;
+    if (process.stdin.isTTY)
+        return false; // allow prompt to run
+    spinner.error({ text: `Missing required argument: ${name}` });
+    process.exit(1);
+}

package/lib/helpers/saveFile.js

@@ -0,0 +1,39 @@
+import { mkdirp } from "mkdirp";
+import moment from "moment";
+import path from "path";
+import { writeFile } from "fs/promises";
+import { spinner } from "../../index.js";
+export async function saveFile(type, opts, result) {
+    if (opts.save) {
+        await mkdirp(opts.outPath);
+        const fileName = opts.name
+            ? opts.name
+            : type +
+                "_page_" +
+                result.meta.pageInfo.page +
+                "_" +
+                moment().format("YYYY_DD_MM_HH_mm_ss");
+        const pathToWrite = path.join(opts.outPath, `${fileName}`).toString();
+        console.log(pathToWrite);
+        spinner.start({
+            text: `Saving operation as ${pathToWrite}.${opts.responseFormat}`,
+            color: "yellow",
+        });
+        await writeFile(`${pathToWrite}.${opts.responseFormat}`, result.content, {
+            encoding: "utf8",
+        });
+        spinner.success({
+            text: `File written: ${pathToWrite}.${opts.responseFormat}`,
+        });
+        if (opts.debug) {
+            spinner.start({
+                text: `Saving operation as ${pathToWrite}.meta.json`,
+                color: "yellow",
+            });
+            await writeFile(`${pathToWrite}.meta.json`, JSON.stringify(result.meta, null, 4), {
+                encoding: "utf8",
+            });
+            spinner.success({ text: `File written: ${pathToWrite}.meta.json` });
+        }
+    }
+}

package/lib/models/getCollections.js

@@ -0,0 +1,15 @@
+import { modelsAndRights } from "../../data/modelsAndRights.js";
+import { addSpacesToCamelCase } from "../helpers/addSpacesToCamelCase.js";
+const getCollections = () => {
+    return modelsAndRights
+        .filter((el) => {
+        return el.module !== "su";
+    })
+        .map((el) => {
+        return {
+            name: addSpacesToCamelCase(el.plural),
+            value: el.plural.toLowerCase(),
+        };
+    });
+};
+export { getCollections };

package/lib/models/getModelsInModules.js

@@ -0,0 +1,13 @@
+import _ from "lodash";
+import { addSpacesToCamelCase } from "../helpers/addSpacesToCamelCase.js";
+import { modelsAndRights } from "../../data/modelsAndRights.js";
+const getModelsInModules = (module) => {
+    const m = _.filter(modelsAndRights, { module });
+    return m.map((el) => {
+        return {
+            name: addSpacesToCamelCase(el.plural),
+            value: el.plural.toLowerCase(),
+        };
+    });
+};
+export { getModelsInModules };