directus 9.0.1 → 9.2.0

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateHelperSQLite = void 0;
+const types_1 = require("../types");
+class DateHelperSQLite extends types_1.DateHelper {
+    year(table, column) {
+        return this.knex.raw("strftime('%Y', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    month(table, column) {
+        return this.knex.raw("strftime('%m', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    week(table, column) {
+        return this.knex.raw("strftime('%W', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    day(table, column) {
+        return this.knex.raw("strftime('%d', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    weekday(table, column) {
+        return this.knex.raw("strftime('%w', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    hour(table, column) {
+        return this.knex.raw("strftime('%H', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    minute(table, column) {
+        return this.knex.raw("strftime('%M', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    second(table, column) {
+        return this.knex.raw("strftime('%S', ??.?? / 1000, 'unixepoch')", [table, column]);
+    }
+    parse(date) {
+        const newDate = new Date(date);
+        return (newDate.getTime() - newDate.getTimezoneOffset() * 60 * 1000).toString();
+    }
+}
+exports.DateHelperSQLite = DateHelperSQLite;

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

@@ -0,0 +1,6 @@
+export { DateHelperPostgres as postgres } from './dialects/postgres';
+export { DateHelperPostgres as redshift } from './dialects/postgres';
+export { DateHelperOracle as oracle } from './dialects/oracle';
+export { DateHelperSQLite as sqlite } from './dialects/sqlite';
+export { DateHelperMySQL as mysql } from './dialects/mysql';
+export { DateHelperMSSQL as mssql } from './dialects/mssql';

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mssql = exports.mysql = exports.sqlite = exports.oracle = exports.redshift = exports.postgres = void 0;
+var postgres_1 = require("./dialects/postgres");
+Object.defineProperty(exports, "postgres", { enumerable: true, get: function () { return postgres_1.DateHelperPostgres; } });
+var postgres_2 = require("./dialects/postgres");
+Object.defineProperty(exports, "redshift", { enumerable: true, get: function () { return postgres_2.DateHelperPostgres; } });
+var oracle_1 = require("./dialects/oracle");
+Object.defineProperty(exports, "oracle", { enumerable: true, get: function () { return oracle_1.DateHelperOracle; } });
+var sqlite_1 = require("./dialects/sqlite");
+Object.defineProperty(exports, "sqlite", { enumerable: true, get: function () { return sqlite_1.DateHelperSQLite; } });
+var mysql_1 = require("./dialects/mysql");
+Object.defineProperty(exports, "mysql", { enumerable: true, get: function () { return mysql_1.DateHelperMySQL; } });
+var mssql_1 = require("./dialects/mssql");
+Object.defineProperty(exports, "mssql", { enumerable: true, get: function () { return mssql_1.DateHelperMSSQL; } });

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

@@ -0,0 +1,13 @@
+import { DatabaseHelper } from '../types';
+import { Knex } from 'knex';
+export declare abstract class DateHelper extends DatabaseHelper {
+    abstract year(table: string, column: string): Knex.Raw;
+    abstract month(table: string, column: string): Knex.Raw;
+    abstract week(table: string, column: string): Knex.Raw;
+    abstract day(table: string, column: string): Knex.Raw;
+    abstract weekday(table: string, column: string): Knex.Raw;
+    abstract hour(table: string, column: string): Knex.Raw;
+    abstract minute(table: string, column: string): Knex.Raw;
+    abstract second(table: string, column: string): Knex.Raw;
+    parse(date: string): string;
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateHelper = void 0;
+const types_1 = require("../types");
+class DateHelper extends types_1.DatabaseHelper {
+    parse(date) {
+        return date;
+    }
+}
+exports.DateHelper = DateHelper;

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

@@ -0,0 +1,14 @@
+import { GeometryHelper } from '../types';
+import { Field, RawField } from '@directus/shared/types';
+import { GeoJSONGeometry } from 'wellknown';
+import { Knex } from 'knex';
+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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperMSSQL = void 0;
+const types_1 = require("../types");
+class GeometryHelperMSSQL extends types_1.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]);
+    }
+}
+exports.GeometryHelperMSSQL = GeometryHelperMSSQL;

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

@@ -0,0 +1,7 @@
+import { GeometryHelper } from '../types';
+import { Knex } from 'knex';
+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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperMySQL = void 0;
+const types_1 = require("../types");
+class GeometryHelperMySQL extends types_1.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]);
+    }
+}
+exports.GeometryHelperMySQL = GeometryHelperMySQL;

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

@@ -0,0 +1,15 @@
+import { GeometryHelper } from '../types';
+import { Field, RawField } from '@directus/shared/types';
+import { GeoJSONGeometry } from 'wellknown';
+import { Knex } from 'knex';
+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,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperOracle = void 0;
+const types_1 = require("../types");
+class GeometryHelperOracle extends types_1.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));
+    }
+}
+exports.GeometryHelperOracle = GeometryHelperOracle;

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

@@ -0,0 +1,10 @@
+import { GeometryHelper } from '../types';
+import { Field, RawField } from '@directus/shared/types';
+import { GeoJSONGeometry } from 'wellknown';
+import { Knex } from 'knex';
+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,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperPostgres = void 0;
+const types_1 = require("../types");
+class GeometryHelperPostgres extends types_1.GeometryHelper {
+    async supported() {
+        const res = await this.knex.select('oid').from('pg_proc').where({ proname: 'postgis_version' });
+        return res.length > 0;
+    }
+    createColumn(table, field) {
+        var _a;
+        const type = (_a = field.type.split('.')[1]) !== null && _a !== void 0 ? _a : '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]);
+    }
+}
+exports.GeometryHelperPostgres = GeometryHelperPostgres;

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

@@ -0,0 +1,7 @@
+import { GeometryHelper } from '../types';
+import { Field, RawField } from '@directus/shared/types';
+import { Knex } from 'knex';
+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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperRedshift = void 0;
+const types_1 = require("../types");
+class GeometryHelperRedshift extends types_1.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]);
+    }
+}
+exports.GeometryHelperRedshift = GeometryHelperRedshift;

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

@@ -0,0 +1,6 @@
+import { GeometryHelper } from '../types';
+import { Knex } from 'knex';
+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,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperSQLite = void 0;
+const types_1 = require("../types");
+class GeometryHelperSQLite extends types_1.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]);
+    }
+}
+exports.GeometryHelperSQLite = GeometryHelperSQLite;

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mssql = exports.mysql = exports.sqlite = exports.oracle = exports.redshift = exports.postgres = void 0;
+var postgres_1 = require("./dialects/postgres");
+Object.defineProperty(exports, "postgres", { enumerable: true, get: function () { return postgres_1.GeometryHelperPostgres; } });
+var redshift_1 = require("./dialects/redshift");
+Object.defineProperty(exports, "redshift", { enumerable: true, get: function () { return redshift_1.GeometryHelperRedshift; } });
+var oracle_1 = require("./dialects/oracle");
+Object.defineProperty(exports, "oracle", { enumerable: true, get: function () { return oracle_1.GeometryHelperOracle; } });
+var sqlite_1 = require("./dialects/sqlite");
+Object.defineProperty(exports, "sqlite", { enumerable: true, get: function () { return sqlite_1.GeometryHelperSQLite; } });
+var mysql_1 = require("./dialects/mysql");
+Object.defineProperty(exports, "mysql", { enumerable: true, get: function () { return mysql_1.GeometryHelperMySQL; } });
+var mssql_1 = require("./dialects/mssql");
+Object.defineProperty(exports, "mssql", { enumerable: true, get: function () { return mssql_1.GeometryHelperMSSQL; } });

package/dist/database/helpers/{geometry.d.ts → geometry/types.d.ts}

@@ -1,16 +1,13 @@
+import { GeoJSONGeometry } from 'wellknown';
 import { Field, RawField } from '@directus/shared/types';
+import { DatabaseHelper } from '../types';
 import { Knex } from 'knex';
-import { GeoJSONGeometry } from 'wellknown';
-export declare function getGeometryHelper(database?: Knex): KnexSpatial;
-declare abstract class KnexSpatial {
-    protected knex: Knex;
-    constructor(knex: Knex);
+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;
-    asGeoJSON?(table: string, column: string): Knex.Raw;
     fromText(text: string): Knex.Raw;
     fromGeoJSON(geojson: GeoJSONGeometry): Knex.Raw;
     _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
@@ -21,4 +18,3 @@ declare abstract class KnexSpatial {
     nintersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
     collect(table: string, column: string): Knex.Raw;
 }
-export {};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelper = void 0;
+const wellknown_1 = require("wellknown");
+const types_1 = require("../types");
+class GeometryHelper extends types_1.DatabaseHelper {
+    supported() {
+        return true;
+    }
+    isTrue(expression) {
+        return expression;
+    }
+    isFalse(expression) {
+        return expression.wrap('NOT ', '');
+    }
+    createColumn(table, field) {
+        var _a;
+        const type = (_a = field.type.split('.')[1]) !== null && _a !== void 0 ? _a : '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((0, wellknown_1.stringify)(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]);
+    }
+}
+exports.GeometryHelper = GeometryHelper;

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

@@ -0,0 +1,8 @@
+import { Knex } from 'knex';
+import * as dateHelpers from './date';
+import * as geometryHelpers from './geometry';
+export declare function getHelpers(database: Knex): {
+    date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.sqlite | dateHelpers.mysql | dateHelpers.mssql;
+    st: geometryHelpers.postgres | geometryHelpers.redshift | geometryHelpers.oracle | geometryHelpers.sqlite | geometryHelpers.mysql | geometryHelpers.mssql;
+};
+export declare type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHelpers = void 0;
+const __1 = require("..");
+const dateHelpers = __importStar(require("./date"));
+const geometryHelpers = __importStar(require("./geometry"));
+function getHelpers(database) {
+    const client = (0, __1.getDatabaseClient)(database);
+    return {
+        date: new dateHelpers[client](database),
+        st: new geometryHelpers[client](database),
+    };
+}
+exports.getHelpers = getHelpers;

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

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

package/dist/database/helpers/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelper = void 0;
+class DatabaseHelper {
+    constructor(knex) {
+        this.knex = knex;
+    }
+}
+exports.DatabaseHelper = DatabaseHelper;

package/dist/database/index.js

@@ -15,7 +15,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const lodash_1 = require("lodash");
 const util_1 = require("util");
-const geometry_1 = require("./helpers/geometry");
+const helpers_1 = require("./helpers");
 let database = null;
 let inspector = null;
 function getDatabase() {
@@ -197,11 +197,11 @@ exports.validateMigrations = validateMigrations;
  */
 async function validateDatabaseExtensions() {
     const database = getDatabase();
-    const databaseClient = getDatabaseClient(database);
-    const geometryHelper = (0, geometry_1.getGeometryHelper)(database);
-    const geometrySupport = await geometryHelper.supported();
+    const client = getDatabaseClient(database);
+    const helpers = (0, helpers_1.getHelpers)(database);
+    const geometrySupport = await helpers.st.supported();
     if (!geometrySupport) {
-        switch (databaseClient) {
+        switch (client) {
             case 'postgres':
                 logger_1.default.warn(`PostGIS isn't installed. Geometry type support will be limited.`);
                 break;
@@ -209,7 +209,7 @@ async function validateDatabaseExtensions() {
                 logger_1.default.warn(`Spatialite isn't installed. Geometry type support will be limited.`);
                 break;
             default:
-                logger_1.default.warn(`Geometry type not supported on ${databaseClient}`);
+                logger_1.default.warn(`Geometry type not supported on ${client}`);
         }
     }
 }

package/dist/database/migrations/20211118A-add-notifications.d.ts

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

package/dist/database/migrations/20211118A-add-notifications.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+async function up(knex) {
+    await knex.schema.createTable('directus_notifications', (table) => {
+        table.increments();
+        table.timestamp('timestamp').notNullable();
+        table.string('status').defaultTo('inbox');
+        table.uuid('recipient').notNullable().references('id').inTable('directus_users').onDelete('CASCADE');
+        table.uuid('sender').notNullable().references('id').inTable('directus_users');
+        table.string('subject').notNullable();
+        table.text('message');
+        table.string('collection', 64);
+        table.string('item');
+    });
+    await knex.schema.alterTable('directus_users', (table) => {
+        table.boolean('email_notifications').defaultTo(true);
+    });
+    await knex('directus_users').update({ email_notifications: true });
+}
+exports.up = up;
+async function down(knex) {
+    await knex.schema.dropTable('directus_notifications');
+    await knex.schema.alterTable('directus_users', (table) => {
+        table.dropColumn('email_notifications');
+    });
+}
+exports.down = down;

package/dist/database/run-ast.js

@@ -10,14 +10,14 @@ const apply_query_1 = __importDefault(require("../utils/apply-query"));
 const get_column_1 = require("../utils/get-column");
 const strip_function_1 = require("../utils/strip-function");
 const utils_1 = require("@directus/shared/utils");
-const index_1 = __importDefault(require("./index"));
-const geometry_1 = require("../database/helpers/geometry");
+const _1 = __importDefault(require("."));
+const helpers_1 = require("../database/helpers");
 /**
  * Execute a given AST using Knex. Returns array of items based on requested AST.
  */
 async function runAST(originalAST, schema, options) {
     const ast = (0, lodash_1.cloneDeep)(originalAST);
-    const knex = (options === null || options === void 0 ? void 0 : options.knex) || (0, index_1.default)();
+    const knex = (options === null || options === void 0 ? void 0 : options.knex) || (0, _1.default)();
     if (ast.type === 'm2a') {
         const results = {};
         for (const collection of ast.names) {
@@ -111,7 +111,7 @@ async function parseCurrentLevel(schema, collection, children, query) {
     return { fieldNodes, nestedCollectionNodes, primaryKeyField };
 }
 function getColumnPreprocessor(knex, schema, table) {
-    const helper = (0, geometry_1.getGeometryHelper)();
+    const helpers = (0, helpers_1.getHelpers)(knex);
     return function (fieldNode) {
         let field;
         if (fieldNode.type === 'field') {
@@ -125,7 +125,7 @@ function getColumnPreprocessor(knex, schema, table) {
             alias = fieldNode.fieldKey;
         }
         if (field.type.startsWith('geometry')) {
-            return helper.asText(table, field.field);
+            return helpers.st.asText(table, field.field);
         }
         return (0, get_column_1.getColumn)(knex, table, fieldNode.name, alias);
     };

package/dist/database/seeds/run.js

@@ -7,8 +7,9 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const lodash_1 = require("lodash");
 const path_1 = __importDefault(require("path"));
-const geometry_1 = require("../helpers/geometry");
+const helpers_1 = require("../helpers");
 async function runSeed(database) {
+    const helpers = (0, helpers_1.getHelpers)(database);
     const exists = await database.schema.hasTable('directus_collections');
     if (exists) {
         throw new Error('Database is already installed');
@@ -38,8 +39,7 @@ async function runSeed(database) {
                     column = tableBuilder.string(columnName, 255);
                 }
                 else if ((_a = columnInfo.type) === null || _a === void 0 ? void 0 : _a.startsWith('geometry')) {
-                    const helper = (0, geometry_1.getGeometryHelper)();
-                    column = helper.createColumn(tableBuilder, { field: columnName, type: columnInfo.type });
+                    column = helpers.st.createColumn(tableBuilder, { field: columnName, type: columnInfo.type });
                 }
                 else {
                     // @ts-ignore

package/dist/database/system-data/app-access-permissions/app-access-permissions.yaml

@@ -72,6 +72,20 @@
 - collection: directus_settings
   action: read
 
+- collection: directus_notifications
+  action: read
+  permissions:
+    recipient:
+      _eq: $CURRENT_USER
+  fields: '*'
+
+- collection: directus_notifications
+  action: update
+  permissions:
+    recipient:
+      _eq: $CURRENT_USER
+  fields: 'status'
+
 - collection: directus_users
   action: read
   permissions:

package/dist/database/system-data/collections/collections.yaml

@@ -63,3 +63,5 @@ data:
     note: $t:directus_collection.directus_dashboards
   - collection: directus_panels
     note: $t:directus_collection.directus_panels
+  - collection: directus_notifications
+    note: $t:directus_collection.directus_notifications

package/dist/database/system-data/fields/notifications.yaml

@@ -0,0 +1,13 @@
+table: directus_notifications
+
+fields:
+  - field: id
+  - field: timestamp
+    special: date-created
+  - field: status
+  - field: recipient
+  - field: sender
+  - field: subject
+  - field: message
+  - field: collection
+  - field: item