@directus/api 33.3.1 → 34.0.1

package/dist/controllers/deployment.js

@@ -1,8 +1,9 @@
-import { ErrorCode, ForbiddenError, InvalidPathParameterError, InvalidPayloadError, isDirectusError, } from '@directus/errors';
+import { ErrorCode, InvalidPathParameterError, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import { DEPLOYMENT_PROVIDER_TYPES } from '@directus/types';
 import express from 'express';
 import Joi from 'joi';
 import getDatabase from '../database/index.js';
+import { useLogger } from '../logger/index.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -11,16 +12,14 @@ import { DeploymentRunsService } from '../services/deployment-runs.js';
 import { DeploymentService } from '../services/deployment.js';
 import { MetaService } from '../services/meta.js';
 import asyncHandler from '../utils/async-handler.js';
+import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { transaction } from '../utils/transaction.js';
 const router = express.Router();
+function parseRange(range, defaultMs) {
+    const ms = getMilliseconds(range, defaultMs);
+    return new Date(Date.now() - ms);
+}
 router.use(useCollection('directus_deployments'));
-// Require admin access for all deployment routes
-router.use((_req, _res, next) => {
-    if (_req.accountability && _req.accountability.admin !== true) {
-        throw new ForbiddenError();
-    }
-    return next();
-});
 // Validate provider parameter
 const validateProvider = (provider) => {
     return DEPLOYMENT_PROVIDER_TYPES.includes(provider);
@@ -101,40 +100,9 @@ router.get('/:provider/projects', asyncHandler(async (req, res, next) => {
         accountability: req.accountability,
         schema: req.schema,
     });
-    // Get provider config to find deployment ID
     const deployment = await service.readByProvider(provider);
-    // Get projects from provider (with cache)
     const { data: providerProjects, remainingTTL } = await service.listProviderProjects(provider);
-    // Get selected projects from DB
-    const selectedProjects = await projectsService.readByQuery({
-        filter: { deployment: { _eq: deployment.id } },
-    });
-    // Map by external_id for quick lookup
-    const selectedMap = new Map(selectedProjects.map((p) => [p.external_id, p]));
-    // Sync names from provider
-    const namesToUpdate = selectedProjects
-        .map((dbProject) => {
-        const providerProject = providerProjects.find((p) => p.id === dbProject.external_id);
-        if (providerProject && providerProject.name !== dbProject.name) {
-            return { id: dbProject.id, name: providerProject.name };
-        }
-        return null;
-    })
-        .filter((update) => update !== null);
-    if (namesToUpdate.length > 0) {
-        await projectsService.updateBatch(namesToUpdate);
-    }
-    // Merge with DB structure (id !== null means selected)
-    const projects = providerProjects.map((project) => {
-        return {
-            id: selectedMap.get(project.id)?.id ?? null,
-            external_id: project.id,
-            name: project.name,
-            deployable: project.deployable,
-            framework: project.framework,
-        };
-    });
-    // Pass remaining TTL for response headers
+    const projects = await projectsService.listWithSync(deployment.id, providerProjects);
     res.locals['cache'] = false;
     res.locals['cacheTTL'] = remainingTTL;
     res.locals['payload'] = { data: projects };
@@ -198,64 +166,42 @@ router.patch('/:provider/projects', asyncHandler(async (req, res, next) => {
         accountability: req.accountability,
         schema: req.schema,
     });
-    // Get provider config
-    const deployment = await service.readByProvider(provider);
     // Validate deployable projects before any mutation
     if (value.create.length > 0) {
-        const driver = await service.getDriver(provider);
-        const providerProjects = await driver.listProjects();
-        const projectsMap = new Map(providerProjects.map((p) => [p.id, p]));
-        const nonDeployable = value.create.filter((p) => !projectsMap.get(p.external_id)?.deployable);
-        if (nonDeployable.length > 0) {
-            const names = nonDeployable
-                .map((p) => projectsMap.get(p.external_id)?.name || p.external_id)
-                .join(', ');
-            throw new InvalidPayloadError({
-                reason: `Cannot add non-deployable projects: ${names}`,
-            });
-        }
+        await projectsService.validateDeployable(provider, value.create);
     }
-    const updatedProjects = await projectsService.updateSelection(deployment.id, value.create, value.delete);
+    const updatedProjects = await projectsService.updateSelection(provider, value.create, value.delete);
+    // Sync webhook with updated project list
+    service.syncWebhook(provider).catch((err) => {
+        const logger = useLogger();
+        logger.error(`Failed to sync webhook for ${provider}: ${err}`);
+    });
     res.locals['payload'] = { data: updatedProjects };
     return next();
 }), respond);
+const rangeQuerySchema = Joi.object({
+    range: Joi.string()
+        .pattern(/^\d+(ms|s|m|h|d|w|y)$/)
+        .optional(),
+});
 // Dashboard - selected projects with stats
 router.get('/:provider/dashboard', asyncHandler(async (req, res, next) => {
     const provider = req.params['provider'];
     if (!validateProvider(provider)) {
         throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
     }
+    const { error, value } = rangeQuerySchema.validate(req.query);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const sinceDate = parseRange(value.range, 86_400_000);
     const service = new DeploymentService({
         accountability: req.accountability,
         schema: req.schema,
     });
-    const projectsService = new DeploymentProjectsService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    // Get provider config
-    const deployment = await service.readByProvider(provider);
-    // Get selected projects from DB
-    const selectedProjects = await projectsService.readByQuery({
-        filter: { deployment: { _eq: deployment.id } },
-    });
-    if (selectedProjects.length === 0) {
-        res.locals['payload'] = { data: { projects: [] } };
-        return next();
-    }
-    // Fetch full details for each selected project (parallel)
-    const driver = await service.getDriver(provider);
-    const projectDetails = await Promise.all(selectedProjects.map(async (p) => {
-        const details = await driver.getProject(p.external_id);
-        return {
-            ...details,
-            id: p.id,
-            external_id: p.external_id,
-        };
-    }));
-    // Disable cache - dashboard needs fresh data from provider
+    const data = await service.getDashboard(provider, sinceDate);
     res.locals['cache'] = false;
-    res.locals['payload'] = { data: { projects: projectDetails } };
+    res.locals['payload'] = { data };
     return next();
 }), respond);
 // Trigger deployment for a project
@@ -277,36 +223,11 @@ router.post('/:provider/projects/:id/deploy', asyncHandler(async (req, res, next
         accountability: req.accountability,
         schema: req.schema,
     });
-    const projectsService = new DeploymentProjectsService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const runsService = new DeploymentRunsService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    // Get project from DB
-    const project = await projectsService.readOne(projectId);
-    // Trigger deployment via driver
-    const driver = await service.getDriver(provider);
-    const result = await driver.triggerDeployment(project.external_id, {
+    const run = await service.triggerDeployment(provider, projectId, {
         preview: value.preview,
         clearCache: value.clear_cache,
     });
-    // Store run in DB
-    const runId = await runsService.createOne({
-        project: projectId,
-        external_id: result.deployment_id,
-        target: value.preview ? 'preview' : 'production',
-    });
-    const run = await runsService.readOne(runId);
-    res.locals['payload'] = {
-        data: {
-            ...run,
-            status: result.status,
-            url: result.url,
-        },
-    };
+    res.locals['payload'] = { data: run };
     return next();
 }), respond);
 // Update deployment config by provider
@@ -356,17 +277,11 @@ router.delete('/:provider', asyncHandler(async (req, _res, next) => {
 }), respond);
 // List runs for a project
 router.get('/:provider/projects/:id/runs', asyncHandler(async (req, res, next) => {
-    // Disable cache - runs status needs to be fresh from provider
-    res.locals['cache'] = false;
     const provider = req.params['provider'];
     const projectId = req.params['id'];
     if (!validateProvider(provider)) {
         throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
     }
-    const service = new DeploymentService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
     const projectsService = new DeploymentProjectsService({
         accountability: req.accountability,
         schema: req.schema,
@@ -377,7 +292,6 @@ router.get('/:provider/projects/:id/runs', asyncHandler(async (req, res, next) =
     });
     // Validate project exists
     await projectsService.readOne(projectId);
-    // Get paginated runs from DB (default limit: 10)
     const query = {
         ...req.sanitizedQuery,
         filter: { project: { _eq: projectId } },
@@ -386,24 +300,39 @@ router.get('/:provider/projects/:id/runs', asyncHandler(async (req, res, next) =
         fields: ['*', 'user_created.first_name', 'user_created.last_name', 'user_created.email'],
     };
     const runs = await runsService.readByQuery(query);
-    // Get pagination meta
     const metaService = new MetaService({
         accountability: req.accountability,
         schema: req.schema,
     });
     const meta = await metaService.getMetaForQuery('directus_deployment_runs', query);
-    // Fetch status for each run from provider
-    const driver = await service.getDriver(provider);
-    const runsWithStatus = await Promise.all(runs.map(async (run) => {
-        const details = await driver.getDeployment(run.external_id);
-        return {
-            ...run,
-            ...details,
-            id: run.id,
-            external_id: run.external_id,
-        };
-    }));
-    res.locals['payload'] = { data: runsWithStatus, meta };
+    res.locals['payload'] = { data: runs, meta };
+    return next();
+}), respond);
+// Project runs stats
+router.get('/:provider/projects/:id/runs/stats', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const projectId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const { error, value } = rangeQuerySchema.validate(req.query);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const sinceDate = parseRange(value.range, 604_800_000).toISOString();
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const runsService = new DeploymentRunsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Validate project exists and user has access
+    await projectsService.readOne(projectId);
+    const data = await runsService.getStats(projectId, sinceDate);
+    res.locals['cache'] = false;
+    res.locals['payload'] = { data };
     return next();
 }), respond);
 // Get single run details
@@ -421,31 +350,13 @@ router.get('/:provider/runs/:id', asyncHandler(async (req, res, next) => {
     if (error) {
         throw new InvalidPayloadError({ reason: error.message });
     }
-    const sinceDate = value.since;
-    const runsService = new DeploymentRunsService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
     const service = new DeploymentService({
         accountability: req.accountability,
         schema: req.schema,
     });
-    const run = await runsService.readOne(runId);
-    const driver = await service.getDriver(provider);
-    const [details, logs] = await Promise.all([
-        driver.getDeployment(run.external_id),
-        driver.getDeploymentLogs(run.external_id, sinceDate ? { since: sinceDate } : undefined),
-    ]);
+    const data = await service.getRunWithLogs(provider, runId, value.since);
     res.locals['cache'] = false;
-    res.locals['payload'] = {
-        data: {
-            ...run,
-            ...details,
-            id: run.id,
-            external_id: run.external_id,
-            logs,
-        },
-    };
+    res.locals['payload'] = { data };
     return next();
 }), respond);
 // Cancel a deployment
@@ -455,27 +366,12 @@ router.post('/:provider/runs/:id/cancel', asyncHandler(async (req, res, next) =>
     if (!validateProvider(provider)) {
         throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
     }
-    const runsService = new DeploymentRunsService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
     const service = new DeploymentService({
         accountability: req.accountability,
         schema: req.schema,
     });
-    const run = await runsService.readOne(runId);
-    const driver = await service.getDriver(provider);
-    await driver.cancelDeployment(run.external_id);
-    // Fetch updated status
-    const details = await driver.getDeployment(run.external_id);
-    res.locals['payload'] = {
-        data: {
-            ...run,
-            ...details,
-            id: run.id,
-            external_id: run.external_id,
-        },
-    };
+    const data = await service.cancelDeployment(provider, runId);
+    res.locals['payload'] = { data };
     return next();
 }), respond);
 export default router;

package/dist/controllers/files.js

@@ -150,6 +150,7 @@ router.post('/', asyncHandler(multipartHandler), asyncHandler(async (req, res, n
 const importSchema = Joi.object({
     url: Joi.string().required(),
     data: Joi.object(),
+    options: Joi.object({ filterMimeType: Joi.array().items(Joi.string()) }),
 });
 router.post('/import', asyncHandler(async (req, res, next) => {
     const { error } = importSchema.validate(req.body);
@@ -160,7 +161,7 @@ router.post('/import', asyncHandler(async (req, res, next) => {
         accountability: req.accountability,
         schema: req.schema,
     });
-    const primaryKey = await service.importOne(req.body.url, req.body.data);
+    const primaryKey = await service.importOne(req.body.url, req.body.data, req.body.options);
     try {
         const record = await service.readOne(primaryKey, req.sanitizedQuery);
         res.locals['payload'] = { data: record || null };

package/dist/controllers/server.js

@@ -1,3 +1,4 @@
+import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, isDirectusError, RouteNotFoundError } from '@directus/errors';
 import { format } from 'date-fns';
 import { Router } from 'express';
@@ -8,32 +9,37 @@ import { SpecificationService } from '../services/specifications.js';
 import asyncHandler from '../utils/async-handler.js';
 import { createAdmin } from '../utils/create-admin.js';
 const router = Router();
-router.get('/specs/oas', asyncHandler(async (req, res, next) => {
-    const service = new SpecificationService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    res.locals['payload'] = await service.oas.generate(req.headers.host);
-    return next();
-}), respond);
-router.get('/specs/graphql/:scope?', asyncHandler(async (req, res) => {
-    const service = new SpecificationService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const serverService = new ServerService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const scope = req.params['scope'] || 'items';
-    if (['items', 'system'].includes(scope) === false)
-        throw new RouteNotFoundError({ path: req.path });
-    const info = await serverService.serverInfo();
-    const result = await service.graphql.generate(scope);
-    const filename = info['project'].project_name + '_' + format(new Date(), 'yyyy-MM-dd') + '.graphql';
-    res.attachment(filename);
-    res.send(result);
-}));
+const env = useEnv();
+if (env['OPENAPI_ENABLED'] !== false) {
+    router.get('/specs/oas', asyncHandler(async (req, res, next) => {
+        const service = new SpecificationService({
+            accountability: req.accountability,
+            schema: req.schema,
+        });
+        res.locals['payload'] = await service.oas.generate(req.headers.host);
+        return next();
+    }), respond);
+}
+if (env['GRAPHQL_INTROSPECTION'] !== false) {
+    router.get('/specs/graphql/:scope?', asyncHandler(async (req, res) => {
+        const service = new SpecificationService({
+            accountability: req.accountability,
+            schema: req.schema,
+        });
+        const serverService = new ServerService({
+            accountability: req.accountability,
+            schema: req.schema,
+        });
+        const scope = req.params['scope'] || 'items';
+        if (['items', 'system'].includes(scope) === false)
+            throw new RouteNotFoundError({ path: req.path });
+        const info = await serverService.serverInfo();
+        const result = await service.graphql.generate(scope);
+        const filename = info['project'].project_name + '_' + format(new Date(), 'yyyy-MM-dd') + '.graphql';
+        res.attachment(filename);
+        res.send(result);
+    }));
+}
 router.get('/info', asyncHandler(async (req, res, next) => {
     const service = new ServerService({
         accountability: req.accountability,

package/dist/controllers/tus.js

@@ -1,3 +1,5 @@
+import { createError } from '@directus/errors';
+import { ERRORS, Metadata } from '@tus/utils';
 import { Router } from 'express';
 import getDatabase from '../database/index.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
@@ -18,11 +20,40 @@ const mapAction = (method) => {
 const checkFileAccess = asyncHandler(async (req, _res, next) => {
     if (req.accountability) {
         const action = mapAction(req.method);
-        await validateAccess({
+        const validateAccessOptions = {
             action,
             collection: 'directus_files',
             accountability: req.accountability,
-        }, {
+        };
+        if (req.method === 'POST' && req.header('upload-metadata')) {
+            let metadata;
+            try {
+                metadata = Metadata.parse(req.header('upload-metadata'));
+            }
+            catch {
+                throw new (createError('INVALID_METADATA', ERRORS.INVALID_METADATA.body, ERRORS.INVALID_METADATA.status_code))();
+            }
+            // On replacement ensure update for that record
+            if (metadata['id']) {
+                validateAccessOptions.action = 'update';
+                validateAccessOptions.primaryKeys = [metadata['id']];
+            }
+            // Validate permissions for any payload fields
+            const fields = [];
+            for (const field of Object.keys(req.schema.collections['directus_files'].fields)) {
+                // PK is not mutable, access to record is already checked via `primaryKeys` for updates
+                if (field === 'id') {
+                    continue;
+                }
+                if (field in metadata) {
+                    fields.push(field);
+                }
+            }
+            if (fields.length > 0) {
+                validateAccessOptions.fields = fields;
+            }
+        }
+        await validateAccess(validateAccessOptions, {
             schema: req.schema,
             knex: getDatabase(),
         });

package/dist/controllers/utils.js

@@ -3,6 +3,7 @@ import argon2 from 'argon2';
 import Busboy from 'busboy';
 import { Router } from 'express';
 import Joi from 'joi';
+import { resolveLoginRedirect } from '../auth/utils/resolve-login-redirect.js';
 import collectionExists from '../middleware/collection-exists.js';
 import { respond } from '../middleware/respond.js';
 import { ExportService, ImportService } from '../services/import-export.js';
@@ -125,4 +126,21 @@ router.post('/cache/clear', asyncHandler(async (req, res) => {
     await service.clearCache({ system: clearSystemCache });
     res.status(200).end();
 }));
+router.post('/resolve-redirect', asyncHandler(async (req, res) => {
+    if (!req.body?.redirect) {
+        throw new InvalidPayloadError({ reason: `"redirect" is required` });
+    }
+    if (req.body?.provider && typeof req.body.provider !== 'string') {
+        throw new InvalidPayloadError({ reason: `"provider" must be a string` });
+    }
+    try {
+        const resolved = resolveLoginRedirect(req.body.redirect, {
+            provider: req.body.provider,
+        });
+        return res.json({ data: resolved });
+    }
+    catch {
+        throw new InvalidPayloadError({ reason: `Invalid "redirect" provided` });
+    }
+}));
 export default router;

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

@@ -1,5 +1,5 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
-import { getRelation, getRelationType } from '@directus/utils';
+import { getRelation, getRelationType, parseFilterFunctionPath } from '@directus/utils';
 import { isEmpty } from 'lodash-es';
 import { fetchPermissions } from '../../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../../permissions/lib/fetch-policies.js';
@@ -35,13 +35,58 @@ export async function parseFields(options, context) {
                 name = options.query.alias[fieldKey];
             }
         }
-        const isRelational = name.includes('.') ||
-            // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
-            // anything
-            !!context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === name);
+        // Normalize function calls to move relational prefixes outside the function.
+        // e.g., json(m2m.data, color) → m2m.json(data, color)
+        // This allows the standard relational handling below to process the traversal
+        // uniformly for all functions (json, count, year, etc.).
+        name = parseFilterFunctionPath(name);
+        const isFunctionCall = name.includes('(') && name.includes(')');
+        if (isFunctionCall) {
+            const functionName = name.split('(')[0];
+            const columnName = name.match(REGEX_BETWEEN_PARENS)[1];
+            const foundField = context.schema.collections[options.parentCollection].fields[columnName];
+            // Create a FunctionFieldNode for relational count functions (count(related_items))
+            if (functionName === 'count' && foundField && foundField.type === 'alias') {
+                const foundRelation = context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === columnName);
+                if (foundRelation) {
+                    children.push({
+                        type: 'functionField',
+                        name,
+                        fieldKey,
+                        query: {},
+                        relatedCollection: foundRelation.collection,
+                        whenCase: [],
+                        cases: [],
+                    });
+                    continue;
+                }
+            }
+            // Create a FunctionFieldNode for direct (non-relational) json function calls
+            if (functionName === 'json') {
+                children.push({
+                    type: 'functionField',
+                    name,
+                    fieldKey,
+                    query: {},
+                    relatedCollection: options.parentCollection,
+                    whenCase: [],
+                    cases: [],
+                });
+                continue;
+            }
+        }
+        const isRelationalFunctionCall = isFunctionCall && name.includes('.') && name.indexOf('.') < name.indexOf('(');
+        const isRelational = (!isFunctionCall || isRelationalFunctionCall) &&
+            (name.includes('.') ||
+                // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
+                // anything
+                !!context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === name));
         if (isRelational) {
-            // field is relational
-            const parts = fieldKey.split('.');
+            // For normalized function calls, split on the resolved name since
+            // parseFilterFunctionPath may have moved relational segments outside
+            // the function args (e.g., json(m2m.data, color) → m2m.json(data, color)).
+            // For plain fields, split on fieldKey to preserve existing alias behavior.
+            const parts = (isFunctionCall ? name : fieldKey).split('.');
             let rootField = parts[0];
             let collectionScope = null;
             // a2o related collection scoped field selector `fields=sections.section_id:headings.title`
@@ -72,25 +117,6 @@ export async function parseFields(options, context) {
             }
         }
         else {
-            if (name.includes('(') && name.includes(')')) {
-                const columnName = name.match(REGEX_BETWEEN_PARENS)[1];
-                const foundField = context.schema.collections[options.parentCollection].fields[columnName];
-                if (foundField && foundField.type === 'alias') {
-                    const foundRelation = context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === columnName);
-                    if (foundRelation) {
-                        children.push({
-                            type: 'functionField',
-                            name,
-                            fieldKey,
-                            query: {},
-                            relatedCollection: foundRelation.collection,
-                            whenCase: [],
-                            cases: [],
-                        });
-                        continue;
-                    }
-                }
-            }
             if (name.includes(':')) {
                 const [key, scope] = name.split(':');
                 if (key in relationalStructure === false) {

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

@@ -16,6 +16,8 @@ export class DateHelperOracle extends DateHelper {
     }
     fieldFlagForField(fieldType) {
         switch (fieldType) {
+            case 'json':
+                return 'cast-json';
             case 'dateTime':
                 return 'cast-datetime';
             default:

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

@@ -17,6 +17,8 @@ export class DateHelperSQLite extends DateHelper {
     }
     fieldFlagForField(fieldType) {
         switch (fieldType) {
+            case 'json':
+                return 'cast-json';
             case 'timestamp':
                 return 'cast-timestamp';
             default:

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

@@ -3,5 +3,5 @@ export declare abstract class DateHelper extends DatabaseHelper {
     parse(date: string | Date): string;
     readTimestampString(date: string): string;
     writeTimestamp(date: string): Date;
-    fieldFlagForField(_fieldType: string): string;
+    fieldFlagForField(fieldType: string): string;
 }

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

@@ -14,7 +14,9 @@ export class DateHelper extends DatabaseHelper {
     writeTimestamp(date) {
         return parseISO(date);
     }
-    fieldFlagForField(_fieldType) {
+    fieldFlagForField(fieldType) {
+        if (fieldType === 'json')
+            return 'cast-json';
         return '';
     }
 }

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

@@ -11,4 +11,5 @@ export declare class FnHelperMSSQL extends FnHelper {
     minute(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     second(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     count(table: string, column: string, options?: FnHelperOptions): Knex.Raw<any>;
+    json(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
 }