@directus/api 24.0.0 → 25.0.0

package/dist/app.js

@@ -9,8 +9,8 @@ import { createRequire } from 'node:module';
 import path from 'path';
 import qs from 'qs';
 import { registerAuthProviders } from './auth.js';
-import activityRouter from './controllers/activity.js';
 import accessRouter from './controllers/access.js';
+import activityRouter from './controllers/activity.js';
 import assetsRouter from './controllers/assets.js';
 import authRouter from './controllers/auth.js';
 import collectionsRouter from './controllers/collections.js';
@@ -23,6 +23,7 @@ import flowsRouter from './controllers/flows.js';
 import foldersRouter from './controllers/folders.js';
 import graphqlRouter from './controllers/graphql.js';
 import itemsRouter from './controllers/items.js';
+import metricsRouter from './controllers/metrics.js';
 import notFoundHandler from './controllers/not-found.js';
 import notificationsRouter from './controllers/notifications.js';
 import operationsRouter from './controllers/operations.js';
@@ -43,9 +44,6 @@ import usersRouter from './controllers/users.js';
 import utilsRouter from './controllers/utils.js';
 import versionsRouter from './controllers/versions.js';
 import webhooksRouter from './controllers/webhooks.js';
-import retentionSchedule from './schedules/retention.js';
-import telemetrySchedule from './schedules/telemetry.js';
-import tusSchedule from './schedules/tus.js';
 import { isInstalled, validateDatabaseConnection, validateDatabaseExtensions, validateMigrations, } from './database/index.js';
 import emitter from './emitter.js';
 import { getExtensionManager } from './extensions/index.js';
@@ -60,6 +58,10 @@ import rateLimiterGlobal from './middleware/rate-limiter-global.js';
 import rateLimiter from './middleware/rate-limiter-ip.js';
 import sanitizeQuery from './middleware/sanitize-query.js';
 import schema from './middleware/schema.js';
+import metricsSchedule from './schedules/metrics.js';
+import retentionSchedule from './schedules/retention.js';
+import telemetrySchedule from './schedules/telemetry.js';
+import tusSchedule from './schedules/tus.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateStorage } from './utils/validate-storage.js';
@@ -223,6 +225,9 @@ export default async function createApp() {
     app.use('/flows', flowsRouter);
     app.use('/folders', foldersRouter);
     app.use('/items', itemsRouter);
+    if (env['METRICS_ENABLED'] === true) {
+        app.use('/metrics', metricsRouter);
+    }
     app.use('/notifications', notificationsRouter);
     app.use('/operations', operationsRouter);
     app.use('/panels', panelsRouter);
@@ -251,6 +256,7 @@ export default async function createApp() {
     await retentionSchedule();
     await telemetrySchedule();
     await tusSchedule();
+    await metricsSchedule();
     await emitter.emitInit('app.after', { app });
     return app;
 }

package/dist/auth/drivers/oauth2.js

@@ -19,6 +19,7 @@ import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
 import { getIPFromReq } from '../../utils/get-ip-from-req.js';
 import { getSecret } from '../../utils/get-secret.js';
 import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
+import { verifyJWT } from '../../utils/jwt.js';
 import { Url } from '../../utils/url.js';
 import { LocalAuthDriver } from './local.js';
 export class OAuth2AuthDriver extends LocalAuthDriver {
@@ -254,9 +255,7 @@ export function createOAuth2AuthRouter(providerName) {
         const logger = useLogger();
         let tokenData;
         try {
-            tokenData = jwt.verify(req.cookies[`oauth2.${providerName}`], getSecret(), {
-                issuer: 'directus',
-            });
+            tokenData = verifyJWT(req.cookies[`oauth2.${providerName}`], getSecret());
         }
         catch (e) {
             logger.warn(e, `[OAuth2] Couldn't verify OAuth2 cookie`);

package/dist/auth/drivers/openid.js

@@ -19,6 +19,7 @@ import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
 import { getIPFromReq } from '../../utils/get-ip-from-req.js';
 import { getSecret } from '../../utils/get-secret.js';
 import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
+import { verifyJWT } from '../../utils/jwt.js';
 import { Url } from '../../utils/url.js';
 import { LocalAuthDriver } from './local.js';
 export class OpenIDAuthDriver extends LocalAuthDriver {
@@ -306,9 +307,7 @@ export function createOpenIDAuthRouter(providerName) {
         const logger = useLogger();
         let tokenData;
         try {
-            tokenData = jwt.verify(req.cookies[`openid.${providerName}`], getSecret(), {
-                issuer: 'directus',
-            });
+            tokenData = verifyJWT(req.cookies[`openid.${providerName}`], getSecret());
         }
         catch (e) {
             logger.warn(e, `[OpenID] Couldn't verify OpenID cookie`);

package/dist/cache.d.ts

@@ -13,7 +13,7 @@ export declare function clearSystemCache(opts?: {
 }): Promise<void>;
 export declare function setSystemCache(key: string, value: any, ttl?: number): Promise<void>;
 export declare function getSystemCache(key: string): Promise<Record<string, any>>;
-export declare function setLocalSchemaCache(schema: SchemaOverview): Promise<void>;
-export declare function getLocalSchemaCache(): Promise<SchemaOverview | undefined>;
+export declare function setMemorySchemaCache(schema: SchemaOverview): void;
+export declare function getMemorySchemaCache(): Readonly<SchemaOverview> | undefined;
 export declare function setCacheValue(cache: Keyv, key: string, value: Record<string, any> | Record<string, any>[], ttl?: number): Promise<void>;
 export declare function getCacheValue(cache: Keyv, key: string): Promise<any>;

package/dist/cache.js

@@ -9,14 +9,16 @@ import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getMilliseconds } from './utils/get-milliseconds.js';
 import { validateEnv } from './utils/validate-env.js';
 import { createRequire } from 'node:module';
+import { freezeSchema, unfreezeSchema } from './utils/freeze-schema.js';
 const logger = useLogger();
 const env = useEnv();
 const require = createRequire(import.meta.url);
 let cache = null;
 let systemCache = null;
-let localSchemaCache = null;
 let lockCache = null;
 let messengerSubscribed = false;
+let localSchemaCache = null;
+let memorySchemaCache = null;
 const messenger = useBus();
 if (redisConfigAvailable() && !messengerSubscribed) {
     messengerSubscribed = true;
@@ -25,6 +27,7 @@ if (redisConfigAvailable() && !messengerSubscribed) {
             await cache.clear();
         }
         await localSchemaCache?.clear();
+        memorySchemaCache = null;
     });
 }
 export function getCache() {
@@ -61,6 +64,7 @@ export async function clearSystemCache(opts) {
         await lockCache.delete('system-cache-lock');
     }
     await localSchemaCache.clear();
+    memorySchemaCache = null;
     // Since a lot of cached permission function rely on the schema it needs to be cleared as well
     await clearPermissionCache();
     messenger.publish('schemaChanged', { autoPurgeCache: opts?.autoPurgeCache });
@@ -75,13 +79,22 @@ export async function getSystemCache(key) {
     const { systemCache } = getCache();
     return await getCacheValue(systemCache, key);
 }
-export async function setLocalSchemaCache(schema) {
-    const { localSchemaCache } = getCache();
-    await localSchemaCache.set('schema', schema);
+export function setMemorySchemaCache(schema) {
+    if (Object.isFrozen(schema)) {
+        memorySchemaCache = schema;
+    }
+    else {
+        memorySchemaCache = freezeSchema(schema);
+    }
 }
-export async function getLocalSchemaCache() {
-    const { localSchemaCache } = getCache();
-    return await localSchemaCache.get('schema');
+export function getMemorySchemaCache() {
+    if (env['CACHE_SCHEMA_FREEZE_ENABLED']) {
+        return memorySchemaCache ?? undefined;
+    }
+    else if (memorySchemaCache) {
+        return unfreezeSchema(memorySchemaCache);
+    }
+    return undefined;
 }
 export async function setCacheValue(cache, key, value, ttl) {
     const compressed = await compress(value);

package/dist/controllers/assets.js

@@ -151,7 +151,7 @@ asyncHandler(async (req, res) => {
             }
         }
     }
-    const { stream, file, stat } = await service.getAsset(id, { transformationParams, acceptFormat }, range);
+    const { stream, file, stat } = await service.getAsset(id, { transformationParams, acceptFormat }, range, true);
     const filename = req.params['filename'] ?? file.filename_download;
     res.attachment(filename);
     res.setHeader('Content-Type', file.type);
@@ -180,7 +180,7 @@ asyncHandler(async (req, res) => {
         res.setHeader('Content-Length', stat.size);
         return res.end();
     }
-    stream
+    (await stream())
         .on('error', (error) => {
         logger.error(error, `Couldn't stream file ${file.id} to the client`);
         if (!res.headersSent) {

package/dist/controllers/metrics.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/controllers/metrics.js

@@ -0,0 +1,33 @@
+import { useEnv } from '@directus/env';
+import { ForbiddenError } from '@directus/errors';
+import { Router } from 'express';
+import { useMetrics } from '../metrics/index.js';
+import asyncHandler from '../utils/async-handler.js';
+const env = useEnv();
+const router = Router();
+const metrics = useMetrics();
+router.get('/', asyncHandler(async (req, _res, next) => {
+    if (req.accountability?.admin === true) {
+        return next();
+    }
+    // support Bearer Token of type `Metrics`
+    const metricTokens = env['METRICS_TOKENS'];
+    if (!req.headers || !req.headers.authorization || !metricTokens) {
+        throw new ForbiddenError();
+    }
+    const parts = req.headers.authorization.split(' ');
+    if (parts.length !== 2 || parts[0].toLowerCase() !== 'metrics') {
+        throw new ForbiddenError();
+    }
+    if (metricTokens.find((mt) => mt.toString() === parts[1]) !== undefined) {
+        return next();
+    }
+    throw new ForbiddenError();
+}), asyncHandler(async (_req, res) => {
+    res.set('Content-Type', 'text/plain');
+    // Don't cache anything by default
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Vary', 'Origin, Cache-Control');
+    return res.send(await metrics?.readAll());
+}));
+export default router;

package/dist/controllers/server.js

@@ -1,6 +1,6 @@
+import { RouteNotFoundError } from '@directus/errors';
 import { format } from 'date-fns';
 import { Router } from 'express';
-import { RouteNotFoundError } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import { ServerService } from '../services/server.js';
 import { SpecificationService } from '../services/specifications.js';

package/dist/database/get-ast-from-query/lib/parse-fields.js

@@ -169,10 +169,11 @@ export async function parseFields(options, context) {
                     continue;
                 }
             }
+            const childQuery = { ...options.query };
             // update query alias for children parseFields
             const deepAlias = getDeepQuery(options.deep?.[fieldKey] || {})?.['alias'];
-            if (!isEmpty(deepAlias))
-                options.query.alias = deepAlias;
+            // reset alias to empty if none are present
+            childQuery.alias = isEmpty(deepAlias) ? {} : deepAlias;
             child = {
                 type: relationType,
                 name: relatedCollection,
@@ -184,7 +185,7 @@ export async function parseFields(options, context) {
                 children: await parseFields({
                     parentCollection: relatedCollection,
                     fields: nestedFields,
-                    query: options.query,
+                    query: childQuery,
                     deep: options.deep?.[fieldKey] || {},
                     accountability: options.accountability,
                 }, context),

package/dist/database/helpers/index.d.ts

@@ -3,17 +3,15 @@ import type { Knex } from 'knex';
 import * as dateHelpers from './date/index.js';
 import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
+import * as numberHelpers from './number/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
-import * as numberHelpers from './number/index.js';
-import * as nullableUpdateHelper from './nullable-update/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     st: geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.mysql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.mysql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle | schemaHelpers.redshift;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;
     number: numberHelpers.cockroachdb | numberHelpers.mssql | numberHelpers.postgres | numberHelpers.sqlite | numberHelpers.oracle;
-    nullableUpdate: nullableUpdateHelper.postgres | nullableUpdateHelper.oracle;
 };
 export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.postgres | fnHelpers.mssql | fnHelpers.mysql | fnHelpers.sqlite | fnHelpers.oracle;
 export type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -2,10 +2,9 @@ import { getDatabaseClient } from '../index.js';
 import * as dateHelpers from './date/index.js';
 import * as fnHelpers from './fn/index.js';
 import * as geometryHelpers from './geometry/index.js';
+import * as numberHelpers from './number/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
-import * as numberHelpers from './number/index.js';
-import * as nullableUpdateHelper from './nullable-update/index.js';
 export function getHelpers(database) {
     const client = getDatabaseClient(database);
     return {
@@ -14,7 +13,6 @@ export function getHelpers(database) {
         schema: new schemaHelpers[client](database),
         sequence: new sequenceHelpers[client](database),
         number: new numberHelpers[client](database),
-        nullableUpdate: new nullableUpdateHelper[client](database),
     };
 }
 export function getFunctions(database, schema) {

package/dist/database/helpers/number/dialects/mssql.d.ts

@@ -1,7 +1,7 @@
+import type { NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { NumberDatabaseHelper, type NumberInfo } from '../types.js';
-import type { NumericValue } from '@directus/types';
 export declare class NumberHelperMSSQL extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
     isNumberValid(value: NumericValue, info: NumberInfo): boolean;
 }

package/dist/database/helpers/number/dialects/mssql.js

@@ -1,9 +1,9 @@
+import { NumberDatabaseHelper } from '../types.js';
 import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
 import { numberInRange } from '../utils/number-in-range.js';
-import { NumberDatabaseHelper } from '../types.js';
 export class NumberHelperMSSQL extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
     }
     isNumberValid(value, info) {
         return numberInRange(value, info);

package/dist/database/helpers/number/dialects/oracle.d.ts

@@ -1,6 +1,6 @@
+import type { NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { NumberDatabaseHelper } from '../types.js';
-import type { NumericValue } from '@directus/types';
 export declare class NumberHelperOracle extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
 }

package/dist/database/helpers/number/dialects/oracle.js

@@ -1,7 +1,7 @@
 import { NumberDatabaseHelper } from '../types.js';
 import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
 export class NumberHelperOracle extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
     }
 }

package/dist/database/helpers/number/dialects/sqlite.d.ts

@@ -1,6 +1,6 @@
+import type { NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { NumberDatabaseHelper } from '../types.js';
-import type { NumericValue } from '@directus/types';
 export declare class NumberHelperSQLite extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
 }

package/dist/database/helpers/number/dialects/sqlite.js

@@ -1,7 +1,7 @@
 import { NumberDatabaseHelper } from '../types.js';
 import { maybeStringifyBigInt } from '../utils/maybe-stringify-big-int.js';
 export class NumberHelperSQLite extends NumberDatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: maybeStringifyBigInt(value) });
     }
 }

package/dist/database/helpers/number/types.d.ts

@@ -1,12 +1,12 @@
+import type { NumericType, NumericValue } from '@directus/types';
 import type { Knex } from 'knex';
 import { DatabaseHelper } from '../types.js';
-import type { NumericType, NumericValue } from '@directus/types';
 export type NumberInfo = {
     type: NumericType;
     precision: number | null;
     scale: number | null;
 };
 export declare abstract class NumberDatabaseHelper extends DatabaseHelper {
-    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue): Knex.QueryBuilder;
+    addSearchCondition(dbQuery: Knex.QueryBuilder, collection: string, name: string, value: NumericValue, logical: 'and' | 'or'): Knex.QueryBuilder;
     isNumberValid(_value: NumericValue, _info: NumberInfo): boolean;
 }

package/dist/database/helpers/number/types.js

@@ -1,7 +1,7 @@
 import { DatabaseHelper } from '../types.js';
 export class NumberDatabaseHelper extends DatabaseHelper {
-    addSearchCondition(dbQuery, collection, name, value) {
-        return dbQuery.orWhere({ [`${collection}.${name}`]: value });
+    addSearchCondition(dbQuery, collection, name, value, logical) {
+        return dbQuery[logical].where({ [`${collection}.${name}`]: value });
     }
     isNumberValid(_value, _info) {
         return true;

package/dist/database/helpers/schema/dialects/oracle.d.ts

@@ -1,5 +1,6 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Field, Relation, Type } from '@directus/types';
+import type { Column } from '@directus/schema';
+import type { Field, RawField, Relation, Type } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Options, SortRecord, Sql } from '../types.js';
 import { SchemaHelper } from '../types.js';
@@ -10,6 +11,10 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     preRelationChange(relation: Partial<Relation>): void;
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
+    /**
+     * Oracle throws an error when overwriting the nullable option for an existing column with the same value.
+     */
+    setNullable(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column | null): void;
     prepQueryParams(queryParams: Sql): Sql;
     prepBindings(bindings: Knex.Value[]): any;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;

package/dist/database/helpers/schema/dialects/oracle.js

@@ -52,6 +52,21 @@ export class SchemaHelperOracle extends SchemaHelper {
             return null;
         }
     }
+    /**
+     * Oracle throws an error when overwriting the nullable option for an existing column with the same value.
+     */
+    setNullable(column, field, existing) {
+        if (!existing) {
+            super.setNullable(column, field, existing);
+            return;
+        }
+        if (field.schema?.is_nullable === false && existing.is_nullable === true) {
+            column.notNullable();
+        }
+        else if (field.schema?.is_nullable === true && existing.is_nullable === false) {
+            column.nullable();
+        }
+    }
     prepQueryParams(queryParams) {
         return prepQueryParams(queryParams, { format: (index) => `:${index + 1}` });
     }

package/dist/database/helpers/schema/types.d.ts

@@ -1,5 +1,6 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Field, Relation, Type } from '@directus/types';
+import type { Column } from '@directus/schema';
+import type { Field, RawField, Relation, Type } from '@directus/types';
 import type { Knex } from 'knex';
 import type { DatabaseClient } from '../../../types/index.js';
 import { DatabaseHelper } from '../types.js';
@@ -25,6 +26,7 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
     preColumnChange(): Promise<boolean>;
     postColumnChange(): Promise<void>;
     preRelationChange(_relation: Partial<Relation>): void;
+    setNullable(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column | null): void;
     processFieldType(field: Field): Type;
     constraintName(existingName: string): string;
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;

package/dist/database/helpers/schema/types.js

@@ -66,6 +66,15 @@ export class SchemaHelper extends DatabaseHelper {
     preRelationChange(_relation) {
         return;
     }
+    setNullable(column, field, existing) {
+        const isNullable = field.schema?.is_nullable ?? existing?.is_nullable ?? true;
+        if (isNullable) {
+            column.nullable();
+        }
+        else {
+            column.notNullable();
+        }
+    }
     processFieldType(field) {
         return field.type;
     }

package/dist/database/index.js

@@ -11,6 +11,7 @@ import { performance } from 'perf_hooks';
 import { promisify } from 'util';
 import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
 import { useLogger } from '../logger/index.js';
+import { useMetrics } from '../metrics/index.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { validateEnv } from '../utils/validate-env.js';
 import { getHelpers } from './helpers/index.js';
@@ -25,6 +26,7 @@ export function getDatabase() {
     }
     const env = useEnv();
     const logger = useLogger();
+    const metrics = useMetrics();
     const { client, version, searchPath, connectionString, pool: poolConfig = {}, ...connectionConfig } = getConfigFromEnv('DB_', ['DB_EXCLUDE_TABLES']);
     const requiredEnvVars = ['DB_CLIENT'];
     switch (client) {
@@ -148,6 +150,7 @@ export function getDatabase() {
         if (time) {
             delta = performance.now() - time;
             times.delete(queryInfo.__knexUid);
+            metrics?.getDatabaseResponseMetric()?.observe(delta);
         }
         // eslint-disable-next-line no-nested-ternary
         const bindings = queryInfo.bindings

package/dist/metrics/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/use-metrics.js';

package/dist/metrics/index.js

@@ -0,0 +1 @@
+export * from './lib/use-metrics.js';

package/dist/metrics/lib/create-metrics.d.ts

@@ -0,0 +1,15 @@
+import type { MetricObjectWithValues, MetricValue } from 'prom-client';
+import { Counter, Histogram } from 'prom-client';
+export declare function createMetrics(): {
+    getDatabaseErrorMetric: () => Counter | null;
+    getDatabaseResponseMetric: () => Histogram | null;
+    getCacheErrorMetric: () => Counter | null;
+    getRedisErrorMetric: () => Counter | null;
+    getStorageErrorMetric: (location: string) => Counter | null;
+    aggregate: (data: {
+        pid: number;
+        metrics: MetricObjectWithValues<MetricValue<string>>[];
+    }) => Promise<void>;
+    generate: () => Promise<void>;
+    readAll: () => Promise<string>;
+};