@aderis-erp/cli 1.0.2 → 1.0.3

package/dist/commands/price-lists.js

@@ -825,32 +825,44 @@ export default class PriceLists 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/processor-mappings.js

@@ -817,32 +817,44 @@ export default class ProcessorMappings 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/processors.js

@@ -9,7 +9,7 @@ const NESTED_IMPORTS = [];
 const SUBCOMMANDS = [...["list-tools", "list", "create", "resolve", "resolve-event", "get", "update", "delete", "template"], ...(HAS_IMPORT ? ['import'] : []), ...(HAS_EXPORT ? ['export'] : []), ...NESTED_IMPORTS.map(n => `import-${n}`)];
 const ENDPOINTS = {
     'list-tools': { method: 'GET', path: '/v1/processors/tools', summary: 'List all available tools', pathParams: [], hasBody: false, isMultipart: false },
-    'list': { method: 'GET', path: '/v1/processors', summary: 'List all processors (tenant and system)', pathParams: [], hasBody: false, isMultipart: false },
+    'list': { method: 'GET', path: '/v1/processors', summary: 'List processors available to the tenant', pathParams: [], hasBody: false, isMultipart: false },
     'create': { method: 'POST', path: '/v1/processors', summary: 'Create a new tenant-scoped processor', pathParams: [], hasBody: true, isMultipart: false },
     'resolve': { method: 'GET', path: '/v1/processors/resolve/{documentType}', summary: 'Resolve processor for a document type', pathParams: ['documentType'], hasBody: false, isMultipart: false },
     'resolve-event': { method: 'GET', path: '/v1/processors/resolve/event/{eventType}', summary: 'Resolve processors for an event type', pathParams: ['eventType'], hasBody: false, isMultipart: false },
@@ -823,32 +823,44 @@ export default class Processors 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/reconciliation.js

@@ -816,32 +816,44 @@ export default class Reconciliation 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/reports.js

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