proteum 2.1.2 → 2.1.6

package/server/app/container/trace/index.ts

@@ -9,8 +9,12 @@ import {
     type TTraceCallOrigin,
     type TTraceEvent,
     type TTraceEventType,
+    type TTraceSqlQuery,
+    type TTraceSqlQueryCallerOrigin,
+    type TTraceSqlQueryKind,
     type TTraceSummaryValue,
     type TRequestTrace,
+    type TTraceMemorySnapshot,
     type TRequestTraceListItem,
 } from '@common/dev/requestTrace';
 
@@ -38,6 +42,44 @@ const isSensitiveKeyPath = (keyPath: string[]) => sensitiveKeyPattern.test(keyPa
 const summarizeString = (value: string) =>
     value.length <= maxStringLength ? value : `${value.slice(0, maxStringLength)}…`;
 
+const serializeJsonValue = (value: unknown, keyPath: string[], seen: WeakSet<object>): unknown => {
+    if (isSensitiveKeyPath(keyPath)) return `[redacted: Sensitive key ${keyPath[keyPath.length - 1] || 'value'}]`;
+    if (value === undefined || value === null) return value;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+    if (typeof value === 'bigint') return `${value.toString()}n`;
+    if (typeof value === 'symbol') return value.toString();
+    if (typeof value === 'function') return `[Function ${value.name || 'anonymous'}]`;
+
+    if (value instanceof Date) return value.toISOString();
+    if (value instanceof Error) return { name: value.name, message: value.message, stack: value.stack };
+    if (Buffer.isBuffer(value)) return `[Buffer ${value.byteLength} bytes]`;
+    if (value instanceof Map) return Array.from(value.entries()).map(([entryKey, entryValue], index) =>
+        serializeJsonValue([entryKey, entryValue], [...keyPath, `[${index}]`], seen),
+    );
+    if (value instanceof Set) {
+        return Array.from(value.values()).map((entryValue, index) => serializeJsonValue(entryValue, [...keyPath, `[${index}]`], seen));
+    }
+
+    if (typeof value !== 'object') return String(value);
+    if (seen.has(value)) return `[Circular ${value.constructor?.name || 'Object'}]`;
+
+    seen.add(value);
+
+    if (Array.isArray(value)) {
+        return value.map((item, index) => serializeJsonValue(item, [...keyPath, `[${index}]`], seen));
+    }
+
+    const serialized: Record<string, unknown> = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+        const nextValue = serializeJsonValue(entryValue, [...keyPath, entryKey], seen);
+        if (nextValue !== undefined) serialized[entryKey] = nextValue;
+    }
+
+    return serialized;
+};
+
+const serializeCaptureValue = (value: TTraceInspectable, key: string) => serializeJsonValue(value, [key], new WeakSet<object>());
+
 const summarizeError = (error: Error): TTraceSummaryValue => ({
     kind: 'error',
     name: error.name,
@@ -118,11 +160,29 @@ const summarizeCaptureValue = (value: TTraceInspectable, capture: TTraceCaptureM
     summarizeValue(value, capture === 'deep' ? 3 : 1, new WeakSet<object>(), [key]);
 
 const nowIso = () => new Date().toISOString();
+const snapshotMemory = (): TTraceMemorySnapshot => {
+    const usage = process.memoryUsage();
+
+    return {
+        arrayBuffers: typeof usage.arrayBuffers === 'number' ? usage.arrayBuffers : 0,
+        external: usage.external,
+        heapTotal: usage.heapTotal,
+        heapUsed: usage.heapUsed,
+        rss: usage.rss,
+    };
+};
 
 export default class Trace {
     private requests = new Map<string, TRequestTrace>();
     private order: string[] = [];
     private armedCapture?: TTraceCaptureMode;
+    private activeMeasurements = new Map<
+        string,
+        {
+            cpu: ReturnType<typeof process.cpuUsage>;
+            memory: TTraceMemorySnapshot;
+        }
+    >();
 
     public constructor(
         private container: typeof ApplicationContainer,
@@ -169,11 +229,14 @@ export default class Trace {
             profilerParentRequestId: input.profilerParentRequestId,
             startedAt: nowIso(),
             droppedEvents: 0,
+            requestDataJson: serializeCaptureValue(input.data, 'requestData'),
             calls: [],
+            sqlQueries: [],
             events: [],
         };
 
         this.requests.set(trace.id, trace);
+        this.activeMeasurements.set(trace.id, { cpu: process.cpuUsage(), memory: snapshotMemory() });
         this.order.push(trace.id);
         this.trimRequestBuffer();
 
@@ -226,6 +289,21 @@ export default class Trace {
         if (output.user) trace.user = output.user;
         trace.statusCode = output.statusCode;
         trace.errorMessage = output.errorMessage;
+        const measurement = this.activeMeasurements.get(requestId);
+        if (measurement) {
+            const cpu = process.cpuUsage(measurement.cpu);
+            trace.performance = {
+                cpu: {
+                    systemMicros: cpu.system,
+                    userMicros: cpu.user,
+                },
+                memory: {
+                    after: snapshotMemory(),
+                    before: measurement.memory,
+                },
+            };
+            this.activeMeasurements.delete(requestId);
+        }
 
         this.record(
             requestId,
@@ -250,6 +328,8 @@ export default class Trace {
             method?: string;
             path?: string;
             fetcherId?: string;
+            connectedProjectNamespace?: string;
+            connectedControllerAccessor?: string;
             parentId?: string;
             requestDataKeys?: string[];
             requestData?: TTraceInspectable;
@@ -266,9 +346,12 @@ export default class Trace {
             method: input.method || '',
             path: input.path || '',
             fetcherId: input.fetcherId,
+            connectedProjectNamespace: input.connectedProjectNamespace,
+            connectedControllerAccessor: input.connectedControllerAccessor,
             startedAt: nowIso(),
             requestDataKeys: input.requestDataKeys || [],
             requestData: input.requestData !== undefined ? summarizeCaptureValue(input.requestData, trace.capture, 'requestData') : undefined,
+            requestDataJson: input.requestData !== undefined ? serializeCaptureValue(input.requestData, 'requestData') : undefined,
             resultKeys: [],
         };
 
@@ -298,6 +381,66 @@ export default class Trace {
         call.errorMessage = output.errorMessage;
         call.resultKeys = output.resultKeys || [];
         call.result = output.result !== undefined ? summarizeCaptureValue(output.result, trace.capture, 'result') : undefined;
+        call.resultJson = output.result !== undefined ? serializeCaptureValue(output.result, 'result') : undefined;
+    }
+
+    public setRequestResult(requestId: string, result: TTraceInspectable) {
+        const trace = this.requests.get(requestId);
+        if (!trace) return;
+
+        trace.resultJson = serializeCaptureValue(result, 'result');
+    }
+
+    public recordSqlQuery(
+        requestId: string,
+        input: {
+            callerCallId?: string;
+            callerFetcherId?: string;
+            callerLabel?: string;
+            callerMethod?: string;
+            callerOrigin?: TTraceSqlQueryCallerOrigin;
+            callerPath?: string;
+            durationMs?: number;
+            finishedAt?: string;
+            kind: TTraceSqlQueryKind;
+            model?: string;
+            operation: string;
+            paramsJson?: unknown;
+            paramsText?: string;
+            query: string;
+            target?: string;
+        },
+    ) {
+        const trace = this.requests.get(requestId);
+        if (!trace) return;
+
+        const durationMs = Math.max(0, input.durationMs || 0);
+        const finishedAt = input.finishedAt || nowIso();
+        const finishedAtMs = Date.parse(finishedAt);
+        const startedAt =
+            Number.isFinite(finishedAtMs) && durationMs > 0 ? new Date(finishedAtMs - durationMs).toISOString() : finishedAt;
+
+        const sqlQuery: TTraceSqlQuery = {
+            id: `${requestId}:sql:${trace.sqlQueries.length}`,
+            callerCallId: input.callerCallId,
+            callerFetcherId: input.callerFetcherId,
+            callerLabel: input.callerLabel,
+            callerMethod: input.callerMethod || '',
+            callerOrigin: input.callerOrigin || 'request',
+            callerPath: input.callerPath || '',
+            durationMs,
+            finishedAt,
+            kind: input.kind,
+            model: input.model,
+            operation: input.operation,
+            paramsJson: input.paramsJson,
+            paramsText: input.paramsText,
+            query: input.query.trim(),
+            startedAt,
+            target: input.target,
+        };
+
+        trace.sqlQueries.push(sqlQuery);
     }
 
     public listRequests(limit = 20): TRequestTraceListItem[] {
@@ -325,9 +468,18 @@ export default class Trace {
                 profilerParentRequestId: trace.profilerParentRequestId,
                 eventCount: trace.events.length,
                 callCount: trace.calls.length,
+                sqlQueryCount: trace.sqlQueries.length,
             }));
     }
 
+    public listTraceRequests(limit = this.config.requestsLimit) {
+        return [...this.order]
+            .reverse()
+            .slice(0, Math.max(1, limit))
+            .map((requestId) => this.requests.get(requestId))
+            .filter((trace): trace is TRequestTrace => trace !== undefined);
+    }
+
     public getLatestRequest() {
         const latestRequestId = this.order[this.order.length - 1];
         return latestRequestId ? this.requests.get(latestRequestId) : undefined;
@@ -359,6 +511,7 @@ export default class Trace {
 
         for (const requestId of this.order.splice(0, overflow)) {
             this.requests.delete(requestId);
+            this.activeMeasurements.delete(requestId);
         }
     }
 }

package/server/app/devDiagnostics.ts

@@ -2,6 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 
 import type { Application } from './index';
+import type { TDevConsoleLogLevel, TDevConsoleLogsResponse } from '@common/dev/console';
 import {
     buildDoctorResponse,
     explainSectionNames,
@@ -9,10 +10,31 @@ import {
     type TDoctorResponse,
     type TExplainSectionName,
 } from '@common/dev/diagnostics';
+import { buildContractsDoctorResponse } from '@common/dev/contractsDoctor';
+import {
+    buildPerfCompareResponse,
+    buildPerfMemoryResponse,
+    buildPerfTopResponse,
+    resolvePerfRequest,
+    type TPerfCompareResponse,
+    type TPerfGroupBy,
+    type TPerfMemoryResponse,
+    type TPerfRequestResponse,
+    type TPerfTopResponse,
+} from '@common/dev/performance';
+import {
+    buildDiagnoseResponse,
+    explainOwner,
+    type TDiagnoseResponse,
+    type TExplainOwnerResponse,
+} from '@common/dev/inspection';
 import type { TProteumManifest } from '@common/dev/proteumManifest';
+import type { TRequestTrace } from '@common/dev/requestTrace';
 
 const isExplainSectionName = (value: string): value is TExplainSectionName =>
     explainSectionNames.includes(value as TExplainSectionName);
+const isConsoleLogLevel = (value: string): value is TDevConsoleLogLevel =>
+    ['silly', 'log', 'info', 'warn', 'error'].includes(value);
 
 export default class DevDiagnosticsRegistry<TApplication extends Application = Application> {
     public constructor(private app: TApplication) {}
@@ -50,4 +72,120 @@ export default class DevDiagnosticsRegistry<TApplication extends Application = A
     public doctor(strict = false): TDoctorResponse {
         return buildDoctorResponse(this.readManifest(), strict);
     }
+
+    public doctorContracts(strict = false): TDoctorResponse {
+        return buildContractsDoctorResponse(this.readManifest(), strict);
+    }
+
+    public explainOwner(query: string): TExplainOwnerResponse {
+        const normalizedQuery = query.trim();
+        if (!normalizedQuery) throw new Error('Owner query is required.');
+
+        return explainOwner(this.readManifest(), normalizedQuery);
+    }
+
+    public readLogs(limit = 100, minimumLevel: TDevConsoleLogLevel = 'log'): TDevConsoleLogsResponse {
+        return { logs: this.app.container.Console.listLogs(limit, isConsoleLogLevel(minimumLevel) ? minimumLevel : 'log') };
+    }
+
+    private resolveRequestTrace({ path, requestId }: { path?: string; requestId?: string }): TRequestTrace | undefined {
+        if (requestId) return this.app.container.Trace.getRequest(requestId);
+        if (!path) return this.app.container.Trace.getLatestRequest();
+
+        const match = this.app.container.Trace.listRequests(200).find((request) => request.path === path);
+        return match ? this.app.container.Trace.getRequest(match.id) : undefined;
+    }
+
+    private readPerfRequests() {
+        return this.app.container.Trace.listTraceRequests(Number.MAX_SAFE_INTEGER);
+    }
+
+    public diagnose({
+        logsLevel = 'warn',
+        logsLimit = 40,
+        path,
+        query,
+        requestId,
+        strict = false,
+    }: {
+        logsLevel?: TDevConsoleLogLevel;
+        logsLimit?: number;
+        path?: string;
+        query?: string;
+        requestId?: string;
+        strict?: boolean;
+    } = {}): TDiagnoseResponse {
+        const manifest = this.readManifest();
+        const request = this.resolveRequestTrace({ path, requestId });
+        const resolvedQuery = query?.trim() || path?.trim() || request?.path || requestId?.trim() || '';
+
+        if (!resolvedQuery) throw new Error('Diagnose requires a query, path, request id, or an existing latest request trace.');
+
+        return buildDiagnoseResponse({
+            contracts: buildContractsDoctorResponse(manifest, strict),
+            doctor: buildDoctorResponse(manifest, strict),
+            manifest,
+            query: resolvedQuery,
+            request,
+            serverLogs: this.readLogs(logsLimit, logsLevel),
+        });
+    }
+
+    public perfTop({
+        groupBy = 'path',
+        limit = 12,
+        since = 'today',
+    }: {
+        groupBy?: TPerfGroupBy;
+        limit?: number;
+        since?: string;
+    } = {}): TPerfTopResponse {
+        return buildPerfTopResponse({
+            groupBy,
+            limit,
+            requests: this.readPerfRequests(),
+            since,
+        });
+    }
+
+    public perfCompare({
+        baseline = 'yesterday',
+        groupBy = 'path',
+        limit = 12,
+        target = 'today',
+    }: {
+        baseline?: string;
+        groupBy?: TPerfGroupBy;
+        limit?: number;
+        target?: string;
+    } = {}): TPerfCompareResponse {
+        return buildPerfCompareResponse({
+            baseline,
+            groupBy,
+            limit,
+            requests: this.readPerfRequests(),
+            target,
+        });
+    }
+
+    public perfMemory({
+        groupBy = 'path',
+        limit = 12,
+        since = 'today',
+    }: {
+        groupBy?: TPerfGroupBy;
+        limit?: number;
+        since?: string;
+    } = {}): TPerfMemoryResponse {
+        return buildPerfMemoryResponse({
+            groupBy,
+            limit,
+            requests: this.readPerfRequests(),
+            since,
+        });
+    }
+
+    public perfRequest(requestIdOrPath: string): TPerfRequestResponse {
+        return { request: resolvePerfRequest(this.readPerfRequests(), requestIdOrPath) };
+    }
 }

package/server/app/index.ts

@@ -10,12 +10,13 @@ import ApplicationService, { AnyService } from './service';
 import CommandsManager from './commandsManager';
 import DevCommandsRegistry from './devCommands';
 import DevDiagnosticsRegistry from './devDiagnostics';
-import ServicesContainer, { ServicesContainer as ServicesContainerClass, TServiceMetas } from './service/container';
+import ServicesContainer, { ServicesContainer as ServicesContainerClass } from './service/container';
 
 // Built-in
 import type { TServerRouter, Request as ServerRequest } from '@server/services/router';
 import { Anomaly } from '@common/errors';
 import { TBasicUser } from '@server/services/auth';
+import { Application as ConfigApplication } from '@common/applicationConfig';
 
 export { default as Services } from './service/container';
 export type { ServiceConfig } from './service/container';
@@ -62,6 +63,9 @@ export abstract class Application<
     TServicesContainer extends ServicesContainerClass = ServicesContainerClass,
     TUser extends TBasicUser = TBasicUser,
 > extends ApplicationService<Config, Hooks, Application, Application> {
+    public static identity = ConfigApplication.identity;
+    public static setup = ConfigApplication.setup;
+
     public app!: this;
     public servicesContainer!: TServicesContainer;
     public userType!: TUser;
@@ -71,18 +75,13 @@ export abstract class Application<
     ----------------------------------*/
 
     public side = 'server' as 'server';
-    public metas: TServiceMetas = {
-        id: 'application',
-        name: 'Application',
-        parent: 'root',
-        dependences: [],
-        class: () => ({ default: Application }),
-    };
 
     // Shortcuts to ApplicationContainer
     public container = AppContainer;
     public env = AppContainer.Environment;
     public identity = AppContainer.Identity;
+    public setup = AppContainer.Setup;
+    public connectedProjects = AppContainer.Environment.connectedProjects;
 
     // Status
     public debug: boolean = false;
@@ -195,6 +194,17 @@ export abstract class Application<
         return rootServices[serviceName];
     }
 
+    public getConnectedProject(namespace: string) {
+        return this.connectedProjects[namespace];
+    }
+
+    public requireConnectedProject(namespace: string) {
+        const connectedProject = this.getConnectedProject(namespace);
+        if (connectedProject) return connectedProject;
+
+        throw new Error(`Connected project "${namespace}" is not configured on ${this.identity.identifier}.`);
+    }
+
     public register(service: AnyService) {
         return (service as AnyService & { ready: () => Promise<any> }).ready();
     }

package/server/app/service/container.ts

@@ -9,15 +9,6 @@ import type { AnyService, AnyServiceClass, StartedServicesIndex } from '.';
 - TYPES
 ----------------------------------*/
 
-// From service/service.json
-export type TServiceMetas<TServiceClass extends AnyService = AnyService> = {
-    id: string;
-    name: string;
-    parent: string;
-    dependences: string[];
-    class: () => { default: ClassType<TServiceClass> };
-};
-
 export type ServiceConfig<TServiceClass extends AnyServiceClass> = NonNullable<ConstructorParameters<TServiceClass>[1]>;
 
 type ExactConfig<TValue, TShape> = TValue extends TShape
@@ -40,9 +31,6 @@ type ExactConfig<TValue, TShape> = TValue extends TShape
 - CLASS
 ----------------------------------*/
 export class ServicesContainer<TServicesIndex extends StartedServicesIndex = StartedServicesIndex> {
-    // All service instances by service id
-    public allServices: TServicesIndex = {} as TServicesIndex;
-
     public config<TServiceClass extends AnyServiceClass, const TConfig extends ServiceConfig<TServiceClass>>(
         _serviceClass: TServiceClass,
         config: TConfig & ExactConfig<TConfig, ServiceConfig<TServiceClass>>,

package/server/app/service/index.ts

@@ -5,7 +5,6 @@
 // Specific
 import type { Application } from '../index';
 import type { Command } from '../commands';
-import type { TServiceMetas } from './container';
 import type { TRouterContext, TAnyRouter } from '../../services/router';
 
 export { schema } from '../../services/router/request/validation/zod';
@@ -95,7 +94,6 @@ export default abstract class Service<
     public status: 'stopped' | 'starting' | 'running' | 'paused' = 'starting';
 
     public commands?: Command[];
-    public metas!: TServiceMetas;
     public bindings: string[] = [];
 
     public parent: TParent;

package/server/services/prisma/index.ts

@@ -4,13 +4,15 @@
 
 // Npm
 import dotenv from 'dotenv';
-import { PrismaClient } from '@generated/server/models';
+import { Prisma, PrismaClient } from '@generated/server/models';
 import mysql from 'mysql2/promise';
 const safeStringify = require('fast-safe-stringify'); // remplace les références circulairs par un [Circular]
 
 // Core
 import type { Application } from '@server/app/index';
+import type { ChannelInfos } from '@server/app/container/console';
 import Service, { TServiceArgs } from '@server/app/service';
+import context from '@server/context';
 
 // Specific
 import Facet, { TDelegate, TSubset, Transform } from './Facet';
@@ -29,6 +31,20 @@ type DecimalLike = {
     toNumber: () => number;
     toString: () => string;
 };
+type TPrismaOperationContext = { kind: 'orm' | 'raw'; model?: string; operation: string };
+type TPrismaQueryEvent = {
+    duration: number;
+    params: string;
+    query: string;
+    target: string;
+    timestamp: Date;
+};
+type TPrismaExtensionOperation = {
+    args: unknown;
+    model?: string;
+    operation: string;
+    query: (args: unknown) => Promise<unknown>;
+};
 
 /*----------------------------------
 - HELPERS
@@ -78,6 +94,51 @@ const normalizeSqlResult = <T>(value: T): T => {
         Object.entries(value).map(([key, nestedValue]) => [key, normalizeSqlResult(nestedValue)]),
     ) as T;
 };
+const rawOperationNames = new Set([
+    '$executeRaw',
+    '$executeRawUnsafe',
+    '$queryRaw',
+    '$queryRawUnsafe',
+    'aggregateRaw',
+    'executeRaw',
+    'findRaw',
+    'queryRaw',
+    'runCommandRaw',
+]);
+
+const inferPrismaOperationKind = (model: string | undefined, operation: string): TPrismaOperationContext['kind'] =>
+    rawOperationNames.has(operation) || operation.toLowerCase().includes('raw') ? 'raw' : model ? 'orm' : 'raw';
+
+const parseQueryParams = (value: string) => {
+    if (!value) return undefined;
+
+    try {
+        return JSON.parse(value);
+    } catch (_error) {
+        return undefined;
+    }
+};
+
+const withPrismaOperationContext = async <T>(meta: TPrismaOperationContext, execute: () => Promise<T>) => {
+    const store = context.getStore() as ChannelInfos | undefined;
+    if (!store) return execute();
+
+    const operations = store.prismaOperations || (store.prismaOperations = []);
+    operations.push(meta);
+
+    try {
+        return await execute();
+    } finally {
+        const lastOperation = operations[operations.length - 1];
+        if (lastOperation === meta) operations.pop();
+        else {
+            const operationIndex = operations.lastIndexOf(meta);
+            if (operationIndex !== -1) operations.splice(operationIndex, 1);
+        }
+
+        if (operations.length === 0) delete store.prismaOperations;
+    }
+};
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -112,9 +173,40 @@ export default class ModelsManager extends Service<Config, Hooks, Application, A
                 'DATABASE_URL is required before starting the Models service. Prisma 7 no longer auto-loads runtime env files.',
             );
 
-        this.client = new PrismaClient({
-            adapter: createMariaDbAdapter(databaseUrl),
-        });
+        const shouldTraceQueries = this.app.container.Trace.isEnabled();
+        const prismaClient = shouldTraceQueries
+            ? new PrismaClient({
+                  adapter: createMariaDbAdapter(databaseUrl),
+                  log: [{ emit: 'event', level: 'query' }],
+              })
+            : new PrismaClient({
+                  adapter: createMariaDbAdapter(databaseUrl),
+              });
+
+        if (!shouldTraceQueries) {
+            this.client = prismaClient;
+            return;
+        }
+
+        prismaClient.$on('query', (event: TPrismaQueryEvent) => this.traceQuery(event));
+
+        this.client = prismaClient.$extends(
+            Prisma.defineExtension({
+                query: {
+                    async $allOperations({ args, model, operation, query }: TPrismaExtensionOperation) {
+                        const normalizedModel = typeof model === 'string' ? model : undefined;
+                        return withPrismaOperationContext(
+                            {
+                                kind: inferPrismaOperationKind(normalizedModel, operation),
+                                model: normalizedModel,
+                                operation,
+                            },
+                            () => query(args),
+                        );
+                    },
+                },
+            }),
+        ) as PrismaClient;
     }
 
     public async ready() {
@@ -241,4 +333,29 @@ export default class ModelsManager extends Service<Config, Hooks, Application, A
     public equalities = (data: TObjetDonnees, forStorage: boolean = false) => {
         return Object.keys(data).map((k) => '' + k + ' = ' + this.esc(data[k], forStorage));
     };
+
+    private traceQuery(event: TPrismaQueryEvent) {
+        const store = context.getStore() as ChannelInfos | undefined;
+        if (!store || store.channelType !== 'request' || !store.channelId) return;
+
+        const operation = store.prismaOperations?.[store.prismaOperations.length - 1];
+
+        this.app.container.Trace.recordSqlQuery(store.channelId, {
+            callerCallId: store.traceCallId,
+            callerFetcherId: store.traceCallFetcherId,
+            callerLabel: store.traceCallLabel,
+            callerMethod: store.method,
+            callerOrigin: store.traceCallOrigin || 'request',
+            callerPath: store.path,
+            durationMs: event.duration,
+            finishedAt: event.timestamp.toISOString(),
+            kind: operation?.kind || 'orm',
+            model: operation?.model,
+            operation: operation?.operation || 'query',
+            paramsJson: parseQueryParams(event.params),
+            paramsText: event.params,
+            query: event.query,
+            target: event.target,
+        });
+    }
 }