@aderis-erp/cli 1.0.2 → 1.0.3

package/dist/commands/bank-integrations.js

@@ -834,32 +834,44 @@ export default class BankIntegrations extends Command {
     filterFields(data, fields) {
         const isUnsafeKey = (k) => k === '__proto__' || k === 'constructor' || k === 'prototype';
         const pick = (obj, keys) => {
-            const result = {};
+            // Group keys by their first segment so sibling sub-paths
+            // (e.g. 'items.amount' + 'items._type') resolve in one recursive pass
+            // and don't clobber each other on merge.
+            const directKeys = new Set();
+            const nestedKeys = new Map();
             for (const key of keys) {
                 if (key.split('.').some(isUnsafeKey))
                     continue;
                 if (key.includes('.')) {
-                    // Handle nested fields like 'customer.name' or 'allocations.salesInvoiceId'
                     const [first, ...rest] = key.split('.');
-                    const val = obj[first];
-                    if (val && typeof val === 'object') {
-                        const restKey = rest.join('.');
-                        if (Array.isArray(val)) {
-                            // Map over array elements (e.g., allocations[].salesInvoiceId)
-                            const existing = Array.isArray(result[first]) ? result[first] : [];
-                            result[first] = val.map((item, i) => ({
-                                ...(existing[i] || {}),
-                                ...pick(item, [restKey]),
-                            }));
-                        }
-                        else {
-                            const nested = pick(val, [restKey]);
-                            result[first] = { ...(result[first] || {}), ...nested };
-                        }
+                    if (isUnsafeKey(first))
+                        continue;
+                    const list = nestedKeys.get(first);
+                    if (list) {
+                        list.push(rest.join('.'));
                     }
+                    else {
+                        nestedKeys.set(first, [rest.join('.')]);
+                    }
+                }
+                else {
+                    directKeys.add(key);
                 }
-                else if (key in obj) {
+            }
+            const result = {};
+            for (const key of directKeys) {
+                if (key in obj)
                     result[key] = obj[key];
+            }
+            for (const [first, restKeys] of nestedKeys) {
+                const val = obj[first];
+                if (!val || typeof val !== 'object')
+                    continue;
+                if (Array.isArray(val)) {
+                    result[first] = val.map(item => pick(item, restKeys));
+                }
+                else {
+                    result[first] = pick(val, restKeys);
                 }
             }
             return result;

package/dist/commands/business-partners---contacts.js

@@ -819,32 +819,44 @@ export default class BusinessPartnersContacts extends Command {
     filterFields(data, fields) {
         const isUnsafeKey = (k) => k === '__proto__' || k === 'constructor' || k === 'prototype';
         const pick = (obj, keys) => {
-            const result = {};
+            // Group keys by their first segment so sibling sub-paths
+            // (e.g. 'items.amount' + 'items._type') resolve in one recursive pass
+            // and don't clobber each other on merge.
+            const directKeys = new Set();
+            const nestedKeys = new Map();
             for (const key of keys) {
                 if (key.split('.').some(isUnsafeKey))
                     continue;
                 if (key.includes('.')) {
-                    // Handle nested fields like 'customer.name' or 'allocations.salesInvoiceId'
                     const [first, ...rest] = key.split('.');
-                    const val = obj[first];
-                    if (val && typeof val === 'object') {
-                        const restKey = rest.join('.');
-                        if (Array.isArray(val)) {
-                            // Map over array elements (e.g., allocations[].salesInvoiceId)
-                            const existing = Array.isArray(result[first]) ? result[first] : [];
-                            result[first] = val.map((item, i) => ({
-                                ...(existing[i] || {}),
-                                ...pick(item, [restKey]),
-                            }));
-                        }
-                        else {
-                            const nested = pick(val, [restKey]);
-                            result[first] = { ...(result[first] || {}), ...nested };
-                        }
+                    if (isUnsafeKey(first))
+                        continue;
+                    const list = nestedKeys.get(first);
+                    if (list) {
+                        list.push(rest.join('.'));
                     }
+                    else {
+                        nestedKeys.set(first, [rest.join('.')]);
+                    }
+                }
+                else {
+                    directKeys.add(key);
                 }
-                else if (key in obj) {
+            }
+            const result = {};
+            for (const key of directKeys) {
+                if (key in obj)
                     result[key] = obj[key];
+            }
+            for (const [first, restKeys] of nestedKeys) {
+                const val = obj[first];
+                if (!val || typeof val !== 'object')
+                    continue;
+                if (Array.isArray(val)) {
+                    result[first] = val.map(item => pick(item, restKeys));
+                }
+                else {
+                    result[first] = pick(val, restKeys);
                 }
             }
             return result;

package/dist/commands/business-partners.js

@@ -825,32 +825,44 @@ export default class BusinessPartners extends Command {
     filterFields(data, fields) {
         const isUnsafeKey = (k) => k === '__proto__' || k === 'constructor' || k === 'prototype';
         const pick = (obj, keys) => {
-            const result = {};
+            // Group keys by their first segment so sibling sub-paths
+            // (e.g. 'items.amount' + 'items._type') resolve in one recursive pass
+            // and don't clobber each other on merge.
+            const directKeys = new Set();
+            const nestedKeys = new Map();
             for (const key of keys) {
                 if (key.split('.').some(isUnsafeKey))
                     continue;
                 if (key.includes('.')) {
-                    // Handle nested fields like 'customer.name' or 'allocations.salesInvoiceId'
                     const [first, ...rest] = key.split('.');
-                    const val = obj[first];
-                    if (val && typeof val === 'object') {
-                        const restKey = rest.join('.');
-                        if (Array.isArray(val)) {
-                            // Map over array elements (e.g., allocations[].salesInvoiceId)
-                            const existing = Array.isArray(result[first]) ? result[first] : [];
-                            result[first] = val.map((item, i) => ({
-                                ...(existing[i] || {}),
-                                ...pick(item, [restKey]),
-                            }));
-                        }
-                        else {
-                            const nested = pick(val, [restKey]);
-                            result[first] = { ...(result[first] || {}), ...nested };
-                        }
+                    if (isUnsafeKey(first))
+                        continue;
+                    const list = nestedKeys.get(first);
+                    if (list) {
+                        list.push(rest.join('.'));
                     }
+                    else {
+                        nestedKeys.set(first, [rest.join('.')]);
+                    }
+                }
+                else {
+                    directKeys.add(key);
                 }
-                else if (key in obj) {
+            }
+            const result = {};
+            for (const key of directKeys) {
+                if (key in obj)
                     result[key] = obj[key];
+            }
+            for (const [first, restKeys] of nestedKeys) {
+                const val = obj[first];
+                if (!val || typeof val !== 'object')
+                    continue;
+                if (Array.isArray(val)) {
+                    result[first] = val.map(item => pick(item, restKeys));
+                }
+                else {
+                    result[first] = pick(val, restKeys);
                 }
             }
             return result;

package/dist/commands/config/add.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class ConfigAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'client-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'client-secret': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/add.js

@@ -0,0 +1,120 @@
+import { confirm, input, select } from '@inquirer/prompts';
+import { Command, Flags } from '@oclif/core';
+import { addContext, DEFAULT_CLIENT_IDS, getContext } from '../../lib/config.js';
+export default class ConfigAdd extends Command {
+    static description = 'Add a new context configuration';
+    static examples = [
+        '<%= config.bin %> config add',
+        '<%= config.bin %> config add --name my-client --environment live',
+        '<%= config.bin %> config add --name dev-context --environment dev --client-id abc123',
+    ];
+    static flags = {
+        'client-id': Flags.string({
+            description: 'OAuth client ID (uses default if not specified)',
+        }),
+        'client-secret': Flags.string({
+            description: 'OAuth client secret (optional, for confidential clients)',
+        }),
+        environment: Flags.string({
+            char: 'e',
+            description: 'Environment (dev, test, live)',
+            options: ['dev', 'test', 'live'],
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Overwrite existing context without prompting',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Context name',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ConfigAdd);
+        // Get context name
+        let { name } = flags;
+        if (!name) {
+            name = await input({
+                message: 'Context name:',
+                validate(value) {
+                    if (!value.trim())
+                        return 'Context name is required';
+                    if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+                        return 'Context name can only contain letters, numbers, hyphens, and underscores';
+                    }
+                    return true;
+                },
+            });
+        }
+        // Check if context already exists
+        const existing = getContext(name);
+        if (existing && !flags.force) {
+            const overwrite = await confirm({
+                default: false,
+                message: `Context "${name}" already exists. Overwrite?`,
+            });
+            if (!overwrite) {
+                this.log('Aborted.');
+                return;
+            }
+        }
+        // Get environment
+        let environment = flags.environment;
+        if (!environment) {
+            environment = (await select({
+                choices: [
+                    { name: 'live (production)', value: 'live' },
+                    { name: 'test (staging)', value: 'test' },
+                    { name: 'dev (development)', value: 'dev' },
+                ],
+                message: 'Environment:',
+            }));
+        }
+        // Get client ID
+        let clientId = flags['client-id'];
+        if (!clientId) {
+            const defaultClientId = DEFAULT_CLIENT_IDS[environment];
+            if (defaultClientId) {
+                const useDefault = await confirm({
+                    default: true,
+                    message: `Use default client ID for ${environment}?`,
+                });
+                if (useDefault) {
+                    clientId = defaultClientId;
+                }
+            }
+            if (!clientId) {
+                clientId = await input({
+                    message: 'OAuth client ID:',
+                    validate: (value) => (value.trim() ? true : 'Client ID is required'),
+                });
+            }
+        }
+        // Get client secret (optional)
+        let clientSecret = flags['client-secret'];
+        if (!clientSecret && !flags.name) {
+            // Only prompt for secret in interactive mode
+            const hasSecret = await confirm({
+                default: false,
+                message: 'Do you have a client secret? (for confidential clients)',
+            });
+            if (hasSecret) {
+                clientSecret = await input({
+                    message: 'OAuth client secret:',
+                });
+            }
+        }
+        // Create the context
+        addContext({
+            client_id: clientId,
+            client_secret: clientSecret,
+            environment,
+            name,
+        });
+        this.log(`\nContext "${name}" created successfully.`);
+        this.log(`Environment: ${environment}`);
+        this.log(`Client ID: ${clientId}`);
+        this.log(`\nTo authenticate, run: aderis auth login`);
+    }
+}

package/dist/commands/config/current.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ConfigCurrent extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/current.js

@@ -0,0 +1,43 @@
+import { Command, Flags } from '@oclif/core';
+import { getCurrentContext } from '../../lib/config.js';
+export default class ConfigCurrent extends Command {
+    static description = 'Show the current context';
+    static examples = ['<%= config.bin %> config current', '<%= config.bin %> config current --json'];
+    static flags = {
+        json: Flags.boolean({
+            default: false,
+            description: 'Output as JSON',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ConfigCurrent);
+        const context = getCurrentContext();
+        if (!context) {
+            if (flags.json) {
+                this.log(JSON.stringify({ current: null }, null, 2));
+            }
+            else {
+                this.log('No current context configured.');
+                this.log('Create one with: aderis auth login --new');
+            }
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({
+                authenticated: Boolean(context.tokens),
+                client_id: context.client_id,
+                environment: context.environment,
+                name: context.name,
+                tenant_id: context.tenant_id,
+            }, null, 2));
+            return;
+        }
+        this.log(`Current context: ${context.name}`);
+        this.log(`Environment: ${context.environment}`);
+        this.log(`Client ID: ${context.client_id}`);
+        if (context.tenant_id) {
+            this.log(`Tenant ID: ${context.tenant_id}`);
+        }
+        this.log(`Authenticated: ${context.tokens ? 'Yes' : 'No'}`);
+    }
+}

package/dist/commands/config/delete.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class ConfigDelete extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/delete.js

@@ -0,0 +1,67 @@
+import { confirm, select } from '@inquirer/prompts';
+import { Args, Command, Flags } from '@oclif/core';
+import { deleteContext, getContext, getCurrentContext, listContexts } from '../../lib/config.js';
+export default class ConfigDelete extends Command {
+    static args = {
+        name: Args.string({
+            description: 'Context name to delete',
+            required: false,
+        }),
+    };
+    static description = 'Delete a configured context';
+    static examples = [
+        '<%= config.bin %> config delete my-client',
+        '<%= config.bin %> config delete my-client --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ConfigDelete);
+        let contextName = args.name;
+        if (!contextName) {
+            const contexts = listContexts();
+            if (contexts.length === 0) {
+                this.error('No contexts configured.');
+            }
+            contextName = await select({
+                choices: contexts.map((c) => ({
+                    name: `${c.name} (${c.environment})`,
+                    value: c.name,
+                })),
+                message: 'Select a context to delete:',
+            });
+        }
+        const context = getContext(contextName);
+        if (!context) {
+            this.error(`Context "${contextName}" not found.`);
+        }
+        const current = getCurrentContext();
+        const isCurrent = current?.name === contextName;
+        if (!flags.force) {
+            const confirmed = await confirm({
+                default: false,
+                message: `Are you sure you want to delete context "${contextName}"?${isCurrent ? ' (This is your current context)' : ''}`,
+            });
+            if (!confirmed) {
+                this.log('Cancelled.');
+                return;
+            }
+        }
+        deleteContext(contextName);
+        this.log(`Context "${contextName}" deleted.`);
+        if (isCurrent) {
+            const newCurrent = getCurrentContext();
+            if (newCurrent) {
+                this.log(`Switched to context "${newCurrent.name}"`);
+            }
+            else {
+                this.log('\nNo contexts remaining. Create one with: aderis auth login --new');
+            }
+        }
+    }
+}

package/dist/commands/config/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ConfigList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/list.js

@@ -0,0 +1,50 @@
+import { Command, Flags } from '@oclif/core';
+import { getCurrentContext, listContexts } from '../../lib/config.js';
+export default class ConfigList extends Command {
+    static description = 'List all configured contexts';
+    static examples = ['<%= config.bin %> config list', '<%= config.bin %> config list --json'];
+    static flags = {
+        json: Flags.boolean({
+            default: false,
+            description: 'Output as JSON',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ConfigList);
+        const contexts = listContexts();
+        const current = getCurrentContext();
+        if (flags.json) {
+            this.log(JSON.stringify({
+                contexts: contexts.map((c) => ({
+                    authenticated: Boolean(c.tokens),
+                    client_id: c.client_id,
+                    environment: c.environment,
+                    name: c.name,
+                    tenant_id: c.tenant_id,
+                })),
+                current: current?.name || null,
+            }, null, 2));
+            return;
+        }
+        if (contexts.length === 0) {
+            this.log('No contexts configured.');
+            this.log('\nCreate a new context with: aderis auth login --new');
+            return;
+        }
+        this.log('Configured contexts:\n');
+        for (const ctx of contexts) {
+            const isCurrent = current?.name === ctx.name;
+            const marker = isCurrent ? '*' : ' ';
+            const auth = ctx.tokens ? '✓' : '✗';
+            this.log(`${marker} ${ctx.name}`);
+            this.log(`    Environment: ${ctx.environment}`);
+            this.log(`    Client ID: ${ctx.client_id}`);
+            this.log(`    Authenticated: ${auth}`);
+            if (ctx.tenant_id) {
+                this.log(`    Tenant ID: ${ctx.tenant_id}`);
+            }
+            this.log('');
+        }
+        this.log('* = current context');
+    }
+}

package/dist/commands/config/use.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ConfigUse extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/use.js

@@ -0,0 +1,40 @@
+import { select } from '@inquirer/prompts';
+import { Args, Command } from '@oclif/core';
+import { getContext, listContexts, setCurrentContext } from '../../lib/config.js';
+export default class ConfigUse extends Command {
+    static args = {
+        name: Args.string({
+            description: 'Context name to switch to',
+            required: false,
+        }),
+    };
+    static description = 'Switch to a different context';
+    static examples = ['<%= config.bin %> config use my-client', '<%= config.bin %> config use'];
+    async run() {
+        const { args } = await this.parse(ConfigUse);
+        let contextName = args.name;
+        if (!contextName) {
+            const contexts = listContexts();
+            if (contexts.length === 0) {
+                this.error('No contexts configured. Create one with: aderis auth login --new');
+            }
+            contextName = await select({
+                choices: contexts.map((c) => ({
+                    name: `${c.name} (${c.environment})${c.tokens ? ' ✓' : ''}`,
+                    value: c.name,
+                })),
+                message: 'Select a context:',
+            });
+        }
+        const context = getContext(contextName);
+        if (!context) {
+            this.error(`Context "${contextName}" not found.`);
+        }
+        setCurrentContext(contextName);
+        this.log(`Switched to context "${contextName}" (${context.environment})`);
+        if (!context.tokens) {
+            this.log(`\nNote: You are not logged in to this context.`);
+            this.log(`Run: aderis auth login`);
+        }
+    }
+}

package/dist/commands/credit-card-accounts.js

@@ -831,32 +831,44 @@ export default class CreditCardAccounts extends Command {
     filterFields(data, fields) {
         const isUnsafeKey = (k) => k === '__proto__' || k === 'constructor' || k === 'prototype';
         const pick = (obj, keys) => {
-            const result = {};
+            // Group keys by their first segment so sibling sub-paths
+            // (e.g. 'items.amount' + 'items._type') resolve in one recursive pass
+            // and don't clobber each other on merge.
+            const directKeys = new Set();
+            const nestedKeys = new Map();
             for (const key of keys) {
                 if (key.split('.').some(isUnsafeKey))
                     continue;
                 if (key.includes('.')) {
-                    // Handle nested fields like 'customer.name' or 'allocations.salesInvoiceId'
                     const [first, ...rest] = key.split('.');
-                    const val = obj[first];
-                    if (val && typeof val === 'object') {
-                        const restKey = rest.join('.');
-                        if (Array.isArray(val)) {
-                            // Map over array elements (e.g., allocations[].salesInvoiceId)
-                            const existing = Array.isArray(result[first]) ? result[first] : [];
-                            result[first] = val.map((item, i) => ({
-                                ...(existing[i] || {}),
-                                ...pick(item, [restKey]),
-                            }));
-                        }
-                        else {
-                            const nested = pick(val, [restKey]);
-                            result[first] = { ...(result[first] || {}), ...nested };
-                        }
+                    if (isUnsafeKey(first))
+                        continue;
+                    const list = nestedKeys.get(first);
+                    if (list) {
+                        list.push(rest.join('.'));
                     }
+                    else {
+                        nestedKeys.set(first, [rest.join('.')]);
+                    }
+                }
+                else {
+                    directKeys.add(key);
                 }
-                else if (key in obj) {
+            }
+            const result = {};
+            for (const key of directKeys) {
+                if (key in obj)
                     result[key] = obj[key];
+            }
+            for (const [first, restKeys] of nestedKeys) {
+                const val = obj[first];
+                if (!val || typeof val !== 'object')
+                    continue;
+                if (Array.isArray(val)) {
+                    result[first] = val.map(item => pick(item, restKeys));
+                }
+                else {
+                    result[first] = pick(val, restKeys);
                 }
             }
             return result;