@aderis-erp/cli 1.0.0

package/dist/lib/base-api-command.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export type OutputFormat = 'json' | 'table' | 'yaml';
+export declare abstract class BaseApiCommand extends Command {
+    static globalFlags: {
+        context: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected contextName?: string;
+    protected outputFormat: OutputFormat;
+    protected quiet: boolean;
+    protected executeApiCall(method: string, path: string, options?: {
+        data?: unknown;
+        params?: Record<string, unknown>;
+    }): Promise<unknown>;
+    protected formatOutput(data: unknown): void;
+    protected init(): Promise<void>;
+    protected printTable(data: unknown): void;
+}

package/dist/lib/base-api-command.js

@@ -0,0 +1,173 @@
+import { Command, Flags } from '@oclif/core';
+import { ApiError, apiRequest } from './api-client.js';
+import { getCurrentContext } from './config.js';
+export class BaseApiCommand extends Command {
+    static globalFlags = {
+        context: Flags.string({
+            char: 'c',
+            description: 'Context to use (defaults to current context)',
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'json',
+            description: 'Output format',
+            options: ['json', 'table', 'yaml'],
+        }),
+        quiet: Flags.boolean({
+            char: 'q',
+            default: false,
+            description: 'Only output the result, no headers or formatting',
+        }),
+    };
+    contextName;
+    outputFormat = 'json';
+    quiet = false;
+    async executeApiCall(method, path, options = {}) {
+        try {
+            const response = await apiRequest(method, path, {
+                ...options,
+                contextName: this.contextName,
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                this.error(`API Error (${error.status}): ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    formatOutput(data) {
+        switch (this.outputFormat) {
+            case 'json': {
+                this.log(JSON.stringify(data, null, this.quiet ? 0 : 2));
+                break;
+            }
+            case 'table': {
+                this.printTable(data);
+                break;
+            }
+            case 'yaml': {
+                // Simple YAML output
+                this.log(toYaml(data));
+                break;
+            }
+            // No default
+        }
+    }
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(this.constructor);
+        this.contextName = flags.context;
+        this.outputFormat = (flags.output || 'json');
+        this.quiet = flags.quiet || false;
+        // Verify we have a valid context
+        const context = this.contextName ? (await import('./config.js')).getContext(this.contextName) : getCurrentContext();
+        if (!context) {
+            this.error('No context configured. Run: aderis auth login --new');
+        }
+        if (!context.tokens) {
+            this.error(`Not logged in to context "${context.name}". Run: aderis auth login`);
+        }
+    }
+    printTable(data) {
+        if (Array.isArray(data)) {
+            if (data.length === 0) {
+                this.log('No results');
+                return;
+            }
+            // Get columns from first item
+            const firstItem = data[0];
+            if (typeof firstItem === 'object' && firstItem !== null) {
+                const columns = Object.keys(firstItem).slice(0, 8); // Limit columns for readability
+                const header = columns.join('\t');
+                this.log(header);
+                this.log('-'.repeat(header.length));
+                for (const item of data) {
+                    const row = columns.map((col) => formatValue(item[col])).join('\t');
+                    this.log(row);
+                }
+            }
+            else {
+                for (const item of data) {
+                    this.log(String(item));
+                }
+            }
+        }
+        else if (typeof data === 'object' && data !== null) {
+            // Handle paginated responses
+            const obj = data;
+            if (Array.isArray(obj.data)) {
+                this.printTable(obj.data);
+                if (obj.meta && typeof obj.meta === 'object') {
+                    const meta = obj.meta;
+                    this.log(`\nPage ${meta.currentPage}/${meta.totalPages} (${meta.totalItems} total items)`);
+                }
+            }
+            else {
+                for (const [key, value] of Object.entries(obj)) {
+                    this.log(`${key}: ${formatValue(value)}`);
+                }
+            }
+        }
+        else {
+            this.log(String(data));
+        }
+    }
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return '-';
+    if (typeof value === 'object') {
+        if (Array.isArray(value))
+            return `[${value.length} items]`;
+        return '{...}';
+    }
+    const str = String(value);
+    return str.length > 50 ? str.slice(0, 47) + '...' : str;
+}
+function toYaml(obj, indent = 0) {
+    const spaces = '  '.repeat(indent);
+    if (obj === null || obj === undefined) {
+        return `${spaces}null`;
+    }
+    if (typeof obj === 'string') {
+        if (obj.includes('\n')) {
+            return `${spaces}|\n${obj
+                .split('\n')
+                .map((line) => spaces + '  ' + line)
+                .join('\n')}`;
+        }
+        return obj.includes(':') || obj.includes('#') ? `"${obj}"` : obj;
+    }
+    if (typeof obj === 'number' || typeof obj === 'boolean') {
+        return String(obj);
+    }
+    if (Array.isArray(obj)) {
+        if (obj.length === 0)
+            return '[]';
+        return obj
+            .map((item) => {
+            const formatted = toYaml(item, indent + 1);
+            if (typeof item === 'object' && item !== null) {
+                return `${spaces}- ${formatted.trim()}`;
+            }
+            return `${spaces}- ${formatted}`;
+        })
+            .join('\n');
+    }
+    if (typeof obj === 'object') {
+        const entries = Object.entries(obj);
+        if (entries.length === 0)
+            return '{}';
+        return entries
+            .map(([key, value]) => {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                return `${spaces}${key}:\n${toYaml(value, indent + 1)}`;
+            }
+            return `${spaces}${key}: ${toYaml(value, indent)}`;
+        })
+            .join('\n');
+    }
+    return String(obj);
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,40 @@
+import Conf from 'conf';
+export type Environment = 'dev' | 'live' | 'test';
+export interface BaseUrls {
+    api: string;
+    auth: string;
+}
+export declare const BASE_URLS: Record<Environment, BaseUrls>;
+export declare const DEFAULT_CLIENT_IDS: Record<Environment, string>;
+export interface TokenData {
+    access_token: string;
+    expires_at?: number;
+    refresh_token?: string;
+    tenant_id?: string;
+}
+export interface Context {
+    client_id: string;
+    client_secret?: string;
+    environment: Environment;
+    name: string;
+    tenant_id?: string;
+    tokens?: TokenData;
+}
+export interface ConfigSchema {
+    contexts: Record<string, Context>;
+    current_context: null | string;
+}
+declare const config: Conf<ConfigSchema>;
+export declare function getConfig(): ConfigSchema;
+export declare function getCurrentContext(): Context | null;
+export declare function setCurrentContext(name: string): void;
+export declare function listContexts(): Context[];
+export declare function getContext(name: string): Context | null;
+export declare function addContext(context: Context): void;
+export declare function updateContext(name: string, updates: Partial<Context>): void;
+export declare function deleteContext(name: string): void;
+export declare function saveTokens(contextName: string, tokens: TokenData): void;
+export declare function getTokens(contextName: string): null | TokenData;
+export declare function clearTokens(contextName: string): void;
+export declare function getBaseUrls(environment: Environment): BaseUrls;
+export { config };

package/dist/lib/config.js

@@ -0,0 +1,113 @@
+import Conf from 'conf';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+export const BASE_URLS = {
+    dev: {
+        api: 'https://api-dev.aderis.com',
+        auth: 'https://auth-dev.aderis.com',
+    },
+    live: {
+        api: 'https://api.aderis.com',
+        auth: 'https://auth.aderis.com',
+    },
+    test: {
+        api: 'https://api-test.aderis.com',
+        auth: 'https://auth-test.aderis.com',
+    },
+};
+// Default OAuth client IDs per environment (public clients, no secret required)
+export const DEFAULT_CLIENT_IDS = {
+    dev: '74fd96f8-cf4b-49d8-b713-2a121ea22910',
+    live: '970d9568-84c9-4613-b966-30d7e1d93828',
+    test: '', // TODO: Add test client ID
+};
+const CONFIG_DIR = path.join(os.homedir(), '.aderis');
+// Ensure config directory exists
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { mode: 0o700, recursive: true });
+}
+const config = new Conf({
+    configName: 'config',
+    cwd: CONFIG_DIR,
+    defaults: {
+        contexts: {},
+        current_context: null,
+    },
+    projectName: 'aderis',
+});
+export function getConfig() {
+    return {
+        contexts: config.get('contexts'),
+        current_context: config.get('current_context'),
+    };
+}
+export function getCurrentContext() {
+    const currentName = config.get('current_context');
+    if (!currentName)
+        return null;
+    const contexts = config.get('contexts');
+    return contexts[currentName] || null;
+}
+export function setCurrentContext(name) {
+    const contexts = config.get('contexts');
+    if (!contexts[name]) {
+        throw new Error(`Context "${name}" does not exist`);
+    }
+    config.set('current_context', name);
+}
+export function listContexts() {
+    const contexts = config.get('contexts');
+    return Object.values(contexts);
+}
+export function getContext(name) {
+    const contexts = config.get('contexts');
+    return contexts[name] || null;
+}
+export function addContext(context) {
+    const contexts = config.get('contexts');
+    contexts[context.name] = context;
+    config.set('contexts', contexts);
+    // If this is the first context, set it as current
+    if (!config.get('current_context')) {
+        config.set('current_context', context.name);
+    }
+}
+export function updateContext(name, updates) {
+    const contexts = config.get('contexts');
+    if (!contexts[name]) {
+        throw new Error(`Context "${name}" does not exist`);
+    }
+    contexts[name] = { ...contexts[name], ...updates };
+    config.set('contexts', contexts);
+}
+export function deleteContext(name) {
+    const contexts = config.get('contexts');
+    if (!contexts[name]) {
+        throw new Error(`Context "${name}" does not exist`);
+    }
+    delete contexts[name];
+    config.set('contexts', contexts);
+    // If we deleted the current context, clear it
+    if (config.get('current_context') === name) {
+        const remaining = Object.keys(contexts);
+        config.set('current_context', remaining.length > 0 ? remaining[0] : null);
+    }
+}
+export function saveTokens(contextName, tokens) {
+    updateContext(contextName, {
+        tenant_id: tokens.tenant_id,
+        tokens,
+    });
+}
+export function getTokens(contextName) {
+    const context = getContext(contextName);
+    return context?.tokens || null;
+}
+export function clearTokens(contextName) {
+    updateContext(contextName, { tokens: undefined });
+}
+export function getBaseUrls(environment) {
+    return BASE_URLS[environment];
+}
+export { config };

package/dist/lib/openapi.d.ts

@@ -0,0 +1,82 @@
+export interface OpenApiParameter {
+    description?: string;
+    in: 'body' | 'header' | 'path' | 'query';
+    name: string;
+    required?: boolean;
+    schema?: {
+        default?: unknown;
+        enum?: string[];
+        example?: unknown;
+        items?: {
+            enum?: string[];
+            type?: string;
+        };
+        type?: string;
+    };
+}
+export interface OpenApiRequestBody {
+    content?: {
+        'application/json'?: {
+            schema?: {
+                $ref?: string;
+                properties?: Record<string, unknown>;
+                type?: string;
+            };
+        };
+    };
+    required?: boolean;
+}
+export interface OpenApiOperation {
+    description?: string;
+    operationId: string;
+    parameters?: OpenApiParameter[];
+    requestBody?: OpenApiRequestBody;
+    responses?: Record<string, {
+        content?: Record<string, {
+            schema?: Record<string, unknown>;
+        }>;
+        description?: string;
+    }>;
+    security?: Array<Record<string, unknown>>;
+    summary?: string;
+    tags?: string[];
+}
+export interface OpenApiPath {
+    delete?: OpenApiOperation;
+    get?: OpenApiOperation;
+    patch?: OpenApiOperation;
+    post?: OpenApiOperation;
+    put?: OpenApiOperation;
+}
+export interface OpenApiSpec {
+    components?: {
+        schemas?: Record<string, unknown>;
+    };
+    info: {
+        description?: string;
+        title: string;
+        version: string;
+    };
+    openapi: string;
+    paths: Record<string, OpenApiPath>;
+}
+export interface ParsedEndpoint {
+    description?: string;
+    hasRequestBody: boolean;
+    method: 'delete' | 'get' | 'patch' | 'post' | 'put';
+    operationId: string;
+    path: string;
+    pathParams: OpenApiParameter[];
+    queryParams: OpenApiParameter[];
+    requestBodyRequired: boolean;
+    requestBodySchema?: string;
+    summary: string;
+    tag: string;
+}
+export declare function loadOpenApiSpec(specPath: string): OpenApiSpec;
+export declare function parseEndpoints(spec: OpenApiSpec): ParsedEndpoint[];
+export declare function normalizeTag(tag: string): string;
+export declare function groupEndpointsByTag(endpoints: ParsedEndpoint[]): Map<string, ParsedEndpoint[]>;
+export declare function getCommandName(endpoint: ParsedEndpoint): string;
+export declare function generateFlagName(param: OpenApiParameter): string;
+export declare function getSchemaDefinition(spec: OpenApiSpec, schemaName: string): null | Record<string, unknown>;

package/dist/lib/openapi.js

@@ -0,0 +1,100 @@
+import * as fs from 'node:fs';
+export function loadOpenApiSpec(specPath) {
+    const content = fs.readFileSync(specPath, 'utf8');
+    return JSON.parse(content);
+}
+export function parseEndpoints(spec) {
+    const endpoints = [];
+    const methods = ['get', 'post', 'put', 'patch', 'delete'];
+    for (const [pathStr, pathObj] of Object.entries(spec.paths)) {
+        for (const method of methods) {
+            const operation = pathObj[method];
+            if (!operation)
+                continue;
+            const params = operation.parameters || [];
+            const pathParams = params.filter((p) => p.in === 'path');
+            const queryParams = params.filter((p) => p.in === 'query');
+            const hasRequestBody = Boolean(operation.requestBody?.content?.['application/json']);
+            const requestBodySchema = operation.requestBody?.content?.['application/json']?.schema?.$ref;
+            endpoints.push({
+                description: operation.description,
+                hasRequestBody,
+                method,
+                operationId: operation.operationId,
+                path: pathStr,
+                pathParams,
+                queryParams,
+                requestBodyRequired: Boolean(operation.requestBody?.required),
+                requestBodySchema: requestBodySchema?.replace('#/components/schemas/', ''),
+                summary: operation.summary || `${method.toUpperCase()} ${pathStr}`,
+                tag: normalizeTag(operation.tags?.[0] || 'misc'),
+            });
+        }
+    }
+    return endpoints;
+}
+export function normalizeTag(tag) {
+    return tag
+        .toLowerCase()
+        .replaceAll(/\s+/g, '-')
+        .replaceAll(/[^a-z0-9-]/g, '');
+}
+export function groupEndpointsByTag(endpoints) {
+    const groups = new Map();
+    for (const endpoint of endpoints) {
+        const existing = groups.get(endpoint.tag) || [];
+        existing.push(endpoint);
+        groups.set(endpoint.tag, existing);
+    }
+    return groups;
+}
+export function getCommandName(endpoint) {
+    // Extract action from operationId like "AccountsController_findAll_v1" -> "list"
+    // or "AccountsController_create_v1" -> "create"
+    const { operationId } = endpoint;
+    // Common mappings
+    const actionMap = {
+        approve: 'approve',
+        cancel: 'cancel',
+        copy: 'copy',
+        create: 'create',
+        delete: 'delete',
+        findAll: 'list',
+        findOne: 'get',
+        import: 'import',
+        pay: 'pay',
+        post: 'post',
+        remove: 'delete',
+        replace: 'replace',
+        resend: 'resend',
+        send: 'send',
+        update: 'update',
+        validate: 'validate',
+    };
+    for (const [key, value] of Object.entries(actionMap)) {
+        if (operationId.toLowerCase().includes(key.toLowerCase())) {
+            return value;
+        }
+    }
+    // Fallback: use method
+    const methodMap = {
+        delete: 'delete',
+        get: 'get',
+        patch: 'update',
+        post: 'create',
+        put: 'update',
+    };
+    return methodMap[endpoint.method] || endpoint.method;
+}
+export function generateFlagName(param) {
+    // Convert parameter name to kebab-case flag
+    return param.name
+        .replaceAll('.', '-')
+        .replaceAll(/([A-Z])/g, '-$1')
+        .toLowerCase()
+        .replace(/^-/, '')
+        .replaceAll(/--+/g, '-');
+}
+export function getSchemaDefinition(spec, schemaName) {
+    return spec.components?.schemas?.[schemaName] || null;
+}