@fnndsc/chili 3.2.5

package/dist/filesystem/filesystemHandler.js

@@ -0,0 +1,135 @@
+/**
+ * @file Commander setup for the ChRIS file-browser command group.
+ *
+ * @module
+ */
+import { ChRISinode_create, listParams_fromOptions, BrowserType, } from "@fnndsc/cumin";
+/**
+ * Lists resources for a given inode path.
+ *
+ * @param path - The inode path to list resources from.
+ * @param options - CLI options for filtering and pagination.
+ */
+async function inodeResources_list(path, options) {
+    const chrisInode = await ChRISinode_create(path);
+    if (!chrisInode) {
+        console.error(`Could not find path '${path}' in the CUBE filesystem.`);
+        return;
+    }
+    const params = listParams_fromOptions({
+        ...options,
+        returnFilter: "limit,offset",
+    });
+    const browserTypes = [
+        BrowserType.Files,
+        BrowserType.Links,
+        BrowserType.Dirs,
+    ];
+    const fieldOptions = {
+        [BrowserType.Files]: options.filefields,
+        [BrowserType.Links]: options.linkfields,
+        [BrowserType.Dirs]: options.dirfields,
+    };
+    for (const browserType of browserTypes) {
+        const browser = chrisInode.browser_get(browserType);
+        if (!browser) {
+            console.error(`WARNING: ${browserType} browser is not available`);
+            continue;
+        }
+        try {
+            const resourceGet = browser.resource_get;
+            if (!resourceGet) {
+                console.error(`WARNING: ${browserType} resource is null`);
+                continue;
+            }
+            const resourcesList = await resourceGet.resources_getList(params);
+            const resourceFields = await resourceGet.resourceFields_get(resourcesList, fieldOptions[browserType]);
+            const results = resourceGet.resources_filterByFields(resourceFields);
+            if (results) {
+                console.log(`${browserType} resources:`);
+                console.table(results.tableData, results.selectedFields);
+            }
+            else {
+                console.error(`${browserType} resources: not found or could not be filtered`);
+            }
+        }
+        catch (error) {
+            console.error(`${browserType} resources: not found`);
+        }
+    }
+}
+/**
+ * Displays resource fields for a given inode type.
+ *
+ * @param inodeType - The type of inode (e.g., "file properties").
+ * @param dataObj - The object containing resource fields.
+ * @returns True if fields were displayed, false otherwise.
+ */
+function inodeFields_list(inodeType, dataObj) {
+    if (!dataObj) {
+        console.log("No " + inodeType + " at this path");
+        return false;
+    }
+    if (dataObj.fields) {
+        console.log(inodeType);
+        console.table(dataObj.fields);
+        return true;
+    }
+    return false;
+}
+/**
+ * Lists all resource fields for different inode types (files, links, dirs).
+ *
+ * @param path - The base path for the inode.
+ */
+async function inodeResourceFields_list(path = "") {
+    const chrisFiles = await ChRISinode_create(path);
+    if (!chrisFiles) {
+        console.error(`Could not create ChRISinode for path: ${path}`);
+        return;
+    }
+    const fileBrowser = chrisFiles.fileBrowser_get;
+    const linkBrowser = chrisFiles.linkBrowser_get;
+    const dirBrowser = chrisFiles.dirBrowser_get;
+    let fileFields = null;
+    if (fileBrowser?.resource_get) {
+        fileFields = await fileBrowser.resource_get.resourceFields_get();
+    }
+    inodeFields_list("file properties", fileFields);
+    let linkFields = null;
+    if (linkBrowser?.resource_get) {
+        linkFields = await linkBrowser.resource_get.resourceFields_get();
+    }
+    inodeFields_list("link properties", linkFields);
+    let dirFields = null;
+    if (dirBrowser?.resource_get) {
+        dirFields = await dirBrowser.resource_get.resourceFields_get();
+    }
+    inodeFields_list("dir properties", dirFields);
+}
+/**
+ * Sets up the 'fobj' command for interacting with ChRIS filesystem objects.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export async function fileBrowserCommand_setup(program) {
+    const pluginsCommand = program
+        .command("fobj")
+        .description("Interact with ChRIS file system objects");
+    pluginsCommand
+        .command("list [path]")
+        .description("List filesystem elements")
+        .option("-p, --page <size>", "Page size (default 20)")
+        .option("-f, --filefields <fields>", "Comma-separated list of fields to display for files")
+        .option("-d, --dirfields <fields>", "Comma-separated list of fields to display for dirs")
+        .option("-l, --linkfields <fields>", "Comma-separated list of fields to display for links")
+        .action(async (path, options) => {
+        await inodeResources_list(path, options);
+    });
+    pluginsCommand
+        .command("fieldslist [path]")
+        .description("List the filebrowser resource fields")
+        .action(async (path) => {
+        await inodeResourceFields_list(path);
+    });
+}

package/dist/filesystem/inodeCommand.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Commander setup for inode-level filesystem commands.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Sets up the 'inode' command for interacting with ChRIS filesystem resources.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export declare function inodeCommand_setup(program: Command): Promise<void>;

package/dist/filesystem/inodeCommand.js

@@ -0,0 +1,37 @@
+/**
+ * @file Commander setup for inode-level filesystem commands.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { FileGroupHandler, FileMemberHandler } from "./fileGroupHandler.js";
+/**
+ * Sets up the 'inode' command for interacting with ChRIS filesystem resources.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export async function inodeCommand_setup(program) {
+    const inodeCommand = program
+        .command("inode <path>")
+        .description("Interact with ChRIS filesystem resources at a specific path")
+        .action(async (path, options, command) => {
+        const args = command.args.slice(1);
+        const subcommand = args[0];
+        if (subcommand === "files") {
+            const fileGroupHandler = await FileGroupHandler.handler_create("files", path);
+            const filesProgram = new Command();
+            fileGroupHandler.fileGroupCommand_setup(filesProgram);
+            await filesProgram.parseAsync(args);
+        }
+        else if (subcommand === "file") {
+            const fileMemberHandler = await FileMemberHandler.handler_create(path);
+            const fileProgram = new Command();
+            fileMemberHandler.fileMemberCommand_setup(fileProgram);
+            await fileProgram.parseAsync(args);
+        }
+        else {
+            console.error("Usage: chili inode <path> <files|file> [options]");
+            command.help();
+        }
+    });
+}

package/dist/handlers/baseGroupHandler.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @file Base class for resource command-group handlers.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { ChRISPluginGroup, ChRISFeedGroup, ChRISEmbeddedResourceGroup, ChRISPACSGroup } from "@fnndsc/cumin";
+import { CLIoptions } from "../utils/cli.js";
+import { TableOptions } from "../screen/screen.js";
+/**
+ * Base handler for groups of ChRIS resources.
+ * Provides common functionality for listing and deleting resources.
+ */
+export declare class BaseGroupHandler {
+    assetName: string;
+    displayOptions: TableOptions;
+    chrisObject: ChRISPluginGroup | ChRISFeedGroup | ChRISEmbeddedResourceGroup<unknown> | ChRISPACSGroup;
+    constructor(assetName: string, chrisObject: ChRISPluginGroup | ChRISFeedGroup | ChRISEmbeddedResourceGroup<unknown> | ChRISPACSGroup);
+    /**
+     * Removes duplicate column headers from FilteredResourceData results.
+     *
+     * @param results - The FilteredResourceData to process.
+     * @returns FilteredResourceData with unique headers and corresponding data.
+     */
+    private columns_removeDuplicates;
+    /**
+     * Lists ChRIS resources based on provided CLI options.
+     *
+     * @param options - CLI options for filtering and pagination.
+     */
+    resources_list(options: CLIoptions): Promise<void>;
+    /**
+     * Lists available fields for the current ChRIS resource type.
+     */
+    resourceFields_list(): Promise<void>;
+    /**
+     * Prompts the user for confirmation before performing an operation.
+     *
+     * @param ID - The ID of the resource.
+     * @param opName - The name of the operation.
+     * @returns A Promise resolving to true if confirmed, false otherwise.
+     */
+    private operation_confirm;
+    /**
+     * Prints details of a specific resource by its ID.
+     *
+     * @param ID - The ID of the resource.
+     * @param fields - Optional comma-separated list of fields to display.
+     */
+    resource_printGivenID(ID: number, fields?: string): Promise<void>;
+    /**
+     * Prompts the user to continue an operation after displaying resource info.
+     *
+     * @param ID - The ID of the resource.
+     * @param operation - The name of the operation.
+     * @param fields - Optional comma-separated list of fields to display.
+     * @returns A Promise resolving to true if confirmed, false otherwise.
+     */
+    user_confirmContinuation(ID: number, operation: string, fields?: string): Promise<boolean>;
+    /**
+     * Generates an "OK" or "Failed" message based on a boolean condition.
+     *
+     * @param obj - The object to check (truthy implies OK).
+     * @param failureNotice - Optional custom failure message.
+     * @returns The formatted status message.
+     */
+    msg_OKorNot(obj: unknown, failureNotice?: string): string;
+    /**
+     * Deletes ChRIS resources by their IDs.
+     *
+     * @param IDs - An array of resource IDs to delete.
+     * @param force - If true, bypasses user confirmation.
+     * @returns A Promise resolving to true on success, false on failure.
+     */
+    resources_delete(IDs: number[], force: boolean): Promise<boolean>;
+    /**
+     * Retrieves resource IDs based on search options.
+     *
+     * @param options - CLI options for searching.
+     * @returns A Promise resolving to an array of IDs or null if no matches.
+     */
+    IDs_getFromSearch(options: CLIoptions): Promise<number[] | null>;
+    /**
+     * Handles the deletion of resources based on CLI options.
+     *
+     * @param options - CLI options including search terms and force flag.
+     */
+    delete_handle(options: CLIoptions): Promise<void>;
+    /**
+     * Creates a standard list command with all base options.
+     * This method provides a consistent set of options across all resource types.
+     *
+     * @param actionHandler - The async function to execute when the command is invoked.
+     * @returns A configured Command object with standard list options.
+     */
+    baseListCommand_create(actionHandler: (options: CLIoptions) => Promise<void>): Command;
+    /**
+     * Sets up the Commander.js commands for resource listing and deletion.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    command_setup(program: Command): void;
+}

package/dist/handlers/baseGroupHandler.js

@@ -0,0 +1,342 @@
+/**
+ * @file Base class for resource command-group handlers.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { ChRISFeedGroup, record_extract, errorStack, } from "@fnndsc/cumin";
+import { options_toParams } from "../utils/cli.js";
+import { table_display, border_draw } from "../screen/screen.js";
+import * as readline from "readline";
+/**
+ * Base handler for groups of ChRIS resources.
+ * Provides common functionality for listing and deleting resources.
+ */
+export class BaseGroupHandler {
+    constructor(assetName, chrisObject) {
+        this.assetName = "";
+        this.assetName = assetName;
+        this.chrisObject = chrisObject;
+        this.displayOptions = {
+            title: { title: this.assetName, justification: "center" },
+        };
+    }
+    /**
+     * Removes duplicate column headers from FilteredResourceData results.
+     *
+     * @param results - The FilteredResourceData to process.
+     * @returns FilteredResourceData with unique headers and corresponding data.
+     */
+    columns_removeDuplicates(results) {
+        const uniqueHeaders = Array.from(new Set(results.selectedFields));
+        const uniqueTableData = results.tableData.map((row) => uniqueHeaders.reduce((acc, header) => {
+            if (typeof header === "string" && header in row) {
+                acc[header] = row[header];
+            }
+            return acc;
+        }, {}));
+        return {
+            ...results,
+            selectedFields: uniqueHeaders,
+            tableData: uniqueTableData,
+        };
+    }
+    /**
+     * Lists ChRIS resources based on provided CLI options.
+     *
+     * @param options - CLI options for filtering and pagination.
+     */
+    async resources_list(options) {
+        try {
+            // Parse fields to handle column width specifiers (e.g., "name:20")
+            const columnWidths = {};
+            if (options.fields) {
+                const fields = options.fields.split(',').map(f => f.trim());
+                const cleanFields = [];
+                fields.forEach(field => {
+                    const parts = field.split(':');
+                    if (parts.length === 2 && !isNaN(Number(parts[1]))) {
+                        const fieldName = parts[0];
+                        const width = Number(parts[1]);
+                        columnWidths[fieldName] = width;
+                        cleanFields.push(fieldName);
+                    }
+                    else {
+                        cleanFields.push(field);
+                    }
+                });
+                options.fields = cleanFields.join(',');
+            }
+            const params = options_toParams(options);
+            const results = await this.chrisObject.asset.resources_listAndFilterByOptions(params);
+            if (!results) {
+                console.error(`No ${this.assetName} resources found. Perhaps check your current context?`);
+                return;
+            }
+            if (results.tableData.length === 0) {
+                console.log(`No ${this.assetName} found matching the criteria.`);
+            }
+            else {
+                const uniqueResults = this.columns_removeDuplicates(results);
+                // Construct column options based on parsed widths
+                const columns = uniqueResults.selectedFields.map(field => {
+                    const width = columnWidths[field];
+                    return width ? { width } : {};
+                });
+                if (options.csv) {
+                    // CSV Output
+                    const header = uniqueResults.selectedFields.map(h => `"${h.toUpperCase()}"`).join(',');
+                    const rows = uniqueResults.tableData.map(row => {
+                        return uniqueResults.selectedFields.map(field => {
+                            const val = row[field];
+                            return `"${String(val !== undefined ? val : '').split('"').join('""')}"`;
+                        }).join(',');
+                    }).join('\n');
+                    console.log(header + '\n' + rows);
+                }
+                else if (options.table) {
+                    // Explicit Table format (with borders and title)
+                    table_display(uniqueResults.tableData, uniqueResults.selectedFields, {
+                        ...this.displayOptions,
+                        columns: columns,
+                        typeColors: {
+                            string: "green",
+                            number: "yellow",
+                            boolean: "cyan",
+                            object: "magenta"
+                        }
+                    });
+                }
+                else {
+                    // Default: Aligned, colorized, borderless list (no title)
+                    table_display(uniqueResults.tableData, uniqueResults.selectedFields, {
+                        borderless: true,
+                        columns: columns,
+                        typeColors: {
+                            string: "green",
+                            number: "yellow",
+                            boolean: "cyan",
+                            object: "magenta"
+                        }
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.log(errorStack.stack_search(this.assetName)[0]);
+        }
+    }
+    /**
+     * Lists available fields for the current ChRIS resource type.
+     */
+    async resourceFields_list() {
+        try {
+            const results = await this.chrisObject.asset.resourceFields_get();
+            if (!results) {
+                console.error(`An error occurred while fetching resource fields for ${this.assetName}.`);
+                return;
+            }
+            if (results.fields.length === 0) {
+                console.log(`No resource fields found for ${this.assetName}.`);
+            }
+            else {
+                table_display(results.fields, ["fields"]);
+            }
+        }
+        catch (error) {
+            console.log(errorStack.stack_search(this.assetName)[0]);
+        }
+    }
+    /**
+     * Prompts the user for confirmation before performing an operation.
+     *
+     * @param ID - The ID of the resource.
+     * @param opName - The name of the operation.
+     * @returns A Promise resolving to true if confirmed, false otherwise.
+     */
+    async operation_confirm(ID, opName) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`Are you sure you want to ${opName} ${this.assetName} resource id ${ID}? (y/N) `, (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() === "y");
+            });
+        });
+    }
+    /**
+     * Prints details of a specific resource by its ID.
+     *
+     * @param ID - The ID of the resource.
+     * @param fields - Optional comma-separated list of fields to display.
+     */
+    async resource_printGivenID(ID, fields) {
+        if (!fields) {
+            if (this.chrisObject instanceof ChRISFeedGroup) {
+                fields = "id,name,creation_date,owner_username";
+            }
+            else {
+                fields = "";
+            }
+        }
+        await this.resources_list({
+            fields: fields,
+            search: `id: ${ID}`,
+        });
+    }
+    /**
+     * Prompts the user to continue an operation after displaying resource info.
+     *
+     * @param ID - The ID of the resource.
+     * @param operation - The name of the operation.
+     * @param fields - Optional comma-separated list of fields to display.
+     * @returns A Promise resolving to true if confirmed, false otherwise.
+     */
+    async user_confirmContinuation(ID, operation, fields) {
+        await this.resource_printGivenID(ID);
+        const confirmed = await this.operation_confirm(ID, operation);
+        return confirmed;
+    }
+    /**
+     * Generates an "OK" or "Failed" message based on a boolean condition.
+     *
+     * @param obj - The object to check (truthy implies OK).
+     * @param failureNotice - Optional custom failure message.
+     * @returns The formatted status message.
+     */
+    msg_OKorNot(obj, failureNotice) {
+        let failMessage;
+        if (!failureNotice) {
+            failMessage = "[ Failed ]";
+        }
+        else {
+            failMessage = failureNotice;
+        }
+        if (obj) {
+            return "[ OK ]";
+        }
+        else {
+            return failMessage;
+        }
+    }
+    /**
+     * Deletes ChRIS resources by their IDs.
+     *
+     * @param IDs - An array of resource IDs to delete.
+     * @param force - If true, bypasses user confirmation.
+     * @returns A Promise resolving to true on success, false on failure.
+     */
+    async resources_delete(IDs, force) {
+        let delop = true;
+        let confirm = false;
+        let title = "";
+        let OKorNot = "";
+        for (const id of IDs) {
+            try {
+                const searchResults = await this.chrisObject.asset.resources_listAndFilterByOptions({
+                    id: id,
+                });
+                console.log(border_draw(`checking ${this.assetName} id ${id} ... ${this.msg_OKorNot(searchResults)}`));
+                if (!force) {
+                    confirm = await this.user_confirmContinuation(id, "delete");
+                    if (!confirm) {
+                        continue;
+                    }
+                }
+                delop = await this.chrisObject.asset.resourceItem_delete(id);
+                border_draw(`deleting ${this.assetName} id ${id} ... ${this.msg_OKorNot(true)}`);
+            }
+            catch (error) {
+                console.error(`${error}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Retrieves resource IDs based on search options.
+     *
+     * @param options - CLI options for searching.
+     * @returns A Promise resolving to an array of IDs or null if no matches.
+     */
+    async IDs_getFromSearch(options) {
+        const params = options_toParams(options);
+        const searchResults = await this.chrisObject.asset.resources_listAndFilterByOptions(params);
+        if (!searchResults) {
+            return null;
+        }
+        const queryHits = record_extract(searchResults.tableData, "id");
+        return queryHits.hits;
+    }
+    /**
+     * Handles the deletion of resources based on CLI options.
+     *
+     * @param options - CLI options including search terms and force flag.
+     */
+    async delete_handle(options) {
+        let nIDs;
+        nIDs = await this.IDs_getFromSearch(options);
+        if (!nIDs) {
+            console.error(`No ${this.assetName} matched the search criteria.`);
+            return;
+        }
+        if (nIDs) {
+            await this.resources_delete(nIDs, options.force);
+        }
+    }
+    /**
+     * Creates a standard list command with all base options.
+     * This method provides a consistent set of options across all resource types.
+     *
+     * @param actionHandler - The async function to execute when the command is invoked.
+     * @returns A configured Command object with standard list options.
+     */
+    baseListCommand_create(actionHandler) {
+        return new Command("list")
+            .description(`list ${this.assetName}`)
+            .option("-p, --page <size>", "Page size (default 20)")
+            .option("-f, --fields <fields>", `comma-separated list of ${this.assetName} fields to display`)
+            .option("-s, --search <searchTerms>", `search for ${this.assetName} using comma-separated key-value pairs`)
+            .option("--sort <field>", "Sort by field (name, size, date, owner, etc.)")
+            .option("-r, --reverse", "Reverse sort order")
+            .option("--table", "Output in table format with headers")
+            .option("--csv", "Output in CSV format (overrides --table)")
+            .action(actionHandler);
+    }
+    /**
+     * Sets up the Commander.js commands for resource listing and deletion.
+     *
+     * @param program - The Commander.js program instance.
+     */
+    command_setup(program) {
+        const command = program
+            .command(this.assetName)
+            .description(`Interact with a group of ChRIS ${this.assetName}`);
+        command.addCommand(this.baseListCommand_create(async (options) => {
+            await this.resources_list(options);
+        }));
+        command
+            .command("fieldslist")
+            .description(`list the ${this.assetName} resource fields`)
+            .action(async () => {
+            await this.resourceFields_list();
+        });
+        command
+            .command("delete <searchable>")
+            .description(`delete target ${this.assetName} resolved from '++' separated <searchable>, i.e. "id:77++id:33"`)
+            .option("-f, --force", `force the deletion without prompting for user confirmation`)
+            .action(async (searchable, options) => {
+            const searchParts = searchable.split("++").map((part) => part.trim());
+            // console.log(`searchParts = ${searchParts}`);
+            for (const searchPart of searchParts) {
+                const currentOptions = {
+                    ...options,
+                    search: searchPart,
+                };
+                await this.delete_handle(currentOptions);
+            }
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * @file Command-line entry point for the chili (ChILI) CLI.
+ *
+ * @module
+ */
+export { logical_toPhysical } from './utils/cli.js';