bways-report 0.1.6 → 0.1.8

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

@@ -0,0 +1,83 @@
+/**
+ * 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.
+ */
+/**
+ * Mapping from friendly palette category names to internal category IDs.
+ */
+export const PALETTE_CATEGORY_MAP = {
+    formInputs: 'input',
+    actionButtons: 'action',
+    displayLabels: 'display',
+    dataLookups: 'data',
+    layout: 'layout',
+};
+/**
+ * Normalizes a `BwaysReportConfig` into the internal format.
+ * Validates required fields 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'.`);
+    }
+    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'.`);
+    }
+    // Map component palette categories
+    let allowedCategories = null;
+    if (config.components && config.components.length > 0) {
+        allowedCategories = config.components.map((friendly) => {
+            const internal = PALETTE_CATEGORY_MAP[friendly];
+            if (!internal) {
+                console.warn(`[bways-report] Unknown component category "${friendly}". ` +
+                    `Valid options: ${Object.keys(PALETTE_CATEGORY_MAP).join(', ')}.`);
+                return friendly; // Pass through unknown categories as-is
+            }
+            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 lookupEndpoint = config.lookupEndpoint?.trim()
+        ? cleanUrl(config.lookupEndpoint)
+        : config.executeEndpoint.includes('/execute')
+            ? cleanUrl(config.executeEndpoint.replace(/\/execute\/?$/, '/lookup'))
+            : null;
+    return {
+        spEndpoint: cleanUrl(config.spEndpoint),
+        tablesEndpoint: cleanUrl(config.tablesEndpoint),
+        executeEndpoint: cleanUrl(config.executeEndpoint),
+        lookupEndpoint,
+        reportsEndpoint: reportsEndpoint ? cleanUrl(reportsEndpoint) : null,
+        allowedCategories,
+        autoParameter: config.autoParameter !== false, // default true
+        routeBase: config.routeBase?.trim() || 'reports',
+        session: config.session ?? null,
+        sessionProvider: config.sessionProvider ?? null,
+        gridComponent: config.grid ?? null,
+        chartComponent: config.chart ?? null,
+        defaultPageSize: config.defaultPageSize ?? 25,
+        dateFormat: config.dateFormat ?? 'dd/MM/yyyy',
+        lookupTimeoutMs: config.lookupTimeoutMs ?? 300000,
+    };
+}
+/** 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"]}

package/esm2022/lib/core/index.mjs

@@ -1,3 +1,4 @@
+export * from './config/bways-report-config';
 export * from './models';
 export * from './registry';
 export * from './tokens';
@@ -7,4 +8,4 @@ export * from './services';
 export * from './utilities';
 export * from './utils/data-normalization.util';
 export * from './utils/report-parameter.util';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vcmVnaXN0cnknO1xuZXhwb3J0ICogZnJvbSAnLi90b2tlbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi92YWxpZGF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsaXRpZXMnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlscy9kYXRhLW5vcm1hbGl6YXRpb24udXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL3JlcG9ydC1wYXJhbWV0ZXIudXRpbCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb25maWcvYndheXMtcmVwb3J0LWNvbmZpZyc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL3JlZ2lzdHJ5JztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW5zJztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vdmFsaWRhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbGl0aWVzJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMvZGF0YS1ub3JtYWxpemF0aW9uLnV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlscy9yZXBvcnQtcGFyYW1ldGVyLnV0aWwnO1xuIl19

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

@@ -10,4 +10,4 @@
  * the required controls, layout, and bindings at runtime.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/report-data-discovery.service.mjs

@@ -1,5 +1,5 @@
 import { inject, Injectable } from '@angular/core';
-import { of } from 'rxjs';
+import { of, throwError } from 'rxjs';
 import { catchError, map } from 'rxjs/operators';
 import { ReportSchemaDiscoveryAdapter, } from '../../data-access/contracts/schema-discovery.contract';
 import { ReportLookupAdapter } from '../../data-access/contracts/lookup.contract';
@@ -122,7 +122,10 @@ export class ReportDataDiscoveryService {
             return [];
         }), catchError((err) => {
             console.warn(`[ReportDataDiscoveryService] Dynamic sample detection failed for ${entityName}:`, err);
-            return of([]);
+            const errorMsg = err?.error?.message ||
+                err?.message ||
+                `Database query failed for ${entityName}.`;
+            return throwError(() => new Error(errorMsg));
         }));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportDataDiscoveryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -132,4 +135,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-data-discovery.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-data-discovery.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport {\n  DatabaseEntityMetadata,\n  DatabaseEntityType,\n  EntityColumnMetadata,\n  ProcedureParameterMetadata,\n  ReportSchemaDiscoveryAdapter,\n} from '../../data-access/contracts/schema-discovery.contract';\nimport { ReportLookupAdapter } from '../../data-access/contracts/lookup.contract';\nimport { ReportSessionContextService } from './report-session-context.service';\nimport { GridColumnDefinition } from '../models/report-grid.model';\nimport { DropdownSourceType } from '../models/report-component.model';\nimport { resolveParameterMappings } from '../utils/report-parameter.util';\nimport { humanizeIdentifier } from '../utils/identifier-humanizer';\n\n/**\n * Centralized service for discovering database schema entities, parameters,\n * and column definitions.\n *\n * Provides a unified static + dynamic detection pipeline:\n * If static schema metadata discovery fails (e.g. SQL Server stored procedures\n * using #temp tables that cannot be analyzed statically), it automatically\n * falls back to executing a safe dynamic sample query with the active parameter\n * values and extracting column definitions from the result dataset.\n */\n@Injectable({ providedIn: 'root' })\nexport class ReportDataDiscoveryService {\n  private readonly discoveryAdapter = inject(ReportSchemaDiscoveryAdapter, { optional: true });\n  private readonly lookupAdapter = inject(ReportLookupAdapter, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  /**\n   * Retrieves all database tables, views, and stored procedures.\n   */\n  getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]> {\n    if (!this.discoveryAdapter) {\n      return of([]);\n    }\n    return this.discoveryAdapter.getEntities(types).pipe(\n      catchError((err) => {\n        console.warn('[ReportDataDiscoveryService] Failed to get entities:', err);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Retrieves stored procedure parameter metadata.\n   */\n  getParameters(procedureName: string, schema = 'dbo'): Observable<ProcedureParameterMetadata[]> {\n    if (!procedureName || !this.discoveryAdapter) {\n      return of([]);\n    }\n    return this.discoveryAdapter.getParameters(procedureName, schema).pipe(\n      catchError((err) => {\n        console.warn(`[ReportDataDiscoveryService] Failed to get parameters for ${procedureName}:`, err);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Unified column detection:\n   * 1. Attempts static schema discovery via ReportSchemaDiscoveryAdapter.\n   * 2. If static discovery returns 0 columns or throws an error (e.g. SQL Error 11526 with #temp tables),\n   *    automatically runs dynamic sample query via ReportLookupAdapter using resolved parameters.\n   */\n  autoDetectColumns(\n    entityName: string,\n    entityType: 'table' | 'stored_procedure' = 'stored_procedure',\n    mappings: Record<string, unknown> = {},\n    schema = 'dbo'\n  ): Observable<GridColumnDefinition[]> {\n    if (!entityName) {\n      return of([]);\n    }\n\n    // Try static discovery first\n    if (this.discoveryAdapter) {\n      return this.discoveryAdapter.getColumns(entityName, schema, entityType).pipe(\n        map((cols) => {\n          if (cols && cols.length > 0) {\n            return this.mapStaticColumnsToGrid(cols);\n          }\n          throw new Error('STATIC_EMPTY');\n        }),\n        catchError(() => {\n          // Fallback to dynamic execution\n          return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);\n        })\n      );\n    }\n\n    return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);\n  }\n\n  private mapStaticColumnsToGrid(cols: EntityColumnMetadata[]): GridColumnDefinition[] {\n    return cols.map((c) => ({\n      field: c.field,\n      label: humanizeIdentifier(c.label || c.field),\n      dataType: (c.dataType as any) || 'string',\n      visible: true,\n      sortable: true,\n      align: c.dataType === 'number' ? 'right' : 'left',\n    }));\n  }\n\n  private fallbackDynamicDetection(\n    entityName: string,\n    sourceType: 'table' | 'stored_procedure',\n    mappings: Record<string, unknown>,\n    schema = 'dbo'\n  ): Observable<GridColumnDefinition[]> {\n    if (!this.lookupAdapter) {\n      return of([]);\n    }\n\n    const session = this.sessionService?.getCurrentSessionContext() ?? {};\n    const resolvedParams = resolveParameterMappings(mappings as any, session, {});\n\n    return this.lookupAdapter\n      .fetchOptions({\n        sourceType: (sourceType === 'stored_procedure' ? 'procedure' : sourceType) as DropdownSourceType,\n        entityName,\n        schema,\n        valueField: '',\n        displayField: '',\n        parameters: resolvedParams,\n      })\n      .pipe(\n        map((items) => {\n          if (items && items.length > 0 && items[0].raw) {\n            const sampleRow = items[0].raw as Record<string, unknown>;\n            const keys = Object.keys(sampleRow);\n            if (keys.length > 0) {\n              return keys.map((key) => {\n                const val = sampleRow[key];\n                let type: 'string' | 'number' | 'date' | 'boolean' = 'string';\n                if (typeof val === 'number') type = 'number';\n                else if (typeof val === 'boolean') type = 'boolean';\n                else if (typeof val === 'string' && /^\\d{4}-\\d{2}-\\d{2}/.test(val)) type = 'date';\n\n                return {\n                  field: key,\n                  label: humanizeIdentifier(key),\n                  dataType: type,\n                  visible: true,\n                  sortable: true,\n                  align: (type === 'number' ? 'right' : 'left') as 'right' | 'left',\n                };\n              });\n            }\n          }\n          return [];\n        }),\n        catchError((err) => {\n          console.warn(`[ReportDataDiscoveryService] Dynamic sample detection failed for ${entityName}:`, err);\n          return of([]);\n        })\n      );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-data-discovery.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-data-discovery.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport {\n  DatabaseEntityMetadata,\n  DatabaseEntityType,\n  EntityColumnMetadata,\n  ProcedureParameterMetadata,\n  ReportSchemaDiscoveryAdapter,\n} from '../../data-access/contracts/schema-discovery.contract';\nimport { ReportLookupAdapter } from '../../data-access/contracts/lookup.contract';\nimport { ReportSessionContextService } from './report-session-context.service';\nimport { GridColumnDefinition } from '../models/report-grid.model';\nimport { DropdownSourceType } from '../models/report-component.model';\nimport { resolveParameterMappings } from '../utils/report-parameter.util';\nimport { humanizeIdentifier } from '../utils/identifier-humanizer';\n\n/**\n * Centralized service for discovering database schema entities, parameters,\n * and column definitions.\n *\n * Provides a unified static + dynamic detection pipeline:\n * If static schema metadata discovery fails (e.g. SQL Server stored procedures\n * using #temp tables that cannot be analyzed statically), it automatically\n * falls back to executing a safe dynamic sample query with the active parameter\n * values and extracting column definitions from the result dataset.\n */\n@Injectable({ providedIn: 'root' })\nexport class ReportDataDiscoveryService {\n  private readonly discoveryAdapter = inject(ReportSchemaDiscoveryAdapter, { optional: true });\n  private readonly lookupAdapter = inject(ReportLookupAdapter, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  /**\n   * Retrieves all database tables, views, and stored procedures.\n   */\n  getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]> {\n    if (!this.discoveryAdapter) {\n      return of([]);\n    }\n    return this.discoveryAdapter.getEntities(types).pipe(\n      catchError((err) => {\n        console.warn('[ReportDataDiscoveryService] Failed to get entities:', err);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Retrieves stored procedure parameter metadata.\n   */\n  getParameters(procedureName: string, schema = 'dbo'): Observable<ProcedureParameterMetadata[]> {\n    if (!procedureName || !this.discoveryAdapter) {\n      return of([]);\n    }\n    return this.discoveryAdapter.getParameters(procedureName, schema).pipe(\n      catchError((err) => {\n        console.warn(`[ReportDataDiscoveryService] Failed to get parameters for ${procedureName}:`, err);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Unified column detection:\n   * 1. Attempts static schema discovery via ReportSchemaDiscoveryAdapter.\n   * 2. If static discovery returns 0 columns or throws an error (e.g. SQL Error 11526 with #temp tables),\n   *    automatically runs dynamic sample query via ReportLookupAdapter using resolved parameters.\n   */\n  autoDetectColumns(\n    entityName: string,\n    entityType: 'table' | 'stored_procedure' = 'stored_procedure',\n    mappings: Record<string, unknown> = {},\n    schema = 'dbo'\n  ): Observable<GridColumnDefinition[]> {\n    if (!entityName) {\n      return of([]);\n    }\n\n    // Try static discovery first\n    if (this.discoveryAdapter) {\n      return this.discoveryAdapter.getColumns(entityName, schema, entityType).pipe(\n        map((cols) => {\n          if (cols && cols.length > 0) {\n            return this.mapStaticColumnsToGrid(cols);\n          }\n          throw new Error('STATIC_EMPTY');\n        }),\n        catchError(() => {\n          // Fallback to dynamic execution\n          return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);\n        })\n      );\n    }\n\n    return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);\n  }\n\n  private mapStaticColumnsToGrid(cols: EntityColumnMetadata[]): GridColumnDefinition[] {\n    return cols.map((c) => ({\n      field: c.field,\n      label: humanizeIdentifier(c.label || c.field),\n      dataType: (c.dataType as any) || 'string',\n      visible: true,\n      sortable: true,\n      align: c.dataType === 'number' ? 'right' : 'left',\n    }));\n  }\n\n  private fallbackDynamicDetection(\n    entityName: string,\n    sourceType: 'table' | 'stored_procedure',\n    mappings: Record<string, unknown>,\n    schema = 'dbo'\n  ): Observable<GridColumnDefinition[]> {\n    if (!this.lookupAdapter) {\n      return of([]);\n    }\n\n    const session = this.sessionService?.getCurrentSessionContext() ?? {};\n    const resolvedParams = resolveParameterMappings(mappings as any, session, {});\n\n    return this.lookupAdapter\n      .fetchOptions({\n        sourceType: (sourceType === 'stored_procedure' ? 'procedure' : sourceType) as DropdownSourceType,\n        entityName,\n        schema,\n        valueField: '',\n        displayField: '',\n        parameters: resolvedParams,\n      })\n      .pipe(\n        map((items) => {\n          if (items && items.length > 0 && items[0].raw) {\n            const sampleRow = items[0].raw as Record<string, unknown>;\n            const keys = Object.keys(sampleRow);\n            if (keys.length > 0) {\n              return keys.map((key) => {\n                const val = sampleRow[key];\n                let type: 'string' | 'number' | 'date' | 'boolean' = 'string';\n                if (typeof val === 'number') type = 'number';\n                else if (typeof val === 'boolean') type = 'boolean';\n                else if (typeof val === 'string' && /^\\d{4}-\\d{2}-\\d{2}/.test(val)) type = 'date';\n\n                return {\n                  field: key,\n                  label: humanizeIdentifier(key),\n                  dataType: type,\n                  visible: true,\n                  sortable: true,\n                  align: (type === 'number' ? 'right' : 'left') as 'right' | 'left',\n                };\n              });\n            }\n          }\n          return [];\n        }),\n        catchError((err) => {\n          console.warn(`[ReportDataDiscoveryService] Dynamic sample detection failed for ${entityName}:`, err);\n          const errorMsg =\n            err?.error?.message ||\n            err?.message ||\n            `Database query failed for ${entityName}.`;\n          return throwError(() => new Error(errorMsg));\n        })\n      );\n  }\n}\n"]}

package/esm2022/lib/core/services/report-session-context.service.mjs

@@ -2,6 +2,7 @@ import { computed, inject, Injectable, signal, } from '@angular/core';
 import { toObservable } from '@angular/core/rxjs-interop';
 import { isObservable } from 'rxjs';
 import { REPORT_SESSION_CONTEXT, REPORT_SESSION_PROVIDER, } from '../tokens/session-context.token';
+import { REPORTING_CONFIG } from '../tokens/reporting-config.token';
 import { humanizeIdentifier } from '../utils/identifier-humanizer';
 import * as i0 from "@angular/core";
 /**
@@ -18,6 +19,7 @@ export class ReportSessionContextService {
     sessionProvider = inject(REPORT_SESSION_PROVIDER, {
         optional: true,
     });
+    reportingConfig = inject(REPORTING_CONFIG, { optional: true });
     /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */
     manualRuntimeContext = signal({});
     latestObservableValue = signal({});
@@ -318,12 +320,14 @@ export class ReportSessionContextService {
                 finalParams[paramName] = explicitVal;
                 continue;
             }
-            // Check for session context match
-            const sessionMatch = this.matchParameter(paramName);
-            if (sessionMatch && sessionMatch.value !== undefined && sessionMatch.value !== null) {
-                finalParams[paramName] = sessionMatch.value;
-                autoDerived[paramName] = sessionMatch;
-                continue;
+            // Check for session context match (skip when autoParameter is disabled)
+            if (this.reportingConfig?.autoParameter !== false) {
+                const sessionMatch = this.matchParameter(paramName);
+                if (sessionMatch && sessionMatch.value !== undefined && sessionMatch.value !== null) {
+                    finalParams[paramName] = sessionMatch.value;
+                    autoDerived[paramName] = sessionMatch;
+                    continue;
+                }
             }
             // If default value is provided in SP metadata
             if (param.defaultValue !== undefined && param.defaultValue !== null) {
@@ -356,4 +360,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-session-context.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-session-context.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  computed,\n  inject,\n  Injectable,\n  OnDestroy,\n  signal,\n  Signal,\n} from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { isObservable, Observable, Subscription } from 'rxjs';\nimport {\n  REPORT_SESSION_CONTEXT,\n  REPORT_SESSION_PROVIDER,\n  SessionContextMap,\n  SessionContextProvider,\n  SessionContextSource,\n  SessionParamPrimitive,\n} from '../tokens/session-context.token';\nimport { ProcedureParameterMetadata } from '../../data-access/contracts/schema-discovery.contract';\nimport { humanizeIdentifier } from '../utils/identifier-humanizer';\n\nexport interface SessionParamMatch {\n  isMatched: boolean;\n  sessionKey: string;\n  value: SessionParamPrimitive;\n  friendlyLabel: string;\n}\n\nexport interface DerivedParametersResult {\n  /** The consolidated parameter payload for stored procedure execution */\n  parameters: Record<string, unknown>;\n  /** Map of which SP parameters were auto-derived from session context */\n  autoDerivedParams: Record<string, SessionParamMatch>;\n  /** Any required parameters that were neither in session context nor explicitly mapped */\n  unresolvedRequiredParams: ProcedureParameterMetadata[];\n}\n\n/**\n * Service that manages host application session context parameters (e.g. branchId, companyId, userId)\n * at runtime and automatically detects and binds them to Stored Procedure parameters.\n *\n * Designed to completely shield end users from entering technical session parameters while\n * eliminating silent failures or thread crashes in host integrations.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportSessionContextService implements OnDestroy {\n  private readonly rawSource = inject<SessionContextSource | null>(REPORT_SESSION_CONTEXT, {\n    optional: true,\n  });\n  private readonly sessionProvider = inject<SessionContextProvider | null>(REPORT_SESSION_PROVIDER, {\n    optional: true,\n  });\n\n  /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */\n  private readonly manualRuntimeContext = signal<SessionContextMap>({});\n  private readonly latestObservableValue = signal<SessionContextMap>({});\n  private readonly providerObservableValue = signal<SessionContextMap>({});\n\n  private observableSub?: Subscription;\n  private providerSub?: Subscription;\n\n  /**\n   * Reactive signal exposing the live session context parameters.\n   * Updates automatically when host app mutates runtime state, when observables emit,\n   * or when reactive signals update.\n   */\n  readonly sessionContext: Signal<SessionContextMap> = computed(() => {\n    let providerMap: SessionContextMap = {};\n    if (this.sessionProvider) {\n      try {\n        const res = this.sessionProvider.getSessionContext();\n        if (typeof res === 'function') {\n          const val = (res as () => SessionContextMap)();\n          if (val && typeof val === 'object') {\n            providerMap = val;\n          }\n        } else if (isObservable(res)) {\n          providerMap = this.providerObservableValue();\n        } else if (res && typeof res === 'object' && !('then' in res)) {\n          providerMap = res as SessionContextMap;\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error reading SessionContextProvider:', err);\n      }\n    }\n\n    let tokenMap: SessionContextMap = {};\n    if (this.rawSource) {\n      try {\n        if (isObservable(this.rawSource)) {\n          tokenMap = this.latestObservableValue();\n        } else if (typeof this.rawSource === 'function') {\n          const res = this.rawSource();\n          if (typeof res === 'function') {\n            const innerRes = (res as () => unknown)();\n            tokenMap = innerRes && typeof innerRes === 'object' ? (innerRes as SessionContextMap) : {};\n          } else if (isObservable(res)) {\n            tokenMap = this.latestObservableValue();\n          } else {\n            tokenMap = res && typeof res === 'object' ? (res as SessionContextMap) : {};\n          }\n        } else if (typeof this.rawSource === 'object' && this.rawSource !== null) {\n          tokenMap = this.rawSource;\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error evaluating raw session source:', err);\n      }\n    }\n\n    const manualMap = this.manualRuntimeContext();\n    const autoDetected = this.detectBrowserSession();\n\n    return {\n      ...autoDetected,\n      ...providerMap,\n      ...tokenMap,\n      ...manualMap,\n    };\n  });\n\n  /**\n   * Observable stream of live session parameters for RxJS-based integrations.\n   */\n  readonly sessionContext$: Observable<SessionContextMap> = toObservable(this.sessionContext);\n\n  constructor() {\n    this.initSubscriptions();\n  }\n\n  ngOnDestroy(): void {\n    this.observableSub?.unsubscribe();\n    this.providerSub?.unsubscribe();\n  }\n\n  private initSubscriptions(): void {\n    if (this.rawSource && isObservable(this.rawSource)) {\n      this.observableSub = this.rawSource.subscribe({\n        next: (val) => {\n          if (val && typeof val === 'object') {\n            this.latestObservableValue.set({ ...val });\n          }\n        },\n        error: (err) => {\n          console.warn('[ReportSessionContextService] Error from session context observable:', err);\n        },\n      });\n    }\n\n    if (this.sessionProvider) {\n      try {\n        const res = this.sessionProvider.getSessionContext();\n        if (isObservable(res)) {\n          this.providerSub = res.subscribe({\n            next: (val) => {\n              if (val && typeof val === 'object') {\n                this.providerObservableValue.set({ ...val });\n              }\n            },\n            error: (err) => {\n              console.warn('[ReportSessionContextService] Error from session provider observable:', err);\n            },\n          });\n        } else if (\n          res &&\n          typeof res === 'object' &&\n          'then' in res &&\n          typeof (res as Promise<unknown>).then === 'function'\n        ) {\n          (res as Promise<SessionContextMap>)\n            .then((val) => {\n              if (val && typeof val === 'object') {\n                this.providerObservableValue.set({ ...val });\n              }\n            })\n            .catch((err) => {\n              console.warn('[ReportSessionContextService] Error from session provider promise:', err);\n            });\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error initializing session provider:', err);\n      }\n    }\n  }\n\n  /**\n   * Sets or replaces the runtime session context.\n   * Can be called dynamically after user authentication, branch change, etc.\n   */\n  setSessionContext(context: SessionContextMap): void {\n    if (context && typeof context === 'object') {\n      this.manualRuntimeContext.set({ ...context });\n    } else {\n      this.manualRuntimeContext.set({});\n    }\n  }\n\n  /**\n   * Updates or sets a specific session parameter at runtime (e.g. branchId = 2).\n   */\n  setSessionParameter(key: string, value: SessionParamPrimitive): void {\n    if (!key) return;\n    this.manualRuntimeContext.update((current) => ({\n      ...current,\n      [key]: value,\n    }));\n  }\n\n  /**\n   * Clears any runtime session parameters set via `setSessionContext` or `setSessionParameter`.\n   */\n  clearSessionContext(): void {\n    this.manualRuntimeContext.set({});\n  }\n\n  /**\n   * Safely returns the current session context map.\n   * Always pulls the latest runtime state. Never throws or crashes the thread.\n   */\n  getCurrentSessionContext(): SessionContextMap {\n    try {\n      return this.sessionContext();\n    } catch (err) {\n      console.warn('[ReportSessionContextService] Failed to evaluate session context:', err);\n      return {};\n    }\n  }\n\n  /**\n   * Safely detects session parameters from host project browser storage\n   * (sessionStorage: user_Info, currentUser; localStorage: currentUser, CompanyData, user_Info).\n   */\n  private detectBrowserSession(): SessionContextMap {\n    const result: SessionContextMap = {};\n    if (typeof window === 'undefined') return result;\n\n    const sources: Array<{ storage: Storage | null; key: string }> = [\n      { storage: typeof sessionStorage !== 'undefined' ? sessionStorage : null, key: 'user_Info' },\n      { storage: typeof localStorage !== 'undefined' ? localStorage : null, key: 'currentUser' },\n      { storage: typeof localStorage !== 'undefined' ? localStorage : null, key: 'CompanyData' },\n      { storage: typeof sessionStorage !== 'undefined' ? sessionStorage : null, key: 'currentUser' },\n      { storage: typeof localStorage !== 'undefined' ? localStorage : null, key: 'user_Info' },\n    ];\n\n    for (const src of sources) {\n      if (!src.storage) continue;\n      try {\n        const item = src.storage.getItem(src.key);\n        if (item) {\n          const parsed = JSON.parse(item);\n          if (parsed && typeof parsed === 'object') {\n            for (const [k, v] of Object.entries(parsed)) {\n              if (\n                v !== undefined &&\n                v !== null &&\n                (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')\n              ) {\n                if (!(k in result)) {\n                  result[k] = v;\n                }\n              }\n            }\n          }\n        }\n      } catch {\n        // Ignore JSON parse errors in storage\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Normalizes a parameter or session key into a lowercase alphanumeric string\n   * for reliable, case-insensitive, and symbol-insensitive matching.\n   * Strips SQL Server Hungarian type prefixes (e.g. '@chrCompanyId' -> 'companyid').\n   */\n  normalizeKey(key: string): string {\n    if (!key || typeof key !== 'string') return '';\n    return key\n      .replace(/^@+/, '')\n      .replace(/^(chr|int|vchr|nchr|dt|str|num|bit|dec|flt)+/i, '')\n      .replace(/[_\\-\\s]+/g, '')\n      .toLowerCase();\n  }\n\n  /**\n   * Checks whether a stored procedure parameter matches any key in the active session context.\n   * Supports exact, normalized, and common ERP synonyms.\n   */\n  matchParameter(paramName: string): SessionParamMatch | null {\n    const session = this.getCurrentSessionContext();\n    const sessionKeys = Object.keys(session);\n    if (sessionKeys.length === 0) return null;\n\n    const normalizedParam = this.normalizeKey(paramName);\n\n    // 1. Exact match on raw name\n    if (paramName in session) {\n      return {\n        isMatched: true,\n        sessionKey: paramName,\n        value: session[paramName],\n        friendlyLabel: humanizeIdentifier(paramName),\n      };\n    }\n\n    // 2. Direct normalized match\n    for (const key of sessionKeys) {\n      if (this.normalizeKey(key) === normalizedParam) {\n        return {\n          isMatched: true,\n          sessionKey: key,\n          value: session[key],\n          friendlyLabel: humanizeIdentifier(key),\n        };\n      }\n    }\n\n    // 3. Common ERP synonym groups (bidirectional matching)\n    const synonymGroups: string[][] = [\n      ['branch', 'branchid', 'bid', 'branchcode', 'locationid', 'location', 'compunit', 'compunitid', 'unitcode', 'unitid', 'compunits'],\n      ['company', 'companyid', 'cid', 'companycode', 'tenant', 'tenantid'],\n      ['user', 'userid', 'uid', 'usercode', 'operatorid', 'loginuser', 'username'],\n      ['financialyear', 'financialyearid', 'yearid', 'fyear', 'fiscalyear', 'finyear'],\n      ['loginidentity', 'login_identity', 'statuscode', 'status_code'],\n      ['org', 'orgid', 'organization', 'organizationid'],\n    ];\n\n    for (const group of synonymGroups) {\n      if (group.includes(normalizedParam)) {\n        for (const key of sessionKeys) {\n          if (group.includes(this.normalizeKey(key))) {\n            return {\n              isMatched: true,\n              sessionKey: key,\n              value: session[key],\n              friendlyLabel: humanizeIdentifier(key),\n            };\n          }\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Resolves and derives all stored procedure parameters:\n   * - Preserves explicit overrides (e.g. from canvas form controls or manual inputs)\n   * - Automatically injects matched session parameters\n   * - Validates whether required parameters are fulfilled\n   */\n  deriveParameters(\n    spParams: ProcedureParameterMetadata[],\n    explicitMappings: Record<string, unknown> = {}\n  ): DerivedParametersResult {\n    const session = this.getCurrentSessionContext();\n    const finalParams: Record<string, unknown> = {};\n    const autoDerived: Record<string, SessionParamMatch> = {};\n    const unresolvedRequired: ProcedureParameterMetadata[] = [];\n\n    for (const param of spParams) {\n      const paramName = param.name;\n      const explicitVal = explicitMappings[paramName];\n\n      // Check if user or canvas explicitly provided a value (and not an empty placeholder)\n      const hasExplicit = explicitVal !== undefined && explicitVal !== '' && explicitVal !== null;\n\n      if (hasExplicit) {\n        finalParams[paramName] = explicitVal;\n        continue;\n      }\n\n      // Check for session context match\n      const sessionMatch = this.matchParameter(paramName);\n      if (sessionMatch && sessionMatch.value !== undefined && sessionMatch.value !== null) {\n        finalParams[paramName] = sessionMatch.value;\n        autoDerived[paramName] = sessionMatch;\n        continue;\n      }\n\n      // If default value is provided in SP metadata\n      if (param.defaultValue !== undefined && param.defaultValue !== null) {\n        finalParams[paramName] = param.defaultValue;\n        continue;\n      }\n\n      // If required but not satisfied\n      if (param.required) {\n        unresolvedRequired.push(param);\n      }\n    }\n\n    // Also include any extra explicit mappings that didn't match parameter list\n    for (const [key, val] of Object.entries(explicitMappings)) {\n      if (!(key in finalParams) && val !== undefined && val !== null && val !== '') {\n        finalParams[key] = val;\n      }\n    }\n\n    return {\n      parameters: finalParams,\n      autoDerivedParams: autoDerived,\n      unresolvedRequiredParams: unresolvedRequired,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-session-context.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-session-context.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  computed,\n  inject,\n  Injectable,\n  OnDestroy,\n  signal,\n  Signal,\n} from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { isObservable, Observable, Subscription } from 'rxjs';\nimport {\n  REPORT_SESSION_CONTEXT,\n  REPORT_SESSION_PROVIDER,\n  SessionContextMap,\n  SessionContextProvider,\n  SessionContextSource,\n  SessionParamPrimitive,\n} from '../tokens/session-context.token';\nimport { REPORTING_CONFIG } from '../tokens/reporting-config.token';\nimport { ProcedureParameterMetadata } from '../../data-access/contracts/schema-discovery.contract';\nimport { humanizeIdentifier } from '../utils/identifier-humanizer';\n\nexport interface SessionParamMatch {\n  isMatched: boolean;\n  sessionKey: string;\n  value: SessionParamPrimitive;\n  friendlyLabel: string;\n}\n\nexport interface DerivedParametersResult {\n  /** The consolidated parameter payload for stored procedure execution */\n  parameters: Record<string, unknown>;\n  /** Map of which SP parameters were auto-derived from session context */\n  autoDerivedParams: Record<string, SessionParamMatch>;\n  /** Any required parameters that were neither in session context nor explicitly mapped */\n  unresolvedRequiredParams: ProcedureParameterMetadata[];\n}\n\n/**\n * Service that manages host application session context parameters (e.g. branchId, companyId, userId)\n * at runtime and automatically detects and binds them to Stored Procedure parameters.\n *\n * Designed to completely shield end users from entering technical session parameters while\n * eliminating silent failures or thread crashes in host integrations.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportSessionContextService implements OnDestroy {\n  private readonly rawSource = inject<SessionContextSource | null>(REPORT_SESSION_CONTEXT, {\n    optional: true,\n  });\n  private readonly sessionProvider = inject<SessionContextProvider | null>(REPORT_SESSION_PROVIDER, {\n    optional: true,\n  });\n  private readonly reportingConfig = inject(REPORTING_CONFIG, { optional: true });\n\n  /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */\n  private readonly manualRuntimeContext = signal<SessionContextMap>({});\n  private readonly latestObservableValue = signal<SessionContextMap>({});\n  private readonly providerObservableValue = signal<SessionContextMap>({});\n\n  private observableSub?: Subscription;\n  private providerSub?: Subscription;\n\n  /**\n   * Reactive signal exposing the live session context parameters.\n   * Updates automatically when host app mutates runtime state, when observables emit,\n   * or when reactive signals update.\n   */\n  readonly sessionContext: Signal<SessionContextMap> = computed(() => {\n    let providerMap: SessionContextMap = {};\n    if (this.sessionProvider) {\n      try {\n        const res = this.sessionProvider.getSessionContext();\n        if (typeof res === 'function') {\n          const val = (res as () => SessionContextMap)();\n          if (val && typeof val === 'object') {\n            providerMap = val;\n          }\n        } else if (isObservable(res)) {\n          providerMap = this.providerObservableValue();\n        } else if (res && typeof res === 'object' && !('then' in res)) {\n          providerMap = res as SessionContextMap;\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error reading SessionContextProvider:', err);\n      }\n    }\n\n    let tokenMap: SessionContextMap = {};\n    if (this.rawSource) {\n      try {\n        if (isObservable(this.rawSource)) {\n          tokenMap = this.latestObservableValue();\n        } else if (typeof this.rawSource === 'function') {\n          const res = this.rawSource();\n          if (typeof res === 'function') {\n            const innerRes = (res as () => unknown)();\n            tokenMap = innerRes && typeof innerRes === 'object' ? (innerRes as SessionContextMap) : {};\n          } else if (isObservable(res)) {\n            tokenMap = this.latestObservableValue();\n          } else {\n            tokenMap = res && typeof res === 'object' ? (res as SessionContextMap) : {};\n          }\n        } else if (typeof this.rawSource === 'object' && this.rawSource !== null) {\n          tokenMap = this.rawSource;\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error evaluating raw session source:', err);\n      }\n    }\n\n    const manualMap = this.manualRuntimeContext();\n    const autoDetected = this.detectBrowserSession();\n\n    return {\n      ...autoDetected,\n      ...providerMap,\n      ...tokenMap,\n      ...manualMap,\n    };\n  });\n\n  /**\n   * Observable stream of live session parameters for RxJS-based integrations.\n   */\n  readonly sessionContext$: Observable<SessionContextMap> = toObservable(this.sessionContext);\n\n  constructor() {\n    this.initSubscriptions();\n  }\n\n  ngOnDestroy(): void {\n    this.observableSub?.unsubscribe();\n    this.providerSub?.unsubscribe();\n  }\n\n  private initSubscriptions(): void {\n    if (this.rawSource && isObservable(this.rawSource)) {\n      this.observableSub = this.rawSource.subscribe({\n        next: (val) => {\n          if (val && typeof val === 'object') {\n            this.latestObservableValue.set({ ...val });\n          }\n        },\n        error: (err) => {\n          console.warn('[ReportSessionContextService] Error from session context observable:', err);\n        },\n      });\n    }\n\n    if (this.sessionProvider) {\n      try {\n        const res = this.sessionProvider.getSessionContext();\n        if (isObservable(res)) {\n          this.providerSub = res.subscribe({\n            next: (val) => {\n              if (val && typeof val === 'object') {\n                this.providerObservableValue.set({ ...val });\n              }\n            },\n            error: (err) => {\n              console.warn('[ReportSessionContextService] Error from session provider observable:', err);\n            },\n          });\n        } else if (\n          res &&\n          typeof res === 'object' &&\n          'then' in res &&\n          typeof (res as Promise<unknown>).then === 'function'\n        ) {\n          (res as Promise<SessionContextMap>)\n            .then((val) => {\n              if (val && typeof val === 'object') {\n                this.providerObservableValue.set({ ...val });\n              }\n            })\n            .catch((err) => {\n              console.warn('[ReportSessionContextService] Error from session provider promise:', err);\n            });\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error initializing session provider:', err);\n      }\n    }\n  }\n\n  /**\n   * Sets or replaces the runtime session context.\n   * Can be called dynamically after user authentication, branch change, etc.\n   */\n  setSessionContext(context: SessionContextMap): void {\n    if (context && typeof context === 'object') {\n      this.manualRuntimeContext.set({ ...context });\n    } else {\n      this.manualRuntimeContext.set({});\n    }\n  }\n\n  /**\n   * Updates or sets a specific session parameter at runtime (e.g. branchId = 2).\n   */\n  setSessionParameter(key: string, value: SessionParamPrimitive): void {\n    if (!key) return;\n    this.manualRuntimeContext.update((current) => ({\n      ...current,\n      [key]: value,\n    }));\n  }\n\n  /**\n   * Clears any runtime session parameters set via `setSessionContext` or `setSessionParameter`.\n   */\n  clearSessionContext(): void {\n    this.manualRuntimeContext.set({});\n  }\n\n  /**\n   * Safely returns the current session context map.\n   * Always pulls the latest runtime state. Never throws or crashes the thread.\n   */\n  getCurrentSessionContext(): SessionContextMap {\n    try {\n      return this.sessionContext();\n    } catch (err) {\n      console.warn('[ReportSessionContextService] Failed to evaluate session context:', err);\n      return {};\n    }\n  }\n\n  /**\n   * Safely detects session parameters from host project browser storage\n   * (sessionStorage: user_Info, currentUser; localStorage: currentUser, CompanyData, user_Info).\n   */\n  private detectBrowserSession(): SessionContextMap {\n    const result: SessionContextMap = {};\n    if (typeof window === 'undefined') return result;\n\n    const sources: Array<{ storage: Storage | null; key: string }> = [\n      { storage: typeof sessionStorage !== 'undefined' ? sessionStorage : null, key: 'user_Info' },\n      { storage: typeof localStorage !== 'undefined' ? localStorage : null, key: 'currentUser' },\n      { storage: typeof localStorage !== 'undefined' ? localStorage : null, key: 'CompanyData' },\n      { storage: typeof sessionStorage !== 'undefined' ? sessionStorage : null, key: 'currentUser' },\n      { storage: typeof localStorage !== 'undefined' ? localStorage : null, key: 'user_Info' },\n    ];\n\n    for (const src of sources) {\n      if (!src.storage) continue;\n      try {\n        const item = src.storage.getItem(src.key);\n        if (item) {\n          const parsed = JSON.parse(item);\n          if (parsed && typeof parsed === 'object') {\n            for (const [k, v] of Object.entries(parsed)) {\n              if (\n                v !== undefined &&\n                v !== null &&\n                (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')\n              ) {\n                if (!(k in result)) {\n                  result[k] = v;\n                }\n              }\n            }\n          }\n        }\n      } catch {\n        // Ignore JSON parse errors in storage\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Normalizes a parameter or session key into a lowercase alphanumeric string\n   * for reliable, case-insensitive, and symbol-insensitive matching.\n   * Strips SQL Server Hungarian type prefixes (e.g. '@chrCompanyId' -> 'companyid').\n   */\n  normalizeKey(key: string): string {\n    if (!key || typeof key !== 'string') return '';\n    return key\n      .replace(/^@+/, '')\n      .replace(/^(chr|int|vchr|nchr|dt|str|num|bit|dec|flt)+/i, '')\n      .replace(/[_\\-\\s]+/g, '')\n      .toLowerCase();\n  }\n\n  /**\n   * Checks whether a stored procedure parameter matches any key in the active session context.\n   * Supports exact, normalized, and common ERP synonyms.\n   */\n  matchParameter(paramName: string): SessionParamMatch | null {\n    const session = this.getCurrentSessionContext();\n    const sessionKeys = Object.keys(session);\n    if (sessionKeys.length === 0) return null;\n\n    const normalizedParam = this.normalizeKey(paramName);\n\n    // 1. Exact match on raw name\n    if (paramName in session) {\n      return {\n        isMatched: true,\n        sessionKey: paramName,\n        value: session[paramName],\n        friendlyLabel: humanizeIdentifier(paramName),\n      };\n    }\n\n    // 2. Direct normalized match\n    for (const key of sessionKeys) {\n      if (this.normalizeKey(key) === normalizedParam) {\n        return {\n          isMatched: true,\n          sessionKey: key,\n          value: session[key],\n          friendlyLabel: humanizeIdentifier(key),\n        };\n      }\n    }\n\n    // 3. Common ERP synonym groups (bidirectional matching)\n    const synonymGroups: string[][] = [\n      ['branch', 'branchid', 'bid', 'branchcode', 'locationid', 'location', 'compunit', 'compunitid', 'unitcode', 'unitid', 'compunits'],\n      ['company', 'companyid', 'cid', 'companycode', 'tenant', 'tenantid'],\n      ['user', 'userid', 'uid', 'usercode', 'operatorid', 'loginuser', 'username'],\n      ['financialyear', 'financialyearid', 'yearid', 'fyear', 'fiscalyear', 'finyear'],\n      ['loginidentity', 'login_identity', 'statuscode', 'status_code'],\n      ['org', 'orgid', 'organization', 'organizationid'],\n    ];\n\n    for (const group of synonymGroups) {\n      if (group.includes(normalizedParam)) {\n        for (const key of sessionKeys) {\n          if (group.includes(this.normalizeKey(key))) {\n            return {\n              isMatched: true,\n              sessionKey: key,\n              value: session[key],\n              friendlyLabel: humanizeIdentifier(key),\n            };\n          }\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Resolves and derives all stored procedure parameters:\n   * - Preserves explicit overrides (e.g. from canvas form controls or manual inputs)\n   * - Automatically injects matched session parameters\n   * - Validates whether required parameters are fulfilled\n   */\n  deriveParameters(\n    spParams: ProcedureParameterMetadata[],\n    explicitMappings: Record<string, unknown> = {}\n  ): DerivedParametersResult {\n    const session = this.getCurrentSessionContext();\n    const finalParams: Record<string, unknown> = {};\n    const autoDerived: Record<string, SessionParamMatch> = {};\n    const unresolvedRequired: ProcedureParameterMetadata[] = [];\n\n    for (const param of spParams) {\n      const paramName = param.name;\n      const explicitVal = explicitMappings[paramName];\n\n      // Check if user or canvas explicitly provided a value (and not an empty placeholder)\n      const hasExplicit = explicitVal !== undefined && explicitVal !== '' && explicitVal !== null;\n\n      if (hasExplicit) {\n        finalParams[paramName] = explicitVal;\n        continue;\n      }\n\n      // Check for session context match (skip when autoParameter is disabled)\n      if (this.reportingConfig?.autoParameter !== false) {\n        const sessionMatch = this.matchParameter(paramName);\n        if (sessionMatch && sessionMatch.value !== undefined && sessionMatch.value !== null) {\n          finalParams[paramName] = sessionMatch.value;\n          autoDerived[paramName] = sessionMatch;\n          continue;\n        }\n      }\n\n      // If default value is provided in SP metadata\n      if (param.defaultValue !== undefined && param.defaultValue !== null) {\n        finalParams[paramName] = param.defaultValue;\n        continue;\n      }\n\n      // If required but not satisfied\n      if (param.required) {\n        unresolvedRequired.push(param);\n      }\n    }\n\n    // Also include any extra explicit mappings that didn't match parameter list\n    for (const [key, val] of Object.entries(explicitMappings)) {\n      if (!(key in finalParams) && val !== undefined && val !== null && val !== '') {\n        finalParams[key] = val;\n      }\n    }\n\n    return {\n      parameters: finalParams,\n      autoDerivedParams: autoDerived,\n      unresolvedRequiredParams: unresolvedRequired,\n    };\n  }\n}\n"]}

package/esm2022/lib/core/tokens/reporting-config.token.mjs

@@ -23,4 +23,4 @@ export const CHART_COMPONENT = new InjectionToken('CHART_COMPONENT');
  * Injection token for the reporting library configuration.
  */
 export const REPORTING_CONFIG = new InjectionToken('REPORTING_CONFIG');
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -53,4 +53,90 @@ export function getFieldCaseInsensitive(record, targetKey) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Normalizes an arbitrary database record into a standardized { value, label, raw } option item.
+ * Supports case-insensitive field matching and intelligent heuristics for SQL Server columns.
+ */
+export function extractLookupOptionItem(row, valueField, displayField) {
+    if (!row || typeof row !== 'object') {
+        return {
+            value: row ?? '',
+            label: String(row ?? ''),
+        };
+    }
+    const rec = row;
+    // If row is already normalized (e.g. from backend lookup endpoint which returned { value, label })
+    // and user did not specify distinct target fields
+    if ('value' in rec &&
+        'label' in rec &&
+        (!valueField || valueField === 'value' || !getFieldCaseInsensitive(rec, valueField)) &&
+        (!displayField || displayField === 'label' || !getFieldCaseInsensitive(rec, displayField))) {
+        const v = rec['value'];
+        const result = {
+            value: typeof v === 'object' ? JSON.stringify(v) : v,
+            label: String(rec['label'] ?? rec['value'] ?? ''),
+        };
+        if ('raw' in rec && rec['raw']) {
+            result.raw = rec['raw'];
+        }
+        return result;
+    }
+    const keys = Object.keys(rec);
+    // 1. Resolve Value
+    let val = undefined;
+    if (valueField && valueField.trim()) {
+        val = getFieldCaseInsensitive(rec, valueField.trim());
+    }
+    if (val === undefined || val === null || val === '') {
+        const candidateValueKeys = ['code', 'id', 'key', 'value', 'val'];
+        for (const cand of candidateValueKeys) {
+            const v = getFieldCaseInsensitive(rec, cand);
+            if (v !== undefined && v !== null && v !== '') {
+                val = v;
+                break;
+            }
+        }
+    }
+    if (val === undefined || val === null || val === '') {
+        const idKeys = keys.filter((k) => /(?:_code|_id|id|code)$/i.test(k));
+        const specificIdKey = idKeys.find((k) => !/^(?:user_?id|company_?id)$/i.test(k)) || idKeys[0];
+        if (specificIdKey) {
+            val = rec[specificIdKey];
+        }
+    }
+    if (val === undefined || val === null || val === '') {
+        const firstPrimitiveKey = keys.find((k) => typeof rec[k] === 'string' || typeof rec[k] === 'number');
+        val = firstPrimitiveKey ? rec[firstPrimitiveKey] : (keys[0] ? rec[keys[0]] : '');
+    }
+    // 2. Resolve Label / Display
+    let label = undefined;
+    if (displayField && displayField.trim()) {
+        label = getFieldCaseInsensitive(rec, displayField.trim());
+    }
+    if (label === undefined || label === null || label === '') {
+        const candidateDisplayKeys = ['name', 'title', 'label', 'description', 'desc', 'text', 'caption'];
+        for (const cand of candidateDisplayKeys) {
+            const l = getFieldCaseInsensitive(rec, cand);
+            if (l !== undefined && l !== null && l !== '') {
+                label = l;
+                break;
+            }
+        }
+    }
+    if (label === undefined || label === null || label === '') {
+        const nameKey = keys.find((k) => /(?:_name|_title|_desc)$/i.test(k));
+        if (nameKey) {
+            label = rec[nameKey];
+        }
+    }
+    if (label === undefined || label === null || label === '') {
+        const secondPrimitiveKey = keys.find((k) => (typeof rec[k] === 'string' || typeof rec[k] === 'number') && rec[k] !== val);
+        label = secondPrimitiveKey ? rec[secondPrimitiveKey] : String(val ?? '');
+    }
+    return {
+        value: typeof val === 'object' ? JSON.stringify(val) : val,
+        label: String(label ?? val ?? ''),
+        raw: rec,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-normalization.util.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/utils/data-normalization.util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Utility to normalize arbitrary backend HTTP responses into standard array of records.\n *\n * Supports:\n * - Direct array payloads: `[ { ... }, { ... } ]`\n * - Standard envelope wrappers: `{ data: [...] }`, `{ rows: [...] }`, `{ result: [...] }`, `{ items: [...] }`\n * - OData envelopes: `{ value: [...] }`\n * - Paginated wrappers: `{ total: 100, page: 1, data: [...] }`\n */\nexport function extractRowArray<T = unknown>(response: unknown): T[] {\n  if (Array.isArray(response)) {\n    return response as T[];\n  }\n\n  if (!response || typeof response !== 'object') {\n    return [];\n  }\n\n  const obj = response as Record<string, unknown>;\n\n  // Check common wrapper property names\n  const candidateKeys = ['data', 'rows', 'result', 'items', 'value', 'records', 'entities'];\n  for (const key of candidateKeys) {\n    const val = obj[key];\n    if (Array.isArray(val)) {\n      return val as T[];\n    }\n  }\n\n  return [];\n}\n\n/**\n * Case-insensitive lookup in an object/record.\n * Searches for exact match first, then lower-cased match, then normalized (ignoring underscores/dashes).\n */\nexport function getFieldCaseInsensitive(\n  record: Record<string, unknown> | null | undefined,\n  targetKey: string\n): unknown {\n  if (!record || typeof record !== 'object') return undefined;\n\n  // 1. Exact match\n  if (targetKey in record) {\n    return record[targetKey];\n  }\n\n  // 2. Case-insensitive match\n  const targetLower = targetKey.toLowerCase();\n  for (const [k, v] of Object.entries(record)) {\n    if (k.toLowerCase() === targetLower) {\n      return v;\n    }\n  }\n\n  // 3. Normalized match (strip leading '@', underscores, dashes)\n  const normalize = (s: string) => s.replace(/^@/, '').replace(/[_\\-\\s]/g, '').toLowerCase();\n  const normalizedTarget = normalize(targetKey);\n  for (const [k, v] of Object.entries(record)) {\n    if (normalize(k) === normalizedTarget) {\n      return v;\n    }\n  }\n\n  return undefined;\n}\n\nexport interface NormalizedLookupOption {\n  value: string | number;\n  label: string;\n  raw?: Record<string, unknown>;\n}\n\n/**\n * Normalizes an arbitrary database record into a standardized { value, label, raw } option item.\n * Supports case-insensitive field matching and intelligent heuristics for SQL Server columns.\n */\nexport function extractLookupOptionItem(\n  row: unknown,\n  valueField?: string,\n  displayField?: string\n): NormalizedLookupOption {\n  if (!row || typeof row !== 'object') {\n    return {\n      value: (row as any) ?? '',\n      label: String(row ?? ''),\n    };\n  }\n\n  const rec = row as Record<string, unknown>;\n\n  // If row is already normalized (e.g. from backend lookup endpoint which returned { value, label })\n  // and user did not specify distinct target fields\n  if (\n    'value' in rec &&\n    'label' in rec &&\n    (!valueField || valueField === 'value' || !getFieldCaseInsensitive(rec, valueField)) &&\n    (!displayField || displayField === 'label' || !getFieldCaseInsensitive(rec, displayField))\n  ) {\n    const v = rec['value'];\n    const result: NormalizedLookupOption = {\n      value: typeof v === 'object' ? JSON.stringify(v) : (v as any),\n      label: String(rec['label'] ?? rec['value'] ?? ''),\n    };\n    if ('raw' in rec && rec['raw']) {\n      result.raw = rec['raw'] as Record<string, unknown>;\n    }\n    return result;\n  }\n\n  const keys = Object.keys(rec);\n\n  // 1. Resolve Value\n  let val: unknown = undefined;\n  if (valueField && valueField.trim()) {\n    val = getFieldCaseInsensitive(rec, valueField.trim());\n  }\n\n  if (val === undefined || val === null || val === '') {\n    const candidateValueKeys = ['code', 'id', 'key', 'value', 'val'];\n    for (const cand of candidateValueKeys) {\n      const v = getFieldCaseInsensitive(rec, cand);\n      if (v !== undefined && v !== null && v !== '') {\n        val = v;\n        break;\n      }\n    }\n  }\n\n  if (val === undefined || val === null || val === '') {\n    const idKeys = keys.filter((k) => /(?:_code|_id|id|code)$/i.test(k));\n    const specificIdKey = idKeys.find((k) => !/^(?:user_?id|company_?id)$/i.test(k)) || idKeys[0];\n    if (specificIdKey) {\n      val = rec[specificIdKey];\n    }\n  }\n\n  if (val === undefined || val === null || val === '') {\n    const firstPrimitiveKey = keys.find((k) => typeof rec[k] === 'string' || typeof rec[k] === 'number');\n    val = firstPrimitiveKey ? rec[firstPrimitiveKey] : (keys[0] ? rec[keys[0]] : '');\n  }\n\n  // 2. Resolve Label / Display\n  let label: unknown = undefined;\n  if (displayField && displayField.trim()) {\n    label = getFieldCaseInsensitive(rec, displayField.trim());\n  }\n\n  if (label === undefined || label === null || label === '') {\n    const candidateDisplayKeys = ['name', 'title', 'label', 'description', 'desc', 'text', 'caption'];\n    for (const cand of candidateDisplayKeys) {\n      const l = getFieldCaseInsensitive(rec, cand);\n      if (l !== undefined && l !== null && l !== '') {\n        label = l;\n        break;\n      }\n    }\n  }\n\n  if (label === undefined || label === null || label === '') {\n    const nameKey = keys.find((k) => /(?:_name|_title|_desc)$/i.test(k));\n    if (nameKey) {\n      label = rec[nameKey];\n    }\n  }\n\n  if (label === undefined || label === null || label === '') {\n    const secondPrimitiveKey = keys.find(\n      (k) => (typeof rec[k] === 'string' || typeof rec[k] === 'number') && rec[k] !== val\n    );\n    label = secondPrimitiveKey ? rec[secondPrimitiveKey] : String(val ?? '');\n  }\n\n  return {\n    value: typeof val === 'object' ? JSON.stringify(val) : (val as any),\n    label: String(label ?? val ?? ''),\n    raw: rec,\n  };\n}\n"]}