@aderis-erp/cli 1.0.1 → 1.0.3

package/dist/commands/salary-types.js

@@ -819,32 +819,44 @@ export default class SalaryTypes 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/sales-invoices.js

@@ -6,7 +6,7 @@ const HAS_IMPORT = true;
 const HAS_EXPORT = true;
 const HAS_CAMT053 = false;
 const NESTED_IMPORTS = ["line-items", "notes", "files"];
-const SUBCOMMANDS = [...["list", "create", "create-migrated-invoice", "pdf", "get", "update", "delete", "approve", "validate", "request-approval", "send", "send-resend", "cancel", "copy", "replace", "create-line-items", "update-line-items", "delete-line-items", "list-notes", "create-notes", "get-notes", "update-notes", "delete-notes", "list-files", "create-files", "get-files", "update-files", "delete-files", "files-download"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
+const SUBCOMMANDS = [...["list", "create", "create-migrated-invoice", "pdf", "get", "update", "delete", "approve", "validate", "request-approval", "send", "send-resend", "cancel", "copy", "replace", "create-line-items", "update-line-items-reorder", "update-line-items", "delete-line-items", "list-notes", "create-notes", "get-notes", "update-notes", "delete-notes", "list-files", "create-files", "get-files", "update-files", "delete-files", "files-download"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
 const ENDPOINTS = {
     'list': { method: 'GET', path: '/v1/sales-invoices', summary: 'Get all sales invoices with pagination', pathParams: [], hasBody: false, isMultipart: false },
     'create': { method: 'POST', path: '/v1/sales-invoices', summary: 'Create a new sales invoice', pathParams: [], hasBody: true, isMultipart: false },
@@ -24,6 +24,7 @@ const ENDPOINTS = {
     'copy': { method: 'POST', path: '/v1/sales-invoices/{id}/copy', summary: 'Create a copy of a cancelled invoice', pathParams: ['id'], hasBody: false, isMultipart: false },
     'replace': { method: 'POST', path: '/v1/sales-invoices/{id}/replace', summary: 'Replace invoice with corrected version (creates new CORRECTED_INVOICE)', pathParams: ['id'], hasBody: false, isMultipart: false },
     'create-line-items': { method: 'POST', path: '/v1/sales-invoices/{invoiceId}/line-items', summary: 'Add a line item to a sales invoice', pathParams: ['invoiceId'], hasBody: true, isMultipart: false },
+    'update-line-items-reorder': { method: 'PATCH', path: '/v1/sales-invoices/{invoiceId}/line-items/reorder', summary: 'Bulk reorder line items (drag-and-drop)', pathParams: ['invoiceId'], hasBody: true, isMultipart: false },
     'update-line-items': { method: 'PATCH', path: '/v1/sales-invoices/{invoiceId}/line-items/{lineItemId}', summary: 'Update a line item on a sales invoice', pathParams: ['invoiceId', 'lineItemId'], hasBody: true, isMultipart: false },
     'delete-line-items': { method: 'DELETE', path: '/v1/sales-invoices/{invoiceId}/line-items/{lineItemId}', summary: 'Remove a line item from a sales invoice', pathParams: ['invoiceId', 'lineItemId'], hasBody: false, isMultipart: false },
     'list-notes': { method: 'GET', path: '/v1/sales-invoices/{salesInvoiceId}/notes', summary: 'Get all notes for a sales invoice', pathParams: ['salesInvoiceId'], hasBody: false, isMultipart: false },
@@ -846,32 +847,44 @@ export default class SalesInvoices 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/sales-orders.js

@@ -6,13 +6,14 @@ const HAS_IMPORT = true;
 const HAS_EXPORT = true;
 const HAS_CAMT053 = false;
 const NESTED_IMPORTS = ["line-items", "notes", "files"];
-const SUBCOMMANDS = [...["list", "create", "get", "update", "delete", "submit", "approve", "accept", "terminate", "cancel", "replace", "create-invoice", "create-line-items", "update-line-items", "delete-line-items", "list-notes", "create-notes", "get-notes", "update-notes", "delete-notes", "list-files", "create-files", "get-files", "update-files", "delete-files", "files-download"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
+const SUBCOMMANDS = [...["list", "create", "get", "update", "delete", "pdf", "submit", "approve", "accept", "terminate", "cancel", "replace", "create-invoice", "create-line-items", "update-line-items-reorder", "update-line-items", "delete-line-items", "list-notes", "create-notes", "get-notes", "update-notes", "delete-notes", "list-files", "create-files", "get-files", "update-files", "delete-files", "files-download"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
 const ENDPOINTS = {
     'list': { method: 'GET', path: '/v1/sales-orders', summary: 'Get all sales orders with pagination', pathParams: [], hasBody: false, isMultipart: false },
     'create': { method: 'POST', path: '/v1/sales-orders', summary: 'Create a new sales order', pathParams: [], hasBody: true, isMultipart: false },
     'get': { method: 'GET', path: '/v1/sales-orders/{id}', summary: 'Get a sales order by ID', pathParams: ['id'], hasBody: false, isMultipart: false },
     'update': { method: 'PATCH', path: '/v1/sales-orders/{id}', summary: 'Update a sales order', pathParams: ['id'], hasBody: true, isMultipart: false },
     'delete': { method: 'DELETE', path: '/v1/sales-orders/{id}', summary: 'Delete a sales order', pathParams: ['id'], hasBody: false, isMultipart: false },
+    'pdf': { method: 'GET', path: '/v1/sales-orders/{id}/pdf', summary: 'Generate a PDF preview (delivery slip) of a sales order', pathParams: ['id'], hasBody: false, isMultipart: false },
     'submit': { method: 'POST', path: '/v1/sales-orders/{id}/submit', summary: 'Submit order for approval (DRAFT → PENDING_APPROVAL)', pathParams: ['id'], hasBody: false, isMultipart: false },
     'approve': { method: 'POST', path: '/v1/sales-orders/{id}/approve', summary: 'Approve order (PENDING_APPROVAL → APPROVED). Generates order number.', pathParams: ['id'], hasBody: false, isMultipart: false },
     'accept': { method: 'POST', path: '/v1/sales-orders/{id}/accept', summary: 'Accept order (APPROVED → ACCEPTED). Adjusts billing start date.', pathParams: ['id'], hasBody: false, isMultipart: false },
@@ -21,6 +22,7 @@ const ENDPOINTS = {
     'replace': { method: 'POST', path: '/v1/sales-orders/{id}/replace', summary: 'Replace order with corrected version (APPROVED → creates new DRAFT)', pathParams: ['id'], hasBody: false, isMultipart: false },
     'create-invoice': { method: 'POST', path: '/v1/sales-orders/{id}/create-invoice', summary: 'Create invoice from sales order (ACCEPTED → creates DRAFT invoice)', pathParams: ['id'], hasBody: false, isMultipart: false },
     'create-line-items': { method: 'POST', path: '/v1/sales-orders/{orderId}/line-items', summary: 'Add a line item to a sales order', pathParams: ['orderId'], hasBody: true, isMultipart: false },
+    'update-line-items-reorder': { method: 'PATCH', path: '/v1/sales-orders/{orderId}/line-items/reorder', summary: 'Bulk reorder line items (drag-and-drop)', pathParams: ['orderId'], hasBody: true, isMultipart: false },
     'update-line-items': { method: 'PATCH', path: '/v1/sales-orders/{orderId}/line-items/{lineItemId}', summary: 'Update a line item on a sales order', pathParams: ['orderId', 'lineItemId'], hasBody: true, isMultipart: false },
     'delete-line-items': { method: 'DELETE', path: '/v1/sales-orders/{orderId}/line-items/{lineItemId}', summary: 'Remove a line item from a sales order', pathParams: ['orderId', 'lineItemId'], hasBody: false, isMultipart: false },
     'list-notes': { method: 'GET', path: '/v1/sales-orders/{salesOrderId}/notes', summary: 'Get all notes for a sales order', pathParams: ['salesOrderId'], hasBody: false, isMultipart: false },
@@ -843,32 +845,44 @@ export default class SalesOrders 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/switch.d.ts

@@ -3,4 +3,5 @@ export default class Switch extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    private handleSessionExpired;
 }

package/dist/commands/switch.js

@@ -1,6 +1,7 @@
-import { select } from '@inquirer/prompts';
+import { confirm, select } from '@inquirer/prompts';
 import { Command } from '@oclif/core';
-import { getCurrentContext, listContexts, setCurrentContext } from '../lib/config.js';
+import { loginAndSwitchTenant } from '../lib/auth.js';
+import { getContext, getCurrentContext, listContexts, setCurrentContext } from '../lib/config.js';
 export default class Switch extends Command {
     static description = 'Switch context and tenant interactively';
     static examples = ['<%= config.bin %> switch'];
@@ -34,8 +35,62 @@ export default class Switch extends Command {
             setCurrentContext(selectedContext);
             this.log(`Switched to context: ${selectedContext}`);
         }
-        // Step 2: Select tenant within chosen context
+        // Step 2: Select tenant within chosen context.
+        // If the session is expired, prompt the user to re-login and then retry.
         const { default: AuthTenant } = await import('./auth/tenant.js');
+        try {
+            await AuthTenant.run([`--context=${selectedContext}`]);
+        }
+        catch (error) {
+            if (!isSessionExpired(error))
+                throw error;
+            await this.handleSessionExpired(selectedContext);
+        }
+    }
+    async handleSessionExpired(selectedContext) {
+        const shouldLogin = await confirm({
+            default: true,
+            message: 'Session expired. Do you want to login again?',
+        });
+        if (!shouldLogin)
+            return;
+        // If we have a cached tenant list from a previous session, let the user pick
+        // tenant FIRST. Then run the combined login + tenant-switch flow which uses
+        // a single browser tab (chained PKCE rounds with a meta-refresh redirect).
+        const ctx = getContext(selectedContext);
+        const cached = ctx?.cachedTenants ?? [];
+        if (cached.length > 1) {
+            const sorted = [...cached].sort((a, b) => {
+                if (a.tenantId === ctx?.tenant_id)
+                    return -1;
+                if (b.tenantId === ctx?.tenant_id)
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            const selectedTenant = await select({
+                choices: sorted.map((t) => ({
+                    name: t.tenantId === ctx?.tenant_id ? `${t.name}  (previous)` : t.name,
+                    value: t.tenantId,
+                })),
+                message: 'Select a tenant:',
+            });
+            const selectedName = cached.find((t) => t.tenantId === selectedTenant)?.name;
+            this.log(`Logging in and switching to ${selectedName ?? selectedTenant}…`);
+            if (ctx) {
+                await loginAndSwitchTenant(ctx, selectedTenant);
+            }
+            this.log(`Successfully switched to tenant ${selectedName ? `${selectedName} (${selectedTenant})` : selectedTenant}`);
+            return;
+        }
+        // No cached tenant list (or only one tenant) — fall back to the two-step
+        // flow: login first, then run the normal tenant selector.
+        const { default: AuthLogin } = await import('./auth/login.js');
+        const { default: AuthTenant } = await import('./auth/tenant.js');
+        await AuthLogin.run([`--context=${selectedContext}`]);
         await AuthTenant.run([`--context=${selectedContext}`]);
     }
 }
+function isSessionExpired(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /session expired/i.test(message) || /not logged in/i.test(message);
+}

package/dist/commands/tags.js

@@ -819,32 +819,44 @@ export default class Tags 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/tax-codes.js

@@ -822,32 +822,44 @@ export default class TaxCodes 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/tax-matrix.js

@@ -819,32 +819,44 @@ export default class TaxMatrix 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/tenants.js

@@ -819,32 +819,44 @@ export default class Tenants 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/text-templates.js

@@ -819,32 +819,44 @@ export default class TextTemplates 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;