bways-report 0.1.2 → 0.1.3

package/esm2022/lib/core/utils/data-normalization.util.mjs

@@ -0,0 +1,56 @@
+/**
+ * Utility to normalize arbitrary backend HTTP responses into standard array of records.
+ *
+ * Supports:
+ * - Direct array payloads: `[ { ... }, { ... } ]`
+ * - Standard envelope wrappers: `{ data: [...] }`, `{ rows: [...] }`, `{ result: [...] }`, `{ items: [...] }`
+ * - OData envelopes: `{ value: [...] }`
+ * - Paginated wrappers: `{ total: 100, page: 1, data: [...] }`
+ */
+export function extractRowArray(response) {
+    if (Array.isArray(response)) {
+        return response;
+    }
+    if (!response || typeof response !== 'object') {
+        return [];
+    }
+    const obj = response;
+    // Check common wrapper property names
+    const candidateKeys = ['data', 'rows', 'result', 'items', 'value', 'records', 'entities'];
+    for (const key of candidateKeys) {
+        const val = obj[key];
+        if (Array.isArray(val)) {
+            return val;
+        }
+    }
+    return [];
+}
+/**
+ * Case-insensitive lookup in an object/record.
+ * Searches for exact match first, then lower-cased match, then normalized (ignoring underscores/dashes).
+ */
+export function getFieldCaseInsensitive(record, targetKey) {
+    if (!record || typeof record !== 'object')
+        return undefined;
+    // 1. Exact match
+    if (targetKey in record) {
+        return record[targetKey];
+    }
+    // 2. Case-insensitive match
+    const targetLower = targetKey.toLowerCase();
+    for (const [k, v] of Object.entries(record)) {
+        if (k.toLowerCase() === targetLower) {
+            return v;
+        }
+    }
+    // 3. Normalized match (strip leading '@', underscores, dashes)
+    const normalize = (s) => s.replace(/^@/, '').replace(/[_\-\s]/g, '').toLowerCase();
+    const normalizedTarget = normalize(targetKey);
+    for (const [k, v] of Object.entries(record)) {
+        if (normalize(k) === normalizedTarget) {
+            return v;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/utils/report-parameter.util.mjs

@@ -0,0 +1,180 @@
+import { getFieldCaseInsensitive } from './data-normalization.util';
+const TOKEN_RE = /^\{\{\s*(.+?)\s*\}\}$/;
+const pad = (n) => String(n).padStart(2, '0');
+const formatYMD = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+/** Resolves `{{context.xxx}}` presets such as today / startOfMonth. */
+export function resolveContextPreset(key) {
+    const now = new Date();
+    switch (key.toLowerCase()) {
+        case 'yesterday': {
+            const y = new Date(now);
+            y.setDate(y.getDate() - 1);
+            return formatYMD(y);
+        }
+        case 'startofmonth':
+            return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-01`;
+        case 'endofmonth':
+            return formatYMD(new Date(now.getFullYear(), now.getMonth() + 1, 0));
+        case 'startofyear':
+            return `${now.getFullYear()}-01-01`;
+        case 'today':
+        default:
+            return formatYMD(now);
+    }
+}
+/**
+ * Looks up a field value from formValues supporting direct names, dot paths (a.b),
+ * and compound date ranges (e.g. dateRange.from, dateRange_from, dateRangeFrom).
+ */
+export function resolveCanvasFieldValue(formValues, inner) {
+    // 1. Direct case-insensitive lookup
+    const direct = getFieldCaseInsensitive(formValues, inner);
+    if (direct !== undefined && direct !== null) {
+        return direct;
+    }
+    // 2. Dot-path lookup (e.g. dateRange.from or user.address.city)
+    if (inner.includes('.')) {
+        const parts = inner.split('.');
+        let curr = formValues;
+        for (const p of parts) {
+            if (curr && typeof curr === 'object') {
+                curr = getFieldCaseInsensitive(curr, p);
+            }
+            else {
+                curr = undefined;
+                break;
+            }
+        }
+        if (curr !== undefined && curr !== null) {
+            return curr;
+        }
+    }
+    // 3. Compound date range matching (e.g. dateRange_from, dateRangeFrom, fromDate, toDate)
+    const lowerInner = inner.toLowerCase();
+    const isFrom = lowerInner.endsWith('_from') ||
+        lowerInner.endsWith('from') ||
+        lowerInner.startsWith('from') ||
+        lowerInner.startsWith('from_');
+    const isTo = !isFrom &&
+        (lowerInner.endsWith('_to') ||
+            lowerInner.endsWith('to') ||
+            lowerInner.startsWith('to') ||
+            lowerInner.startsWith('to_'));
+    if (isFrom || isTo) {
+        for (const [key, val] of Object.entries(formValues)) {
+            if (val && typeof val === 'object' && 'from' in val && 'to' in val) {
+                const rangeObj = val;
+                const cleanInner = lowerInner
+                    .replace(/^from_?|^to_?|_from$|_to$|from$|to$/, '')
+                    .toLowerCase();
+                if (cleanInner === '' || key.toLowerCase().includes(cleanInner) || cleanInner.includes(key.toLowerCase())) {
+                    return isFrom ? rangeObj.from : rangeObj.to;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolves one raw mapping value against session + canvas form values.
+ * - `{{session.branchId}}`  -> session value (case-insensitive)
+ * - `{{context.today}}`     -> computed date
+ * - `{{fromDate}}`          -> value of canvas field with key `fromDate` (case-insensitive)
+ * - `{{dateRange.from}}`    -> value of nested from property
+ * - anything else           -> returned unchanged (fixed value)
+ */
+export function resolveParameterValue(raw, session, formValues) {
+    if (typeof raw !== 'string')
+        return raw;
+    const m = TOKEN_RE.exec(raw);
+    if (!m)
+        return raw;
+    const inner = m[1];
+    if (inner.startsWith('session.')) {
+        const sessionKey = inner.slice(8);
+        const val = getFieldCaseInsensitive(session, sessionKey);
+        return val !== undefined && val !== null ? val : '';
+    }
+    if (inner.startsWith('context.')) {
+        return resolveContextPreset(inner.slice(8));
+    }
+    const v = resolveCanvasFieldValue(formValues, inner);
+    return v !== undefined && v !== null ? v : '';
+}
+/** Resolves every mapping into concrete values (de-duplicating `@name` / `name`). */
+export function resolveParameterMappings(mappings, session, formValues) {
+    const out = {};
+    for (const [key, raw] of Object.entries(mappings ?? {})) {
+        const val = resolveParameterValue(raw, session, formValues);
+        const cleanKey = key.replace(/^@/, '');
+        out[cleanKey] = val;
+        out[`@${cleanKey}`] = val;
+    }
+    return out;
+}
+/**
+ * Returns canvas field keys referenced by mappings that currently have no value.
+ * Session / context / fixed values never block execution.
+ */
+export function findMissingCanvasFields(mappings, formValues) {
+    const missing = new Set();
+    for (const raw of Object.values(mappings ?? {})) {
+        if (typeof raw !== 'string')
+            continue;
+        const m = TOKEN_RE.exec(raw);
+        if (!m)
+            continue;
+        const inner = m[1];
+        if (inner.startsWith('session.') || inner.startsWith('context.'))
+            continue;
+        const v = resolveCanvasFieldValue(formValues, inner);
+        if (v === undefined || v === null || (typeof v === 'string' && v.trim() === '')) {
+            missing.add(inner);
+        }
+        else if (typeof v === 'object' && !Array.isArray(v) && 'from' in v) {
+            const r = v;
+            if (!r.from && !r.to) {
+                missing.add(inner);
+            }
+        }
+    }
+    return [...missing];
+}
+/**
+ * Picks the data source the result grid should run:
+ * 1. the one referenced by `grid.dataSourceId`
+ * 2. otherwise the first declared data source
+ * 3. otherwise a procedure/table bound to a component (legacy reports)
+ */
+export function resolveExecutionDataSource(def) {
+    const sources = def.dataSources ?? [];
+    const byId = sources.find((d) => d.id === def.grid?.dataSourceId);
+    if (byId)
+        return byId;
+    if (sources.length > 0)
+        return sources[0];
+    const comp = def.components.find((c) => c.dataSource?.entityName);
+    const cds = comp?.dataSource;
+    if (cds?.entityName) {
+        const isTable = cds.sourceType === 'table';
+        return {
+            id: `sp-${cds.entityName}`,
+            name: cds.entityName,
+            endpoint: cds.entityName,
+            schema: cds.schema || 'dbo',
+            type: isTable ? 'table' : 'stored_procedure',
+            method: isTable ? 'GET' : 'STORED_PROCEDURE',
+            parameterMappings: cds.parameterMappings,
+        };
+    }
+    return null;
+}
+/** Strips SQL Server Hungarian prefixes: `@chrFromDate` -> `fromDate`. */
+export function toFieldKey(paramName) {
+    const stripped = paramName
+        .replace(/^@+/, '')
+        .replace(/^(chr|int|vchr|nchr|dt|str|num|bit|dec|flt)(?=[A-Z_])/, '');
+    const clean = stripped.replace(/[^a-zA-Z0-9]+(.)?/g, (_m, c) => (c ? c.toUpperCase() : ''));
+    return clean ? clean.charAt(0).toLowerCase() + clean.slice(1) : paramName;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-parameter.util.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/utils/report-parameter.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReportDefinition } from '../models/report-definition.model';\nimport { ReportDataSourceDefinition } from '../models/report-datasource.model';\nimport { getFieldCaseInsensitive } from './data-normalization.util';\n\nexport type ParameterMappings = Record<string, string | number | boolean>;\n\nconst TOKEN_RE = /^\\{\\{\\s*(.+?)\\s*\\}\\}$/;\n\nconst pad = (n: number): string => String(n).padStart(2, '0');\nconst formatYMD = (d: Date): string => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;\n\n/** Resolves `{{context.xxx}}` presets such as today / startOfMonth. */\nexport function resolveContextPreset(key: string): string {\n  const now = new Date();\n  switch (key.toLowerCase()) {\n    case 'yesterday': {\n      const y = new Date(now);\n      y.setDate(y.getDate() - 1);\n      return formatYMD(y);\n    }\n    case 'startofmonth':\n      return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-01`;\n    case 'endofmonth':\n      return formatYMD(new Date(now.getFullYear(), now.getMonth() + 1, 0));\n    case 'startofyear':\n      return `${now.getFullYear()}-01-01`;\n    case 'today':\n    default:\n      return formatYMD(now);\n  }\n}\n\n/**\n * Looks up a field value from formValues supporting direct names, dot paths (a.b),\n * and compound date ranges (e.g. dateRange.from, dateRange_from, dateRangeFrom).\n */\nexport function resolveCanvasFieldValue(\n  formValues: Record<string, unknown>,\n  inner: string\n): unknown {\n  // 1. Direct case-insensitive lookup\n  const direct = getFieldCaseInsensitive(formValues, inner);\n  if (direct !== undefined && direct !== null) {\n    return direct;\n  }\n\n  // 2. Dot-path lookup (e.g. dateRange.from or user.address.city)\n  if (inner.includes('.')) {\n    const parts = inner.split('.');\n    let curr: unknown = formValues;\n    for (const p of parts) {\n      if (curr && typeof curr === 'object') {\n        curr = getFieldCaseInsensitive(curr as Record<string, unknown>, p);\n      } else {\n        curr = undefined;\n        break;\n      }\n    }\n    if (curr !== undefined && curr !== null) {\n      return curr;\n    }\n  }\n\n  // 3. Compound date range matching (e.g. dateRange_from, dateRangeFrom, fromDate, toDate)\n  const lowerInner = inner.toLowerCase();\n  const isFrom =\n    lowerInner.endsWith('_from') ||\n    lowerInner.endsWith('from') ||\n    lowerInner.startsWith('from') ||\n    lowerInner.startsWith('from_');\n\n  const isTo =\n    !isFrom &&\n    (lowerInner.endsWith('_to') ||\n      lowerInner.endsWith('to') ||\n      lowerInner.startsWith('to') ||\n      lowerInner.startsWith('to_'));\n\n  if (isFrom || isTo) {\n    for (const [key, val] of Object.entries(formValues)) {\n      if (val && typeof val === 'object' && 'from' in (val as any) && 'to' in (val as any)) {\n        const rangeObj = val as { from: unknown; to: unknown };\n        const cleanInner = lowerInner\n          .replace(/^from_?|^to_?|_from$|_to$|from$|to$/, '')\n          .toLowerCase();\n        if (cleanInner === '' || key.toLowerCase().includes(cleanInner) || cleanInner.includes(key.toLowerCase())) {\n          return isFrom ? rangeObj.from : rangeObj.to;\n        }\n      }\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Resolves one raw mapping value against session + canvas form values.\n * - `{{session.branchId}}`  -> session value (case-insensitive)\n * - `{{context.today}}`     -> computed date\n * - `{{fromDate}}`          -> value of canvas field with key `fromDate` (case-insensitive)\n * - `{{dateRange.from}}`    -> value of nested from property\n * - anything else           -> returned unchanged (fixed value)\n */\nexport function resolveParameterValue(\n  raw: unknown,\n  session: Record<string, unknown>,\n  formValues: Record<string, unknown>\n): unknown {\n  if (typeof raw !== 'string') return raw;\n  const m = TOKEN_RE.exec(raw);\n  if (!m) return raw;\n  const inner = m[1];\n  if (inner.startsWith('session.')) {\n    const sessionKey = inner.slice(8);\n    const val = getFieldCaseInsensitive(session, sessionKey);\n    return val !== undefined && val !== null ? val : '';\n  }\n  if (inner.startsWith('context.')) {\n    return resolveContextPreset(inner.slice(8));\n  }\n  const v = resolveCanvasFieldValue(formValues, inner);\n  return v !== undefined && v !== null ? v : '';\n}\n\n/** Resolves every mapping into concrete values (de-duplicating `@name` / `name`). */\nexport function resolveParameterMappings(\n  mappings: ParameterMappings | undefined,\n  session: Record<string, unknown>,\n  formValues: Record<string, unknown>\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const [key, raw] of Object.entries(mappings ?? {})) {\n    const val = resolveParameterValue(raw, session, formValues);\n    const cleanKey = key.replace(/^@/, '');\n    out[cleanKey] = val;\n    out[`@${cleanKey}`] = val;\n  }\n  return out;\n}\n\n/**\n * Returns canvas field keys referenced by mappings that currently have no value.\n * Session / context / fixed values never block execution.\n */\nexport function findMissingCanvasFields(\n  mappings: ParameterMappings | undefined,\n  formValues: Record<string, unknown>\n): string[] {\n  const missing = new Set<string>();\n  for (const raw of Object.values(mappings ?? {})) {\n    if (typeof raw !== 'string') continue;\n    const m = TOKEN_RE.exec(raw);\n    if (!m) continue;\n    const inner = m[1];\n    if (inner.startsWith('session.') || inner.startsWith('context.')) continue;\n    const v = resolveCanvasFieldValue(formValues, inner);\n    if (v === undefined || v === null || (typeof v === 'string' && v.trim() === '')) {\n      missing.add(inner);\n    } else if (typeof v === 'object' && !Array.isArray(v) && 'from' in (v as any)) {\n      const r = v as { from?: string; to?: string };\n      if (!r.from && !r.to) {\n        missing.add(inner);\n      }\n    }\n  }\n  return [...missing];\n}\n\n/**\n * Picks the data source the result grid should run:\n * 1. the one referenced by `grid.dataSourceId`\n * 2. otherwise the first declared data source\n * 3. otherwise a procedure/table bound to a component (legacy reports)\n */\nexport function resolveExecutionDataSource(def: ReportDefinition): ReportDataSourceDefinition | null {\n  const sources = def.dataSources ?? [];\n  const byId = sources.find((d) => d.id === def.grid?.dataSourceId);\n  if (byId) return byId;\n  if (sources.length > 0) return sources[0];\n\n  const comp = def.components.find((c) => c.dataSource?.entityName);\n  const cds = comp?.dataSource;\n  if (cds?.entityName) {\n    const isTable = cds.sourceType === 'table';\n    return {\n      id: `sp-${cds.entityName}`,\n      name: cds.entityName,\n      endpoint: cds.entityName,\n      schema: cds.schema || 'dbo',\n      type: isTable ? 'table' : 'stored_procedure',\n      method: isTable ? 'GET' : 'STORED_PROCEDURE',\n      parameterMappings: cds.parameterMappings,\n    };\n  }\n  return null;\n}\n\n/** Strips SQL Server Hungarian prefixes: `@chrFromDate` -> `fromDate`. */\nexport function toFieldKey(paramName: string): string {\n  const stripped = paramName\n    .replace(/^@+/, '')\n    .replace(/^(chr|int|vchr|nchr|dt|str|num|bit|dec|flt)(?=[A-Z_])/, '');\n  const clean = stripped.replace(/[^a-zA-Z0-9]+(.)?/g, (_m, c: string | undefined) => (c ? c.toUpperCase() : ''));\n  return clean ? clean.charAt(0).toLowerCase() + clean.slice(1) : paramName;\n}\n"]}

package/esm2022/lib/data-access/adapters/http-datasource.adapter.mjs

@@ -0,0 +1,82 @@
+import { inject, Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { of, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { ReportDataSourceAdapter } from '../contracts/data-source.contract';
+import { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';
+import { ReportSessionContextService } from '../../core/services/report-session-context.service';
+import { extractRowArray } from '../../core/utils/data-normalization.util';
+import * as i0 from "@angular/core";
+/**
+ * Built-in HTTP adapter for executing report data sources against the reporting backend.
+ * Automatically injects active multi-tenant session headers (X-Company-Id, X-Branch-Id)
+ * and includes rich development fallback data when the backend is unreachable.
+ */
+export class HttpReportDataSourceAdapter extends ReportDataSourceAdapter {
+    http = inject(HttpClient, { optional: true });
+    config = inject(REPORTING_CONFIG, { optional: true });
+    sessionService = inject(ReportSessionContextService, { optional: true });
+    execute(dataSource, parameters) {
+        const baseUrl = this.config?.apiBaseUrl;
+        const session = this.sessionService?.sessionContext() ?? {};
+        if (baseUrl && this.http) {
+            let headers = new HttpHeaders();
+            if (session['companyId'] !== undefined && session['companyId'] !== null) {
+                headers = headers.set('X-Company-Id', String(session['companyId']));
+            }
+            if (session['branchId'] !== undefined && session['branchId'] !== null) {
+                headers = headers.set('X-Branch-Id', String(session['branchId']));
+            }
+            const payload = {
+                dataSource,
+                parameters,
+                sessionContext: session,
+            };
+            return this.http.post(`${baseUrl}/execute`, payload, { headers }).pipe(map((response) => extractRowArray(response)), catchError((err) => {
+                const msg = err?.error?.message || err?.message || 'Report execution failed';
+                return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));
+            }));
+        }
+        return of(this.getMockExecutionData(parameters));
+    }
+    getMockExecutionData(parameters) {
+        const rawData = [
+            { invoiceNo: 'INV-2024-001', date: '2024-01-05', customer: 'Acme Corp', branch: 'New York', amount: 12500, status: 'Paid', customerId: 101, branchId: 1 },
+            { invoiceNo: 'INV-2024-002', date: '2024-01-12', customer: 'Globex Inc', branch: 'London', amount: 8400, status: 'Paid', customerId: 102, branchId: 2 },
+            { invoiceNo: 'INV-2024-003', date: '2024-01-18', customer: 'Initech Software', branch: 'New York', amount: 3200, status: 'Pending', customerId: 103, branchId: 1 },
+            { invoiceNo: 'INV-2024-004', date: '2024-01-25', customer: 'Umbrella Corp', branch: 'Singapore', amount: 21000, status: 'Paid', customerId: 104, branchId: 3 },
+            { invoiceNo: 'INV-2024-005', date: '2024-02-02', customer: 'Wayne Enterprises', branch: 'London', amount: 15600, status: 'Pending', customerId: 105, branchId: 2 },
+            { invoiceNo: 'INV-2024-006', date: '2024-02-08', customer: 'Stark Industries', branch: 'New York', amount: 45000, status: 'Paid', customerId: 106, branchId: 1 },
+            { invoiceNo: 'INV-2024-007', date: '2024-02-14', customer: 'Acme Corp', branch: 'New York', amount: 6750, status: 'Pending', customerId: 101, branchId: 1 },
+            { invoiceNo: 'INV-2024-008', date: '2024-02-20', customer: 'Globex Inc', branch: 'London', amount: 11200, status: 'Paid', customerId: 102, branchId: 2 },
+            { invoiceNo: 'INV-2024-009', date: '2024-02-24', customer: 'Initech Software', branch: 'New York', amount: 4800, status: 'Overdue', customerId: 103, branchId: 1 },
+            { invoiceNo: 'INV-2024-010', date: '2024-02-28', customer: 'Wayne Enterprises', branch: 'London', amount: 9800, status: 'Paid', customerId: 105, branchId: 2 },
+        ];
+        let result = [...rawData];
+        if (parameters['customerId']) {
+            const cid = Number(parameters['customerId']);
+            result = result.filter((row) => row.customerId === cid);
+        }
+        if (parameters['status']) {
+            const st = String(parameters['status']).toLowerCase();
+            result = result.filter((row) => row.status.toLowerCase().includes(st) || st.includes(row.status.toLowerCase()));
+        }
+        if (parameters['fromDate']) {
+            const from = String(parameters['fromDate']);
+            result = result.filter((row) => row.date >= from);
+        }
+        if (parameters['toDate']) {
+            const to = String(parameters['toDate']);
+            result = result.filter((row) => row.date <= to);
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpReportDataSourceAdapter, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpReportDataSourceAdapter });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpReportDataSourceAdapter, decorators: [{
+            type: Injectable
+        }] });
+/** Convenience alias */
+export const HttpDataSourceAdapter = HttpReportDataSourceAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-datasource.adapter.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/data-access/adapters/http-datasource.adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { ReportDataSourceAdapter } from '../contracts/data-source.contract';\nimport { ReportDataSourceDefinition } from '../../core/models/report-datasource.model';\nimport { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';\nimport { ReportSessionContextService } from '../../core/services/report-session-context.service';\nimport { ExecuteReportRequest } from '../contracts/api-dtos';\nimport { extractRowArray } from '../../core/utils/data-normalization.util';\n\n/**\n * Built-in HTTP adapter for executing report data sources against the reporting backend.\n * Automatically injects active multi-tenant session headers (X-Company-Id, X-Branch-Id)\n * and includes rich development fallback data when the backend is unreachable.\n */\n@Injectable()\nexport class HttpReportDataSourceAdapter extends ReportDataSourceAdapter {\n  private readonly http = inject(HttpClient, { optional: true });\n  private readonly config = inject(REPORTING_CONFIG, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  execute(\n    dataSource: ReportDataSourceDefinition,\n    parameters: Record<string, unknown>\n  ): Observable<unknown[]> {\n    const baseUrl = this.config?.apiBaseUrl;\n    const session = this.sessionService?.sessionContext() ?? {};\n\n    if (baseUrl && this.http) {\n      let headers = new HttpHeaders();\n      if (session['companyId'] !== undefined && session['companyId'] !== null) {\n        headers = headers.set('X-Company-Id', String(session['companyId']));\n      }\n      if (session['branchId'] !== undefined && session['branchId'] !== null) {\n        headers = headers.set('X-Branch-Id', String(session['branchId']));\n      }\n\n      const payload: ExecuteReportRequest = {\n        dataSource,\n        parameters,\n        sessionContext: session,\n      };\n\n      return this.http.post<unknown>(`${baseUrl}/execute`, payload, { headers }).pipe(\n        map((response) => extractRowArray(response)),\n        catchError((err) => {\n          const msg = err?.error?.message || err?.message || 'Report execution failed';\n          return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));\n        })\n      );\n    }\n\n    return of(this.getMockExecutionData(parameters));\n  }\n\n  private getMockExecutionData(parameters: Record<string, unknown>): unknown[] {\n    const rawData = [\n      { invoiceNo: 'INV-2024-001', date: '2024-01-05', customer: 'Acme Corp', branch: 'New York', amount: 12500, status: 'Paid', customerId: 101, branchId: 1 },\n      { invoiceNo: 'INV-2024-002', date: '2024-01-12', customer: 'Globex Inc', branch: 'London', amount: 8400, status: 'Paid', customerId: 102, branchId: 2 },\n      { invoiceNo: 'INV-2024-003', date: '2024-01-18', customer: 'Initech Software', branch: 'New York', amount: 3200, status: 'Pending', customerId: 103, branchId: 1 },\n      { invoiceNo: 'INV-2024-004', date: '2024-01-25', customer: 'Umbrella Corp', branch: 'Singapore', amount: 21000, status: 'Paid', customerId: 104, branchId: 3 },\n      { invoiceNo: 'INV-2024-005', date: '2024-02-02', customer: 'Wayne Enterprises', branch: 'London', amount: 15600, status: 'Pending', customerId: 105, branchId: 2 },\n      { invoiceNo: 'INV-2024-006', date: '2024-02-08', customer: 'Stark Industries', branch: 'New York', amount: 45000, status: 'Paid', customerId: 106, branchId: 1 },\n      { invoiceNo: 'INV-2024-007', date: '2024-02-14', customer: 'Acme Corp', branch: 'New York', amount: 6750, status: 'Pending', customerId: 101, branchId: 1 },\n      { invoiceNo: 'INV-2024-008', date: '2024-02-20', customer: 'Globex Inc', branch: 'London', amount: 11200, status: 'Paid', customerId: 102, branchId: 2 },\n      { invoiceNo: 'INV-2024-009', date: '2024-02-24', customer: 'Initech Software', branch: 'New York', amount: 4800, status: 'Overdue', customerId: 103, branchId: 1 },\n      { invoiceNo: 'INV-2024-010', date: '2024-02-28', customer: 'Wayne Enterprises', branch: 'London', amount: 9800, status: 'Paid', customerId: 105, branchId: 2 },\n    ];\n\n    let result = [...rawData];\n\n    if (parameters['customerId']) {\n      const cid = Number(parameters['customerId']);\n      result = result.filter((row) => row.customerId === cid);\n    }\n    if (parameters['status']) {\n      const st = String(parameters['status']).toLowerCase();\n      result = result.filter((row) => row.status.toLowerCase().includes(st) || st.includes(row.status.toLowerCase()));\n    }\n    if (parameters['fromDate']) {\n      const from = String(parameters['fromDate']);\n      result = result.filter((row) => row.date >= from);\n    }\n    if (parameters['toDate']) {\n      const to = String(parameters['toDate']);\n      result = result.filter((row) => row.date <= to);\n    }\n\n    return result;\n  }\n}\n\n/** Convenience alias */\nexport const HttpDataSourceAdapter = HttpReportDataSourceAdapter;\n"]}

package/esm2022/lib/data-access/adapters/http-lookup.adapter.mjs

@@ -1,9 +1,11 @@
 import { inject, Injectable } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { of } from 'rxjs';
-import { catchError, tap } from 'rxjs/operators';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { of, throwError } from 'rxjs';
+import { catchError, map, tap } from 'rxjs/operators';
 import { ReportLookupAdapter, } from '../contracts/lookup.contract';
 import { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';
+import { ReportSessionContextService } from '../../core/services/report-session-context.service';
+import { extractRowArray } from '../../core/utils/data-normalization.util';
 import * as i0 from "@angular/core";
 /**
  * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.
@@ -12,6 +14,7 @@ import * as i0 from "@angular/core";
 export class HttpReportLookupAdapter extends ReportLookupAdapter {
     http = inject(HttpClient, { optional: true });
     config = inject(REPORTING_CONFIG, { optional: true });
+    sessionService = inject(ReportSessionContextService, { optional: true });
     cache = new Map();
     mockDataStore = {
         Customers: [
@@ -61,11 +64,31 @@ export class HttpReportLookupAdapter extends ReportLookupAdapter {
         }
         const baseUrl = this.config?.apiBaseUrl;
         if (baseUrl && this.http) {
-            return this.http.post(`${baseUrl}/lookup`, request).pipe(tap((items) => this.setCache(cacheKey, items)), catchError((err) => {
-                console.warn('[HttpLookupAdapter] Remote lookup failed, falling back to mock:', err);
-                const fallback = this.resolveMockOptions(request);
-                this.setCache(cacheKey, fallback);
-                return of(fallback);
+            const session = this.sessionService?.sessionContext() ?? {};
+            let headers = new HttpHeaders();
+            if (session['companyId'] !== undefined && session['companyId'] !== null) {
+                headers = headers.set('X-Company-Id', String(session['companyId']));
+            }
+            if (session['branchId'] !== undefined && session['branchId'] !== null) {
+                headers = headers.set('X-Branch-Id', String(session['branchId']));
+            }
+            return this.http.post(`${baseUrl}/lookup`, request, { headers }).pipe(map((response) => {
+                const rawItems = extractRowArray(response);
+                return rawItems.map((r) => {
+                    if (r && typeof r === 'object' && 'value' in r) {
+                        return r;
+                    }
+                    const val = r?.[request.valueField] ?? r?.id ?? r?.code ?? String(r ?? '');
+                    const lbl = r?.[request.displayField] ?? r?.name ?? r?.title ?? String(val);
+                    return { value: val, label: lbl, raw: r };
+                });
+            }), tap((items) => {
+                // Never cache empty results: parameters may simply not have been filled yet.
+                if (items.length > 0)
+                    this.setCache(cacheKey, items);
+            }), catchError((err) => {
+                const msg = err?.error?.message || err?.message || 'Lookup request failed';
+                return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));
             }));
         }
         const fallback = this.resolveMockOptions(request);
@@ -104,4 +127,6 @@ export class HttpReportLookupAdapter extends ReportLookupAdapter {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpReportLookupAdapter, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-lookup.adapter.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/data-access/adapters/http-lookup.adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, of } from 'rxjs';\nimport { catchError, map, tap } from 'rxjs/operators';\nimport {\n  LookupOptionItem,\n  LookupQueryRequest,\n  ReportLookupAdapter,\n} from '../contracts/lookup.contract';\nimport { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';\n\ninterface CacheEntry {\n  expiresAt: number;\n  data: LookupOptionItem[];\n}\n\n/**\n * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.\n * Includes in-memory caching with TTL and rich fallback mock data for testing.\n */\n@Injectable()\nexport class HttpReportLookupAdapter extends ReportLookupAdapter {\n  private readonly http = inject(HttpClient, { optional: true });\n  private readonly config = inject(REPORTING_CONFIG, { optional: true });\n\n  private readonly cache = new Map<string, CacheEntry>();\n\n  private readonly mockDataStore: Record<string, Array<{ [key: string]: unknown }>> = {\n    Customers: [\n      { customerId: 101, customerName: 'Acme Corporation', branchId: 1, isActive: true },\n      { customerId: 102, customerName: 'Globex Industries', branchId: 2, isActive: true },\n      { customerId: 103, customerName: 'Initech Software', branchId: 1, isActive: true },\n      { customerId: 104, customerName: 'Umbrella Corporation', branchId: 3, isActive: true },\n      { customerId: 105, customerName: 'Wayne Enterprises', branchId: 2, isActive: true },\n      { customerId: 106, customerName: 'Stark Industries', branchId: 1, isActive: true },\n    ],\n    Branches: [\n      { branchId: 1, branchName: 'North America HQ (New York)', region: 'North America' },\n      { branchId: 2, branchName: 'EMEA Division (London)', region: 'Europe' },\n      { branchId: 3, branchName: 'APAC Hub (Singapore)', region: 'Asia Pacific' },\n      { branchId: 4, branchName: 'LATAM Office (São Paulo)', region: 'Latin America' },\n    ],\n    Products: [\n      { productId: 1, productName: 'Enterprise ERP Suite', category: 'Software', unitPrice: 2400 },\n      { productId: 2, productName: 'Cloud Analytics Pro', category: 'SaaS', unitPrice: 1200 },\n      { productId: 3, productName: 'Security Shield Endpoint', category: 'Security', unitPrice: 850 },\n      { productId: 4, productName: 'Dedicated API Gateway', category: 'Infrastructure', unitPrice: 3100 },\n    ],\n    PaymentMethods: [\n      { code: 'BANK_TRANSFER', title: 'Direct Bank Wire' },\n      { code: 'CREDIT_CARD', title: 'Corporate Credit Card' },\n      { code: 'PAYPAL', title: 'PayPal Corporate' },\n      { code: 'NET_30', title: 'Net 30 Invoicing' },\n    ],\n    usp_GetCustomerList: [\n      { id: 101, name: 'Acme Corporation (SP)', branchId: 1, branch: 'NA' },\n      { id: 102, name: 'Globex Industries (SP)', branchId: 2, branch: 'EMEA' },\n      { id: 105, name: 'Wayne Enterprises (SP)', branchId: 1, branch: 'NA' },\n      { id: 106, name: 'Stark Industries (SP)', branchId: 3, branch: 'APAC' },\n    ],\n    usp_GetBranchLookup: [\n      { id: 1, name: 'North America HQ' },\n      { id: 2, name: 'EMEA Division' },\n      { id: 3, name: 'APAC Hub' },\n    ],\n  };\n\n  fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]> {\n    const cacheKey = this.generateCacheKey(request);\n    const cached = this.cache.get(cacheKey);\n    const now = Date.now();\n\n    if (cached && cached.expiresAt > now) {\n      return of(cached.data);\n    }\n\n    const baseUrl = this.config?.apiBaseUrl;\n    if (baseUrl && this.http) {\n      return this.http.post<LookupOptionItem[]>(`${baseUrl}/lookup`, request).pipe(\n        tap((items) => this.setCache(cacheKey, items)),\n        catchError((err) => {\n          console.warn('[HttpLookupAdapter] Remote lookup failed, falling back to mock:', err);\n          const fallback = this.resolveMockOptions(request);\n          this.setCache(cacheKey, fallback);\n          return of(fallback);\n        })\n      );\n    }\n\n    const fallback = this.resolveMockOptions(request);\n    this.setCache(cacheKey, fallback);\n    return of(fallback);\n  }\n\n  private setCache(key: string, data: LookupOptionItem[], ttlSeconds = 300): void {\n    this.cache.set(key, {\n      expiresAt: Date.now() + ttlSeconds * 1000,\n      data,\n    });\n  }\n\n  private generateCacheKey(req: LookupQueryRequest): string {\n    return `${req.sourceType}:${req.entityName}:${req.valueField}:${req.displayField}:${JSON.stringify(req.filter ?? {})}:${JSON.stringify(req.parameters ?? {})}`;\n  }\n\n  private resolveMockOptions(req: LookupQueryRequest): LookupOptionItem[] {\n    const entity = req.entityName || '';\n    const records = this.mockDataStore[entity] ?? [];\n    const valKey = req.valueField;\n    const labelKey = req.displayField;\n\n    let filteredRecords = records;\n    const branchParam = req.parameters?.['@BranchId'] ?? req.parameters?.['branchId'];\n    if (branchParam !== undefined && branchParam !== null && branchParam !== '') {\n      const matchNum = Number(branchParam);\n      filteredRecords = records.filter(\n        (r) => r['branchId'] === undefined || r['branchId'] === matchNum || r['branch'] === String(branchParam)\n      );\n    }\n\n    return filteredRecords.map((r) => ({\n      value: (r[valKey] as string | number) ?? String(r['id'] ?? r['code'] ?? ''),\n      label: (r[labelKey] as string) ?? String(r['name'] ?? r['title'] ?? ''),\n      raw: r,\n    }));\n  }\n}\n"]}
+/** Convenience alias */
+export const HttpLookupAdapter = HttpReportLookupAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-lookup.adapter.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/data-access/adapters/http-lookup.adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map, tap } from 'rxjs/operators';\nimport {\n  LookupOptionItem,\n  LookupQueryRequest,\n  ReportLookupAdapter,\n} from '../contracts/lookup.contract';\nimport { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';\nimport { ReportSessionContextService } from '../../core/services/report-session-context.service';\nimport { extractRowArray } from '../../core/utils/data-normalization.util';\n\ninterface CacheEntry {\n  expiresAt: number;\n  data: LookupOptionItem[];\n}\n\n/**\n * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.\n * Includes in-memory caching with TTL and rich fallback mock data for testing.\n */\n@Injectable()\nexport class HttpReportLookupAdapter extends ReportLookupAdapter {\n  private readonly http = inject(HttpClient, { optional: true });\n  private readonly config = inject(REPORTING_CONFIG, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  private readonly cache = new Map<string, CacheEntry>();\n\n  private readonly mockDataStore: Record<string, Array<{ [key: string]: unknown }>> = {\n    Customers: [\n      { customerId: 101, customerName: 'Acme Corporation', branchId: 1, isActive: true },\n      { customerId: 102, customerName: 'Globex Industries', branchId: 2, isActive: true },\n      { customerId: 103, customerName: 'Initech Software', branchId: 1, isActive: true },\n      { customerId: 104, customerName: 'Umbrella Corporation', branchId: 3, isActive: true },\n      { customerId: 105, customerName: 'Wayne Enterprises', branchId: 2, isActive: true },\n      { customerId: 106, customerName: 'Stark Industries', branchId: 1, isActive: true },\n    ],\n    Branches: [\n      { branchId: 1, branchName: 'North America HQ (New York)', region: 'North America' },\n      { branchId: 2, branchName: 'EMEA Division (London)', region: 'Europe' },\n      { branchId: 3, branchName: 'APAC Hub (Singapore)', region: 'Asia Pacific' },\n      { branchId: 4, branchName: 'LATAM Office (São Paulo)', region: 'Latin America' },\n    ],\n    Products: [\n      { productId: 1, productName: 'Enterprise ERP Suite', category: 'Software', unitPrice: 2400 },\n      { productId: 2, productName: 'Cloud Analytics Pro', category: 'SaaS', unitPrice: 1200 },\n      { productId: 3, productName: 'Security Shield Endpoint', category: 'Security', unitPrice: 850 },\n      { productId: 4, productName: 'Dedicated API Gateway', category: 'Infrastructure', unitPrice: 3100 },\n    ],\n    PaymentMethods: [\n      { code: 'BANK_TRANSFER', title: 'Direct Bank Wire' },\n      { code: 'CREDIT_CARD', title: 'Corporate Credit Card' },\n      { code: 'PAYPAL', title: 'PayPal Corporate' },\n      { code: 'NET_30', title: 'Net 30 Invoicing' },\n    ],\n    usp_GetCustomerList: [\n      { id: 101, name: 'Acme Corporation (SP)', branchId: 1, branch: 'NA' },\n      { id: 102, name: 'Globex Industries (SP)', branchId: 2, branch: 'EMEA' },\n      { id: 105, name: 'Wayne Enterprises (SP)', branchId: 1, branch: 'NA' },\n      { id: 106, name: 'Stark Industries (SP)', branchId: 3, branch: 'APAC' },\n    ],\n    usp_GetBranchLookup: [\n      { id: 1, name: 'North America HQ' },\n      { id: 2, name: 'EMEA Division' },\n      { id: 3, name: 'APAC Hub' },\n    ],\n  };\n\n  fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]> {\n    const cacheKey = this.generateCacheKey(request);\n    const cached = this.cache.get(cacheKey);\n    const now = Date.now();\n\n    if (cached && cached.expiresAt > now) {\n      return of(cached.data);\n    }\n\n    const baseUrl = this.config?.apiBaseUrl;\n    if (baseUrl && this.http) {\n      const session = this.sessionService?.sessionContext() ?? {};\n      let headers = new HttpHeaders();\n      if (session['companyId'] !== undefined && session['companyId'] !== null) {\n        headers = headers.set('X-Company-Id', String(session['companyId']));\n      }\n      if (session['branchId'] !== undefined && session['branchId'] !== null) {\n        headers = headers.set('X-Branch-Id', String(session['branchId']));\n      }\n\n      return this.http.post<unknown>(`${baseUrl}/lookup`, request, { headers }).pipe(\n        map((response) => {\n          const rawItems = extractRowArray(response);\n          return rawItems.map((r: any) => {\n            if (r && typeof r === 'object' && 'value' in r) {\n              return r as LookupOptionItem;\n            }\n            const val = r?.[request.valueField] ?? r?.id ?? r?.code ?? String(r ?? '');\n            const lbl = r?.[request.displayField] ?? r?.name ?? r?.title ?? String(val);\n            return { value: val, label: lbl, raw: r };\n          });\n        }),\n        tap((items) => {\n          // Never cache empty results: parameters may simply not have been filled yet.\n          if (items.length > 0) this.setCache(cacheKey, items);\n        }),\n        catchError((err) => {\n          const msg = err?.error?.message || err?.message || 'Lookup request failed';\n          return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));\n        })\n      );\n    }\n\n    const fallback = this.resolveMockOptions(request);\n    this.setCache(cacheKey, fallback);\n    return of(fallback);\n  }\n\n  private setCache(key: string, data: LookupOptionItem[], ttlSeconds = 300): void {\n    this.cache.set(key, {\n      expiresAt: Date.now() + ttlSeconds * 1000,\n      data,\n    });\n  }\n\n  private generateCacheKey(req: LookupQueryRequest): string {\n    return `${req.sourceType}:${req.entityName}:${req.valueField}:${req.displayField}:${JSON.stringify(req.filter ?? {})}:${JSON.stringify(req.parameters ?? {})}`;\n  }\n\n  private resolveMockOptions(req: LookupQueryRequest): LookupOptionItem[] {\n    const entity = req.entityName || '';\n    const records = this.mockDataStore[entity] ?? [];\n    const valKey = req.valueField;\n    const labelKey = req.displayField;\n\n    let filteredRecords = records;\n    const branchParam = req.parameters?.['@BranchId'] ?? req.parameters?.['branchId'];\n    if (branchParam !== undefined && branchParam !== null && branchParam !== '') {\n      const matchNum = Number(branchParam);\n      filteredRecords = records.filter(\n        (r) => r['branchId'] === undefined || r['branchId'] === matchNum || r['branch'] === String(branchParam)\n      );\n    }\n\n    return filteredRecords.map((r) => ({\n      value: (r[valKey] as string | number) ?? String(r['id'] ?? r['code'] ?? ''),\n      label: (r[labelKey] as string) ?? String(r['name'] ?? r['title'] ?? ''),\n      raw: r,\n    }));\n  }\n}\n\n/** Convenience alias */\nexport const HttpLookupAdapter = HttpReportLookupAdapter;\n"]}

package/esm2022/lib/data-access/adapters/http-masterdata.adapter.mjs

@@ -0,0 +1,38 @@
+import { inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { MasterDataProvider, } from '../contracts/master-data.provider';
+import { ReportLookupAdapter } from '../contracts/lookup.contract';
+import * as i0 from "@angular/core";
+/**
+ * Built-in HTTP adapter for legacy master data queries.
+ * Integrates directly with the reporting backend lookup service.
+ */
+export class HttpMasterDataAdapter extends MasterDataProvider {
+    lookupAdapter = inject(ReportLookupAdapter);
+    getMasterData(masterName, options) {
+        return this.lookupAdapter
+            .fetchOptions({
+            sourceType: 'table',
+            entityName: masterName,
+            valueField: 'id',
+            displayField: 'name',
+            filter: options?.filter,
+            parameters: {
+                searchText: options?.searchText,
+                limit: options?.limit,
+                ...(options?.filter || {}),
+            },
+        })
+            .pipe(map((items) => items.map((item) => ({
+            value: item.value,
+            label: item.label,
+            ...(item.raw || {}),
+        }))));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpMasterDataAdapter, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpMasterDataAdapter });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpMasterDataAdapter, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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