@zintrust/core 0.4.75 → 0.4.77

package/src/orm/migrations/MigrationStore.js

@@ -1,6 +1,17 @@
 import { Env } from '../../config/env.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { QueryBuilder } from '../QueryBuilder.js';
+const DEFAULT_LAYOUT = Object.freeze({
+    hasAppliedAt: true,
+    hasCreatedAt: true,
+    hasMigration: false,
+    hasName: true,
+    hasScope: true,
+    hasService: true,
+    hasStatus: true,
+    requiresCompatibilityMode: false,
+});
+const tableLayoutCache = new WeakMap();
 function nowIso() {
     // MySQL/MariaDB DATETIME does not accept ISO8601 with timezone (e.g. trailing 'Z').
     // Use a portable UTC datetime string.
@@ -11,6 +22,230 @@ const toSafeService = (service) => {
         return '';
     return service.length > 0 ? service : '';
 };
+const isDefaultTrackingTarget = (scope, service) => {
+    return scope === 'global' && service === '';
+};
+const queryExists = async (db, sql, parameters) => {
+    const rows = await db.query(sql, parameters, true);
+    return rows.length > 0;
+};
+const schemaHasTable = async (db, tableName) => {
+    const driver = db.getType();
+    if (driver === 'sqlite' || driver === 'd1' || driver === 'd1-remote') {
+        return queryExists(db, "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1", [tableName]);
+    }
+    if (driver === 'postgresql') {
+        return queryExists(db, "SELECT 1 FROM information_schema.tables WHERE table_schema='public' AND table_name=? LIMIT 1", [tableName]);
+    }
+    if (driver === 'mysql') {
+        return queryExists(db, 'SELECT 1 FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name=? LIMIT 1', [tableName]);
+    }
+    if (driver === 'sqlserver') {
+        return queryExists(db, 'SELECT 1 FROM sys.tables WHERE name=? LIMIT 1', [tableName]);
+    }
+    throw ErrorFactory.createCliError(`Unsupported DB driver: ${driver}`);
+};
+const schemaHasColumn = async (db, tableName, columnName) => {
+    const driver = db.getType();
+    if (driver === 'sqlite' || driver === 'd1' || driver === 'd1-remote') {
+        const rows = await db.query(`PRAGMA table_info("${tableName}")`, [], true);
+        return rows.some((row) => {
+            const record = row;
+            return typeof record.name === 'string' && record.name === columnName;
+        });
+    }
+    if (driver === 'postgresql') {
+        return queryExists(db, "SELECT 1 FROM information_schema.columns WHERE table_schema='public' AND table_name=? AND column_name=? LIMIT 1", [tableName, columnName]);
+    }
+    if (driver === 'mysql') {
+        return queryExists(db, 'SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name=? AND column_name=? LIMIT 1', [tableName, columnName]);
+    }
+    if (driver === 'sqlserver') {
+        return queryExists(db, 'SELECT 1 FROM sys.columns WHERE object_id = OBJECT_ID(?) AND name=?', [
+            tableName,
+            columnName,
+        ]);
+    }
+    throw ErrorFactory.createCliError(`Unsupported DB driver: ${driver}`);
+};
+const clearTableLayoutCache = (db) => {
+    tableLayoutCache.delete(db);
+};
+const ensureTrackingTable = async (db) => {
+    assertDbSupportsMigrations(db);
+    const adapter = db.getAdapterInstance(false);
+    const ensure = requireMigrationsTableSupport(adapter);
+    // getAdapterInstance(false) returns a raw adapter without going through Database.query()
+    // which auto-connects; ensure we're connected before creating the migrations table.
+    if (typeof db.connect === 'function') {
+        await db.connect();
+    }
+    else if (typeof adapter.connect === 'function') {
+        await adapter.connect();
+    }
+    clearTableLayoutCache(db);
+    await ensure();
+    clearTableLayoutCache(db);
+};
+const resolveTableLayout = async (db, allowEnsure = true) => {
+    const cached = tableLayoutCache.get(db);
+    if (cached !== undefined)
+        return cached;
+    const layoutPromise = (async () => {
+        if (typeof db.query !== 'function')
+            return DEFAULT_LAYOUT;
+        const [hasTable, hasName, hasMigration, hasScope, hasService, hasStatus, hasAppliedAt, hasCreatedAt] = await Promise.all([
+            schemaHasTable(db, 'migrations'),
+            schemaHasColumn(db, 'migrations', 'name'),
+            schemaHasColumn(db, 'migrations', 'migration'),
+            schemaHasColumn(db, 'migrations', 'scope'),
+            schemaHasColumn(db, 'migrations', 'service'),
+            schemaHasColumn(db, 'migrations', 'status'),
+            schemaHasColumn(db, 'migrations', 'applied_at'),
+            schemaHasColumn(db, 'migrations', 'created_at'),
+        ]);
+        if (!hasTable && allowEnsure) {
+            await ensureTrackingTable(db);
+            return resolveTableLayout(db, false);
+        }
+        if (!hasName && !hasMigration) {
+            throw ErrorFactory.createCliError('The migrations table is missing both `name` and `migration` columns. Update the tracking table before running migrations.');
+        }
+        return {
+            hasAppliedAt,
+            hasCreatedAt,
+            hasMigration,
+            hasName,
+            hasScope,
+            hasService,
+            hasStatus,
+            requiresCompatibilityMode: hasMigration || !hasName || !hasScope || !hasService || !hasStatus,
+        };
+    })();
+    tableLayoutCache.set(db, layoutPromise);
+    return layoutPromise.catch((error) => {
+        if (tableLayoutCache.get(db) === layoutPromise) {
+            clearTableLayoutCache(db);
+        }
+        throw error;
+    });
+};
+const assertCompatibleTrackingTarget = (layout, scope, service) => {
+    if ((layout.hasScope && layout.hasService) || isDefaultTrackingTarget(scope, service))
+        return;
+    throw ErrorFactory.createCliError('The existing migrations table uses the legacy schema and does not support scoped/service-specific migration tracking yet.');
+};
+const buildLegacyIdentity = (layout, name, scope, service) => {
+    const conditions = [];
+    const params = [];
+    if (layout.hasName && layout.hasMigration) {
+        conditions.push('(name = ? OR migration = ?)');
+        params.push(name, name);
+    }
+    else if (layout.hasName) {
+        conditions.push('name = ?');
+        params.push(name);
+    }
+    else {
+        conditions.push('migration = ?');
+        params.push(name);
+    }
+    if (layout.hasScope) {
+        conditions.push('scope = ?');
+        params.push(scope);
+    }
+    if (layout.hasService) {
+        conditions.push('service = ?');
+        params.push(service);
+    }
+    return { params, sql: conditions.join(' AND ') };
+};
+const normalizeLegacyName = (row) => {
+    if (typeof row['name'] === 'string' && row['name'].length > 0)
+        return row['name'];
+    if (typeof row['migration'] === 'string' && row['migration'].length > 0)
+        return row['migration'];
+    return '';
+};
+const getLegacyBatch = (row) => {
+    const value = row['batch'];
+    return typeof value === 'number' ? value : Number(value);
+};
+const getLegacyAppliedAt = (row) => {
+    return typeof row['applied_at'] === 'string' ? row['applied_at'] : null;
+};
+const getLegacyAppliedRows = async (db, layout, scope, service) => {
+    const normalizedService = toSafeService(service);
+    assertCompatibleTrackingTarget(layout, scope, normalizedService);
+    const selectColumns = [
+        ...(layout.hasName ? ['name'] : []),
+        ...(layout.hasMigration ? ['migration'] : []),
+        'batch',
+        ...(layout.hasAppliedAt ? ['applied_at'] : []),
+    ];
+    const conditions = [];
+    const params = [];
+    if (layout.hasStatus) {
+        conditions.push('status = ?');
+        params.push('completed');
+    }
+    if (layout.hasScope) {
+        conditions.push('scope = ?');
+        params.push(scope);
+    }
+    if (layout.hasService) {
+        conditions.push('service = ?');
+        params.push(normalizedService);
+    }
+    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+    return (await db.query(`SELECT ${selectColumns.join(', ')} FROM migrations${whereClause}`, params, true));
+};
+const findLegacyMigrationRecord = async (db, layout, params) => {
+    const identity = buildLegacyIdentity(layout, params.name, params.scope, params.service);
+    const existing = (await db.query(`SELECT id FROM migrations WHERE ${identity.sql} LIMIT 1`, identity.params, true));
+    return existing.length > 0;
+};
+const updateLegacyRunningRecord = async (db, layout, params) => {
+    const identity = buildLegacyIdentity(layout, params.name, params.scope, params.service);
+    const assignments = ['batch = ?'];
+    const updateParams = [params.batch];
+    if (layout.hasAppliedAt) {
+        assignments.push('applied_at = ?');
+        updateParams.push(null);
+    }
+    await db.execute(`UPDATE migrations SET ${assignments.join(', ')} WHERE ${identity.sql}`, [
+        ...updateParams,
+        ...identity.params,
+    ]);
+};
+const buildLegacyInsertRunningPayload = (layout, params) => {
+    return {
+        columns: [
+            ...(layout.hasName ? ['name'] : []),
+            ...(layout.hasMigration ? ['migration'] : []),
+            ...(layout.hasScope ? ['scope'] : []),
+            ...(layout.hasService ? ['service'] : []),
+            'batch',
+            ...(layout.hasStatus ? ['status'] : []),
+            ...(layout.hasAppliedAt ? ['applied_at'] : []),
+            ...(layout.hasCreatedAt ? ['created_at'] : []),
+        ],
+        values: [
+            ...(layout.hasName ? [params.name] : []),
+            ...(layout.hasMigration ? [params.name] : []),
+            ...(layout.hasScope ? [params.scope] : []),
+            ...(layout.hasService ? [params.service] : []),
+            params.batch,
+            ...(layout.hasStatus ? ['running'] : []),
+            ...(layout.hasAppliedAt ? [null] : []),
+            ...(layout.hasCreatedAt ? [nowIso()] : []),
+        ],
+    };
+};
+const insertLegacyRunningRecord = async (db, layout, params) => {
+    const payload = buildLegacyInsertRunningPayload(layout, params);
+    await db.execute(`INSERT INTO migrations (${payload.columns.join(', ')}) VALUES (${payload.columns.map(() => '?').join(', ')})`, payload.values);
+};
 const assertDbSupportsMigrations = (db) => {
     const t = db.getType();
     if (t === 'd1') {
@@ -42,22 +277,22 @@ const requireMigrationsTableSupport = (adapter) => {
 };
 export const MigrationStore = Object.freeze({
     async ensureTable(db) {
-        assertDbSupportsMigrations(db);
-        const adapter = db.getAdapterInstance(false);
-        const ensure = requireMigrationsTableSupport(adapter);
-        // getAdapterInstance(false) returns a raw adapter without going through Database.query()
-        // which auto-connects; ensure we're connected before creating the migrations table.
-        if (typeof db.connect === 'function') {
-            await db.connect();
-        }
-        else if (typeof adapter.connect === 'function') {
-            await adapter.connect();
-        }
-        await ensure();
+        await ensureTrackingTable(db);
     },
     async getLastCompletedBatch(db, scope = 'global', service = '') {
         assertDbSupportsMigrations(db);
+        const layout = await resolveTableLayout(db);
         const normalizedService = toSafeService(service);
+        if (layout.requiresCompatibilityMode) {
+            const rows = await getLegacyAppliedRows(db, layout, scope, normalizedService);
+            let maxBatch = 0;
+            for (const row of rows) {
+                const batch = getLegacyBatch(row);
+                if (Number.isFinite(batch) && batch > maxBatch)
+                    maxBatch = batch;
+            }
+            return maxBatch;
+        }
         const row = await QueryBuilder.create('migrations', db)
             .max('batch', 'max_batch')
             .where('status', '=', 'completed')
@@ -70,6 +305,28 @@ export const MigrationStore = Object.freeze({
     async getAppliedMap(db, scope, service) {
         assertDbSupportsMigrations(db);
         const normalizedService = toSafeService(service);
+        const layout = await resolveTableLayout(db);
+        if (layout.requiresCompatibilityMode) {
+            const rows = await getLegacyAppliedRows(db, layout, scope, normalizedService);
+            const map = new Map();
+            for (const row of rows) {
+                const name = normalizeLegacyName(row);
+                const batch = getLegacyBatch(row);
+                if (name === '' || !Number.isFinite(batch))
+                    continue;
+                map.set(name, {
+                    name,
+                    scope: layout.hasScope ? scope : 'global',
+                    service: layout.hasService ? normalizedService : '',
+                    batch,
+                    status: typeof row['status'] === 'string'
+                        ? row['status']
+                        : 'completed',
+                    appliedAt: getLegacyAppliedAt(row),
+                });
+            }
+            return map;
+        }
         const rows = await QueryBuilder.create('migrations', db)
             .select('name', 'scope', 'service', 'batch', 'status')
             .selectAs('applied_at', 'appliedAt')
@@ -90,6 +347,22 @@ export const MigrationStore = Object.freeze({
     async insertRunning(db, params) {
         assertDbSupportsMigrations(db);
         const normalizedService = toSafeService(params.service);
+        const layout = await resolveTableLayout(db);
+        if (layout.requiresCompatibilityMode) {
+            assertCompatibleTrackingTarget(layout, params.scope, normalizedService);
+            const legacyParams = {
+                name: params.name,
+                scope: params.scope,
+                service: normalizedService,
+                batch: params.batch,
+            };
+            if (await findLegacyMigrationRecord(db, layout, legacyParams)) {
+                await updateLegacyRunningRecord(db, layout, legacyParams);
+                return;
+            }
+            await insertLegacyRunningRecord(db, layout, legacyParams);
+            return;
+        }
         const existing = await QueryBuilder.create('migrations', db)
             .select('id')
             .where('name', '=', params.name)
@@ -122,10 +395,37 @@ export const MigrationStore = Object.freeze({
     },
     async markStatus(db, params) {
         assertDbSupportsMigrations(db);
+        const normalizedService = toSafeService(params.service);
+        const layout = await resolveTableLayout(db);
+        if (layout.requiresCompatibilityMode) {
+            assertCompatibleTrackingTarget(layout, params.scope, normalizedService);
+            const identity = buildLegacyIdentity(layout, params.name, params.scope, normalizedService);
+            if (!layout.hasStatus && params.status === 'failed') {
+                await db.execute(`DELETE FROM migrations WHERE ${identity.sql}`, identity.params);
+                return;
+            }
+            const assignments = [];
+            const updateParams = [];
+            if (layout.hasStatus) {
+                assignments.push('status = ?');
+                updateParams.push(params.status);
+            }
+            if (params.appliedAt !== undefined && layout.hasAppliedAt) {
+                assignments.push('applied_at = ?');
+                updateParams.push(params.appliedAt);
+            }
+            if (assignments.length === 0)
+                return;
+            await db.execute(`UPDATE migrations SET ${assignments.join(', ')} WHERE ${identity.sql}`, [
+                ...updateParams,
+                ...identity.params,
+            ]);
+            return;
+        }
         const builder = QueryBuilder.create('migrations', db)
             .where('name', '=', params.name)
             .andWhere('scope', '=', params.scope)
-            .andWhere('service', '=', toSafeService(params.service));
+            .andWhere('service', '=', normalizedService);
         if (params.appliedAt !== undefined) {
             await builder.update({ status: params.status, applied_at: params.appliedAt });
             return;
@@ -134,11 +434,30 @@ export const MigrationStore = Object.freeze({
     },
     async listCompletedInBatchesGte(db, params) {
         assertDbSupportsMigrations(db);
+        const normalizedService = toSafeService(params.service);
+        const layout = await resolveTableLayout(db);
+        if (layout.requiresCompatibilityMode) {
+            const rows = await getLegacyAppliedRows(db, layout, params.scope, normalizedService);
+            const out = [];
+            for (const row of rows) {
+                const name = normalizeLegacyName(row);
+                const batch = getLegacyBatch(row);
+                if (name === '' || !Number.isFinite(batch) || batch < params.minBatch)
+                    continue;
+                out.push({ name, batch });
+            }
+            out.sort((left, right) => {
+                if (left.batch !== right.batch)
+                    return right.batch - left.batch;
+                return right.name.localeCompare(left.name);
+            });
+            return out;
+        }
         const rows = await QueryBuilder.create('migrations', db)
             .select('name', 'batch')
             .where('status', '=', 'completed')
             .andWhere('scope', '=', params.scope)
-            .andWhere('service', '=', toSafeService(params.service))
+            .andWhere('service', '=', normalizedService)
             .andWhere('batch', '>=', params.minBatch)
             .orderBy('batch', 'DESC')
             .orderBy('id', 'DESC')
@@ -157,11 +476,20 @@ export const MigrationStore = Object.freeze({
     },
     async listAllCompletedNames(db, params) {
         assertDbSupportsMigrations(db);
+        const normalizedService = toSafeService(params.service);
+        const layout = await resolveTableLayout(db);
+        if (layout.requiresCompatibilityMode) {
+            const rows = await getLegacyAppliedRows(db, layout, params.scope, normalizedService);
+            return rows
+                .map(normalizeLegacyName)
+                .filter((name) => name.length > 0)
+                .sort((left, right) => right.localeCompare(left));
+        }
         const rows = await QueryBuilder.create('migrations', db)
             .select('name')
             .where('status', '=', 'completed')
             .andWhere('scope', '=', params.scope)
-            .andWhere('service', '=', toSafeService(params.service))
+            .andWhere('service', '=', normalizedService)
             .orderBy('batch', 'DESC')
             .orderBy('id', 'DESC')
             .get();
@@ -169,10 +497,18 @@ export const MigrationStore = Object.freeze({
     },
     async deleteRecord(db, params) {
         assertDbSupportsMigrations(db);
+        const normalizedService = toSafeService(params.service);
+        const layout = await resolveTableLayout(db);
+        if (layout.requiresCompatibilityMode) {
+            assertCompatibleTrackingTarget(layout, params.scope, normalizedService);
+            const identity = buildLegacyIdentity(layout, params.name, params.scope, normalizedService);
+            await db.execute(`DELETE FROM migrations WHERE ${identity.sql}`, identity.params);
+            return;
+        }
         await QueryBuilder.create('migrations', db)
             .where('name', '=', params.name)
             .andWhere('scope', '=', params.scope)
-            .andWhere('service', '=', toSafeService(params.service))
+            .andWhere('service', '=', normalizedService)
             .delete();
     },
 });

package/src/runtime/StartupConfigFileRegistry.d.ts

@@ -3,13 +3,14 @@ export declare const StartupConfigFile: {
     readonly Cache: "config/cache.ts";
     readonly Database: "config/database.ts";
     readonly Mail: "config/mail.ts";
+    readonly Trace: "config/trace.ts";
     readonly Middleware: "config/middleware.ts";
     readonly Notification: "config/notification.ts";
     readonly Queue: "config/queue.ts";
     readonly Storage: "config/storage.ts";
     readonly Workers: "config/workers.ts";
 };
-export type StartupConfigFileTypes = typeof StartupConfigFile.Broadcast | typeof StartupConfigFile.Cache | typeof StartupConfigFile.Database | typeof StartupConfigFile.Mail | typeof StartupConfigFile.Middleware | typeof StartupConfigFile.Notification | typeof StartupConfigFile.Queue | typeof StartupConfigFile.Storage | typeof StartupConfigFile.Workers;
+export type StartupConfigFileTypes = typeof StartupConfigFile.Broadcast | typeof StartupConfigFile.Cache | typeof StartupConfigFile.Database | typeof StartupConfigFile.Mail | typeof StartupConfigFile.Trace | typeof StartupConfigFile.Middleware | typeof StartupConfigFile.Notification | typeof StartupConfigFile.Queue | typeof StartupConfigFile.Storage | typeof StartupConfigFile.Workers;
 export declare const StartupConfigFileRegistry: Readonly<{
     preload(files: readonly StartupConfigFileTypes[]): Promise<void>;
     isPreloaded(): boolean;

package/src/runtime/StartupConfigFileRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StartupConfigFileRegistry.d.ts","sourceRoot":"","sources":["../../../src/runtime/StartupConfigFileRegistry.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB;;;;;;;;;;CAUpB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAC9B,OAAO,iBAAiB,CAAC,SAAS,GAClC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,QAAQ,GACjC,OAAO,iBAAiB,CAAC,IAAI,GAC7B,OAAO,iBAAiB,CAAC,UAAU,GACnC,OAAO,iBAAiB,CAAC,YAAY,GACrC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,OAAO,GAChC,OAAO,iBAAiB,CAAC,OAAO,CAAC;AAiDrC,eAAO,MAAM,yBAAyB;mBACf,SAAS,sBAAsB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;mBAcvD,OAAO;QAIlB,CAAC,QAAQ,sBAAsB,GAAG,CAAC,GAAG,SAAS;cAIzC,sBAAsB,GAAG,OAAO;IAI1C,+BAA+B;aACtB,IAAI;EAIb,CAAC;AAEH,eAAe,yBAAyB,CAAC"}
+{"version":3,"file":"StartupConfigFileRegistry.d.ts","sourceRoot":"","sources":["../../../src/runtime/StartupConfigFileRegistry.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB;;;;;;;;;;;CAWpB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAC9B,OAAO,iBAAiB,CAAC,SAAS,GAClC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,QAAQ,GACjC,OAAO,iBAAiB,CAAC,IAAI,GAC7B,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,UAAU,GACnC,OAAO,iBAAiB,CAAC,YAAY,GACrC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,OAAO,GAChC,OAAO,iBAAiB,CAAC,OAAO,CAAC;AAiDrC,eAAO,MAAM,yBAAyB;mBACf,SAAS,sBAAsB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;mBAcvD,OAAO;QAIlB,CAAC,QAAQ,sBAAsB,GAAG,CAAC,GAAG,SAAS;cAIzC,sBAAsB,GAAG,OAAO;IAI1C,+BAA+B;aACtB,IAAI;EAIb,CAAC;AAEH,eAAe,yBAAyB,CAAC"}

package/src/runtime/StartupConfigFileRegistry.js

@@ -8,6 +8,7 @@ export const StartupConfigFile = {
     Cache: 'config/cache.ts',
     Database: 'config/database.ts',
     Mail: 'config/mail.ts',
+    Trace: 'config/trace.ts',
     Middleware: 'config/middleware.ts',
     Notification: 'config/notification.ts',
     Queue: 'config/queue.ts',

package/src/runtime/plugins/trace-runtime.d.ts

@@ -0,0 +1,24 @@
+type TraceConfigApi = {
+    merge(overrides?: unknown): {
+        enabled?: boolean;
+        connection?: string;
+    };
+};
+type TraceStorageApi = {
+    resolveStorage(db: unknown): unknown;
+};
+export declare const isAvailable: () => boolean;
+export declare const TraceConfig: TraceConfigApi;
+export declare const TraceStorage: TraceStorageApi;
+export declare const registerTraceDashboard: (router: unknown, options?: {
+    basePath?: string;
+    middleware?: ReadonlyArray<string>;
+}) => void;
+export declare const registerTraceRoutes: (router: unknown, storage: unknown, options?: {
+    basePath?: string;
+    middleware?: ReadonlyArray<string>;
+}) => void;
+export declare const captureTraceException: (error: unknown) => void;
+export declare const ensureSystemTraceRegistered: () => Promise<void>;
+export {};
+//# sourceMappingURL=trace-runtime.d.ts.map

package/src/runtime/plugins/trace-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-runtime.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/trace-runtime.ts"],"names":[],"mappings":"AAAA,KAAK,cAAc,GAAG;IACpB,KAAK,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACxE,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC;CACtC,CAAC;AA6DF,eAAO,MAAM,WAAW,QAAO,OAA0C,CAAC;AAE1E,eAAO,MAAM,WAAW,EAAE,cAIxB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,eAIzB,CAAC;AAEH,eAAO,MAAM,sBAAsB,GACjC,QAAQ,OAAO,EACf,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,KAClE,IAEF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,OAAO,EACf,SAAS,OAAO,EAChB,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,KAClE,IAEF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,IAStD,CAAC;AAEF,eAAO,MAAM,2BAA2B,QAAa,OAAO,CAAC,IAAI,CAIhE,CAAC"}

package/src/runtime/plugins/trace-runtime.js

@@ -0,0 +1,63 @@
+const fallbackTraceConfig = Object.freeze({
+    merge: () => ({ enabled: false }),
+});
+const fallbackTraceStorage = Object.freeze({
+    resolveStorage: (_db) => undefined,
+});
+const fallbackRegisterTraceDashboard = (_router, _options) => undefined;
+const fallbackRegisterTraceRoutes = (_router, _storage, _options) => undefined;
+const fallbackCaptureTraceException = (_error) => undefined;
+let systemTraceModule;
+let didAttemptSystemTraceLoad = false;
+let pendingSystemTraceLoad;
+const loadSystemTraceModule = async () => {
+    if (systemTraceModule !== undefined)
+        return systemTraceModule;
+    if (didAttemptSystemTraceLoad && pendingSystemTraceLoad === undefined)
+        return undefined;
+    if (pendingSystemTraceLoad !== undefined)
+        return pendingSystemTraceLoad;
+    pendingSystemTraceLoad = import('@zintrust/trace')
+        .then((module) => {
+        systemTraceModule = module;
+        return systemTraceModule;
+    })
+        .catch(() => undefined)
+        .finally(() => {
+        didAttemptSystemTraceLoad = true;
+        pendingSystemTraceLoad = undefined;
+    });
+    return pendingSystemTraceLoad;
+};
+export const isAvailable = () => systemTraceModule !== undefined;
+export const TraceConfig = Object.freeze({
+    merge(overrides) {
+        return (systemTraceModule?.TraceConfig ?? fallbackTraceConfig).merge(overrides);
+    },
+});
+export const TraceStorage = Object.freeze({
+    resolveStorage(db) {
+        return (systemTraceModule?.TraceStorage ?? fallbackTraceStorage).resolveStorage(db);
+    },
+});
+export const registerTraceDashboard = (router, options) => {
+    (systemTraceModule?.registerTraceDashboard ?? fallbackRegisterTraceDashboard)(router, options);
+};
+export const registerTraceRoutes = (router, storage, options) => {
+    (systemTraceModule?.registerTraceRoutes ?? fallbackRegisterTraceRoutes)(router, storage, options);
+};
+export const captureTraceException = (error) => {
+    if (systemTraceModule?.captureTraceException !== undefined) {
+        systemTraceModule.captureTraceException(error);
+        return;
+    }
+    void loadSystemTraceModule().then((module) => {
+        (module?.captureTraceException ?? fallbackCaptureTraceException)(error);
+    });
+};
+export const ensureSystemTraceRegistered = async () => {
+    const module = await loadSystemTraceModule();
+    if (module === undefined)
+        return;
+    await import('../../../packages/trace/src/register.js').catch(() => undefined);
+};

package/src/runtime/plugins/trace.d.ts

@@ -0,0 +1,2 @@
+export type {};
+//# sourceMappingURL=trace.d.ts.map

package/src/runtime/plugins/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/trace.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,CAAC"}

package/src/runtime/plugins/{system-debugger.js → trace.js}

@@ -7,8 +7,8 @@ const tryImport = async (specifier) => {
         return false;
     }
 };
-const importedPackagePlugin = await tryImport('@zintrust/system-debugger/plugin');
+const importedPackagePlugin = await tryImport('@zintrust/trace/plugin');
 if (!importedPackagePlugin) {
-    await import('../../../packages/system-debugger/src/plugin.js').catch(() => undefined);
+    await import('../../../packages/trace/src/plugin.js').catch(() => undefined);
 }
 export {};

package/src/security/JwtManager.js

@@ -3,7 +3,7 @@
  * JSON Web Token generation, verification, and claims management
  * Uses native Node.js crypto module (zero external dependencies)
  */
-import { SystemDebuggerBridge } from '../debugger/SystemDebuggerBridge.js';
+import { SystemTraceBridge } from '../trace/SystemTraceBridge.js';
 import { securityConfig } from '../config/security.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
 import { createHmac, createSign, createVerify, randomBytes } from '../node-singletons/crypto.js';
@@ -44,11 +44,11 @@ const getLogoutSubject = (authHeader) => {
 const logout = async (authHeader) => {
     const subject = getLogoutSubject(authHeader);
     await JwtSessions.logout(authHeader);
-    SystemDebuggerBridge.emitAuth('logout', subject);
+    SystemTraceBridge.emitAuth('logout', subject);
 };
 const logoutAll = async (sub) => {
     await JwtSessions.logoutAll(sub);
-    SystemDebuggerBridge.emitAuth('logout', sub);
+    SystemTraceBridge.emitAuth('logout', sub);
 };
 const signAccessToken = async (payload, expiresIn) => {
     const algorithm = securityConfig.jwt.algorithm;
@@ -75,7 +75,7 @@ const signAccessToken = async (payload, expiresIn) => {
         });
     }
     await JwtSessions.register(token);
-    SystemDebuggerBridge.emitAuth('login', typeof payload.sub === 'string' ? payload.sub : undefined);
+    SystemTraceBridge.emitAuth('login', typeof payload.sub === 'string' ? payload.sub : undefined);
     return token;
 };
 /**

package/src/templates/project/basic/tsconfig.json.tpl

@@ -1,6 +1,5 @@
 {
   "compilerOptions": {
-    "ignoreDeprecations": "6.0",
     "baseUrl": ".",
     "outDir": "./dist",
     "rootDir": "./",
@@ -17,17 +16,17 @@
       "@routes/*": ["./routes/*"],
       "@database/*": ["./database/*"],
 
-      "@tools/*": ["app/Tools/*"],
-      "@httpClient/*": ["app/Tools/http/*"],
-      "@templates": ["app/Tools/templates/index.ts"],
-      "@templates/*": ["app/Tools/templates/*"],
-      "@mail/*": ["app/Tools/mail/*"],
-      "@storage": ["app/Tools/storage/index.ts"],
-      "@storage/*": ["app/Tools/storage/*"],
-      "@drivers/*": ["app/Tools/storage/drivers/*"],
-      "@notification/*": ["app/Tools/notification/*"],
-      "@broadcast/*": ["app/Tools/broadcast/*"],
-      "@queue/*": ["app/Tools/queue/*"]
+      "@tools/*": ["./app/Tools/*"],
+      "@httpClient/*": ["./app/Tools/http/*"],
+      "@templates": ["./app/Tools/templates/index.ts"],
+      "@templates/*": ["./app/Tools/templates/*"],
+      "@mail/*": ["./app/Tools/mail/*"],
+      "@storage": ["./app/Tools/storage/index.ts"],
+      "@storage/*": ["./app/Tools/storage/*"],
+      "@drivers/*": ["./app/Tools/storage/drivers/*"],
+      "@notification/*": ["./app/Tools/notification/*"],
+      "@broadcast/*": ["./app/Tools/broadcast/*"],
+      "@queue/*": ["./app/Tools/queue/*"]
     }
   },
   "include": ["src/**/*", "app/**/*", "routes/**/*", "database/**/*"],