@directus/api 27.1.0 → 28.0.1

package/dist/database/errors/dialects/mysql.js

@@ -9,126 +9,130 @@ var MySQLErrorCodes;
     MySQLErrorCodes["ER_INVALID_USE_OF_NULL"] = "ER_INVALID_USE_OF_NULL";
     MySQLErrorCodes["WARN_DATA_TRUNCATED"] = "WARN_DATA_TRUNCATED";
 })(MySQLErrorCodes || (MySQLErrorCodes = {}));
-export function extractError(error) {
+export function extractError(error, data) {
     switch (error.code) {
         case MySQLErrorCodes.UNIQUE_VIOLATION:
-            return uniqueViolation(error);
+            return uniqueViolation();
         case MySQLErrorCodes.NUMERIC_VALUE_OUT_OF_RANGE:
-            return numericValueOutOfRange(error);
+            return numericValueOutOfRange();
         case MySQLErrorCodes.ER_DATA_TOO_LONG:
-            return valueLimitViolation(error);
+            return valueLimitViolation();
         case MySQLErrorCodes.NOT_NULL_VIOLATION:
-            return notNullViolation(error);
+            return notNullViolation();
         case MySQLErrorCodes.FOREIGN_KEY_VIOLATION:
-            return foreignKeyViolation(error);
+            return foreignKeyViolation();
         // Note: MariaDB throws data truncated for null value error
         case MySQLErrorCodes.ER_INVALID_USE_OF_NULL:
         case MySQLErrorCodes.WARN_DATA_TRUNCATED:
-            return containsNullValues(error);
+            return containsNullValues();
     }
     return error;
-}
-function uniqueViolation(error) {
-    const betweenQuotes = /'([^']+)'/g;
-    const matches = error.sqlMessage.match(betweenQuotes);
-    if (!matches)
-        return error;
-    /**
-     * MySQL's error doesn't return the field name in the error. In case the field is created through
-     * Directus (/ Knex), the key name will be `<collection>_<field>_unique` in which case we can pull
-     * the field name from the key name.
-     * If the field is the primary key it instead will be `<collection>_PRIMARY` for MySQL 8+
-     * and `PRIMARY` for MySQL 5.7 and MariaDB.
-     */
-    let collection;
-    let indexName;
-    let field = null;
-    if (matches[1].includes('.')) {
-        // MySQL 8+ style error message
-        // In case of primary key matches[1] is `'<collection>.PRIMARY'`
-        // In case of other field matches[1] is `'<collection>.<collection>_<field>_unique'`
-        [collection, indexName] = matches[1].slice(1, -1).split('.');
+    function uniqueViolation() {
+        const betweenQuotes = /'([^']+)'/g;
+        const matches = error.sqlMessage.match(betweenQuotes);
+        if (!matches)
+            return error;
+        /**
+         * MySQL's error doesn't return the field name in the error. In case the field is created through
+         * Directus (/ Knex), the key name will be `<collection>_<field>_unique` in which case we can pull
+         * the field name from the key name.
+         * If the field is the primary key it instead will be `<collection>_PRIMARY` for MySQL 8+
+         * and `PRIMARY` for MySQL 5.7 and MariaDB.
+         */
+        let collection;
+        let indexName;
+        let field = null;
+        if (matches[1].includes('.')) {
+            // MySQL 8+ style error message
+            // In case of primary key matches[1] is `'<collection>.PRIMARY'`
+            // In case of other field matches[1] is `'<collection>.<collection>_<field>_unique'`
+            [collection, indexName] = matches[1].slice(1, -1).split('.');
+        }
+        else {
+            // MySQL 5.7 and MariaDB style error message
+            // In case of primary key matches[1] is `'PRIMARY'`
+            // In case of other field matches[1] is `'<collection>_<field>_unique'`
+            indexName = matches[1].slice(1, -1);
+            collection = indexName.includes('_') ? indexName.split('_')[0] : null;
+        }
+        if (collection !== null && indexName.startsWith(`${collection}_`) && indexName.endsWith('_unique')) {
+            field = indexName?.slice(collection.length + 1, -7);
+        }
+        return new RecordNotUniqueError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+            primaryKey: indexName === 'PRIMARY', // propagate information about primary key violation
+        });
     }
-    else {
-        // MySQL 5.7 and MariaDB style error message
-        // In case of primary key matches[1] is `'PRIMARY'`
-        // In case of other field matches[1] is `'<collection>_<field>_unique'`
-        indexName = matches[1].slice(1, -1);
-        collection = indexName.includes('_') ? indexName.split('_')[0] : null;
+    function numericValueOutOfRange() {
+        const betweenTicks = /`([^`]+)`/g;
+        const betweenQuotes = /'([^']+)'/g;
+        const tickMatches = error.sql.match(betweenTicks);
+        const quoteMatches = error.sqlMessage.match(betweenQuotes);
+        if (!tickMatches || !quoteMatches)
+            return error;
+        const collection = tickMatches[0]?.slice(1, -1);
+        const field = quoteMatches[0]?.slice(1, -1);
+        return new ValueOutOfRangeError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
     }
-    if (collection !== null && indexName.startsWith(`${collection}_`) && indexName.endsWith('_unique')) {
-        field = indexName?.slice(collection.length + 1, -7);
+    function valueLimitViolation() {
+        const betweenTicks = /`([^`]+)`/g;
+        const betweenQuotes = /'([^']+)'/g;
+        const tickMatches = error.sql.match(betweenTicks);
+        const quoteMatches = error.sqlMessage.match(betweenQuotes);
+        if (!tickMatches || !quoteMatches)
+            return error;
+        const collection = tickMatches[0]?.slice(1, -1);
+        const field = quoteMatches[0]?.slice(1, -1);
+        return new ValueTooLongError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
+    }
+    function notNullViolation() {
+        const betweenTicks = /`([^`]+)`/g;
+        const betweenQuotes = /'([^']+)'/g;
+        const tickMatches = error.sql.match(betweenTicks);
+        const quoteMatches = error.sqlMessage.match(betweenQuotes);
+        if (!tickMatches || !quoteMatches)
+            return error;
+        const collection = tickMatches[0]?.slice(1, -1);
+        const field = quoteMatches[0]?.slice(1, -1);
+        return new NotNullViolationError({
+            collection,
+            field,
+        });
+    }
+    function foreignKeyViolation() {
+        const betweenTicks = /`([^`]+)`/g;
+        const betweenParens = /\(([^)]+)\)/g;
+        const tickMatches = error.sqlMessage.match(betweenTicks);
+        const parenMatches = error.sql.match(betweenParens);
+        if (!tickMatches || !parenMatches)
+            return error;
+        const collection = tickMatches[1].slice(1, -1);
+        const field = tickMatches[3].slice(1, -1);
+        return new InvalidForeignKeyError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
+    }
+    function containsNullValues() {
+        const betweenTicks = /`([^`]+)`/g;
+        // Normally, we shouldn't read from the executed SQL. In this case, we're altering a single
+        // column, so we shouldn't have the problem where multiple columns are altered at the same time
+        const tickMatches = error.sql.match(betweenTicks);
+        if (!tickMatches)
+            return error;
+        const collection = tickMatches[0].slice(1, -1);
+        const field = tickMatches[1].slice(1, -1);
+        return new ContainsNullValuesError({ collection, field });
     }
-    return new RecordNotUniqueError({
-        collection,
-        field,
-        primaryKey: indexName === 'PRIMARY', // propagate information about primary key violation
-    });
-}
-function numericValueOutOfRange(error) {
-    const betweenTicks = /`([^`]+)`/g;
-    const betweenQuotes = /'([^']+)'/g;
-    const tickMatches = error.sql.match(betweenTicks);
-    const quoteMatches = error.sqlMessage.match(betweenQuotes);
-    if (!tickMatches || !quoteMatches)
-        return error;
-    const collection = tickMatches[0]?.slice(1, -1);
-    const field = quoteMatches[0]?.slice(1, -1);
-    return new ValueOutOfRangeError({
-        collection,
-        field,
-    });
-}
-function valueLimitViolation(error) {
-    const betweenTicks = /`([^`]+)`/g;
-    const betweenQuotes = /'([^']+)'/g;
-    const tickMatches = error.sql.match(betweenTicks);
-    const quoteMatches = error.sqlMessage.match(betweenQuotes);
-    if (!tickMatches || !quoteMatches)
-        return error;
-    const collection = tickMatches[0]?.slice(1, -1);
-    const field = quoteMatches[0]?.slice(1, -1);
-    return new ValueTooLongError({
-        collection,
-        field,
-    });
-}
-function notNullViolation(error) {
-    const betweenTicks = /`([^`]+)`/g;
-    const betweenQuotes = /'([^']+)'/g;
-    const tickMatches = error.sql.match(betweenTicks);
-    const quoteMatches = error.sqlMessage.match(betweenQuotes);
-    if (!tickMatches || !quoteMatches)
-        return error;
-    const collection = tickMatches[0]?.slice(1, -1);
-    const field = quoteMatches[0]?.slice(1, -1);
-    return new NotNullViolationError({
-        collection,
-        field,
-    });
-}
-function foreignKeyViolation(error) {
-    const betweenTicks = /`([^`]+)`/g;
-    const betweenParens = /\(([^)]+)\)/g;
-    const tickMatches = error.sqlMessage.match(betweenTicks);
-    const parenMatches = error.sql.match(betweenParens);
-    if (!tickMatches || !parenMatches)
-        return error;
-    const collection = tickMatches[1].slice(1, -1);
-    const field = tickMatches[3].slice(1, -1);
-    return new InvalidForeignKeyError({
-        collection,
-        field,
-    });
-}
-function containsNullValues(error) {
-    const betweenTicks = /`([^`]+)`/g;
-    // Normally, we shouldn't read from the executed SQL. In this case, we're altering a single
-    // column, so we shouldn't have the problem where multiple columns are altered at the same time
-    const tickMatches = error.sql.match(betweenTicks);
-    if (!tickMatches)
-        return error;
-    const collection = tickMatches[0].slice(1, -1);
-    const field = tickMatches[1].slice(1, -1);
-    return new ContainsNullValuesError({ collection, field });
 }

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

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

package/dist/database/errors/dialects/postgres.js

@@ -7,85 +7,89 @@ var PostgresErrorCodes;
     PostgresErrorCodes["UNIQUE_VIOLATION"] = "23505";
     PostgresErrorCodes["VALUE_LIMIT_VIOLATION"] = "22001";
 })(PostgresErrorCodes || (PostgresErrorCodes = {}));
-export function extractError(error) {
+export function extractError(error, data) {
     switch (error.code) {
         case PostgresErrorCodes.UNIQUE_VIOLATION:
-            return uniqueViolation(error);
+            return uniqueViolation();
         case PostgresErrorCodes.NUMERIC_VALUE_OUT_OF_RANGE:
-            return numericValueOutOfRange(error);
+            return numericValueOutOfRange();
         case PostgresErrorCodes.VALUE_LIMIT_VIOLATION:
-            return valueLimitViolation(error);
+            return valueLimitViolation();
         case PostgresErrorCodes.NOT_NULL_VIOLATION:
-            return notNullViolation(error);
+            return notNullViolation();
         case PostgresErrorCodes.FOREIGN_KEY_VIOLATION:
-            return foreignKeyViolation(error);
+            return foreignKeyViolation();
         default:
             return error;
     }
-}
-function uniqueViolation(error) {
-    const { table, detail } = error;
-    const betweenParens = /\(([^)]+)\)/g;
-    const matches = detail.match(betweenParens);
-    if (!matches)
-        return error;
-    const collection = table;
-    const field = matches[0].slice(1, -1);
-    return new RecordNotUniqueError({
-        collection,
-        field,
-    });
-}
-function numericValueOutOfRange(error) {
-    const regex = /"(.*?)"/g;
-    const matches = error.message.match(regex);
-    if (!matches)
-        return error;
-    const collection = matches[0].slice(1, -1);
-    const field = null;
-    return new ValueOutOfRangeError({
-        collection,
-        field,
-    });
-}
-function valueLimitViolation(error) {
-    /**
-     * NOTE:
-     * Postgres doesn't return the offending column
-     */
-    const regex = /"(.*?)"/g;
-    const matches = error.message.match(regex);
-    if (!matches)
-        return error;
-    const collection = matches[0].slice(1, -1);
-    const field = null;
-    return new ValueTooLongError({
-        collection,
-        field,
-    });
-}
-function notNullViolation(error) {
-    const { table, column } = error;
-    if (!column)
-        return error;
-    if (error.message.endsWith('contains null values')) {
-        return new ContainsNullValuesError({ collection: table, field: column });
+    function uniqueViolation() {
+        const { table, detail } = error;
+        const betweenParens = /\(([^)]+)\)/g;
+        const matches = detail.match(betweenParens);
+        if (!matches)
+            return error;
+        const collection = table;
+        const field = matches[0].slice(1, -1);
+        return new RecordNotUniqueError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
+    }
+    function numericValueOutOfRange() {
+        const regex = /"(.*?)"/g;
+        const matches = error.message.match(regex);
+        if (!matches)
+            return error;
+        const collection = matches[0].slice(1, -1);
+        const field = matches[1]?.slice(1, -1) ?? null;
+        return new ValueOutOfRangeError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
+    }
+    function valueLimitViolation() {
+        /**
+         * NOTE:
+         * Postgres doesn't return the offending column
+         */
+        const regex = /"(.*?)"/g;
+        const matches = error.message.match(regex);
+        if (!matches)
+            return error;
+        const collection = matches[0].slice(1, -1);
+        const field = matches[1]?.slice(1, -1) ?? null;
+        return new ValueTooLongError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
+    }
+    function notNullViolation() {
+        const { table, column } = error;
+        if (!column)
+            return error;
+        if (error.message.endsWith('contains null values')) {
+            return new ContainsNullValuesError({ collection: table, field: column });
+        }
+        return new NotNullViolationError({
+            collection: table,
+            field: column,
+        });
+    }
+    function foreignKeyViolation() {
+        const { table, detail } = error;
+        const betweenParens = /\(([^)]+)\)/g;
+        const matches = detail.match(betweenParens);
+        if (!matches)
+            return error;
+        const collection = table;
+        const field = matches[0].slice(1, -1);
+        return new InvalidForeignKeyError({
+            collection,
+            field,
+            value: field ? data[field] : null,
+        });
     }
-    return new NotNullViolationError({
-        collection: table,
-        field: column,
-    });
-}
-function foreignKeyViolation(error) {
-    const { table, detail } = error;
-    const betweenParens = /\(([^)]+)\)/g;
-    const matches = detail.match(betweenParens);
-    if (!matches)
-        return error;
-    const collection = table;
-    const field = matches[0].slice(1, -1);
-    return new InvalidForeignKeyError({
-        collection,
-        field,
-    });
 }

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

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

package/dist/database/errors/dialects/sqlite.js

@@ -2,18 +2,19 @@ import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError,
 // NOTE:
 // - Sqlite doesn't have varchar with length support, so no ValueTooLongError
 // - Sqlite doesn't have a max range for numbers, so no ValueOutOfRangeError
-export function extractError(error) {
+export function extractError(error, data) {
     if (error.message.includes('SQLITE_CONSTRAINT: NOT NULL')) {
         return notNullConstraint(error);
     }
     if (error.message.includes('SQLITE_CONSTRAINT: UNIQUE')) {
         const errorParts = error.message.split(' ');
-        const [table, column] = errorParts[errorParts.length - 1].split('.');
-        if (!table || !column)
+        const [table, field] = errorParts[errorParts.length - 1].split('.');
+        if (!table || !field)
             return error;
         return new RecordNotUniqueError({
             collection: table,
-            field: column,
+            field,
+            value: field ? data[field] : null,
         });
     }
     if (error.message.includes('SQLITE_CONSTRAINT: FOREIGN KEY')) {
@@ -22,7 +23,7 @@ export function extractError(error) {
          * SQLite doesn't return any useful information in it's foreign key constraint failed error, so
          * we can't extract the table/column/value accurately
          */
-        return new InvalidForeignKeyError({ collection: null, field: null });
+        return new InvalidForeignKeyError({ collection: null, field: null, value: null });
     }
     return error;
 }

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

@@ -1,4 +1,5 @@
 import type { SQLError } from './dialects/types.js';
+import type { Item } from '@directus/types';
 /**
  * Translates an error thrown by any of the databases into a pre-defined Exception. Currently
  * supports:
@@ -8,4 +9,4 @@ import type { SQLError } from './dialects/types.js';
  * - Value Out of Range
  * - Value Too Long
  */
-export declare function translateDatabaseError(error: SQLError): Promise<any>;
+export declare function translateDatabaseError(error: SQLError, data: Partial<Item>): Promise<any>;

package/dist/database/errors/translate.js

@@ -14,25 +14,25 @@ import { extractError as sqlite } from './dialects/sqlite.js';
  * - Value Out of Range
  * - Value Too Long
  */
-export async function translateDatabaseError(error) {
+export async function translateDatabaseError(error, data) {
     const client = getDatabaseClient();
     let defaultError;
     switch (client) {
         case 'mysql':
-            defaultError = mysql(error);
+            defaultError = mysql(error, data);
             break;
         case 'cockroachdb':
         case 'postgres':
-            defaultError = postgres(error);
+            defaultError = postgres(error, data);
             break;
         case 'sqlite':
-            defaultError = sqlite(error);
+            defaultError = sqlite(error, data);
             break;
         case 'oracle':
             defaultError = oracle(error);
             break;
         case 'mssql':
-            defaultError = await mssql(error);
+            defaultError = await mssql(error, data);
             break;
     }
     const hookError = await emitter.emitFilter('database.error', defaultError, { client }, {

package/dist/database/get-ast-from-query/lib/convert-wildcards.d.ts

@@ -1,13 +1,15 @@
-import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { Accountability, Query, Relation, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 export interface ConvertWildcardsOptions {
     collection: string;
     fields: string[];
     alias: Query['alias'];
     accountability: Accountability | null;
+    backlink: boolean | undefined;
 }
 export interface ConvertWildCardsContext {
     schema: SchemaOverview;
     knex: Knex;
+    parentRelation?: Relation;
 }
 export declare function convertWildcards(options: ConvertWildcardsOptions, context: ConvertWildCardsContext): Promise<string[]>;

package/dist/database/get-ast-from-query/lib/convert-wildcards.js

@@ -40,14 +40,24 @@ export async function convertWildcards(options, context) {
         // Swap *.* case for *,<relational-field>.*,<another-relational>.*
         if (fieldKey.includes('.') && fieldKey.split('.')[0] === '*') {
             const parts = fieldKey.split('.');
-            const relationalFields = allowedFields.includes('*')
-                ? context.schema.relations
-                    .filter((relation) => relation.collection === options.collection || relation.related_collection === options.collection)
-                    .map((relation) => {
-                    const isMany = relation.collection === options.collection;
-                    return isMany ? relation.field : relation.meta?.one_field;
-                })
-                : allowedFields.filter((fieldKey) => !!getRelation(context.schema.relations, options.collection, fieldKey));
+            let relationalFields = [];
+            if (allowedFields.includes('*')) {
+                relationalFields = context.schema.relations.reduce((acc, relation) => {
+                    if (relation.collection === options.collection && !acc.includes(relation.field)) {
+                        acc.push(relation.field);
+                    }
+                    if (relation.related_collection === options.collection && !acc.includes(relation.meta.one_field)) {
+                        acc.push(relation.meta.one_field);
+                    }
+                    return acc;
+                }, []);
+            }
+            else {
+                relationalFields = allowedFields.filter((fieldKey) => getRelation(context.schema.relations, options.collection, fieldKey) !== undefined);
+            }
+            if (options.backlink === false) {
+                relationalFields = relationalFields.filter((relationField) => getRelation(context.schema.relations, options.collection, relationField) !== context.parentRelation);
+            }
             const nonRelationalFields = allowedFields.filter((fieldKey) => relationalFields.includes(fieldKey) === false);
             const aliasFields = Object.keys(options.alias ?? {}).map((fieldKey) => {
                 const name = options.alias[fieldKey];

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

@@ -1,4 +1,4 @@
-import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { Accountability, Query, Relation, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { FieldNode, FunctionFieldNode, NestedCollectionNode, O2MNode } from '../../../types/index.js';
 export interface ParseFieldsOptions {
@@ -11,6 +11,7 @@ export interface ParseFieldsOptions {
 export interface ParseFieldsContext {
     schema: SchemaOverview;
     knex: Knex;
+    parentRelation?: Relation;
 }
 export declare function parseFields(options: ParseFieldsOptions, context: ParseFieldsContext): Promise<[] | (NestedCollectionNode | FieldNode | FunctionFieldNode)[]>;
 export declare function isO2MNode(node: NestedCollectionNode | null): node is O2MNode;

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

@@ -17,6 +17,7 @@ export async function parseFields(options, context) {
         collection: options.parentCollection,
         alias: options.query.alias,
         accountability: options.accountability,
+        backlink: options.query.backlink,
     }, context);
     if (!fields || !Array.isArray(fields))
         return [];
@@ -151,7 +152,7 @@ export async function parseFields(options, context) {
                     query: options.query,
                     deep: options.deep?.[`${fieldKey}:${relatedCollection}`],
                     accountability: options.accountability,
-                }, context);
+                }, { ...context, parentRelation: relation });
                 child.query[relatedCollection] = getDeepQuery(options.deep?.[`${fieldKey}:${relatedCollection}`] || {});
                 child.relatedKey[relatedCollection] = context.schema.collections[relatedCollection].primary;
             }
@@ -188,7 +189,7 @@ export async function parseFields(options, context) {
                     query: childQuery,
                     deep: options.deep?.[fieldKey] || {},
                     accountability: options.accountability,
-                }, context),
+                }, { ...context, parentRelation: relation }),
                 cases: [],
                 whenCase: [],
             };

package/dist/database/migrations/20250609A-license-banner.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20250609A-license-banner.js

@@ -0,0 +1,14 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+export async function up(knex) {
+    const env = useEnv();
+    const acceptedTerms = toBoolean(env['ACCEPT_TERMS']);
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.boolean('accepted_terms').defaultTo(acceptedTerms);
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('accepted_terms');
+    });
+}

package/dist/database/migrations/20250613A-add-project-id.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20250613A-add-project-id.js

@@ -0,0 +1,26 @@
+import { v7 as uuid } from 'uuid';
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.uuid('project_id');
+    });
+    const existing = await knex('directus_settings').select('id').first();
+    const timestamp = await knex('directus_migrations').select('timestamp').first();
+    const msecs = timestamp ? new Date(timestamp.timestamp).getTime() : Date.now();
+    if (existing) {
+        await knex('directus_settings').update({
+            project_id: uuid({
+                msecs,
+            }),
+        });
+    }
+    else {
+        await knex('directus_settings').insert({
+            project_id: uuid(),
+        });
+    }
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('project_id');
+    });
+}