@directus/api 32.2.0 → 33.1.0

package/dist/controllers/deployment.js

@@ -0,0 +1,481 @@
+import { ErrorCode, ForbiddenError, 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 { respond } from '../middleware/respond.js';
+import useCollection from '../middleware/use-collection.js';
+import { validateBatch } from '../middleware/validate-batch.js';
+import { DeploymentProjectsService } from '../services/deployment-projects.js';
+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 { transaction } from '../utils/transaction.js';
+const router = express.Router();
+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);
+};
+// Validation schema for creating/updating deployment
+const deploymentSchema = Joi.object({
+    provider: Joi.string()
+        .valid(...DEPLOYMENT_PROVIDER_TYPES)
+        .required(),
+    credentials: Joi.object().required(),
+    options: Joi.object(),
+}).unknown();
+// Create deployment config
+router.post('/', asyncHandler(async (req, res, next) => {
+    const { error } = deploymentSchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const db = getDatabase();
+    const item = await transaction(db, async (trx) => {
+        const service = new DeploymentService({
+            accountability: req.accountability,
+            schema: req.schema,
+            knex: trx,
+        });
+        const key = await service.createOne({
+            provider: req.body.provider,
+            credentials: req.body.credentials,
+            options: req.body.options,
+        });
+        return service.readOne(key, req.sanitizedQuery);
+    });
+    res.locals['payload'] = { data: item };
+    return next();
+}), respond);
+// Read all deployment configs
+const readHandler = asyncHandler(async (req, res, next) => {
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const records = await service.readByQuery(req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+    res.locals['payload'] = { data: records || null, meta };
+    return next();
+});
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+// Read single deployment config by provider
+router.get('/:provider', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readByProvider(provider, req.sanitizedQuery);
+    res.locals['payload'] = { data: record || null };
+    return next();
+}), respond);
+// List projects from provider (for config/selection)
+router.get('/:provider/projects', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    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,
+    });
+    // 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
+    res.locals['cache'] = false;
+    res.locals['cacheTTL'] = remainingTTL;
+    res.locals['payload'] = { data: projects };
+    return next();
+}), respond);
+// Get single project details
+router.get('/:provider/projects/:id', 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 service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const projectsService = new DeploymentProjectsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Get project from DB (validates it exists and is selected)
+    const project = await projectsService.readOne(projectId);
+    // Fetch details from provider using external_id (with cache)
+    const { data: details, remainingTTL } = await service.getProviderProject(provider, project.external_id);
+    // Pass remaining TTL for response headers
+    res.locals['cache'] = false;
+    res.locals['cacheTTL'] = remainingTTL;
+    res.locals['payload'] = {
+        data: {
+            ...details,
+            id: project.id,
+            external_id: project.external_id,
+        },
+    };
+    return next();
+}), respond);
+// Update selected projects
+const updateProjectsSchema = Joi.object({
+    create: Joi.array()
+        .items(Joi.object({
+        external_id: Joi.string().required(),
+        name: Joi.string().required(),
+    }))
+        .default([]),
+    delete: Joi.array().items(Joi.string()).default([]),
+});
+router.patch('/:provider/projects', 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 } = updateProjectsSchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    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);
+    // 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}`,
+            });
+        }
+    }
+    const updatedProjects = await projectsService.updateSelection(deployment.id, value.create, value.delete);
+    res.locals['payload'] = { data: updatedProjects };
+    return next();
+}), respond);
+// 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 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
+    res.locals['cache'] = false;
+    res.locals['payload'] = { data: { projects: projectDetails } };
+    return next();
+}), respond);
+// Trigger deployment for a project
+const triggerDeploySchema = Joi.object({
+    preview: Joi.boolean().default(false),
+    clear_cache: Joi.boolean().default(true), // Default at true (matches Vercel UI behavior)
+});
+router.post('/:provider/projects/:id/deploy', 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 } = triggerDeploySchema.validate(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: error.message });
+    }
+    const service = new DeploymentService({
+        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, {
+        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,
+        },
+    };
+    return next();
+}), respond);
+// Update deployment config by provider
+router.patch('/:provider', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const db = getDatabase();
+    const item = await transaction(db, async (trx) => {
+        const service = new DeploymentService({
+            accountability: req.accountability,
+            schema: req.schema,
+            knex: trx,
+        });
+        const data = {};
+        if ('credentials' in req.body)
+            data['credentials'] = req.body.credentials;
+        if ('options' in req.body)
+            data['options'] = req.body.options;
+        const primaryKey = await service.updateByProvider(provider, data);
+        try {
+            return await service.readOne(primaryKey, req.sanitizedQuery);
+        }
+        catch (error) {
+            if (isDirectusError(error, ErrorCode.Forbidden)) {
+                return null;
+            }
+            throw error;
+        }
+    });
+    res.locals['payload'] = { data: item };
+    return next();
+}), respond);
+// Delete deployment config by provider
+router.delete('/:provider', asyncHandler(async (req, _res, next) => {
+    const provider = req.params['provider'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const service = new DeploymentService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteByProvider(provider);
+    return 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,
+    });
+    const runsService = new DeploymentRunsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    // Validate project exists
+    await projectsService.readOne(projectId);
+    // Get paginated runs from DB (default limit: 10)
+    const query = {
+        ...req.sanitizedQuery,
+        filter: { project: { _eq: projectId } },
+        sort: ['-date_created'],
+        limit: req.sanitizedQuery.limit ?? 10,
+        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 };
+    return next();
+}), respond);
+// Get single run details
+const runDetailsQuerySchema = Joi.object({
+    since: Joi.date().iso().optional(),
+    _t: Joi.number().optional(), // Cache-buster parameter for polling
+});
+router.get('/:provider/runs/:id', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const runId = req.params['id'];
+    if (!validateProvider(provider)) {
+        throw new InvalidPathParameterError({ reason: `${provider} is not a supported provider` });
+    }
+    const { error, value } = runDetailsQuerySchema.validate(req.query);
+    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),
+    ]);
+    res.locals['cache'] = false;
+    res.locals['payload'] = {
+        data: {
+            ...run,
+            ...details,
+            id: run.id,
+            external_id: run.external_id,
+            logs,
+        },
+    };
+    return next();
+}), respond);
+// Cancel a deployment
+router.post('/:provider/runs/:id/cancel', asyncHandler(async (req, res, next) => {
+    const provider = req.params['provider'];
+    const runId = req.params['id'];
+    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,
+        },
+    };
+    return next();
+}), respond);
+export default router;

package/dist/controllers/extensions.js

@@ -1,6 +1,6 @@
+import { EXTENSION_TYPES } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ErrorCode, ForbiddenError, isDirectusError, RouteNotFoundError } from '@directus/errors';
-import { EXTENSION_TYPES } from '@directus/constants';
 import { account, describe, list, } from '@directus/extensions-registry';
 import { isIn } from '@directus/utils';
 import express from 'express';

package/dist/controllers/fields.js

@@ -1,15 +1,15 @@
 import { TYPES } from '@directus/constants';
+import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import { ForbiddenError, isDirectusError } from '@directus/errors';
+import { isSystemField } from '@directus/system-data';
 import { Router } from 'express';
 import Joi from 'joi';
 import { ALIAS_TYPES } from '../constants.js';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import validateCollection from '../middleware/collection-exists.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { FieldsService, systemFieldUpdateSchema } from '../services/fields.js';
 import asyncHandler from '../utils/async-handler.js';
-import { isSystemField } from '@directus/system-data';
 const router = Router();
 router.use(useCollection('directus_fields'));
 router.get('/', asyncHandler(async (req, res, next) => {
@@ -91,8 +91,9 @@ router.patch('/:collection', validateCollection, asyncHandler(async (req, res, n
     for (const fieldData of req.body) {
         if (isSystemField(req.params['collection'], fieldData['field'])) {
             const { error } = systemFieldUpdateSchema.safeParse(fieldData);
-            if (error)
-                throw error.issues.map((details) => new InvalidPayloadError({ reason: details.message }));
+            if (error) {
+                throw new InvalidPayloadError({ reason: 'Only "schema.is_indexed" may be modified for system fields' });
+            }
         }
     }
     await service.updateFields(req.params['collection'], req.body, {
@@ -134,8 +135,9 @@ router.patch('/:collection/:field', validateCollection, asyncHandler(async (req,
     });
     if (isSystemField(req.params['collection'], req.params['field'])) {
         const { error } = systemFieldUpdateSchema.safeParse(req.body);
-        if (error)
-            throw error.issues.map((details) => new InvalidPayloadError({ reason: details.message }));
+        if (error) {
+            throw new InvalidPayloadError({ reason: 'Only "schema.is_indexed" may be modified for system fields' });
+        }
     }
     else {
         const { error } = updateSchema.validate(req.body);

package/dist/controllers/files.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import { useEnv } from '@directus/env';
 import { ErrorCode, InvalidPayloadError, isDirectusError } from '@directus/errors';
 import formatTitle from '@directus/format-title';
@@ -7,7 +8,6 @@ import bytes from 'bytes';
 import express from 'express';
 import Joi from 'joi';
 import { minimatch } from 'minimatch';
-import path from 'path';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';

package/dist/controllers/items.js

@@ -1,4 +1,4 @@
-import { ErrorCode, ForbiddenError, RouteNotFoundError, isDirectusError } from '@directus/errors';
+import { ErrorCode, ForbiddenError, isDirectusError, RouteNotFoundError } from '@directus/errors';
 import { isSystemCollection } from '@directus/system-data';
 import express from 'express';
 import collectionExists from '../middleware/collection-exists.js';

package/dist/controllers/not-found.js

@@ -1,6 +1,6 @@
+import { RouteNotFoundError } from '@directus/errors';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
-import { RouteNotFoundError } from '@directus/errors';
 /**
  * Handles not found routes.
  *

package/dist/controllers/relations.js

@@ -1,7 +1,7 @@
+import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import { isDirectusError } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
-import { ErrorCode, InvalidPayloadError } from '@directus/errors';
 import validateCollection from '../middleware/collection-exists.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';

package/dist/database/errors/dialects/mysql.d.ts

@@ -1,3 +1,3 @@
-import type { MySQLError } from './types.js';
 import type { Item } from '@directus/types';
+import type { MySQLError } from './types.js';
 export declare function extractError(error: MySQLError, data: Partial<Item>): MySQLError | Error;

package/dist/database/errors/dialects/postgres.d.ts

@@ -1,3 +1,3 @@
-import type { PostgresError } from './types.js';
 import type { Item } from '@directus/types';
+import type { PostgresError } from './types.js';
 export declare function extractError(error: PostgresError, data: Partial<Item>): PostgresError | Error;

package/dist/database/errors/dialects/sqlite.d.ts

@@ -1,3 +1,3 @@
-import type { SQLiteError } from './types.js';
 import type { Item } from '@directus/types';
+import type { SQLiteError } from './types.js';
 export declare function extractError(error: SQLiteError, data: Partial<Item>): SQLiteError | Error;

package/dist/database/errors/translate.d.ts

@@ -1,5 +1,5 @@
-import type { SQLError } from './dialects/types.js';
 import type { Item } from '@directus/types';
+import type { SQLError } from './dialects/types.js';
 /**
  * Translates an error thrown by any of the databases into a pre-defined Exception. Currently
  * supports:

package/dist/database/errors/translate.js

@@ -1,5 +1,5 @@
-import getDatabase, { getDatabaseClient } from '../index.js';
 import emitter from '../../emitter.js';
+import getDatabase, { getDatabaseClient } from '../index.js';
 import { extractError as mssql } from './dialects/mssql.js';
 import { extractError as mysql } from './dialects/mysql.js';
 import { extractError as oracle } from './dialects/oracle.js';

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

@@ -1,9 +1,8 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
-import { getRelation } from '@directus/utils';
+import { getRelation, getRelationType } from '@directus/utils';
 import { isEmpty } from 'lodash-es';
 import { fetchPermissions } from '../../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../../permissions/lib/fetch-policies.js';
-import { getRelationType } from '../../../utils/get-relation-type.js';
 import { getAllowedSort } from '../utils/get-allowed-sort.js';
 import { getDeepQuery } from '../utils/get-deep-query.js';
 import { getRelatedCollection } from '../utils/get-related-collection.js';
@@ -118,6 +117,7 @@ export async function parseFields(options, context) {
             relation,
             collection: options.parentCollection,
             field: fieldName,
+            useA2O: true,
         });
         if (!relationType)
             continue;

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

@@ -1,5 +1,5 @@
-import { DateHelper } from '../types.js';
 import { parseISO } from 'date-fns';
+import { DateHelper } from '../types.js';
 export class DateHelperMSSQL extends DateHelper {
     writeTimestamp(date) {
         const parsedDate = parseISO(date);

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

@@ -1,5 +1,5 @@
-import { DateHelper } from '../types.js';
 import { parseISO } from 'date-fns';
+import { DateHelper } from '../types.js';
 export class DateHelperMySQL extends DateHelper {
     readTimestampString(date) {
         const parsedDate = new Date(date);

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

@@ -1,5 +1,5 @@
-import { DatabaseHelper } from '../types.js';
 import { parseISO } from 'date-fns';
+import { DatabaseHelper } from '../types.js';
 export class DateHelper extends DatabaseHelper {
     parse(date) {
         // Date generated from NOW()

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

@@ -5,6 +5,7 @@ import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperCockroachDb extends SchemaHelper {
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
     constraintName(existingName: string): string;
+    changePrimaryKey(table: string, to: string | string[]): Promise<void>;
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
     createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;