@directus/api 9.25.0

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

@@ -0,0 +1,26 @@
+import { applyFilter } from '../../../utils/apply-query.js';
+import { DatabaseHelper } from '../types.js';
+export class FnHelper extends DatabaseHelper {
+    schema;
+    constructor(knex, schema) {
+        super(knex);
+        this.schema = schema;
+        this.schema = schema;
+    }
+    _relationalCount(table, column, options) {
+        const collectionName = options?.originalCollectionName || table;
+        const relation = this.schema.relations.find((relation) => relation.related_collection === collectionName && relation?.meta?.one_field === column);
+        const currentPrimary = this.schema.collections[collectionName].primary;
+        if (!relation) {
+            throw new Error(`Field ${collectionName}.${column} isn't a nested relational collection`);
+        }
+        let countQuery = this.knex
+            .count('*')
+            .from(relation.collection)
+            .where(relation.field, '=', this.knex.raw(`??.??`, [table, currentPrimary]));
+        if (options?.query?.filter) {
+            countQuery = applyFilter(this.knex, this.schema, countQuery, options.query.filter, relation.collection, {}).query;
+        }
+        return this.knex.raw('(' + countQuery.toQuery() + ')');
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { Field, RawField } from '@directus/types';
+import type { Knex } from 'knex';
+import type { GeoJSONGeometry } from 'wellknown';
+import { GeometryHelper } from '../types.js';
+export declare class GeometryHelperMSSQL extends GeometryHelper {
+    isTrue(expression: Knex.Raw): Knex.Raw<any>;
+    isFalse(expression: Knex.Raw): Knex.Raw<any>;
+    createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
+    asText(table: string, column: string): Knex.Raw;
+    fromText(text: string): Knex.Raw;
+    _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    _intersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    collect(table: string, column: string): Knex.Raw;
+}

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

@@ -0,0 +1,32 @@
+import { GeometryHelper } from '../types.js';
+export class GeometryHelperMSSQL extends GeometryHelper {
+    isTrue(expression) {
+        return expression.wrap(``, ` = 1`);
+    }
+    isFalse(expression) {
+        return expression.wrap(``, ` = 0`);
+    }
+    createColumn(table, field) {
+        if (field.type.split('.')[1]) {
+            field.meta.special = [field.type];
+        }
+        return table.specificType(field.field, 'geometry');
+    }
+    asText(table, column) {
+        return this.knex.raw('??.??.STAsText() as ??', [table, column, column]);
+    }
+    fromText(text) {
+        return this.knex.raw('geometry::STGeomFromText(?, 4326)', text);
+    }
+    _intersects(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('??.STIntersects(?)', [key, geometry]);
+    }
+    _intersects_bbox(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('??.STEnvelope().STIntersects(?.STEnvelope())', [key, geometry]);
+    }
+    collect(table, column) {
+        return this.knex.raw('geometry::CollectionAggregate(??.??).STAsText()', [table, column]);
+    }
+}

package/dist/database/helpers/geometry/dialects/mysql.d.ts

@@ -0,0 +1,7 @@
+import type { Knex } from 'knex';
+import { GeometryHelper } from '../types.js';
+export declare class GeometryHelperMySQL extends GeometryHelper {
+    collect(table: string, column: string): Knex.Raw;
+    fromText(text: string): Knex.Raw;
+    asGeoJSON(table: string, column: string): Knex.Raw;
+}

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

@@ -0,0 +1,12 @@
+import { GeometryHelper } from '../types.js';
+export class GeometryHelperMySQL extends GeometryHelper {
+    collect(table, column) {
+        return this.knex.raw(`concat('geometrycollection(', group_concat(? separator ', '), ')'`, this.asText(table, column));
+    }
+    fromText(text) {
+        return this.knex.raw('st_geomfromtext(?)', text);
+    }
+    asGeoJSON(table, column) {
+        return this.knex.raw('st_asgeojson(??.??) as ??', [table, column, column]);
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Field, RawField } from '@directus/types';
+import type { Knex } from 'knex';
+import type { GeoJSONGeometry } from 'wellknown';
+import { GeometryHelper } from '../types.js';
+export declare class GeometryHelperOracle extends GeometryHelper {
+    isTrue(expression: Knex.Raw): Knex.Raw<any>;
+    isFalse(expression: Knex.Raw): Knex.Raw<any>;
+    createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
+    asText(table: string, column: string): Knex.Raw;
+    asGeoJSON(table: string, column: string): Knex.Raw;
+    fromText(text: string): Knex.Raw;
+    _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    _intersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    collect(table: string, column: string): Knex.Raw;
+}

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

@@ -0,0 +1,35 @@
+import { GeometryHelper } from '../types.js';
+export class GeometryHelperOracle extends GeometryHelper {
+    isTrue(expression) {
+        return expression.wrap(``, ` = 'TRUE'`);
+    }
+    isFalse(expression) {
+        return expression.wrap(``, ` = 'FALSE'`);
+    }
+    createColumn(table, field) {
+        if (field.type.split('.')[1]) {
+            field.meta.special = [field.type];
+        }
+        return table.specificType(field.field, 'sdo_geometry');
+    }
+    asText(table, column) {
+        return this.knex.raw('sdo_util.to_wktgeometry(??.??) as ??', [table, column, column]);
+    }
+    asGeoJSON(table, column) {
+        return this.knex.raw('sdo_util.to_geojson(??.??) as ??', [table, column, column]);
+    }
+    fromText(text) {
+        return this.knex.raw('sdo_geometry(?, 4326)', text);
+    }
+    _intersects(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw(`sdo_overlapbdyintersect(??, ?)`, [key, geometry]);
+    }
+    _intersects_bbox(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw(`sdo_overlapbdyintersect(sdo_geom.sdo_mbr(??), sdo_geom.sdo_mbr(?))`, [key, geometry]);
+    }
+    collect(table, column) {
+        return this.knex.raw(`concat('geometrycollection(', listagg(?, ', '), ')'`, this.asText(table, column));
+    }
+}

package/dist/database/helpers/geometry/dialects/postgres.d.ts

@@ -0,0 +1,10 @@
+import type { Field, RawField } from '@directus/types';
+import type { Knex } from 'knex';
+import type { GeoJSONGeometry } from 'wellknown';
+import { GeometryHelper } from '../types.js';
+export declare class GeometryHelperPostgres extends GeometryHelper {
+    supported(): Promise<boolean>;
+    createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
+    _intersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    asGeoJSON(table: string, column: string): Knex.Raw;
+}

package/dist/database/helpers/geometry/dialects/postgres.js

@@ -0,0 +1,18 @@
+import { GeometryHelper } from '../types.js';
+export class GeometryHelperPostgres extends GeometryHelper {
+    async supported() {
+        const res = await this.knex.select('oid').from('pg_proc').where({ proname: 'postgis_version' });
+        return res.length > 0;
+    }
+    createColumn(table, field) {
+        const type = field.type.split('.')[1] ?? 'geometry';
+        return table.specificType(field.field, `geometry(${type}, 4326)`);
+    }
+    _intersects_bbox(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('?? && ?', [key, geometry]);
+    }
+    asGeoJSON(table, column) {
+        return this.knex.raw('st_asgeojson(??.??) as ??', [table, column, column]);
+    }
+}

package/dist/database/helpers/geometry/dialects/redshift.d.ts

@@ -0,0 +1,7 @@
+import type { Field, RawField } from '@directus/types';
+import type { Knex } from 'knex';
+import { GeometryHelper } from '../types.js';
+export declare class GeometryHelperRedshift extends GeometryHelper {
+    createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
+    asGeoJSON(table: string, column: string): Knex.Raw;
+}

package/dist/database/helpers/geometry/dialects/redshift.js

@@ -0,0 +1,12 @@
+import { GeometryHelper } from '../types.js';
+export class GeometryHelperRedshift extends GeometryHelper {
+    createColumn(table, field) {
+        if (field.type.split('.')[1]) {
+            field.meta.special = [field.type];
+        }
+        return table.specificType(field.field, 'geometry');
+    }
+    asGeoJSON(table, column) {
+        return this.knex.raw('st_asgeojson(??.??) as ??', [table, column, column]);
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { Knex } from 'knex';
+import { GeometryHelper } from '../types.js';
+export declare class GeometryHelperSQLite extends GeometryHelper {
+    supported(): Promise<boolean>;
+    asGeoJSON(table: string, column: string): Knex.Raw;
+}

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

@@ -0,0 +1,10 @@
+import { GeometryHelper } from '../types.js';
+export class GeometryHelperSQLite extends GeometryHelper {
+    async supported() {
+        const res = await this.knex.select('name').from('pragma_function_list').where({ name: 'spatialite_version' });
+        return res.length > 0;
+    }
+    asGeoJSON(table, column) {
+        return this.knex.raw('asgeojson(??.??) as ??', [table, column, column]);
+    }
+}

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

@@ -0,0 +1,7 @@
+export { GeometryHelperPostgres as postgres } from './dialects/postgres.js';
+export { GeometryHelperPostgres as cockroachdb } from './dialects/postgres.js';
+export { GeometryHelperRedshift as redshift } from './dialects/redshift.js';
+export { GeometryHelperOracle as oracle } from './dialects/oracle.js';
+export { GeometryHelperSQLite as sqlite } from './dialects/sqlite.js';
+export { GeometryHelperMySQL as mysql } from './dialects/mysql.js';
+export { GeometryHelperMSSQL as mssql } from './dialects/mssql.js';

package/dist/database/helpers/geometry/index.js

@@ -0,0 +1,7 @@
+export { GeometryHelperPostgres as postgres } from './dialects/postgres.js';
+export { GeometryHelperPostgres as cockroachdb } from './dialects/postgres.js';
+export { GeometryHelperRedshift as redshift } from './dialects/redshift.js';
+export { GeometryHelperOracle as oracle } from './dialects/oracle.js';
+export { GeometryHelperSQLite as sqlite } from './dialects/sqlite.js';
+export { GeometryHelperMySQL as mysql } from './dialects/mysql.js';
+export { GeometryHelperMSSQL as mssql } from './dialects/mssql.js';

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

@@ -0,0 +1,20 @@
+import type { Field, RawField } from '@directus/types';
+import type { Knex } from 'knex';
+import { GeoJSONGeometry } from 'wellknown';
+import { DatabaseHelper } from '../types.js';
+export declare abstract class GeometryHelper extends DatabaseHelper {
+    supported(): boolean | Promise<boolean>;
+    isTrue(expression: Knex.Raw): Knex.Raw<any>;
+    isFalse(expression: Knex.Raw): Knex.Raw<any>;
+    createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
+    asText(table: string, column: string): Knex.Raw;
+    fromText(text: string): Knex.Raw;
+    fromGeoJSON(geojson: GeoJSONGeometry): Knex.Raw;
+    _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    nintersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    _intersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    intersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    nintersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
+    collect(table: string, column: string): Knex.Raw;
+}

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

@@ -0,0 +1,49 @@
+import { stringify as geojsonToWKT } from 'wellknown';
+import { DatabaseHelper } from '../types.js';
+export class GeometryHelper extends DatabaseHelper {
+    supported() {
+        return true;
+    }
+    isTrue(expression) {
+        return expression;
+    }
+    isFalse(expression) {
+        return expression.wrap('NOT ', '');
+    }
+    createColumn(table, field) {
+        const type = field.type.split('.')[1] ?? 'geometry';
+        return table.specificType(field.field, type);
+    }
+    asText(table, column) {
+        return this.knex.raw('st_astext(??.??) as ??', [table, column, column]);
+    }
+    fromText(text) {
+        return this.knex.raw('st_geomfromtext(?, 4326)', text);
+    }
+    fromGeoJSON(geojson) {
+        return this.fromText(geojsonToWKT(geojson));
+    }
+    _intersects(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('st_intersects(??, ?)', [key, geometry]);
+    }
+    intersects(key, geojson) {
+        return this.isTrue(this._intersects(key, geojson));
+    }
+    nintersects(key, geojson) {
+        return this.isFalse(this._intersects(key, geojson));
+    }
+    _intersects_bbox(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('st_intersects(??, ?)', [key, geometry]);
+    }
+    intersects_bbox(key, geojson) {
+        return this.isTrue(this._intersects_bbox(key, geojson));
+    }
+    nintersects_bbox(key, geojson) {
+        return this.isFalse(this._intersects_bbox(key, geojson));
+    }
+    collect(table, column) {
+        return this.knex.raw('st_astext(st_collect(??.??))', [table, column]);
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { SchemaOverview } from '@directus/types';
+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 schemaHelpers from './schema/index.js';
+export declare function getHelpers(database: Knex): {
+    date: dateHelpers.mysql | dateHelpers.postgres | dateHelpers.mssql | dateHelpers.sqlite | dateHelpers.oracle;
+    st: geometryHelpers.mysql | geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
+    schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle;
+};
+export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.mysql | fnHelpers.postgres | fnHelpers.mssql | fnHelpers.sqlite | fnHelpers.oracle;
+export type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -0,0 +1,17 @@
+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 schemaHelpers from './schema/index.js';
+export function getHelpers(database) {
+    const client = getDatabaseClient(database);
+    return {
+        date: new dateHelpers[client](database),
+        st: new geometryHelpers[client](database),
+        schema: new schemaHelpers[client](database),
+    };
+}
+export function getFunctions(database, schema) {
+    const client = getDatabaseClient(database);
+    return new fnHelpers[client](database, schema);
+}

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

@@ -0,0 +1,6 @@
+import type { KNEX_TYPES } from '@directus/constants';
+import { Options, 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;
+}

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

@@ -0,0 +1,17 @@
+import { SchemaHelper } from '../types.js';
+export class SchemaHelperCockroachDb extends SchemaHelper {
+    async changeToType(table, column, type, options = {}) {
+        await this.changeToTypeByCopy(table, column, type, options);
+    }
+    constraintName(existingName) {
+        const suffix = '_replaced';
+        // CockroachDB does not allow for dropping/creating constraints with the same
+        // name in a single transaction. reference issue #14873
+        if (existingName.endsWith(suffix)) {
+            return existingName.substring(0, existingName.length - suffix.length);
+        }
+        else {
+            return existingName + suffix;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import { SchemaHelper } from '../types.js';
+export declare class SchemaHelperDefault extends SchemaHelper {
+}

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

@@ -0,0 +1,3 @@
+import { SchemaHelper } from '../types.js';
+export class SchemaHelperDefault extends SchemaHelper {
+}

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

@@ -0,0 +1,7 @@
+import type { Knex } from 'knex';
+import { SchemaHelper } from '../types.js';
+export declare class SchemaHelperMSSQL extends SchemaHelper {
+    applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
+    applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
+    formatUUID(uuid: string): string;
+}

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

@@ -0,0 +1,20 @@
+import { SchemaHelper } from '../types.js';
+export class SchemaHelperMSSQL extends SchemaHelper {
+    applyLimit(rootQuery, limit) {
+        // The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries,
+        // and common table expressions, unless TOP, OFFSET or FOR XML is also specified.
+        if (limit === -1) {
+            rootQuery.limit(Number.MAX_SAFE_INTEGER);
+        }
+        else {
+            rootQuery.limit(limit);
+        }
+    }
+    applyOffset(rootQuery, offset) {
+        rootQuery.offset(offset);
+        rootQuery.orderBy(1);
+    }
+    formatUUID(uuid) {
+        return uuid.toUpperCase();
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { Knex } from 'knex';
+import { SchemaHelper } from '../types.js';
+export declare class SchemaHelperMySQL extends SchemaHelper {
+    applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
+}

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

@@ -0,0 +1,14 @@
+import { getDatabaseVersion } from '../../../../database/index.js';
+import { SchemaHelper } from '../types.js';
+export class SchemaHelperMySQL extends SchemaHelper {
+    applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
+        if (getDatabaseVersion()?.startsWith('5.7')) {
+            dbQuery.orderByRaw(`?? asc, ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]);
+            dbQuery = knex
+                .select(knex.raw(`??, ( @rank := IF ( @cur_id = deep.${primaryKey}, @rank + 1, 1 ) ) AS directus_row_number, ( @cur_id := deep.${primaryKey} ) AS current_id`, 'deep.*'))
+                .from(knex.raw('? as ??, (SELECT @rank := 0,  @cur_id := null) vars', [dbQuery, 'deep']));
+            return dbQuery;
+        }
+        return super.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { KNEX_TYPES } from '@directus/constants';
+import type { Field, Relation, Type } from '@directus/types';
+import { Options, SchemaHelper } from '../types.js';
+export declare class SchemaHelperOracle extends SchemaHelper {
+    changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
+    castA2oPrimaryKey(): string;
+    preRelationChange(relation: Partial<Relation>): void;
+    processFieldType(field: Field): Type;
+}

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

@@ -0,0 +1,32 @@
+import { SchemaHelper } from '../types.js';
+export class SchemaHelperOracle extends SchemaHelper {
+    async changeToType(table, column, type, options = {}) {
+        await this.changeToTypeByCopy(table, column, type, options);
+    }
+    castA2oPrimaryKey() {
+        return 'CAST(?? AS VARCHAR2(255))';
+    }
+    preRelationChange(relation) {
+        if (relation.collection === relation.related_collection) {
+            // Constraints are not allowed on self referencing relationships
+            // Setting NO ACTION throws - ORA-00905: missing keyword
+            if (relation.schema?.on_delete) {
+                relation.schema.on_delete = null;
+            }
+        }
+    }
+    processFieldType(field) {
+        if (field.type === 'integer') {
+            if (field.schema?.numeric_precision === 20) {
+                return 'bigInteger';
+            }
+            else if (field.schema?.numeric_precision === 1) {
+                return 'boolean';
+            }
+            else if (field.schema?.numeric_precision || field.schema?.numeric_scale) {
+                return 'decimal';
+            }
+        }
+        return field.type;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { SchemaHelper } from '../types.js';
+export declare class SchemaHelperSQLite extends SchemaHelper {
+    preColumnChange(): Promise<boolean>;
+    postColumnChange(): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { SchemaHelper } from '../types.js';
+export class SchemaHelperSQLite extends SchemaHelper {
+    async preColumnChange() {
+        const foreignCheckStatus = (await this.knex.raw('PRAGMA foreign_keys'))[0].foreign_keys === 1;
+        if (foreignCheckStatus) {
+            await this.knex.raw('PRAGMA foreign_keys = OFF');
+        }
+        return foreignCheckStatus;
+    }
+    async postColumnChange() {
+        await this.knex.raw('PRAGMA foreign_keys = ON');
+    }
+}

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

@@ -0,0 +1,7 @@
+export { SchemaHelperDefault as postgres } from './dialects/default.js';
+export { SchemaHelperCockroachDb as cockroachdb } from './dialects/cockroachdb.js';
+export { SchemaHelperDefault as redshift } from './dialects/default.js';
+export { SchemaHelperOracle as oracle } from './dialects/oracle.js';
+export { SchemaHelperSQLite as sqlite } from './dialects/sqlite.js';
+export { SchemaHelperMySQL as mysql } from './dialects/mysql.js';
+export { SchemaHelperMSSQL as mssql } from './dialects/mssql.js';

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

@@ -0,0 +1,7 @@
+export { SchemaHelperDefault as postgres } from './dialects/default.js';
+export { SchemaHelperCockroachDb as cockroachdb } from './dialects/cockroachdb.js';
+export { SchemaHelperDefault as redshift } from './dialects/default.js';
+export { SchemaHelperOracle as oracle } from './dialects/oracle.js';
+export { SchemaHelperSQLite as sqlite } from './dialects/sqlite.js';
+export { SchemaHelperMySQL as mysql } from './dialects/mysql.js';
+export { SchemaHelperMSSQL as mssql } from './dialects/mssql.js';

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

@@ -0,0 +1,26 @@
+import type { KNEX_TYPES } from '@directus/constants';
+import type { Field, Relation, Type } from '@directus/types';
+import type { Knex } from 'knex';
+import type { DatabaseClient } from '../../../types/index.js';
+import { DatabaseHelper } from '../types.js';
+export type Options = {
+    nullable?: boolean;
+    default?: any;
+    length?: number;
+};
+export declare abstract class SchemaHelper extends DatabaseHelper {
+    isOneOfClients(clients: DatabaseClient[]): boolean;
+    changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
+    changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
+    protected changeToTypeByCopy(table: string, column: string, type: (typeof KNEX_TYPES)[number], options: Options): Promise<void>;
+    preColumnChange(): Promise<boolean>;
+    postColumnChange(): Promise<void>;
+    preRelationChange(_relation: Partial<Relation>): void;
+    processFieldType(field: Field): Type;
+    constraintName(existingName: string): string;
+    applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
+    applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
+    castA2oPrimaryKey(): string;
+    applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
+    formatUUID(uuid: string): string;
+}

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

@@ -0,0 +1,91 @@
+import { getDatabaseClient } from '../../index.js';
+import { DatabaseHelper } from '../types.js';
+export class SchemaHelper extends DatabaseHelper {
+    isOneOfClients(clients) {
+        return clients.includes(getDatabaseClient(this.knex));
+    }
+    async changeNullable(table, column, nullable) {
+        await this.knex.schema.alterTable(table, (builder) => {
+            if (nullable) {
+                builder.setNullable(column);
+            }
+            else {
+                builder.dropNullable(column);
+            }
+        });
+    }
+    async changeToType(table, column, type, options = {}) {
+        await this.knex.schema.alterTable(table, (builder) => {
+            const b = type === 'string' ? builder.string(column, options.length) : builder[type](column);
+            if (options.nullable === true) {
+                b.nullable();
+            }
+            if (options.nullable === false) {
+                b.notNullable();
+            }
+            if (options.default !== undefined) {
+                b.defaultTo(options.default);
+            }
+            b.alter();
+        });
+    }
+    async changeToTypeByCopy(table, column, type, options) {
+        const tempName = `${column}__temp`;
+        await this.knex.schema.alterTable(table, (builder) => {
+            const col = type === 'string' ? builder.string(tempName, options.length) : builder[type](tempName);
+            if (options.default !== undefined) {
+                col.defaultTo(options.default);
+            }
+            // Force new temporary column to be nullable (required, as there will already be rows in
+            // the table)
+            col.nullable();
+        });
+        await this.knex(table).update(tempName, this.knex.ref(column));
+        await this.knex.schema.alterTable(table, (builder) => {
+            builder.dropColumn(column);
+        });
+        await this.knex.schema.alterTable(table, (builder) => {
+            builder.renameColumn(tempName, column);
+        });
+        // We're altering the temporary column here. That starts nullable, so we only want to set it
+        // to NOT NULL when applicable
+        if (options.nullable === false) {
+            await this.changeNullable(table, column, options.nullable);
+        }
+    }
+    async preColumnChange() {
+        return false;
+    }
+    async postColumnChange() {
+        return;
+    }
+    preRelationChange(_relation) {
+        return;
+    }
+    processFieldType(field) {
+        return field.type;
+    }
+    constraintName(existingName) {
+        // most vendors allow for dropping/creating constraints with the same name
+        // reference issue #14873
+        return existingName;
+    }
+    applyLimit(rootQuery, limit) {
+        if (limit !== -1) {
+            rootQuery.limit(limit);
+        }
+    }
+    applyOffset(rootQuery, offset) {
+        rootQuery.offset(offset);
+    }
+    castA2oPrimaryKey() {
+        return 'CAST(?? AS CHAR(255))';
+    }
+    applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
+        dbQuery.rowNumber(knex.ref('directus_row_number').toQuery(), knex.raw(`partition by ?? order by ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]));
+        return dbQuery;
+    }
+    formatUUID(uuid) {
+        return uuid; // no-op by default
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { Knex } from 'knex';
+export declare abstract class DatabaseHelper {
+    protected knex: Knex;
+    constructor(knex: Knex);
+}