@servicelabsco/slabs-access-manager 1.0.67 → 1.0.69

package/dist/development/gates/reporting.catalog.gate.d.ts

@@ -0,0 +1,8 @@
+import { OnModuleInit } from '@nestjs/common';
+import { AdminReportViewService } from '../services/admin.report.view.service';
+export declare class ReportingCatalogGate implements OnModuleInit {
+    private readonly service;
+    private readonly logger;
+    constructor(service: AdminReportViewService);
+    onModuleInit(): Promise<void>;
+}

package/dist/development/gates/reporting.catalog.gate.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ReportingCatalogGate_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportingCatalogGate = void 0;
+const common_1 = require("@nestjs/common");
+const admin_report_view_service_1 = require("../services/admin.report.view.service");
+let ReportingCatalogGate = ReportingCatalogGate_1 = class ReportingCatalogGate {
+    constructor(service) {
+        this.service = service;
+        this.logger = new common_1.Logger(ReportingCatalogGate_1.name);
+    }
+    async onModuleInit() {
+        try {
+            const result = await this.service.validate();
+            const views = Array.isArray(result?.views) ? result.views : [];
+            const dropped = views.filter((view) => view.dropped);
+            this.logger.log(`reporting catalog gate: ${views.length} view(s), dropped=${dropped.length}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn(`reporting catalog gate skipped: ${message}`);
+        }
+    }
+};
+exports.ReportingCatalogGate = ReportingCatalogGate;
+exports.ReportingCatalogGate = ReportingCatalogGate = ReportingCatalogGate_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [admin_report_view_service_1.AdminReportViewService])
+], ReportingCatalogGate);
+//# sourceMappingURL=reporting.catalog.gate.js.map

package/dist/development/gates/reporting.catalog.gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporting.catalog.gate.js","sourceRoot":"","sources":["../../../src/development/gates/reporting.catalog.gate.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,2CAAkE;AAClE,qFAA+E;AAOxE,IAAM,oBAAoB,4BAA1B,MAAM,oBAAoB;IAG7B,YAA6B,OAA+B;QAA/B,YAAO,GAAP,OAAO,CAAwB;QAF3C,WAAM,GAAG,IAAI,eAAM,CAAC,sBAAoB,CAAC,IAAI,CAAC,CAAC;IAED,CAAC;IAEhE,KAAK,CAAC,YAAY;QACd,IAAI,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAE,MAAc,EAAE,KAAK,CAAC,CAAC,CAAC,CAAE,MAAc,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACjF,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAA2B,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC5E,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,2BAA2B,KAAK,CAAC,MAAM,qBAAqB,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAClG,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACvE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mCAAmC,OAAO,EAAE,CAAC,CAAC;QACnE,CAAC;IACL,CAAC;CACJ,CAAA;AAhBY,oDAAoB;+BAApB,oBAAoB;IADhC,IAAA,mBAAU,GAAE;qCAI6B,kDAAsB;GAHnD,oBAAoB,CAgBhC"}

package/dist/development/index.d.ts

@@ -1,5 +1,7 @@
 export * from './commands';
 export * from './controllers';
+export * from './dtos';
+export * from './gates';
 export * from './interfaces';
 export * from './middlewares';
 export * from './registries';

package/dist/development/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./commands"), exports);
 __exportStar(require("./controllers"), exports);
+__exportStar(require("./dtos"), exports);
+__exportStar(require("./gates"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./middlewares"), exports);
 __exportStar(require("./registries"), exports);

package/dist/development/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/development/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAAA,gDAA8B;AAAA,+CAA6B;AAAA,gDAA8B;AAAA,+CAA6B;AAAA,6CAA2B;AAAA,uDAAoC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/development/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAAA,gDAA8B;AAAA,yCAAuB;AAAA,0CAAwB;AAAA,+CAA6B;AAAA,gDAA8B;AAAA,+CAA6B;AAAA,6CAA2B;AAAA,uDAAoC"}

package/dist/development/services/admin.report.view.service.d.ts

@@ -0,0 +1,92 @@
+import { MaterialViewEntity, SqlService } from '@servicelabsco/nestjs-utility-services';
+export type CatalogFinding = string;
+export type CatalogGateResult = {
+    table_name: string;
+    ok: boolean;
+    findings: CatalogFinding[];
+    agent_visible: boolean;
+    dropped?: boolean;
+};
+export type ColumnDescribePatch = {
+    name: string;
+    display_name?: string;
+    description?: string;
+    visibility?: boolean;
+    attributes?: Record<string, unknown>;
+};
+export type ColumnsSyncInput = {
+    table_name?: string;
+    source_type?: string;
+    source_id?: number;
+    name?: string;
+};
+export declare class AdminReportViewService {
+    private readonly sqlService;
+    private readonly logger;
+    constructor(sqlService: SqlService);
+    list(): Promise<{
+        views: Array<Record<string, unknown>>;
+    }>;
+    register(body: {
+        table_name?: string;
+        timing?: string;
+        active?: boolean;
+        attributes?: Record<string, unknown>;
+    }): Promise<MaterialViewEntity>;
+    update(tableName: string, body: {
+        timing?: string;
+        active?: boolean;
+        attributes?: Record<string, unknown>;
+    }): Promise<{
+        view: MaterialViewEntity;
+        gate: CatalogGateResult;
+    }>;
+    sample(tableName: string, limit?: number | string, offset?: number | string): Promise<{
+        table_name: string;
+        limit: number;
+        offset: number;
+        rows: any[];
+    }>;
+    columnsSync(input?: string | ColumnsSyncInput): Promise<{
+        table_name: string;
+        created: string[];
+        adopted: string[];
+        orphaned: string[];
+    }>;
+    private resolveView;
+    private upsertLiveColumn;
+    describeColumns(tableName: string, patches?: ColumnDescribePatch[]): Promise<{
+        table_name: string;
+        updated: string[];
+        missing: string[];
+        gate: CatalogGateResult;
+    }>;
+    validate(tableName?: string): Promise<CatalogGateResult | {
+        views: CatalogGateResult[];
+    }>;
+    private evaluate;
+    private parseViewAttributes;
+    private parseColumnAttributes;
+    private tryParseViewAttributes;
+    private tryParseColumnAttributes;
+    private formatErrors;
+    private applyViewDefaults;
+    private defaultCatalogName;
+    private tenancyColumn;
+    private asViewRow;
+    private requireRegisteredView;
+    private assertTableName;
+    private quoteIdent;
+    private clampLimit;
+    private clampOffset;
+    private assertRelationExists;
+    private relationExists;
+    private boundReadFirst;
+    private loadLiveColumns;
+    private normalizeLiveColumn;
+    private resolveTypeId;
+    private loadLiveColumnsSafe;
+    private columnTypeMapping;
+    private displayName;
+    private hasEnumMap;
+}

package/dist/development/services/admin.report.view.service.js

@@ -0,0 +1,459 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AdminReportViewService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminReportViewService = void 0;
+const common_1 = require("@nestjs/common");
+const nestjs_utility_services_1 = require("@servicelabsco/nestjs-utility-services");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const typeorm_1 = require("typeorm");
+const SourceHash = require("../../config/source.hash");
+const column_catalog_attributes_dto_1 = require("../dtos/column.catalog.attributes.dto");
+const material_view_catalog_attributes_dto_1 = require("../dtos/material.view.catalog.attributes.dto");
+const SAMPLE_CAP = 100;
+const DEFAULT_SAMPLE_LIMIT = 20;
+const DEFAULT_TENANCY = 'business_id';
+const DEFAULT_TIMING = '0 * * * *';
+let AdminReportViewService = AdminReportViewService_1 = class AdminReportViewService {
+    constructor(sqlService) {
+        this.sqlService = sqlService;
+        this.logger = new common_1.Logger(AdminReportViewService_1.name);
+    }
+    async list() {
+        const rows = await nestjs_utility_services_1.MaterialViewEntity.find({ order: { table_name: 'ASC' } });
+        const views = [];
+        for (const row of rows) {
+            const gate = await this.evaluate(row, { persistDrop: false });
+            views.push({
+                id: row.id,
+                table_name: row.table_name,
+                active: row.active,
+                timing: row.timing,
+                last_run_time: row.last_run_time,
+                attributes: row.attributes || {},
+                gate: { ok: gate.ok, findings: gate.findings },
+            });
+        }
+        return { views };
+    }
+    async register(body) {
+        const tableName = this.assertTableName(body?.table_name);
+        await this.assertRelationExists(tableName);
+        const attributes = this.parseViewAttributes(body?.attributes || {}, true);
+        this.applyViewDefaults(tableName, attributes);
+        if (attributes.agent_visible) {
+            const probe = this.asViewRow({ table_name: tableName, attributes });
+            const gate = await this.evaluate(probe, { persistDrop: false });
+            if (!gate.ok) {
+                throw new nestjs_utility_services_1.OperationException(`Cannot set agent_visible: ${gate.findings.join('; ')}`);
+            }
+        }
+        const row = await nestjs_utility_services_1.MaterialViewEntity.firstOrNew({ table_name: tableName });
+        row.table_name = tableName;
+        row.timing = body?.timing || row.timing || DEFAULT_TIMING;
+        row.active = body?.active === undefined ? (row.active ?? true) : Boolean(body.active);
+        row.attributes = { ...(row.attributes || {}), ...attributes };
+        await row.save();
+        return row;
+    }
+    async update(tableName, body) {
+        const row = await this.requireRegisteredView(tableName);
+        const patch = this.parseViewAttributes(body?.attributes || {}, true);
+        const next = { ...(row.attributes || {}), ...patch };
+        if (body?.timing !== undefined)
+            row.timing = body.timing;
+        if (body?.active !== undefined)
+            row.active = Boolean(body.active);
+        row.attributes = next;
+        const turningOn = Boolean(next.agent_visible);
+        const gate = await this.evaluate(row, { persistDrop: false });
+        if (turningOn && !gate.ok) {
+            throw new nestjs_utility_services_1.OperationException(`Cannot set agent_visible: ${gate.findings.join('; ')}`);
+        }
+        await row.save();
+        return { view: row, gate };
+    }
+    async sample(tableName, limit, offset) {
+        const row = await this.requireRegisteredView(tableName);
+        const cap = this.clampLimit(limit);
+        const skip = this.clampOffset(offset);
+        const ident = this.quoteIdent(row.table_name);
+        const rows = await this.sqlService.boundRead(`SELECT * FROM ${ident} LIMIT $1 OFFSET $2`, [cap, skip]);
+        return {
+            table_name: row.table_name,
+            limit: cap,
+            offset: skip,
+            rows: Array.isArray(rows) ? rows : [],
+        };
+    }
+    async columnsSync(input = {}) {
+        const args = typeof input === 'string' ? { table_name: input } : input || {};
+        const sourceType = args.source_type || SourceHash.materialView;
+        if (sourceType !== SourceHash.materialView) {
+            throw new nestjs_utility_services_1.OperationException('source_type must be the material-view hash 6cc76494999951a1ac3631ca815c1786');
+        }
+        const row = await this.resolveView(args);
+        await this.assertRelationExists(row.table_name);
+        const live = await this.loadLiveColumns(row.table_name);
+        const typeMap = await this.columnTypeMapping();
+        if (args.name) {
+            const liveCol = live.find((column) => column.column_name === args.name);
+            if (!liveCol)
+                throw new common_1.BadRequestException(`column '${args.name}' is not on ${row.table_name}`);
+            const created = await this.upsertLiveColumn(row, liveCol, typeMap, sourceType);
+            return {
+                table_name: row.table_name,
+                created: created ? [args.name] : [],
+                adopted: created ? [] : [args.name],
+                orphaned: [],
+            };
+        }
+        const existing = await nestjs_utility_services_1.ColumnEntity.find({
+            where: { source_type: sourceType, source_id: row.id },
+        });
+        const byName = new Map(existing.map((column) => [column.name, column]));
+        const liveNames = new Set(live.map((column) => column.column_name));
+        const created = [];
+        const adopted = [];
+        for (const liveCol of live) {
+            const isNew = await this.upsertLiveColumn(row, liveCol, typeMap, sourceType);
+            if (isNew)
+                created.push(liveCol.column_name);
+            else
+                adopted.push(liveCol.column_name);
+            byName.delete(liveCol.column_name);
+        }
+        const orphaned = [...byName.keys()].filter((name) => !liveNames.has(name));
+        return { table_name: row.table_name, created, adopted, orphaned };
+    }
+    async resolveView(args) {
+        if (args.source_id) {
+            const row = await nestjs_utility_services_1.MaterialViewEntity.findOne({ where: { id: args.source_id } });
+            if (!row)
+                throw new nestjs_utility_services_1.OperationException(`No material view found with id ${args.source_id}`);
+            if (args.table_name && args.table_name !== row.table_name) {
+                throw new nestjs_utility_services_1.OperationException(`table_name '${args.table_name}' does not match source_id ${args.source_id}`);
+            }
+            return row;
+        }
+        if (args.table_name)
+            return this.requireRegisteredView(args.table_name);
+        throw new nestjs_utility_services_1.OperationException('table_name or source_id is required');
+    }
+    async upsertLiveColumn(row, liveCol, typeMap, sourceType) {
+        const column = await nestjs_utility_services_1.ColumnEntity.firstOrNew({
+            source_type: sourceType,
+            source_id: row.id,
+            name: liveCol.column_name,
+        });
+        const isNew = !column.id;
+        column.ordinal_position = Number(liveCol.ordinal_position);
+        const isNullable = liveCol.is_nullable === 'YES';
+        column.nullable = isNullable;
+        column.required = !isNullable;
+        column.type_id = this.resolveTypeId(liveCol.col_type || liveCol.udt_name || liveCol.data_type, typeMap);
+        if (isNew) {
+            const tenancy = this.tenancyColumn(row);
+            column.display_name = this.displayName(liveCol.column_name);
+            column.description = '';
+            column.visibility = liveCol.column_name !== tenancy;
+            column.query_params = '{}';
+            column.is_custom_column = false;
+            column.attributes = {};
+        }
+        await column.save();
+        return isNew;
+    }
+    async describeColumns(tableName, patches = []) {
+        const row = await this.requireRegisteredView(tableName);
+        if (!Array.isArray(patches) || !patches.length) {
+            throw new nestjs_utility_services_1.OperationException('columns array is required');
+        }
+        const missing = [];
+        const updated = [];
+        for (const patch of patches) {
+            if (!patch?.name)
+                throw new nestjs_utility_services_1.OperationException('each column patch requires name');
+            const column = await nestjs_utility_services_1.ColumnEntity.findOne({
+                where: { source_type: SourceHash.materialView, source_id: row.id, name: patch.name },
+            });
+            if (!column) {
+                missing.push(patch.name);
+                continue;
+            }
+            if (patch.display_name !== undefined)
+                column.display_name = patch.display_name;
+            if (patch.description !== undefined)
+                column.description = patch.description;
+            if (patch.visibility !== undefined)
+                column.visibility = Boolean(patch.visibility);
+            if (patch.attributes !== undefined) {
+                const parsed = this.parseColumnAttributes(patch.attributes, true);
+                column.attributes = { ...(column.attributes || {}), ...parsed };
+            }
+            await column.save();
+            updated.push(patch.name);
+        }
+        const gate = await this.evaluate(row, { persistDrop: true });
+        return { table_name: row.table_name, updated, missing, gate };
+    }
+    async validate(tableName) {
+        if (tableName) {
+            const row = await this.requireRegisteredView(tableName);
+            return this.evaluate(row, { persistDrop: true });
+        }
+        const rows = await nestjs_utility_services_1.MaterialViewEntity.find();
+        const views = [];
+        for (const row of rows) {
+            views.push(await this.evaluate(row, { persistDrop: true }));
+        }
+        return { views };
+    }
+    async evaluate(row, options) {
+        const findings = [];
+        const attributes = row.attributes || {};
+        const viewParse = this.tryParseViewAttributes(attributes);
+        if (viewParse.error)
+            findings.push(`view attributes: ${viewParse.error}`);
+        const parsed = viewParse.dto || new material_view_catalog_attributes_dto_1.MaterialViewCatalogAttributesDto();
+        const tenancy = parsed.tenancy_column || DEFAULT_TENANCY;
+        const catalogName = parsed.catalog_name || this.defaultCatalogName(row.table_name);
+        if (catalogName && !/^[a-z][a-z0-9_]{1,40}$/.test(catalogName)) {
+            findings.push(`catalog_name '${catalogName}' is invalid`);
+        }
+        if (row.table_name) {
+            const exists = await this.relationExists(row.table_name);
+            if (!exists)
+                findings.push(`relation '${row.table_name}' does not exist`);
+        }
+        else {
+            findings.push('table_name is missing');
+        }
+        const liveNames = new Set((await this.loadLiveColumnsSafe(row.table_name)).map((column) => column.column_name));
+        if (row.table_name && liveNames.size && !liveNames.has(tenancy)) {
+            findings.push(`tenancy column '${tenancy}' is missing from ${row.table_name}`);
+        }
+        const columns = row.id ? await nestjs_utility_services_1.ColumnEntity.find({ where: { source_type: SourceHash.materialView, source_id: row.id } }) : [];
+        if (row.id && columns.length === 0) {
+            findings.push('no_columns_registered');
+        }
+        const tenancyColumn = columns.find((column) => column.name === tenancy);
+        if (tenancyColumn?.visibility) {
+            findings.push(`tenancy column '${tenancy}' must not be agent-exposed (visibility=false)`);
+        }
+        const agentVisible = Boolean(parsed.agent_visible);
+        if (agentVisible && !(parsed.description || '').trim()) {
+            findings.push('agent_visible views require a non-empty description');
+        }
+        for (const column of columns) {
+            if (liveNames.size && !liveNames.has(column.name)) {
+                findings.push(`registered column '${column.name}' is missing from ${row.table_name}`);
+            }
+            const colParse = this.tryParseColumnAttributes(column.attributes || {});
+            if (colParse.error)
+                findings.push(`column '${column.name}' attributes: ${colParse.error}`);
+            const colAttrs = colParse.dto || new column_catalog_attributes_dto_1.ColumnCatalogAttributesDto();
+            if (agentVisible && !(column.description || '').trim()) {
+                findings.push(`column '${column.name}' needs a description`);
+            }
+            if (colAttrs.semantic_type === 'enum' && !this.hasEnumMap(colAttrs.enum_map)) {
+                findings.push(`column '${column.name}' is enum but has no enum_map`);
+            }
+        }
+        const ok = findings.length === 0;
+        let dropped = false;
+        if (!ok && agentVisible && options.persistDrop && row.id) {
+            row.attributes = { ...attributes, agent_visible: false };
+            await row.save();
+            dropped = true;
+            this.logger.warn(`reporting catalog gate: dropped agent_visible on ${row.table_name}: ${findings.join('; ')}`);
+        }
+        return {
+            table_name: row.table_name,
+            ok,
+            findings,
+            agent_visible: dropped ? false : agentVisible,
+            ...(dropped ? { dropped: true } : {}),
+        };
+    }
+    parseViewAttributes(raw, forbidUnknown) {
+        const parsed = this.tryParseViewAttributes(raw, forbidUnknown);
+        if (parsed.error)
+            throw new nestjs_utility_services_1.OperationException(`Invalid view attributes: ${parsed.error}`);
+        return parsed.dto;
+    }
+    parseColumnAttributes(raw, forbidUnknown) {
+        const parsed = this.tryParseColumnAttributes(raw, forbidUnknown);
+        if (parsed.error)
+            throw new nestjs_utility_services_1.OperationException(`Invalid column attributes: ${parsed.error}`);
+        return parsed.dto;
+    }
+    tryParseViewAttributes(raw, forbidUnknown = true) {
+        const dto = (0, class_transformer_1.plainToInstance)(material_view_catalog_attributes_dto_1.MaterialViewCatalogAttributesDto, raw || {}, { enableImplicitConversion: true });
+        const errors = (0, class_validator_1.validateSync)(dto, { whitelist: true, forbidNonWhitelisted: forbidUnknown });
+        return { dto, error: this.formatErrors(errors) };
+    }
+    tryParseColumnAttributes(raw, forbidUnknown = false) {
+        const dto = (0, class_transformer_1.plainToInstance)(column_catalog_attributes_dto_1.ColumnCatalogAttributesDto, raw || {}, { enableImplicitConversion: true });
+        const errors = (0, class_validator_1.validateSync)(dto, { whitelist: true, forbidNonWhitelisted: forbidUnknown });
+        return { dto, error: this.formatErrors(errors) };
+    }
+    formatErrors(errors) {
+        if (!errors.length)
+            return null;
+        return errors
+            .map((error) => {
+            const constraints = error.constraints ? Object.values(error.constraints).join(', ') : 'invalid';
+            return `${error.property}: ${constraints}`;
+        })
+            .join('; ');
+    }
+    applyViewDefaults(tableName, attributes) {
+        if (!attributes.catalog_name)
+            attributes.catalog_name = this.defaultCatalogName(tableName);
+        if (!attributes.tenancy_column)
+            attributes.tenancy_column = DEFAULT_TENANCY;
+        if (attributes.row_cap === undefined)
+            attributes.row_cap = 500;
+        if (attributes.agent_visible === undefined)
+            attributes.agent_visible = false;
+    }
+    defaultCatalogName(tableName) {
+        return tableName.replace(/^rpt_/, '') || tableName;
+    }
+    tenancyColumn(row) {
+        return row.attributes?.tenancy_column || DEFAULT_TENANCY;
+    }
+    asViewRow(partial) {
+        const row = new nestjs_utility_services_1.MaterialViewEntity();
+        row.table_name = partial.table_name;
+        row.attributes = partial.attributes;
+        return row;
+    }
+    async requireRegisteredView(tableName) {
+        const name = this.assertTableName(tableName);
+        const row = await nestjs_utility_services_1.MaterialViewEntity.findOne({ where: { table_name: name } });
+        if (!row)
+            throw new nestjs_utility_services_1.OperationException(`table_name '${name}' is not a registered material view`);
+        return row;
+    }
+    assertTableName(tableName) {
+        if (!tableName || !material_view_catalog_attributes_dto_1.TABLE_NAME_PATTERN.test(tableName)) {
+            throw new nestjs_utility_services_1.OperationException('table_name must match ^[a-z][a-z0-9_]{1,62}$');
+        }
+        return tableName;
+    }
+    quoteIdent(tableName) {
+        return `"${tableName.replace(/"/g, '""')}"`;
+    }
+    clampLimit(limit) {
+        const n = Number(limit);
+        if (!Number.isFinite(n) || n <= 0)
+            return DEFAULT_SAMPLE_LIMIT;
+        return Math.min(Math.floor(n), SAMPLE_CAP);
+    }
+    clampOffset(offset) {
+        const n = Number(offset);
+        if (!Number.isFinite(n) || n <= 0)
+            return 0;
+        return Math.floor(n);
+    }
+    async assertRelationExists(tableName) {
+        if (!(await this.relationExists(tableName))) {
+            throw new nestjs_utility_services_1.OperationException(`materialized view '${tableName}' does not exist`);
+        }
+    }
+    async relationExists(tableName) {
+        if (!tableName || !material_view_catalog_attributes_dto_1.TABLE_NAME_PATTERN.test(tableName))
+            return false;
+        const row = await this.boundReadFirst(`SELECT 1 AS ok
+             FROM pg_catalog.pg_class c
+             JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+             WHERE n.nspname = 'public' AND c.relname = $1 AND c.relkind = 'm'
+             LIMIT 1`, [tableName], 'ok');
+        return Boolean(row);
+    }
+    async boundReadFirst(query, params = [], column) {
+        const rows = await this.sqlService.boundRead(query, params);
+        const data = Array.isArray(rows) ? rows[0] : null;
+        if (!column)
+            return data;
+        return data?.[column];
+    }
+    async loadLiveColumns(tableName) {
+        const rows = await this.sqlService.boundRead(`SELECT a.attname,
+                    format_type(a.atttypid, a.atttypmod) AS col_type,
+                    a.attnum,
+                    CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable
+             FROM pg_catalog.pg_attribute a
+             JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+             JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+             WHERE n.nspname = 'public' AND c.relname = $1 AND c.relkind = 'm'
+               AND a.attnum > 0 AND NOT a.attisdropped
+             ORDER BY a.attnum`, [tableName]);
+        if (!Array.isArray(rows))
+            return [];
+        return rows.map((row) => this.normalizeLiveColumn(row));
+    }
+    normalizeLiveColumn(row) {
+        const columnName = String(row.attname ?? row.column_name ?? '');
+        const colType = String(row.col_type ?? row.udt_name ?? row.data_type ?? '');
+        return {
+            column_name: columnName,
+            col_type: colType,
+            ordinal_position: Number(row.attnum ?? row.ordinal_position ?? 0),
+            is_nullable: String(row.is_nullable ?? 'YES'),
+        };
+    }
+    resolveTypeId(colType, typeMap) {
+        const raw = String(colType || '')
+            .toLowerCase()
+            .trim();
+        const base = raw.replace(/\(.*/, '').trim();
+        return typeMap[raw] || typeMap[base] || 1;
+    }
+    async loadLiveColumnsSafe(tableName) {
+        if (!tableName || !material_view_catalog_attributes_dto_1.TABLE_NAME_PATTERN.test(tableName))
+            return [];
+        try {
+            return await this.loadLiveColumns(tableName);
+        }
+        catch {
+            return [];
+        }
+    }
+    async columnTypeMapping() {
+        const mapping = {};
+        const types = await nestjs_utility_services_1.ColumnDefinitionEntity.find({ where: { supported_identifiers: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) } });
+        for (const type of types) {
+            for (const identifier of String(type.supported_identifiers || '').split(',')) {
+                const key = identifier.trim().toLowerCase();
+                if (key)
+                    mapping[key] = type.id;
+            }
+        }
+        return mapping;
+    }
+    displayName(name) {
+        const stripped = name.endsWith('_id') ? name.slice(0, -3) : name;
+        return stripped.replace(/_/g, ' ').replace(/\b[a-z]/g, (char) => char.toUpperCase());
+    }
+    hasEnumMap(map) {
+        return Boolean(map && typeof map === 'object' && Object.keys(map).length);
+    }
+};
+exports.AdminReportViewService = AdminReportViewService;
+exports.AdminReportViewService = AdminReportViewService = AdminReportViewService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [nestjs_utility_services_1.SqlService])
+], AdminReportViewService);
+//# sourceMappingURL=admin.report.view.service.js.map