directus 9.1.2 → 9.3.0

package/dist/database/{functions → helpers/date}/dialects/mssql.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HelperMSSQL = void 0;
-class HelperMSSQL {
-    constructor(knex) {
-        this.knex = knex;
-    }
+exports.DateHelperMSSQL = void 0;
+const types_1 = require("../types");
+class DateHelperMSSQL extends types_1.DateHelper {
     year(table, column) {
         return this.knex.raw('DATEPART(year, ??.??)', [table, column]);
     }
@@ -30,4 +28,4 @@ class HelperMSSQL {
         return this.knex.raw('DATEPART(second, ??.??)', [table, column]);
     }
 }
-exports.HelperMSSQL = HelperMSSQL;
+exports.DateHelperMSSQL = DateHelperMSSQL;

package/dist/database/{functions → helpers/date}/dialects/mysql.d.ts

@@ -1,8 +1,6 @@
+import { DateHelper } from '../types';
 import { Knex } from 'knex';
-import { HelperFn } from '../types';
-export declare class HelperMySQL implements HelperFn {
-    private knex;
-    constructor(knex: Knex);
+export declare class DateHelperMySQL extends DateHelper {
     year(table: string, column: string): Knex.Raw;
     month(table: string, column: string): Knex.Raw;
     week(table: string, column: string): Knex.Raw;

package/dist/database/{functions → helpers/date}/dialects/mysql.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HelperMySQL = void 0;
-class HelperMySQL {
-    constructor(knex) {
-        this.knex = knex;
-    }
+exports.DateHelperMySQL = void 0;
+const types_1 = require("../types");
+class DateHelperMySQL extends types_1.DateHelper {
     year(table, column) {
         return this.knex.raw('YEAR(??.??)', [table, column]);
     }
@@ -30,4 +28,4 @@ class HelperMySQL {
         return this.knex.raw('SECOND(??.??)', [table, column]);
     }
 }
-exports.HelperMySQL = HelperMySQL;
+exports.DateHelperMySQL = DateHelperMySQL;

package/dist/database/{functions/dialects/mssql.d.ts → helpers/date/dialects/oracle.d.ts}

@@ -1,8 +1,6 @@
+import { DateHelper } from '../types';
 import { Knex } from 'knex';
-import { HelperFn } from '../types';
-export declare class HelperMSSQL implements HelperFn {
-    private knex;
-    constructor(knex: Knex);
+export declare class DateHelperOracle extends DateHelper {
     year(table: string, column: string): Knex.Raw;
     month(table: string, column: string): Knex.Raw;
     week(table: string, column: string): Knex.Raw;

package/dist/database/{functions → helpers/date}/dialects/oracle.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HelperOracle = void 0;
-class HelperOracle {
-    constructor(knex) {
-        this.knex = knex;
-    }
+exports.DateHelperOracle = void 0;
+const types_1 = require("../types");
+class DateHelperOracle extends types_1.DateHelper {
     year(table, column) {
         return this.knex.raw("TO_CHAR(??.??, 'IYYY')", [table, column]);
     }
@@ -30,4 +28,4 @@ class HelperOracle {
         return this.knex.raw("TO_CHAR(??.??, 'SS')", [table, column]);
     }
 }
-exports.HelperOracle = HelperOracle;
+exports.DateHelperOracle = DateHelperOracle;

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

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

package/dist/database/{functions → helpers/date}/dialects/postgres.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HelperPostgres = void 0;
-class HelperPostgres {
-    constructor(knex) {
-        this.knex = knex;
-    }
+exports.DateHelperPostgres = void 0;
+const types_1 = require("../types");
+class DateHelperPostgres extends types_1.DateHelper {
     year(table, column) {
         return this.knex.raw('EXTRACT(YEAR FROM ??.??)', [table, column]);
     }
@@ -30,4 +28,4 @@ class HelperPostgres {
         return this.knex.raw('EXTRACT(SECOND FROM ??.??)', [table, column]);
     }
 }
-exports.HelperPostgres = HelperPostgres;
+exports.DateHelperPostgres = DateHelperPostgres;

package/dist/database/{functions → helpers/date}/dialects/sqlite.d.ts

@@ -1,8 +1,6 @@
+import { DateHelper } from '../types';
 import { Knex } from 'knex';
-import { HelperFn } from '../types';
-export declare class HelperSQLite implements HelperFn {
-    private knex;
-    constructor(knex: Knex);
+export declare class DateHelperSQLite extends DateHelper {
     year(table: string, column: string): Knex.Raw;
     month(table: string, column: string): Knex.Raw;
     week(table: string, column: string): Knex.Raw;
@@ -11,4 +9,5 @@ export declare class HelperSQLite implements HelperFn {
     hour(table: string, column: string): Knex.Raw;
     minute(table: string, column: string): Knex.Raw;
     second(table: string, column: string): Knex.Raw;
+    parse(date: string): string;
 }

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;