bways-report 0.1.8 → 0.2.0

package/esm2022/lib/core/config/bways-report-config.mjs

@@ -1,11 +1,4 @@
-/**
- * Simplified configuration for bways-report.
- *
- * This is the developer-facing config object that makes integration
- * as simple as 3–4 endpoint URLs + optional overrides.
- * The normalizer converts this into the internal `ReportingConfig`
- * plus adapter wiring decisions.
- */
+import { resolveReportsEndpoint } from '../utils/report-endpoint.util';
 /**
  * Mapping from friendly palette category names to internal category IDs.
  */
@@ -18,22 +11,29 @@ export const PALETTE_CATEGORY_MAP = {
 };
 /**
  * Normalizes a `BwaysReportConfig` into the internal format.
- * Validates required fields and maps friendly names to internal IDs.
+ * Validates supplied endpoints and maps friendly names to internal IDs.
  */
 export function normalizeBwaysConfig(config) {
-    // Validate required endpoints
-    if (!config.spEndpoint || typeof config.spEndpoint !== 'string' || config.spEndpoint.trim() === '') {
-        throw new Error(`[bways-report] "spEndpoint" is required in BwaysReportConfig. ` +
-            `Please provide the URL for fetching stored procedures, e.g. '/api/reporting/procedures'.`);
+    // Capabilities are optional; validate only URLs the host supplies.
+    for (const key of ['spEndpoint', 'tablesEndpoint', 'executeEndpoint', 'lookupEndpoint', 'reportsEndpoint', 'apisEndpoint']) {
+        if (config[key] !== undefined && (typeof config[key] !== 'string' || !config[key]?.trim())) {
+            throw new Error('[bways-report] "' + key + '" must be a non-empty URL when supplied.');
+        }
     }
-    if (!config.tablesEndpoint || typeof config.tablesEndpoint !== 'string' || config.tablesEndpoint.trim() === '') {
-        throw new Error(`[bways-report] "tablesEndpoint" is required in BwaysReportConfig. ` +
-            `Please provide the URL for fetching tables/views, e.g. '/api/reporting/tables'.`);
-    }
-    if (!config.executeEndpoint || typeof config.executeEndpoint !== 'string' || config.executeEndpoint.trim() === '') {
-        throw new Error(`[bways-report] "executeEndpoint" is required in BwaysReportConfig. ` +
-            `Please provide the URL for executing queries, e.g. '/api/reporting/execute'.`);
+    for (const key of ['lookupTimeoutMs', 'executionTimeoutMs']) {
+        if (config[key] !== undefined && (!Number.isFinite(config[key]) || config[key] <= 0))
+            throw new Error(key + ' must be a positive timeout.');
     }
+    if (config.trustedApiOrigins !== undefined && (!Array.isArray(config.trustedApiOrigins) || config.trustedApiOrigins.some(origin => {
+        try {
+            const parsed = new URL(origin);
+            return !/^https?:$/.test(parsed.protocol) || parsed.origin !== origin || !!parsed.username || !!parsed.password;
+        }
+        catch {
+            return true;
+        }
+    })))
+        throw new Error('trustedApiOrigins must contain exact HTTP(S) origins, without paths or credentials.');
     // Map component palette categories
     let allowedCategories = null;
     if (config.components && config.components.length > 0) {
@@ -47,23 +47,20 @@ export function normalizeBwaysConfig(config) {
             return internal;
         });
     }
-    // Warn if reportsEndpoint is missing
-    const reportsEndpoint = config.reportsEndpoint?.trim() || null;
-    if (!reportsEndpoint) {
-        console.warn(`[bways-report] No "reportsEndpoint" provided. Reports will be saved to browser localStorage. ` +
-            `For shared report menus across users, provide a reportsEndpoint, e.g. '/api/reporting/reports'.`);
-    }
+    const reportsEndpoint = resolveReportsEndpoint(config);
     const lookupEndpoint = config.lookupEndpoint?.trim()
         ? cleanUrl(config.lookupEndpoint)
-        : config.executeEndpoint.includes('/execute')
+        : config.executeEndpoint?.includes('/execute')
             ? cleanUrl(config.executeEndpoint.replace(/\/execute\/?$/, '/lookup'))
             : null;
     return {
-        spEndpoint: cleanUrl(config.spEndpoint),
-        tablesEndpoint: cleanUrl(config.tablesEndpoint),
-        executeEndpoint: cleanUrl(config.executeEndpoint),
+        spEndpoint: config.spEndpoint ? cleanUrl(config.spEndpoint) : '',
+        tablesEndpoint: config.tablesEndpoint ? cleanUrl(config.tablesEndpoint) : '',
+        executeEndpoint: config.executeEndpoint ? cleanUrl(config.executeEndpoint) : '',
         lookupEndpoint,
-        reportsEndpoint: reportsEndpoint ? cleanUrl(reportsEndpoint) : null,
+        reportsEndpoint,
+        apisEndpoint: config.apisEndpoint?.trim() ? cleanUrl(config.apisEndpoint) : null,
+        apiEndpoints: Array.isArray(config.apiEndpoints) ? config.apiEndpoints : [],
         allowedCategories,
         autoParameter: config.autoParameter !== false, // default true
         routeBase: config.routeBase?.trim() || 'reports',
@@ -74,10 +71,12 @@ export function normalizeBwaysConfig(config) {
         defaultPageSize: config.defaultPageSize ?? 25,
         dateFormat: config.dateFormat ?? 'dd/MM/yyyy',
         lookupTimeoutMs: config.lookupTimeoutMs ?? 300000,
+        executionTimeoutMs: config.executionTimeoutMs,
+        trustedApiOrigins: config.trustedApiOrigins ?? [],
     };
 }
 /** Remove trailing slashes from a URL */
 function cleanUrl(url) {
     return url.trim().replace(/\/+$/, '');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bways-report-config.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/config/bways-report-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Simplified configuration for bways-report.\n *\n * This is the developer-facing config object that makes integration\n * as simple as 3–4 endpoint URLs + optional overrides.\n * The normalizer converts this into the internal `ReportingConfig`\n * plus adapter wiring decisions.\n */\n\nimport { Type } from '@angular/core';\nimport { SessionContextProvider, SessionContextSource } from '../tokens/session-context.token';\n\n/**\n * Palette component category names the developer can use\n * when restricting the designer component palette.\n *\n * Maps to internal registry category IDs:\n * - `formInputs`    → `input`\n * - `actionButtons` → `action`\n * - `displayLabels` → `display`\n * - `dataLookups`   → `data`\n * - `layout`        → `layout`\n */\nexport type PaletteCategory =\n  | 'formInputs'\n  | 'actionButtons'\n  | 'displayLabels'\n  | 'dataLookups'\n  | 'layout';\n\n/**\n * Mapping from friendly palette category names to internal category IDs.\n */\nexport const PALETTE_CATEGORY_MAP: Record<PaletteCategory, string> = {\n  formInputs: 'input',\n  actionButtons: 'action',\n  displayLabels: 'display',\n  dataLookups: 'data',\n  layout: 'layout',\n};\n\n/**\n * Simplified, developer-facing configuration for bways-report.\n *\n * @example\n * ```typescript\n * const reportConfig: BwaysReportConfig = {\n *   spEndpoint:      '/api/reporting/procedures',\n *   tablesEndpoint:  '/api/reporting/tables',\n *   executeEndpoint: '/api/reporting/execute',\n *   reportsEndpoint: '/api/reporting/reports',\n *   components: ['formInputs', 'actionButtons', 'displayLabels'],\n *   autoParameter: true,\n *   session: () => inject(AuthService).session(),\n *   routeBase: 'reports',\n * };\n * ```\n */\nexport interface BwaysReportConfig {\n  // ─── Backend endpoints (the 3–4 endpoint contract) ──────────────\n\n  /**\n   * GET endpoint returning the list of stored procedures with their parameters.\n   * Response: `[{ name, schema, parameters: [{ name, sqlType, required, defaultValue? }] }]`\n   */\n  spEndpoint: string;\n\n  /**\n   * GET endpoint returning the list of tables/views with their columns.\n   * Response: `[{ name, schema, type: 'table'|'view', columns: [{ name, sqlType }] }]`\n   */\n  tablesEndpoint: string;\n\n  /**\n   * POST endpoint that runs a stored procedure or table query and returns rows.\n   * Body: `{ kind: 'procedure'|'table', name, schema, parameters, columns?, top? }`\n   * Response: `rows[]`\n   */\n  executeEndpoint: string;\n\n  /**\n   * Optional POST endpoint for fetching dropdown master data and lookup options.\n   * Defaults to replacing `/execute` with `/lookup` if omitted.\n   */\n  lookupEndpoint?: string;\n\n  /**\n   * Optional CRUD endpoint for saving/loading report page definitions.\n   * When omitted, reports are saved to browser localStorage with a console warning.\n   * - GET    → list saved reports\n   * - GET /:id → load a specific report\n   * - POST   → save a new or updated report\n   * - DELETE /:id → delete a report\n   */\n  reportsEndpoint?: string;\n\n  // ─── Designer options ────────────────────────────────────────────\n\n  /**\n   * Component palette groups to show in the designer.\n   * Defaults to all groups when not specified.\n   *\n   * @example ['formInputs', 'actionButtons', 'displayLabels']\n   */\n  components?: PaletteCategory[];\n\n  /**\n   * When true, stored procedure parameters like `@BranchId`, `@CompanyId`\n   * are automatically bound from the session context.\n   * Requires `session` to be provided.\n   *\n   * @default true\n   */\n  autoParameter?: boolean;\n\n  /**\n   * Session context provider for auto-parameter binding.\n   * Can be a service class implementing `SessionContextProvider`,\n   * a plain object, a factory function, an Observable, or a Signal.\n   *\n   * @example\n   * session: PlaygroundSessionService\n   * session: () => inject(AuthService).session()\n   * session: { branchId: 1, companyId: 10 }\n   */\n  session?: Type<SessionContextProvider> | SessionContextSource | (() => Record<string, unknown>);\n\n  /**\n   * Optional service class implementing `SessionContextProvider`.\n   * Equivalent to `session: MySessionService`.\n   */\n  sessionProvider?: Type<SessionContextProvider>;\n\n  // ─── Live page options ───────────────────────────────────────────\n\n  /**\n   * Base path for live report pages.\n   * Generated report pages open at `/<routeBase>/<slug>`.\n   *\n   * @default 'reports'\n   */\n  routeBase?: string;\n\n  /**\n   * Optional Angular component for rendering data grids.\n   * Pass your grid component (BWays-grid, AG Grid wrapper, etc.).\n   */\n  grid?: Type<unknown>;\n\n  /**\n   * Optional Angular component for rendering charts.\n   */\n  chart?: Type<unknown>;\n\n  // ─── General options ─────────────────────────────────────────────\n\n  /** Default page size for grid results. @default 25 */\n  defaultPageSize?: number;\n\n  /** Date format string used across the library. @default 'dd/MM/yyyy' */\n  dateFormat?: string;\n\n  /** Timeout in ms for lookup/execute queries. @default 300000 */\n  lookupTimeoutMs?: number;\n}\n\n/**\n * Result of normalizing a `BwaysReportConfig` for internal use.\n */\nexport interface NormalizedBwaysConfig {\n  /** Endpoint URLs */\n  spEndpoint: string;\n  tablesEndpoint: string;\n  executeEndpoint: string;\n  lookupEndpoint: string | null;\n  reportsEndpoint: string | null;\n\n  /** Resolved internal category IDs (e.g. ['input', 'action', 'display']) */\n  allowedCategories: string[] | null;\n\n  /** Whether auto-parameter binding is enabled */\n  autoParameter: boolean;\n\n  /** Route base path */\n  routeBase: string;\n\n  /** Session source */\n  session: Type<SessionContextProvider> | SessionContextSource | (() => Record<string, unknown>) | null;\n  sessionProvider: Type<SessionContextProvider> | null;\n\n  /** Grid component */\n  gridComponent: Type<unknown> | null;\n\n  /** Chart component */\n  chartComponent: Type<unknown> | null;\n\n  /** General config values */\n  defaultPageSize: number;\n  dateFormat: string;\n  lookupTimeoutMs: number;\n}\n\n/**\n * Normalizes a `BwaysReportConfig` into the internal format.\n * Validates required fields and maps friendly names to internal IDs.\n */\nexport function normalizeBwaysConfig(config: BwaysReportConfig): NormalizedBwaysConfig {\n  // Validate required endpoints\n  if (!config.spEndpoint || typeof config.spEndpoint !== 'string' || config.spEndpoint.trim() === '') {\n    throw new Error(\n      `[bways-report] \"spEndpoint\" is required in BwaysReportConfig. ` +\n      `Please provide the URL for fetching stored procedures, e.g. '/api/reporting/procedures'.`\n    );\n  }\n  if (!config.tablesEndpoint || typeof config.tablesEndpoint !== 'string' || config.tablesEndpoint.trim() === '') {\n    throw new Error(\n      `[bways-report] \"tablesEndpoint\" is required in BwaysReportConfig. ` +\n      `Please provide the URL for fetching tables/views, e.g. '/api/reporting/tables'.`\n    );\n  }\n  if (!config.executeEndpoint || typeof config.executeEndpoint !== 'string' || config.executeEndpoint.trim() === '') {\n    throw new Error(\n      `[bways-report] \"executeEndpoint\" is required in BwaysReportConfig. ` +\n      `Please provide the URL for executing queries, e.g. '/api/reporting/execute'.`\n    );\n  }\n\n  // Map component palette categories\n  let allowedCategories: string[] | null = null;\n  if (config.components && config.components.length > 0) {\n    allowedCategories = config.components.map((friendly) => {\n      const internal = PALETTE_CATEGORY_MAP[friendly];\n      if (!internal) {\n        console.warn(\n          `[bways-report] Unknown component category \"${friendly}\". ` +\n          `Valid options: ${Object.keys(PALETTE_CATEGORY_MAP).join(', ')}.`\n        );\n        return friendly; // Pass through unknown categories as-is\n      }\n      return internal;\n    });\n  }\n\n  // Warn if reportsEndpoint is missing\n  const reportsEndpoint = config.reportsEndpoint?.trim() || null;\n  if (!reportsEndpoint) {\n    console.warn(\n      `[bways-report] No \"reportsEndpoint\" provided. Reports will be saved to browser localStorage. ` +\n      `For shared report menus across users, provide a reportsEndpoint, e.g. '/api/reporting/reports'.`\n    );\n  }\n\n  const lookupEndpoint = config.lookupEndpoint?.trim()\n    ? cleanUrl(config.lookupEndpoint)\n    : config.executeEndpoint.includes('/execute')\n    ? cleanUrl(config.executeEndpoint.replace(/\\/execute\\/?$/, '/lookup'))\n    : null;\n\n  return {\n    spEndpoint: cleanUrl(config.spEndpoint),\n    tablesEndpoint: cleanUrl(config.tablesEndpoint),\n    executeEndpoint: cleanUrl(config.executeEndpoint),\n    lookupEndpoint,\n    reportsEndpoint: reportsEndpoint ? cleanUrl(reportsEndpoint) : null,\n\n    allowedCategories,\n    autoParameter: config.autoParameter !== false, // default true\n    routeBase: config.routeBase?.trim() || 'reports',\n    session: config.session ?? null,\n    sessionProvider: config.sessionProvider ?? null,\n\n    gridComponent: config.grid ?? null,\n    chartComponent: config.chart ?? null,\n\n    defaultPageSize: config.defaultPageSize ?? 25,\n    dateFormat: config.dateFormat ?? 'dd/MM/yyyy',\n    lookupTimeoutMs: config.lookupTimeoutMs ?? 300000,\n  };\n}\n\n/** Remove trailing slashes from a URL */\nfunction cleanUrl(url: string): string {\n  return url.trim().replace(/\\/+$/, '');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bways-report-config.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/config/bways-report-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { resolveReportsEndpoint } from '../utils/report-endpoint.util';\n/**\n * Simplified configuration for bways-report.\n *\n * This is the developer-facing config object that makes integration\n * as simple as 3–4 endpoint URLs + optional overrides.\n * The normalizer converts this into the internal `ReportingConfig`\n * plus adapter wiring decisions.\n */\n\nimport { Type } from '@angular/core';\nimport { SessionContextProvider, SessionContextSource } from '../tokens/session-context.token';\nimport { ReportApiEndpointDefinition } from '../models/report-api-endpoint.model';\n\n/**\n * Palette component category names the developer can use\n * when restricting the designer component palette.\n *\n * Maps to internal registry category IDs:\n * - `formInputs`    → `input`\n * - `actionButtons` → `action`\n * - `displayLabels` → `display`\n * - `dataLookups`   → `data`\n * - `layout`        → `layout`\n */\nexport type PaletteCategory =\n  | 'formInputs'\n  | 'actionButtons'\n  | 'displayLabels'\n  | 'dataLookups'\n  | 'layout';\n\n/**\n * Mapping from friendly palette category names to internal category IDs.\n */\nexport const PALETTE_CATEGORY_MAP: Record<PaletteCategory, string> = {\n  formInputs: 'input',\n  actionButtons: 'action',\n  displayLabels: 'display',\n  dataLookups: 'data',\n  layout: 'layout',\n};\n\n/**\n * Simplified, developer-facing configuration for bways-report.\n *\n * @example\n * ```typescript\n * const reportConfig: BwaysReportConfig = {\n *   spEndpoint:      '/api/reporting/procedures',\n *   tablesEndpoint:  '/api/reporting/tables',\n *   executeEndpoint: '/api/reporting/execute',\n *   reportsEndpoint: '/api/reporting/reports',\n *   components: ['formInputs', 'actionButtons', 'displayLabels'],\n *   autoParameter: true,\n *   session: () => inject(AuthService).session(),\n *   routeBase: 'reports',\n * };\n * ```\n */\nexport interface BwaysReportConfig {\n  // ─── Backend endpoints (the 3–4 endpoint contract) ──────────────\n\n  /**\n   * GET endpoint returning the list of stored procedures with their parameters.\n   * Response: `[{ name, schema, parameters: [{ name, sqlType, required, defaultValue? }] }]`\n   */\n  spEndpoint?: string;\n\n  /**\n   * GET endpoint returning the list of tables/views with their columns.\n   * Response: `[{ name, schema, type: 'table'|'view', columns: [{ name, sqlType }] }]`\n   */\n  tablesEndpoint?: string;\n\n  /**\n   * POST endpoint that runs a stored procedure or table query and returns rows.\n   * Body: `{ kind: 'procedure'|'table', name, schema, parameters, columns?, top? }`\n   * Response: `rows[]`\n   */\n  executeEndpoint?: string;\n\n  /**\n   * Optional POST endpoint for fetching dropdown master data and lookup options.\n   * Defaults to replacing `/execute` with `/lookup` if omitted.\n   */\n  lookupEndpoint?: string;\n\n  /**\n   * Optional CRUD endpoint for saving/loading report page definitions.\n   * When omitted, uses the reporting service base inferred from the configured endpoints.\n   * Defaults to /api/reporting/reports; the backend stores definitions in dbo.CNFREPORTDEF.\n   * - GET    → list saved reports\n   * - GET /:id → load a specific report\n   * - POST   → save a new or updated report\n   * - DELETE /:id → delete a report\n   */\n  reportsEndpoint?: string;\n\n  /**\n   * Optional GET endpoint returning the catalog of registered REST APIs.\n   * Response: ReportApiEndpointDefinition[]\n   */\n  apisEndpoint?: string;\n\n  /**\n   * Optional static/in-memory API endpoints registered directly in the host application.\n   * Merged with backend-discovered APIs in the Visual Designer.\n   */\n  apiEndpoints?: ReportApiEndpointDefinition[];\n\n  // ─── Designer options ────────────────────────────────────────────\n\n  /**\n   * Component palette groups to show in the designer.\n   * Defaults to all groups when not specified.\n   *\n   * @example ['formInputs', 'actionButtons', 'displayLabels']\n   */\n  components?: PaletteCategory[];\n\n  /**\n   * When true, stored procedure parameters like `@BranchId`, `@CompanyId`\n   * are automatically bound from the session context.\n   * Requires `session` to be provided.\n   *\n   * @default true\n   */\n  autoParameter?: boolean;\n\n  /**\n   * Session context provider for auto-parameter binding.\n   * Can be a service class implementing `SessionContextProvider`,\n   * a plain object, a factory function, an Observable, or a Signal.\n   *\n   * @example\n   * session: PlaygroundSessionService\n   * session: () => inject(AuthService).session()\n   * session: { branchId: 1, companyId: 10 }\n   */\n  session?: Type<SessionContextProvider> | SessionContextSource | (() => Record<string, unknown>);\n\n  /**\n   * Optional service class implementing `SessionContextProvider`.\n   * Equivalent to `session: MySessionService`.\n   */\n  sessionProvider?: Type<SessionContextProvider>;\n\n  // ─── Live page options ───────────────────────────────────────────\n\n  /**\n   * Base path for live report pages.\n   * Generated report pages open at `/<routeBase>/<slug>`.\n   *\n   * @default 'reports'\n   */\n  routeBase?: string;\n\n  /**\n   * Optional Angular component for rendering data grids.\n   * Pass your grid component (BWays-grid, AG Grid wrapper, etc.).\n   */\n  grid?: Type<unknown>;\n\n  /**\n   * Optional Angular component for rendering charts.\n   */\n  chart?: Type<unknown>;\n\n  // ─── General options ─────────────────────────────────────────────\n\n  /** Default page size for grid results. @default 25 */\n  defaultPageSize?: number;\n\n  /** Date format string used across the library. @default 'dd/MM/yyyy' */\n  dateFormat?: string;\n\n  /** Timeout in ms for lookup/execute queries. @default 300000 */\n  lookupTimeoutMs?: number;\n\n  /** Maximum duration of an execution request (defaults to lookupTimeoutMs). */\n  executionTimeoutMs?: number;\n  /** Exact HTTP(S) origins permitted to receive API credentials and custom headers. Same-origin is trusted by default. */\n  trustedApiOrigins?: string[];\n}\n\n/**\n * Result of normalizing a `BwaysReportConfig` for internal use.\n */\nexport interface NormalizedBwaysConfig {\n  /** Endpoint URLs */\n  spEndpoint: string;\n  tablesEndpoint: string;\n  executeEndpoint: string;\n  lookupEndpoint: string | null;\n  reportsEndpoint: string | null;\n  apisEndpoint: string | null;\n  apiEndpoints: ReportApiEndpointDefinition[];\n\n  /** Resolved internal category IDs (e.g. ['input', 'action', 'display']) */\n  allowedCategories: string[] | null;\n\n  /** Whether auto-parameter binding is enabled */\n  autoParameter: boolean;\n\n  /** Route base path */\n  routeBase: string;\n\n  /** Session source */\n  session: Type<SessionContextProvider> | SessionContextSource | (() => Record<string, unknown>) | null;\n  sessionProvider: Type<SessionContextProvider> | null;\n\n  /** Grid component */\n  gridComponent: Type<unknown> | null;\n\n  /** Chart component */\n  chartComponent: Type<unknown> | null;\n\n  /** General config values */\n  defaultPageSize: number;\n  dateFormat: string;\n  lookupTimeoutMs: number;\n\n  /** Maximum duration of an execution request (defaults to lookupTimeoutMs). */\n  executionTimeoutMs?: number;\n  /** Exact HTTP(S) origins permitted to receive API credentials and custom headers. Same-origin is trusted by default. */\n  trustedApiOrigins?: string[];\n}\n\n/**\n * Normalizes a `BwaysReportConfig` into the internal format.\n * Validates supplied endpoints and maps friendly names to internal IDs.\n */\nexport function normalizeBwaysConfig(config: BwaysReportConfig): NormalizedBwaysConfig {\n  // Capabilities are optional; validate only URLs the host supplies.\n  for (const key of ['spEndpoint', 'tablesEndpoint', 'executeEndpoint', 'lookupEndpoint', 'reportsEndpoint', 'apisEndpoint'] as const) {\n    if (config[key] !== undefined && (typeof config[key] !== 'string' || !config[key]?.trim())) {\n      throw new Error('[bways-report] \"' + key + '\" must be a non-empty URL when supplied.');\n    }\n  }\n\n  for (const key of ['lookupTimeoutMs', 'executionTimeoutMs'] as const) {\n    if (config[key] !== undefined && (!Number.isFinite(config[key]) || config[key]! <= 0)) throw new Error(key + ' must be a positive timeout.');\n  }\n  if (config.trustedApiOrigins !== undefined && (!Array.isArray(config.trustedApiOrigins) || config.trustedApiOrigins.some(origin => {\n    try { const parsed = new URL(origin); return !/^https?:$/.test(parsed.protocol) || parsed.origin !== origin || !!parsed.username || !!parsed.password; }\n    catch { return true; }\n  }))) throw new Error('trustedApiOrigins must contain exact HTTP(S) origins, without paths or credentials.');\n\n  // Map component palette categories\n  let allowedCategories: string[] | null = null;\n  if (config.components && config.components.length > 0) {\n    allowedCategories = config.components.map((friendly) => {\n      const internal = PALETTE_CATEGORY_MAP[friendly];\n      if (!internal) {\n        console.warn(\n          `[bways-report] Unknown component category \"${friendly}\". ` +\n          `Valid options: ${Object.keys(PALETTE_CATEGORY_MAP).join(', ')}.`\n        );\n        return friendly; // Pass through unknown categories as-is\n      }\n      return internal;\n    });\n  }\n\n  const reportsEndpoint = resolveReportsEndpoint(config);\n\n  const lookupEndpoint = config.lookupEndpoint?.trim()\n    ? cleanUrl(config.lookupEndpoint)\n    : config.executeEndpoint?.includes('/execute')\n    ? cleanUrl(config.executeEndpoint.replace(/\\/execute\\/?$/, '/lookup'))\n    : null;\n\n  return {\n    spEndpoint: config.spEndpoint ? cleanUrl(config.spEndpoint) : '',\n    tablesEndpoint: config.tablesEndpoint ? cleanUrl(config.tablesEndpoint) : '',\n    executeEndpoint: config.executeEndpoint ? cleanUrl(config.executeEndpoint) : '',\n    lookupEndpoint,\n    reportsEndpoint,\n    apisEndpoint: config.apisEndpoint?.trim() ? cleanUrl(config.apisEndpoint) : null,\n    apiEndpoints: Array.isArray(config.apiEndpoints) ? config.apiEndpoints : [],\n\n    allowedCategories,\n    autoParameter: config.autoParameter !== false, // default true\n    routeBase: config.routeBase?.trim() || 'reports',\n    session: config.session ?? null,\n    sessionProvider: config.sessionProvider ?? null,\n\n    gridComponent: config.grid ?? null,\n    chartComponent: config.chart ?? null,\n\n    defaultPageSize: config.defaultPageSize ?? 25,\n    dateFormat: config.dateFormat ?? 'dd/MM/yyyy',\n    lookupTimeoutMs: config.lookupTimeoutMs ?? 300000,\n    executionTimeoutMs: config.executionTimeoutMs,\n    trustedApiOrigins: config.trustedApiOrigins ?? [],\n  };\n}\n\n/** Remove trailing slashes from a URL */\nfunction cleanUrl(url: string): string {\n  return url.trim().replace(/\\/+$/, '');\n}\n"]}

package/esm2022/lib/core/models/index.mjs

@@ -2,4 +2,4 @@
  * Barrel export for all core domain models.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQmFycmVsIGV4cG9ydCBmb3IgYWxsIGNvcmUgZG9tYWluIG1vZGVscy5cbiAqL1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydERlZmluaXRpb24sXG4gIFJlcG9ydFN1bW1hcnksXG4gIFJlcG9ydFBlcm1pc3Npb25EZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1kZWZpbml0aW9uLm1vZGVsJztcblxuZXhwb3J0IHR5cGUge1xuICBSZXBvcnRDb21wb25lbnREZWZpbml0aW9uLFxuICBDb21wb25lbnRCaW5kaW5nRGVmaW5pdGlvbixcbiAgQ29tcG9uZW50RGF0YVNvdXJjZURlZmluaXRpb24sXG4gIFZpc2liaWxpdHlEZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1jb21wb25lbnQubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydFBhcmFtZXRlckRlZmluaXRpb24sXG59IGZyb20gJy4vcmVwb3J0LXBhcmFtZXRlci5tb2RlbCc7XG5cbmV4cG9ydCB0eXBlIHtcbiAgUmVwb3J0RGF0YVNvdXJjZURlZmluaXRpb24sXG4gIERhdGFTb3VyY2VDYWNoZURlZmluaXRpb24sXG59IGZyb20gJy4vcmVwb3J0LWRhdGFzb3VyY2UubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydEdyaWREZWZpbml0aW9uLFxuICBHcmlkQ29sdW1uRGVmaW5pdGlvbixcbiAgR3JpZE9wdGlvbnNEZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1ncmlkLm1vZGVsJztcblxuZXhwb3J0IHR5cGUge1xuICBSZXBvcnRMYXlvdXREZWZpbml0aW9uLFxuICBDb21wb25lbnRMYXlvdXREZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1sYXlvdXQubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIFZhbGlkYXRpb25EZWZpbml0aW9uLFxufSBmcm9tICcuL3ZhbGlkYXRpb24ubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIENvbXBvbmVudEV2ZW50RGVmaW5pdGlvbixcbiAgQ29tcG9uZW50QWN0aW9uRGVmaW5pdGlvbixcbn0gZnJvbSAnLi9jb21wb25lbnQtZXZlbnQubW9kZWwnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQmFycmVsIGV4cG9ydCBmb3IgYWxsIGNvcmUgZG9tYWluIG1vZGVscy5cbiAqL1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydERlZmluaXRpb24sXG4gIFJlcG9ydFN1bW1hcnksXG4gIFJlcG9ydFBlcm1pc3Npb25EZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1kZWZpbml0aW9uLm1vZGVsJztcblxuZXhwb3J0IHR5cGUge1xuICBSZXBvcnRDb21wb25lbnREZWZpbml0aW9uLFxuICBDb21wb25lbnRCaW5kaW5nRGVmaW5pdGlvbixcbiAgQ29tcG9uZW50RGF0YVNvdXJjZURlZmluaXRpb24sXG4gIERyb3Bkb3duU291cmNlVHlwZSxcbiAgVmlzaWJpbGl0eURlZmluaXRpb24sXG59IGZyb20gJy4vcmVwb3J0LWNvbXBvbmVudC5tb2RlbCc7XG5cbmV4cG9ydCB0eXBlIHtcbiAgUmVwb3J0QXBpRW5kcG9pbnREZWZpbml0aW9uLFxuICBSZXBvcnRBcGlQYXJhbWV0ZXJEZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1hcGktZW5kcG9pbnQubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydFBhcmFtZXRlckRlZmluaXRpb24sXG59IGZyb20gJy4vcmVwb3J0LXBhcmFtZXRlci5tb2RlbCc7XG5cbmV4cG9ydCB0eXBlIHtcbiAgUmVwb3J0RGF0YVNvdXJjZURlZmluaXRpb24sXG4gIERhdGFTb3VyY2VDYWNoZURlZmluaXRpb24sXG59IGZyb20gJy4vcmVwb3J0LWRhdGFzb3VyY2UubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydEdyaWREZWZpbml0aW9uLFxuICBHcmlkQ29sdW1uRGVmaW5pdGlvbixcbiAgR3JpZE9wdGlvbnNEZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1ncmlkLm1vZGVsJztcblxuZXhwb3J0IHR5cGUge1xuICBSZXBvcnRMYXlvdXREZWZpbml0aW9uLFxuICBDb21wb25lbnRMYXlvdXREZWZpbml0aW9uLFxufSBmcm9tICcuL3JlcG9ydC1sYXlvdXQubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIFZhbGlkYXRpb25EZWZpbml0aW9uLFxufSBmcm9tICcuL3ZhbGlkYXRpb24ubW9kZWwnO1xuXG5leHBvcnQgdHlwZSB7XG4gIENvbXBvbmVudEV2ZW50RGVmaW5pdGlvbixcbiAgQ29tcG9uZW50QWN0aW9uRGVmaW5pdGlvbixcbn0gZnJvbSAnLi9jb21wb25lbnQtZXZlbnQubW9kZWwnO1xuIl19

package/esm2022/lib/core/models/report-api-endpoint.model.mjs

@@ -0,0 +1,8 @@
+/**
+ * Definitions for API-based data retrieval endpoints.
+ *
+ * Enables reports and form components to consume REST / HTTP APIs
+ * with parameter interpolation, custom headers, and data path resolution.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwb3J0LWFwaS1lbmRwb2ludC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J3YXlzLXJlcG9ydC9zcmMvbGliL2NvcmUvbW9kZWxzL3JlcG9ydC1hcGktZW5kcG9pbnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERlZmluaXRpb25zIGZvciBBUEktYmFzZWQgZGF0YSByZXRyaWV2YWwgZW5kcG9pbnRzLlxuICpcbiAqIEVuYWJsZXMgcmVwb3J0cyBhbmQgZm9ybSBjb21wb25lbnRzIHRvIGNvbnN1bWUgUkVTVCAvIEhUVFAgQVBJc1xuICogd2l0aCBwYXJhbWV0ZXIgaW50ZXJwb2xhdGlvbiwgY3VzdG9tIGhlYWRlcnMsIGFuZCBkYXRhIHBhdGggcmVzb2x1dGlvbi5cbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlcG9ydEFwaVBhcmFtZXRlckRlZmluaXRpb24ge1xuICBuYW1lOiBzdHJpbmc7XG4gIGxhYmVsPzogc3RyaW5nO1xuICB0eXBlOiAnc3RyaW5nJyB8ICdudW1iZXInIHwgJ2Jvb2xlYW4nIHwgJ2RhdGUnIHwgJ2FycmF5JztcbiAgaW46ICdxdWVyeScgfCAncGF0aCcgfCAnYm9keScgfCAnaGVhZGVyJztcbiAgcmVxdWlyZWQ/OiBib29sZWFuO1xuICBkZWZhdWx0VmFsdWU/OiB1bmtub3duO1xuICBkZXNjcmlwdGlvbj86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZXBvcnRBcGlFbmRwb2ludERlZmluaXRpb24ge1xuICBpZDogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIHVybD86IHN0cmluZztcbiAgZW5kcG9pbnQ/OiBzdHJpbmc7XG4gIG1ldGhvZD86ICdHRVQnIHwgJ1BPU1QnIHwgJ1BVVCc7XG4gIGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuICBjYXRlZ29yeT86IHN0cmluZztcbiAgZGF0YVBhdGg/OiBzdHJpbmc7XG4gIHRvdGFsUGF0aD86IHN0cmluZztcbiAgcGFyYW1ldGVycz86IFJlcG9ydEFwaVBhcmFtZXRlckRlZmluaXRpb25bXTtcbiAgaGVhZGVycz86IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG4gIHJlc3BvbnNlU2FtcGxlPzogUmVjb3JkPHN0cmluZywgdW5rbm93bj5bXTtcbiAgdXNlUHJveHk/OiBib29sZWFuO1xufVxuIl19

package/esm2022/lib/core/models/report-component.model.mjs

@@ -7,4 +7,4 @@
  * in the renderer.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/models/report-datasource.model.mjs

@@ -6,4 +6,4 @@
  * `ReportDataSourceAdapter` contract.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/index.mjs

@@ -2,4 +2,5 @@ export { DynamicFormBuilder } from './dynamic-form-builder.service';
 export { ReportSessionContextService } from './report-session-context.service';
 export { ReportStorageService } from './report-storage.service';
 export { ReportDataDiscoveryService } from './report-data-discovery.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBSy9FLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRHluYW1pY0Zvcm1CdWlsZGVyIH0gZnJvbSAnLi9keW5hbWljLWZvcm0tYnVpbGRlci5zZXJ2aWNlJztcbmV4cG9ydCB7IFJlcG9ydFNlc3Npb25Db250ZXh0U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXNlc3Npb24tY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHtcbiAgU2Vzc2lvblBhcmFtTWF0Y2gsXG4gIERlcml2ZWRQYXJhbWV0ZXJzUmVzdWx0LFxufSBmcm9tICcuL3JlcG9ydC1zZXNzaW9uLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnRTdG9yYWdlU2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXN0b3JhZ2Uuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnREYXRhRGlzY292ZXJ5U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LWRhdGEtZGlzY292ZXJ5LnNlcnZpY2UnO1xuIl19
+export { ReportApiExecutionService } from './report-api-execution.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBSy9FLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzdFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRHluYW1pY0Zvcm1CdWlsZGVyIH0gZnJvbSAnLi9keW5hbWljLWZvcm0tYnVpbGRlci5zZXJ2aWNlJztcbmV4cG9ydCB7IFJlcG9ydFNlc3Npb25Db250ZXh0U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXNlc3Npb24tY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHtcbiAgU2Vzc2lvblBhcmFtTWF0Y2gsXG4gIERlcml2ZWRQYXJhbWV0ZXJzUmVzdWx0LFxufSBmcm9tICcuL3JlcG9ydC1zZXNzaW9uLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnRTdG9yYWdlU2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXN0b3JhZ2Uuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnREYXRhRGlzY292ZXJ5U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LWRhdGEtZGlzY292ZXJ5LnNlcnZpY2UnO1xuZXhwb3J0IHsgUmVwb3J0QXBpRXhlY3V0aW9uU2VydmljZSB9IGZyb20gJy4vcmVwb3J0LWFwaS1leGVjdXRpb24uc2VydmljZSc7XG4iXX0=

package/esm2022/lib/core/services/report-api-execution.service.mjs

@@ -0,0 +1,210 @@
+import { inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { catchError, map, timeout } from 'rxjs/operators';
+import { ReportSessionContextService } from './report-session-context.service';
+import { REPORTING_CONFIG } from '../tokens/reporting-config.token';
+import { BWAYS_REPORT_ENDPOINTS } from '../../data-access/adapters/endpoint-tokens';
+import * as i0 from "@angular/core";
+/**
+ * Service responsible for executing API-based data retrieval requests.
+ *
+ * Supports URL path parameter interpolation (:id, {{id}}), query string parameter
+ * placement, JSON payload mapping, session header substitution, proxy routing,
+ * and dot-path response data extraction.
+ */
+export class ReportApiExecutionService {
+    http = inject(HttpClient, { optional: true });
+    session = inject(ReportSessionContextService, { optional: true });
+    reportingConfig = inject(REPORTING_CONFIG, { optional: true });
+    endpoints = inject(BWAYS_REPORT_ENDPOINTS, { optional: true });
+    getRegisteredEndpoints() {
+        return this.endpoints?.apiEndpoints || [];
+    }
+    /**
+     * Executes a parameterized REST API request and extracts the result array.
+     *
+     * @param options Target endpoint configuration, URL, method, and data path.
+     * @param formValues Active parameter and filter values from the form/context.
+     * @param customMappings Additional fixed or mapped parameter values.
+     */
+    executeApi(options, formValues = {}, customMappings = {}) {
+        if (!this.http) {
+            return throwError(() => new Error('[ReportApiExecutionService] HttpClient is not provided in injector.'));
+        }
+        const rawUrl = options.url || options.endpoint;
+        if (!rawUrl || typeof rawUrl !== 'string' || rawUrl.trim() === '') {
+            return throwError(() => new Error('[ReportApiExecutionService] No valid URL or endpoint provided for API execution.'));
+        }
+        const sessionContext = this.session?.getCurrentSessionContext() ?? {};
+        const allValuesForPath = {
+            ...sessionContext,
+            ...formValues,
+            ...customMappings,
+        };
+        // 1. Interpolate Path Variables: /api/orders/:orderId or /api/orders/{{orderId}}
+        const pathKeys = new Set();
+        const resolvedUrl = rawUrl.replace(/(^|\/):([a-zA-Z_][a-zA-Z0-9_]*)|\{\{([a-zA-Z0-9_]+)\}\}/g, (_, prefix, pathKey, templateKey) => {
+            const key = pathKey || templateKey;
+            pathKeys.add(key);
+            const val = allValuesForPath[key];
+            return (prefix || '') + (val !== undefined && val !== null ? encodeURIComponent(String(val)) : '');
+        });
+        let destination;
+        const browserOrigin = typeof location !== 'undefined' ? location.origin : undefined;
+        try {
+            destination = new URL(resolvedUrl, browserOrigin);
+        }
+        catch {
+            return throwError(() => new Error('Invalid API destination URL.'));
+        }
+        if (!/^https?:$/.test(destination.protocol) || destination.username || destination.password) {
+            return throwError(() => new Error('API destinations must use HTTP(S) without embedded credentials.'));
+        }
+        const trusted = destination.origin === browserOrigin || (this.reportingConfig?.trustedApiOrigins ?? []).includes(destination.origin);
+        const method = (options.method || 'GET').toUpperCase();
+        const queryParams = {};
+        const bodyPayload = { ...(options.bodyTemplate || {}) };
+        const payloadValues = {
+            ...formValues,
+            ...customMappings,
+        };
+        // 2. Separate remaining params into Query params and Body payload
+        for (const [k, v] of Object.entries(payloadValues)) {
+            if (pathKeys.has(k) || v === undefined || v === null || v === '')
+                continue;
+            if (method === 'GET' || method === 'DELETE') {
+                if (typeof v === 'object') {
+                    queryParams[k] = JSON.stringify(v);
+                }
+                else {
+                    queryParams[k] = String(v);
+                }
+            }
+            else {
+                bodyPayload[k] = v;
+            }
+        }
+        if (!trusted) {
+            const secrets = Object.entries(sessionContext).filter(([key, value]) => /token|secret|password|authorization|api.?key/i.test(key) && value != null && String(value).length > 0).map(([, value]) => String(value));
+            const payloadText = JSON.stringify([queryParams, bodyPayload]);
+            if (secrets.some(secret => resolvedUrl.includes(secret) || resolvedUrl.includes(encodeURIComponent(secret)) || payloadText.includes(secret))) {
+                return throwError(() => new Error('Session credentials may only be sent to a trusted API origin.'));
+            }
+        }
+        // 3. Resolve Headers with Token Interpolation & Standard Session Context
+        const headers = {};
+        if (trusted && sessionContext['companyId'] !== undefined && sessionContext['companyId'] !== null) {
+            headers['X-Company-Id'] = String(sessionContext['companyId']);
+        }
+        if (trusted && sessionContext['branchId'] !== undefined && sessionContext['branchId'] !== null) {
+            headers['X-Branch-Id'] = String(sessionContext['branchId']);
+        }
+        if (trusted && sessionContext['userId'] !== undefined && sessionContext['userId'] !== null) {
+            headers['X-User-Id'] = String(sessionContext['userId']);
+        }
+        if (trusted && sessionContext['token'] !== undefined && sessionContext['token'] !== null) {
+            headers['Authorization'] = `Bearer ${sessionContext['token']}`;
+        }
+        if (options.headers) {
+            for (const [hk, hv] of Object.entries(options.headers)) {
+                // Report JSON cannot opt an external origin into receiving session credentials.
+                if (!trusted && (!/^(accept|content-type)$/i.test(hk) || /\{\{/.test(String(hv))))
+                    continue;
+                if (typeof hv === 'string') {
+                    headers[hk] = hv.replace(/\{\{session\.([a-zA-Z0-9_]+)\}\}|\{\{([a-zA-Z0-9_]+)\}\}/g, (_, sk1, sk2) => {
+                        const key = sk1 || sk2;
+                        return sessionContext[key] !== undefined ? String(sessionContext[key]) : '';
+                    });
+                }
+                else {
+                    headers[hk] = String(hv);
+                }
+            }
+        }
+        // 4. Determine Request: Direct vs. Backend Proxy Gateway
+        const useProxy = options.useProxy === true;
+        let request$;
+        if (useProxy) {
+            const proxyBase = this.endpoints?.apisEndpoint ||
+                (this.reportingConfig?.apiBaseUrl ? `${this.reportingConfig.apiBaseUrl}/apis` : '/api/reporting/apis');
+            const proxyUrl = `${proxyBase.replace(/\/+$/, '')}/proxy`;
+            request$ = this.http.post(proxyUrl, {
+                endpoint: resolvedUrl,
+                url: resolvedUrl,
+                method,
+                parameters: queryParams,
+                queryParams,
+                body: Object.keys(bodyPayload).length > 0 ? bodyPayload : undefined,
+                headers,
+            });
+        }
+        else {
+            if (method === 'GET') {
+                request$ = this.http.get(resolvedUrl, { params: queryParams, headers });
+            }
+            else if (method === 'POST') {
+                request$ = this.http.post(resolvedUrl, bodyPayload, { params: queryParams, headers });
+            }
+            else if (method === 'PUT') {
+                request$ = this.http.put(resolvedUrl, bodyPayload, { params: queryParams, headers });
+            }
+            else {
+                request$ = this.http.request(method, resolvedUrl, {
+                    body: bodyPayload,
+                    params: queryParams,
+                    headers,
+                });
+            }
+        }
+        // 5. Extract & Normalize Target Data Array
+        return request$.pipe(timeout({ first: this.reportingConfig?.executionTimeoutMs ?? this.reportingConfig?.lookupTimeoutMs ?? 300000 }), map((response) => this.extractDataArray(response, options.dataPath)), catchError((err) => {
+            console.error(`[ReportApiExecutionService] API execution error [${method} ${resolvedUrl}]:`, err);
+            const message = err?.error?.message ||
+                err?.message ||
+                `API request failed with status ${err?.status || 'unknown'}`;
+            return throwError(() => new Error(message));
+        }));
+    }
+    /**
+     * Dot-notation extractor: 'data.items' -> response.data.items
+     */
+    extractDataArray(response, dataPath) {
+        if (!response)
+            return [];
+        if (Array.isArray(response))
+            return response;
+        if (dataPath && typeof dataPath === 'string' && dataPath.trim() !== '') {
+            const parts = dataPath.trim().split('.');
+            let current = response;
+            for (const part of parts) {
+                if (current && typeof current === 'object' && part in current) {
+                    current = current[part];
+                }
+                else {
+                    current = null;
+                    break;
+                }
+            }
+            if (Array.isArray(current))
+                return current;
+        }
+        // Auto-detect common response collection containers
+        for (const key of ['data', 'items', 'rows', 'records', 'results', 'result']) {
+            if (Array.isArray(response[key]))
+                return response[key];
+        }
+        // If single object returned, wrap in array for grid display
+        if (typeof response === 'object' && response !== null) {
+            return [response];
+        }
+        return [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportApiExecutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportApiExecutionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportApiExecutionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-api-execution.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-api-execution.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError, map, timeout } from 'rxjs/operators';\nimport { ReportSessionContextService } from './report-session-context.service';\nimport { REPORTING_CONFIG, ReportingConfig } from '../tokens/reporting-config.token';\nimport { BWAYS_REPORT_ENDPOINTS, BwaysReportEndpoints } from '../../data-access/adapters/endpoint-tokens';\nimport { ReportApiEndpointDefinition } from '../models/report-api-endpoint.model';\n\nexport interface ApiExecutionOptions {\n  url?: string;\n  endpoint?: string;\n  method?: string;\n  dataPath?: string;\n  totalPath?: string;\n  headers?: Record<string, string>;\n  useProxy?: boolean;\n  bodyTemplate?: Record<string, unknown>;\n}\n\n/**\n * Service responsible for executing API-based data retrieval requests.\n *\n * Supports URL path parameter interpolation (:id, {{id}}), query string parameter\n * placement, JSON payload mapping, session header substitution, proxy routing,\n * and dot-path response data extraction.\n */\n@Injectable({ providedIn: 'root' })\nexport class ReportApiExecutionService {\n  private readonly http = inject(HttpClient, { optional: true });\n  private readonly session = inject(ReportSessionContextService, { optional: true });\n  private readonly reportingConfig = inject(REPORTING_CONFIG, { optional: true }) as ReportingConfig | null;\n  private readonly endpoints = inject(BWAYS_REPORT_ENDPOINTS, { optional: true }) as BwaysReportEndpoints | null;\n\n  getRegisteredEndpoints(): ReportApiEndpointDefinition[] {\n    return this.endpoints?.apiEndpoints || [];\n  }\n\n  /**\n   * Executes a parameterized REST API request and extracts the result array.\n   *\n   * @param options Target endpoint configuration, URL, method, and data path.\n   * @param formValues Active parameter and filter values from the form/context.\n   * @param customMappings Additional fixed or mapped parameter values.\n   */\n  executeApi(\n    options: ApiExecutionOptions | Partial<ReportApiEndpointDefinition>,\n    formValues: Record<string, unknown> = {},\n    customMappings: Record<string, unknown> = {}\n  ): Observable<unknown[]> {\n    if (!this.http) {\n      return throwError(() => new Error('[ReportApiExecutionService] HttpClient is not provided in injector.'));\n    }\n\n    const rawUrl = options.url || options.endpoint;\n    if (!rawUrl || typeof rawUrl !== 'string' || rawUrl.trim() === '') {\n      return throwError(() => new Error('[ReportApiExecutionService] No valid URL or endpoint provided for API execution.'));\n    }\n\n    const sessionContext = this.session?.getCurrentSessionContext() ?? {};\n    const allValuesForPath: Record<string, unknown> = {\n      ...sessionContext,\n      ...formValues,\n      ...customMappings,\n    };\n\n    // 1. Interpolate Path Variables: /api/orders/:orderId or /api/orders/{{orderId}}\n    const pathKeys = new Set<string>();\n    const resolvedUrl = rawUrl.replace(/(^|\\/):([a-zA-Z_][a-zA-Z0-9_]*)|\\{\\{([a-zA-Z0-9_]+)\\}\\}/g, (_, prefix, pathKey, templateKey) => {\n      const key = pathKey || templateKey;\n      pathKeys.add(key);\n      const val = allValuesForPath[key];\n      return (prefix || '') + (val !== undefined && val !== null ? encodeURIComponent(String(val)) : '');\n    });\n\n    let destination: URL;\n    const browserOrigin = typeof location !== 'undefined' ? location.origin : undefined;\n    try { destination = new URL(resolvedUrl, browserOrigin); }\n    catch { return throwError(() => new Error('Invalid API destination URL.')); }\n    if (!/^https?:$/.test(destination.protocol) || destination.username || destination.password) {\n      return throwError(() => new Error('API destinations must use HTTP(S) without embedded credentials.'));\n    }\n    const trusted = destination.origin === browserOrigin || (this.reportingConfig?.trustedApiOrigins ?? []).includes(destination.origin);\n\n    const method = (options.method || 'GET').toUpperCase();\n    const queryParams: Record<string, string> = {};\n    const bodyPayload: Record<string, unknown> = { ...((options as any).bodyTemplate || {}) };\n\n    const payloadValues: Record<string, unknown> = {\n      ...formValues,\n      ...customMappings,\n    };\n\n    // 2. Separate remaining params into Query params and Body payload\n    for (const [k, v] of Object.entries(payloadValues)) {\n      if (pathKeys.has(k) || v === undefined || v === null || v === '') continue;\n\n      if (method === 'GET' || method === 'DELETE') {\n        if (typeof v === 'object') {\n          queryParams[k] = JSON.stringify(v);\n        } else {\n          queryParams[k] = String(v);\n        }\n      } else {\n        bodyPayload[k] = v;\n      }\n    }\n\n    if (!trusted) {\n      const secrets = Object.entries(sessionContext).filter(([key, value]) => /token|secret|password|authorization|api.?key/i.test(key) && value != null && String(value).length > 0).map(([, value]) => String(value));\n      const payloadText = JSON.stringify([queryParams, bodyPayload]);\n      if (secrets.some(secret => resolvedUrl.includes(secret) || resolvedUrl.includes(encodeURIComponent(secret)) || payloadText.includes(secret))) {\n        return throwError(() => new Error('Session credentials may only be sent to a trusted API origin.'));\n      }\n    }\n\n    // 3. Resolve Headers with Token Interpolation & Standard Session Context\n    const headers: Record<string, string> = {};\n    if (trusted && sessionContext['companyId'] !== undefined && sessionContext['companyId'] !== null) {\n      headers['X-Company-Id'] = String(sessionContext['companyId']);\n    }\n    if (trusted && sessionContext['branchId'] !== undefined && sessionContext['branchId'] !== null) {\n      headers['X-Branch-Id'] = String(sessionContext['branchId']);\n    }\n    if (trusted && sessionContext['userId'] !== undefined && sessionContext['userId'] !== null) {\n      headers['X-User-Id'] = String(sessionContext['userId']);\n    }\n    if (trusted && sessionContext['token'] !== undefined && sessionContext['token'] !== null) {\n      headers['Authorization'] = `Bearer ${sessionContext['token']}`;\n    }\n\n    if (options.headers) {\n      for (const [hk, hv] of Object.entries(options.headers)) {\n        // Report JSON cannot opt an external origin into receiving session credentials.\n        if (!trusted && (!/^(accept|content-type)$/i.test(hk) || /\\{\\{/.test(String(hv)))) continue;\n        if (typeof hv === 'string') {\n          headers[hk] = hv.replace(/\\{\\{session\\.([a-zA-Z0-9_]+)\\}\\}|\\{\\{([a-zA-Z0-9_]+)\\}\\}/g, (_, sk1, sk2) => {\n            const key = sk1 || sk2;\n            return sessionContext[key] !== undefined ? String(sessionContext[key]) : '';\n          });\n        } else {\n          headers[hk] = String(hv);\n        }\n      }\n    }\n\n    // 4. Determine Request: Direct vs. Backend Proxy Gateway\n    const useProxy = options.useProxy === true;\n    let request$: Observable<unknown>;\n\n    if (useProxy) {\n      const proxyBase =\n        this.endpoints?.apisEndpoint ||\n        (this.reportingConfig?.apiBaseUrl ? `${this.reportingConfig.apiBaseUrl}/apis` : '/api/reporting/apis');\n      const proxyUrl = `${proxyBase.replace(/\\/+$/, '')}/proxy`;\n\n      request$ = this.http.post<unknown>(proxyUrl, {\n        endpoint: resolvedUrl,\n        url: resolvedUrl,\n        method,\n        parameters: queryParams,\n        queryParams,\n        body: Object.keys(bodyPayload).length > 0 ? bodyPayload : undefined,\n        headers,\n      });\n    } else {\n      if (method === 'GET') {\n        request$ = this.http.get<unknown>(resolvedUrl, { params: queryParams, headers });\n      } else if (method === 'POST') {\n        request$ = this.http.post<unknown>(resolvedUrl, bodyPayload, { params: queryParams, headers });\n      } else if (method === 'PUT') {\n        request$ = this.http.put<unknown>(resolvedUrl, bodyPayload, { params: queryParams, headers });\n      } else {\n        request$ = this.http.request<unknown>(method, resolvedUrl, {\n          body: bodyPayload,\n          params: queryParams,\n          headers,\n        });\n      }\n    }\n\n    // 5. Extract & Normalize Target Data Array\n    return request$.pipe(\n      timeout({ first: this.reportingConfig?.executionTimeoutMs ?? this.reportingConfig?.lookupTimeoutMs ?? 300000 }),\n      map((response) => this.extractDataArray(response, options.dataPath)),\n      catchError((err) => {\n        console.error(`[ReportApiExecutionService] API execution error [${method} ${resolvedUrl}]:`, err);\n        const message =\n          err?.error?.message ||\n          err?.message ||\n          `API request failed with status ${err?.status || 'unknown'}`;\n        return throwError(() => new Error(message));\n      })\n    );\n  }\n\n  /**\n   * Dot-notation extractor: 'data.items' -> response.data.items\n   */\n  extractDataArray(response: any, dataPath?: string): unknown[] {\n    if (!response) return [];\n    if (Array.isArray(response)) return response;\n\n    if (dataPath && typeof dataPath === 'string' && dataPath.trim() !== '') {\n      const parts = dataPath.trim().split('.');\n      let current: any = response;\n      for (const part of parts) {\n        if (current && typeof current === 'object' && part in current) {\n          current = current[part];\n        } else {\n          current = null;\n          break;\n        }\n      }\n      if (Array.isArray(current)) return current;\n    }\n\n    // Auto-detect common response collection containers\n    for (const key of ['data', 'items', 'rows', 'records', 'results', 'result']) {\n      if (Array.isArray(response[key])) return response[key];\n    }\n\n    // If single object returned, wrap in array for grid display\n    if (typeof response === 'object' && response !== null) {\n      return [response];\n    }\n\n    return [];\n  }\n}\n"]}