@tolinax/ayoune-cli 2026.3.1 → 2026.4.0

package/lib/helpers/contextInjector.js

@@ -0,0 +1,65 @@
+import { contextSlots } from "../../data/contextSlots.js";
+import { getActiveContext } from "./contextStore.js";
+let contextDisabled = false;
+export function disableContext() {
+    contextDisabled = true;
+}
+export function hasActiveContext() {
+    if (contextDisabled)
+        return false;
+    return Object.keys(getActiveContext()).length > 0;
+}
+export function getContextCreateFields(collection) {
+    if (contextDisabled)
+        return {};
+    const active = getActiveContext();
+    const fields = {};
+    const col = collection.toLowerCase();
+    for (const slot of contextSlots) {
+        const entry = active[slot.slot];
+        if (!entry)
+            continue;
+        const fieldName = slot.injectAsCreateField[col];
+        if (fieldName) {
+            fields[fieldName] = entry.id;
+        }
+    }
+    return fields;
+}
+export function getContextFilterParams(collection) {
+    if (contextDisabled)
+        return {};
+    const active = getActiveContext();
+    const params = {};
+    const col = collection.toLowerCase();
+    for (const slot of contextSlots) {
+        const entry = active[slot.slot];
+        if (!entry)
+            continue;
+        const paramName = slot.injectAsFilterField[col];
+        if (paramName) {
+            params[paramName] = entry.id;
+        }
+    }
+    return params;
+}
+export function getContextSummary() {
+    if (contextDisabled)
+        return "";
+    const active = getActiveContext();
+    const entries = Object.entries(active);
+    if (entries.length === 0)
+        return "";
+    const lines = entries.map(([slot, entry]) => `- Active ${slot}: "${entry.name}" (${entry.collection}, ID: ${entry.id})`);
+    return `[Active context]\n${lines.join("\n")}`;
+}
+export function getContextForAI() {
+    if (contextDisabled)
+        return {};
+    const active = getActiveContext();
+    const result = {};
+    for (const [slot, entry] of Object.entries(active)) {
+        result[slot] = { id: entry.id, name: entry.name, collection: entry.collection };
+    }
+    return result;
+}

package/lib/helpers/contextResolver.js

@@ -0,0 +1,70 @@
+import { apiCallHandler } from "../api/apiCallHandler.js";
+import { getSlot, getChildSlots } from "../../data/contextSlots.js";
+import { getContextEntry } from "./contextStore.js";
+const OBJECT_ID_RE = /^[0-9a-fA-F]{24}$/;
+export async function resolveEntity(slot, input) {
+    const slotDef = getSlot(slot);
+    if (!slotDef)
+        return [];
+    // Direct ID lookup
+    if (OBJECT_ID_RE.test(input)) {
+        try {
+            const res = await apiCallHandler(slotDef.module, `${slotDef.collection}/${input}`, "get", null, { fields: `_id,${slotDef.nameField}`, responseFormat: "json" });
+            if (res === null || res === void 0 ? void 0 : res.payload) {
+                const entity = Array.isArray(res.payload) ? res.payload[0] : res.payload;
+                if (entity === null || entity === void 0 ? void 0 : entity._id) {
+                    return [{ id: entity._id, name: entity[slotDef.nameField] || entity._id }];
+                }
+            }
+        }
+        catch (_a) {
+            // Fall through to search
+        }
+    }
+    // Search by name
+    const params = {
+        q: input,
+        limit: 5,
+        responseFormat: "json",
+        fields: `_id,${slotDef.nameField}`,
+    };
+    // If parent context is active, filter by it
+    if (slotDef.parent) {
+        const parentEntry = getContextEntry(slotDef.parent);
+        if (parentEntry) {
+            const parentSlot = getSlot(slotDef.parent);
+            if (parentSlot) {
+                const filterField = parentSlot.injectAsFilterField[slotDef.collection];
+                if (filterField) {
+                    params[filterField] = parentEntry.id;
+                }
+            }
+        }
+    }
+    try {
+        const res = await apiCallHandler(slotDef.module, slotDef.collection, "get", null, params);
+        if ((res === null || res === void 0 ? void 0 : res.payload) && Array.isArray(res.payload)) {
+            return res.payload.map((e) => ({
+                id: e._id,
+                name: e[slotDef.nameField] || e._id,
+            }));
+        }
+    }
+    catch (_b) {
+        // API error — return empty
+    }
+    return [];
+}
+export function validateHierarchy(slot) {
+    const slotDef = getSlot(slot);
+    if (!(slotDef === null || slotDef === void 0 ? void 0 : slotDef.parent))
+        return null;
+    const parentEntry = getContextEntry(slotDef.parent);
+    if (!parentEntry) {
+        return `Warning: Setting "${slot}" without parent "${slotDef.parent}" context. Results may not be scoped correctly.`;
+    }
+    return null;
+}
+export function getDependentSlots(slot) {
+    return getChildSlots(slot).map((s) => s.slot);
+}

package/lib/helpers/contextStore.js

@@ -0,0 +1,46 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+const CONTEXT_PATH = path.join(os.homedir(), ".config", "ayoune", "context.json");
+function ensureDir() {
+    const dir = path.dirname(CONTEXT_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+export function loadContext() {
+    if (!existsSync(CONTEXT_PATH)) {
+        return { active: {} };
+    }
+    try {
+        const raw = readFileSync(CONTEXT_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (_a) {
+        return { active: {} };
+    }
+}
+export function saveContext(data) {
+    ensureDir();
+    writeFileSync(CONTEXT_PATH, JSON.stringify(data, null, 2), "utf-8");
+}
+export function getContextEntry(slot) {
+    const ctx = loadContext();
+    return ctx.active[slot];
+}
+export function setContextEntry(slot, entry) {
+    const ctx = loadContext();
+    ctx.active[slot] = entry;
+    saveContext(ctx);
+}
+export function unsetContextEntry(slot) {
+    const ctx = loadContext();
+    delete ctx.active[slot];
+    saveContext(ctx);
+}
+export function clearAllContext() {
+    saveContext({ active: {} });
+}
+export function getActiveContext() {
+    return loadContext().active;
+}

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,134 @@
+import yaml from "js-yaml";
+import jmespath from "jmespath";
+/**
+ * Maps CLI response format to the API-compatible format.
+ * The API only supports json, yaml, csv — not table.
+ * Table formatting is done client-side from JSON data.
+ */
+export function getApiResponseFormat(cliFormat) {
+    if (cliFormat === "table")
+        return "json";
+    return cliFormat;
+}
+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") {
+        // API returns YAML string when responseFormat=yaml, but locally-constructed
+        // responses (sync status, dry-run) are already objects — handle both
+        if (typeof res === "string") {
+            plainResult = yaml.load(res);
+        }
+        else {
+            plainResult = res;
+        }
+        // With hideMeta, API returns raw data (no {payload, meta} wrapper)
+        // Without hideMeta, API returns {payload, meta} wrapper
+        if (plainResult && plainResult.payload !== undefined) {
+            result = plainResult.payload;
+            meta = plainResult.meta || {};
+        }
+        else {
+            result = plainResult;
+            meta = {};
+        }
+    }
+    if (opts.responseFormat && opts.responseFormat === "csv") {
+        // API returns raw CSV string when responseFormat=csv — no {payload,meta} wrapper
+        if (typeof res === "string") {
+            plainResult = res;
+            result = res;
+            meta = {};
+        }
+        else {
+            plainResult = res;
+            result = res.payload;
+            meta = res.meta || {};
+        }
+    }
+    if (opts.responseFormat && opts.responseFormat === "table") {
+        plainResult = res;
+        if (res && res.payload !== undefined) {
+            result = res.payload;
+            meta = res.meta || {};
+        }
+        else if (Array.isArray(res)) {
+            result = res;
+        }
+        else {
+            result = res;
+        }
+    }
+    if (opts.responseFormat && opts.responseFormat === "json") {
+        plainResult = res;
+        if (res && res.payload !== undefined) {
+            result = res.payload;
+            meta = res.meta || {};
+        }
+        else if (Array.isArray(res)) {
+            result = res;
+        }
+        else {
+            result = res;
+        }
+    }
+    // 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/logo.js

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import figlet from "figlet";
+export const BRAND_PURPLE = "#6B3FA0";
+export const BRAND_BLUE = "#2B8DC6";
+export const BRAND_PINK = "#E91E8C";
+export function getLogo() {
+    try {
+        const raw = figlet.textSync("aYOUne", { font: "Slant" });
+        return colorizeByColumns(raw);
+    }
+    catch (_a) {
+        // Fallback: simple colored text
+        return ("\n  " +
+            chalk.hex(BRAND_PURPLE).bold("a") +
+            chalk.hex(BRAND_BLUE).bold("YOU") +
+            chalk.hex(BRAND_PINK).bold("ne") +
+            "\n");
+    }
+}
+function colorizeByColumns(text) {
+    const lines = text.split("\n");
+    const colored = lines.map((line) => {
+        let result = "";
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (ch === " ") {
+                result += ch;
+            }
+            else if (i < 7) {
+                result += chalk.hex(BRAND_PURPLE)(ch);
+            }
+            else if (i < 26) {
+                result += chalk.hex(BRAND_BLUE)(ch);
+            }
+            else {
+                result += chalk.hex(BRAND_PINK)(ch);
+            }
+        }
+        return result;
+    });
+    return "\n" + colored.join("\n") + "\n";
+}
+export function getDescription() {
+    return (chalk.hex(BRAND_PURPLE)("a") +
+        chalk.hex(BRAND_BLUE)("YOU") +
+        chalk.hex(BRAND_PINK)("ne") +
+        chalk.dim(" — Business as a Service CLI"));
+}

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/resolveCollectionArgs.js

@@ -0,0 +1,36 @@
+import { getModuleFromCollection } from "../models/getModuleFromCollection.js";
+import { aYOUneModules } from "../../data/modules.js";
+import { isSuperUser } from "./tokenPayload.js";
+/**
+ * Resolves module and collection from CLI arguments.
+ * Supports both `ay list consumers` and `ay list crm consumers`.
+ * Blocks access to superuser-only modules for non-superusers.
+ *
+ * @param arg1 - Collection name, or module name if arg2 is provided
+ * @param arg2 - Collection name when arg1 is a module
+ */
+export function resolveCollectionArgs(arg1, arg2) {
+    if (arg2) {
+        // ay list crm consumers → arg1=module, arg2=collection
+        enforceSuperUserAccess(arg1);
+        return { module: arg1, collection: arg2.toLowerCase() };
+    }
+    // Check if arg1 is a module name (user forgot the collection)
+    const isModule = aYOUneModules.some((mod) => mod.module === arg1.toLowerCase());
+    if (isModule) {
+        throw new Error(`"${arg1}" is a module name, not a collection. Use: ay <command> ${arg1} <collection>`);
+    }
+    // ay list consumers → lookup module from collection (throws if unknown)
+    const m = getModuleFromCollection(arg1.toLowerCase());
+    enforceSuperUserAccess(m.module);
+    return { module: m.module, collection: arg1.toLowerCase() };
+}
+/**
+ * Throws if the resolved module is superuser-only and the current user is not a superuser.
+ */
+function enforceSuperUserAccess(module) {
+    const mod = aYOUneModules.find((m) => m.module === module.toLowerCase());
+    if ((mod === null || mod === void 0 ? void 0 : mod.superuserOnly) && !isSuperUser()) {
+        throw new Error(`Module "${module}" requires superuser access. Log in as a superuser to use this module.`);
+    }
+}

package/lib/helpers/sanitizeFields.js

@@ -0,0 +1,18 @@
+import { EXIT_MISUSE } from "../exitCodes.js";
+import { cliError } from "./cliError.js";
+const VALID_FIELD_PATTERN = /^-?[a-zA-Z_][a-zA-Z0-9_.$]*$/;
+/**
+ * Validates and sanitizes field names for MongoDB projections.
+ * Rejects MongoDB operators ($where, $function, etc.) and injection attempts.
+ * Accepts dot-notation paths (e.g., "address.city") and sort prefixes ("-createdAt").
+ */
+export function sanitizeFields(fields) {
+    const fieldArray = Array.isArray(fields)
+        ? fields.flatMap((f) => f.split(",").map((s) => s.trim()))
+        : fields.split(",").map((s) => s.trim());
+    const invalid = fieldArray.filter((f) => !VALID_FIELD_PATTERN.test(f));
+    if (invalid.length > 0) {
+        cliError(`Invalid field name(s): ${invalid.join(", ")}. Field names must be alphanumeric (with dots for nested paths).`, EXIT_MISUSE, "invalid_fields");
+    }
+    return fieldArray;
+}