@yandjin-mikro-orm/sqlite 6.1.4-rc-sti-changes-1

package/SqliteMikroORM.d.ts

@@ -0,0 +1,19 @@
+import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from "@yandjin-mikro-orm/core";
+import { SqliteDriver } from "./SqliteDriver";
+import type { SqlEntityManager } from "@yandjin-mikro-orm/knex";
+/**
+ * @inheritDoc
+ */
+export declare class SqliteMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<SqliteDriver, EM> {
+    private static DRIVER;
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = SqliteDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    /**
+     * @inheritDoc
+     */
+    static initSync<D extends IDatabaseDriver = SqliteDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+}
+export type SqliteOptions = Options<SqliteDriver>;
+export declare function defineSqliteConfig(options: SqliteOptions): Options<SqliteDriver, SqlEntityManager<SqliteDriver> & EntityManager<IDatabaseDriver<import("@yandjin-mikro-orm/core").Connection>>>;

package/SqliteMikroORM.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineSqliteConfig = exports.SqliteMikroORM = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const SqliteDriver_1 = require("./SqliteDriver");
+/**
+ * @inheritDoc
+ */
+class SqliteMikroORM extends core_1.MikroORM {
+    static DRIVER = SqliteDriver_1.SqliteDriver;
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    static initSync(options) {
+        return super.initSync(options);
+    }
+}
+exports.SqliteMikroORM = SqliteMikroORM;
+/* istanbul ignore next */
+function defineSqliteConfig(options) {
+    return (0, core_1.defineConfig)({ driver: SqliteDriver_1.SqliteDriver, ...options });
+}
+exports.defineSqliteConfig = defineSqliteConfig;

package/SqlitePlatform.d.ts

@@ -0,0 +1,56 @@
+import { type EntityProperty } from "@yandjin-mikro-orm/core";
+import { AbstractSqlPlatform } from "@yandjin-mikro-orm/knex";
+import { SqliteSchemaHelper } from "./SqliteSchemaHelper";
+import { SqliteExceptionConverter } from "./SqliteExceptionConverter";
+export declare class SqlitePlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: SqliteSchemaHelper;
+    protected readonly exceptionConverter: SqliteExceptionConverter;
+    usesDefaultKeyword(): boolean;
+    usesReturningStatement(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length: number;
+    }): string;
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getFloatDeclarationSQL(): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    convertsJsonAutomatically(): boolean;
+    allowsComparingTuples(): boolean;
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value: unknown): string | number | Date;
+    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    quoteValue(value: any): string;
+    getIndexName(tableName: string, columns: string[], type: "index" | "unique" | "foreign" | "primary" | "sequence"): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsDownMigrations(): boolean;
+    getFullTextWhereClause(): string;
+}

package/SqlitePlatform.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlitePlatform = void 0;
+// @ts-ignore
+const sqlstring_sqlite_1 = require("sqlstring-sqlite");
+const core_1 = require("@yandjin-mikro-orm/core");
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const SqliteSchemaHelper_1 = require("./SqliteSchemaHelper");
+const SqliteExceptionConverter_1 = require("./SqliteExceptionConverter");
+class SqlitePlatform extends knex_1.AbstractSqlPlatform {
+    schemaHelper = new SqliteSchemaHelper_1.SqliteSchemaHelper(this);
+    exceptionConverter = new SqliteExceptionConverter_1.SqliteExceptionConverter();
+    usesDefaultKeyword() {
+        return false;
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return super.getCurrentTimestampSQL(0);
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        return "datetime";
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every((item) => core_1.Utils.isString(item))) {
+            return "text";
+        }
+        /* istanbul ignore next */
+        return this.getTinyIntTypeDeclarationSQL(column);
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getSmallIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        return "integer";
+    }
+    getFloatDeclarationSQL() {
+        return "real";
+    }
+    getBooleanTypeDeclarationSQL() {
+        return "integer";
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return "text";
+    }
+    convertsJsonAutomatically() {
+        return false;
+    }
+    allowsComparingTuples() {
+        return false;
+    }
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value) {
+        if (value instanceof Date) {
+            return +value;
+        }
+        return value;
+    }
+    quoteVersionValue(value, prop) {
+        if (prop.runtimeType === "Date") {
+            return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone).replace(/^'|\.\d{3}'$/g, "");
+        }
+        return value;
+    }
+    quoteValue(value) {
+        /* istanbul ignore if */
+        if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
+            return (0, sqlstring_sqlite_1.escape)(JSON.stringify(value), true, this.timezone);
+        }
+        if (value instanceof Date) {
+            return "" + +value;
+        }
+        return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone);
+    }
+    getIndexName(tableName, columns, type) {
+        if (type === "primary") {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        return super.getIndexName(tableName, columns, type);
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        return "primary";
+    }
+    supportsDownMigrations() {
+        return false;
+    }
+    getFullTextWhereClause() {
+        return `:column: match :query`;
+    }
+}
+exports.SqlitePlatform = SqlitePlatform;

package/SqliteSchemaHelper.d.ts

@@ -0,0 +1,23 @@
+import type { Connection, Dictionary } from "@yandjin-mikro-orm/core";
+import { SchemaHelper, type AbstractSqlConnection, type IndexDef, type CheckDef } from "@yandjin-mikro-orm/knex";
+export declare class SqliteSchemaHelper extends SchemaHelper {
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    supportsSchemaConstraints(): boolean;
+    getListTablesSQL(): string;
+    private parseTableDefinition;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<any[]>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName: string): Promise<Dictionary<string[]>>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<CheckDef[]>;
+    getForeignKeysSQL(tableName: string): string;
+    mapForeignKeys(fks: any[], tableName: string): Dictionary;
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(name: string): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name: string): boolean;
+}

package/SqliteSchemaHelper.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSchemaHelper = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+class SqliteSchemaHelper extends knex_1.SchemaHelper {
+    disableForeignKeysSQL() {
+        return "pragma foreign_keys = off;";
+    }
+    enableForeignKeysSQL() {
+        return "pragma foreign_keys = on;";
+    }
+    supportsSchemaConstraints() {
+        return false;
+    }
+    getListTablesSQL() {
+        return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
+            `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);
+    }
+    parseTableDefinition(sql, cols) {
+        const columns = {};
+        // extract all columns definitions
+        let columnsDef = sql
+            .replaceAll("\n", "")
+            .match(new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, "i"))?.[1];
+        /* istanbul ignore else */
+        if (columnsDef) {
+            for (let i = cols.length - 1; i >= 0; i--) {
+                const col = cols[i];
+                const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
+                const columnDef = columnsDef.match(new RegExp(re, "i"));
+                /* istanbul ignore else */
+                if (columnDef) {
+                    columns[col.name] = { name: col.name, definition: columnDef[1] };
+                    columnsDef = columnsDef.substring(0, columnDef.index);
+                }
+            }
+        }
+        return columns;
+    }
+    async getColumns(connection, tableName, schemaName) {
+        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ["table", tableName], "get");
+        const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
+        // there can be only one, so naive check like this should be enough
+        const hasAutoincrement = tableDefinition.sql
+            .toLowerCase()
+            .includes("autoincrement");
+        const columnDefinitions = this.parseTableDefinition(tableDefinition.sql, columns);
+        return columns.map((col) => {
+            const mappedType = connection.getPlatform().getMappedType(col.type);
+            let generated;
+            if (col.hidden > 1) {
+                const storage = col.hidden === 2 ? "virtual" : "stored";
+                const re = `(generated always)? as \\((.*)\\)( ${storage})?$`;
+                const match = columnDefinitions[col.name].definition.match(re);
+                if (match) {
+                    generated = `${match[2]} ${storage}`;
+                }
+            }
+            return {
+                name: col.name,
+                type: col.type,
+                default: col.dflt_value,
+                nullable: !col.notnull,
+                primary: !!col.pk,
+                mappedType,
+                unsigned: false,
+                autoincrement: !composite &&
+                    col.pk &&
+                    this.platform.isNumericColumn(mappedType) &&
+                    hasAutoincrement,
+                generated,
+            };
+        });
+    }
+    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ["table", tableName], "get");
+        const checkConstraints = [
+            ...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? []),
+        ];
+        return checkConstraints.reduce((o, item) => {
+            // check constraints are defined as (note that last closing paren is missing):
+            // `type` text check (`type` in ('local', 'global')
+            const match = item.match(/[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i);
+            /* istanbul ignore else */
+            if (match) {
+                o[match[1]] = match[2]
+                    .split(",")
+                    .map((item) => item.trim().match(/^\(?'(.*)'/)[1]);
+            }
+            return o;
+        }, {});
+    }
+    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        return cols.filter((col) => !!col.pk).map((col) => col.name);
+    }
+    async getIndexes(connection, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const ret = [];
+        for (const col of cols.filter((c) => c.pk)) {
+            ret.push({
+                columnNames: [col.name],
+                keyName: "primary",
+                constraint: true,
+                unique: true,
+                primary: true,
+            });
+        }
+        for (const index of indexes.filter((index) => !this.isImplicitIndex(index.name))) {
+            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            ret.push(...res.map((row) => ({
+                columnNames: [row.name],
+                keyName: index.name,
+                unique: !!index.unique,
+                constraint: !!index.unique,
+                primary: false,
+            })));
+        }
+        return this.mapIndexes(ret);
+    }
+    async getChecks(connection, tableName, schemaName) {
+        // Not supported at the moment.
+        return [];
+    }
+    getForeignKeysSQL(tableName) {
+        return `pragma foreign_key_list(\`${tableName}\`)`;
+    }
+    mapForeignKeys(fks, tableName) {
+        return fks.reduce((ret, fk) => {
+            ret[fk.from] = {
+                constraintName: this.platform.getIndexName(tableName, [fk.from], "foreign"),
+                columnName: fk.from,
+                columnNames: [fk.from],
+                localTableName: tableName,
+                referencedTableName: fk.table,
+                referencedColumnName: fk.to,
+                referencedColumnNames: [fk.to],
+                updateRule: fk.on_update.toLowerCase(),
+                deleteRule: fk.on_delete.toLowerCase(),
+            };
+            return ret;
+        }, {});
+    }
+    getManagementDbName() {
+        return "";
+    }
+    getCreateDatabaseSQL(name) {
+        return "";
+    }
+    async databaseExists(connection, name) {
+        const tables = await connection.execute(this.getListTablesSQL());
+        return tables.length > 0;
+    }
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name) {
+        // Ignore indexes with reserved names, e.g. autoindexes
+        return name.startsWith("sqlite_");
+    }
+}
+exports.SqliteSchemaHelper = SqliteSchemaHelper;

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from "@yandjin-mikro-orm/knex";
+export * from "./SqliteConnection";
+export * from "./SqliteDriver";
+export * from "./SqlitePlatform";
+export * from "./SqliteSchemaHelper";
+export * from "./SqliteExceptionConverter";
+export { SqliteMikroORM as MikroORM, SqliteOptions as Options, defineSqliteConfig as defineConfig, } from "./SqliteMikroORM";

package/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = exports.MikroORM = void 0;
+__exportStar(require("@yandjin-mikro-orm/knex"), exports);
+__exportStar(require("./SqliteConnection"), exports);
+__exportStar(require("./SqliteDriver"), exports);
+__exportStar(require("./SqlitePlatform"), exports);
+__exportStar(require("./SqliteSchemaHelper"), exports);
+__exportStar(require("./SqliteExceptionConverter"), exports);
+var SqliteMikroORM_1 = require("./SqliteMikroORM");
+Object.defineProperty(exports, "MikroORM", { enumerable: true, get: function () { return SqliteMikroORM_1.SqliteMikroORM; } });
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return SqliteMikroORM_1.defineSqliteConfig; } });

package/index.mjs

@@ -0,0 +1,220 @@
+import mod from "./index.js";
+
+export default mod;
+export const ALIAS_REPLACEMENT = mod.ALIAS_REPLACEMENT;
+export const ALIAS_REPLACEMENT_RE = mod.ALIAS_REPLACEMENT_RE;
+export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
+export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
+export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
+export const AbstractSqlConnection = mod.AbstractSqlConnection;
+export const AbstractSqlDriver = mod.AbstractSqlDriver;
+export const AbstractSqlPlatform = mod.AbstractSqlPlatform;
+export const AfterCreate = mod.AfterCreate;
+export const AfterDelete = mod.AfterDelete;
+export const AfterUpdate = mod.AfterUpdate;
+export const AfterUpsert = mod.AfterUpsert;
+export const ArrayCollection = mod.ArrayCollection;
+export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
+export const ArrayType = mod.ArrayType;
+export const BaseEntity = mod.BaseEntity;
+export const BeforeCreate = mod.BeforeCreate;
+export const BeforeDelete = mod.BeforeDelete;
+export const BeforeUpdate = mod.BeforeUpdate;
+export const BeforeUpsert = mod.BeforeUpsert;
+export const BigIntType = mod.BigIntType;
+export const BlobType = mod.BlobType;
+export const BooleanType = mod.BooleanType;
+export const Cascade = mod.Cascade;
+export const ChangeSet = mod.ChangeSet;
+export const ChangeSetComputer = mod.ChangeSetComputer;
+export const ChangeSetPersister = mod.ChangeSetPersister;
+export const ChangeSetType = mod.ChangeSetType;
+export const Check = mod.Check;
+export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
+export const Collection = mod.Collection;
+export const CommitOrderCalculator = mod.CommitOrderCalculator;
+export const Config = mod.Config;
+export const Configuration = mod.Configuration;
+export const ConfigurationLoader = mod.ConfigurationLoader;
+export const Connection = mod.Connection;
+export const ConnectionException = mod.ConnectionException;
+export const ConstraintViolationException = mod.ConstraintViolationException;
+export const CreateRequestContext = mod.CreateRequestContext;
+export const CriteriaNode = mod.CriteriaNode;
+export const CriteriaNodeFactory = mod.CriteriaNodeFactory;
+export const Cursor = mod.Cursor;
+export const CursorError = mod.CursorError;
+export const DatabaseDriver = mod.DatabaseDriver;
+export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
+export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
+export const DatabaseSchema = mod.DatabaseSchema;
+export const DatabaseTable = mod.DatabaseTable;
+export const DataloaderType = mod.DataloaderType;
+export const DataloaderUtils = mod.DataloaderUtils;
+export const DateTimeType = mod.DateTimeType;
+export const DateType = mod.DateType;
+export const DeadlockException = mod.DeadlockException;
+export const DecimalType = mod.DecimalType;
+export const DefaultLogger = mod.DefaultLogger;
+export const DoubleType = mod.DoubleType;
+export const DriverException = mod.DriverException;
+export const EagerProps = mod.EagerProps;
+export const Embeddable = mod.Embeddable;
+export const Embedded = mod.Embedded;
+export const EnsureRequestContext = mod.EnsureRequestContext;
+export const Entity = mod.Entity;
+export const EntityAssigner = mod.EntityAssigner;
+export const EntityCaseNamingStrategy = mod.EntityCaseNamingStrategy;
+export const EntityComparator = mod.EntityComparator;
+export const EntityFactory = mod.EntityFactory;
+export const EntityHelper = mod.EntityHelper;
+export const EntityIdentifier = mod.EntityIdentifier;
+export const EntityLoader = mod.EntityLoader;
+export const EntityManager = mod.EntityManager;
+export const EntityManagerType = mod.EntityManagerType;
+export const EntityMetadata = mod.EntityMetadata;
+export const EntityRepository = mod.EntityRepository;
+export const EntityRepositoryType = mod.EntityRepositoryType;
+export const EntitySchema = mod.EntitySchema;
+export const EntitySerializer = mod.EntitySerializer;
+export const EntityTransformer = mod.EntityTransformer;
+export const EntityValidator = mod.EntityValidator;
+export const Enum = mod.Enum;
+export const EnumArrayType = mod.EnumArrayType;
+export const EnumType = mod.EnumType;
+export const EventManager = mod.EventManager;
+export const EventType = mod.EventType;
+export const EventTypeMap = mod.EventTypeMap;
+export const ExceptionConverter = mod.ExceptionConverter;
+export const FileCacheAdapter = mod.FileCacheAdapter;
+export const Filter = mod.Filter;
+export const FloatType = mod.FloatType;
+export const FlushMode = mod.FlushMode;
+export const ForeignKeyConstraintViolationException = mod.ForeignKeyConstraintViolationException;
+export const Formula = mod.Formula;
+export const GeneratedCacheAdapter = mod.GeneratedCacheAdapter;
+export const GroupOperator = mod.GroupOperator;
+export const HiddenProps = mod.HiddenProps;
+export const Hydrator = mod.Hydrator;
+export const IdentityMap = mod.IdentityMap;
+export const Index = mod.Index;
+export const IntegerType = mod.IntegerType;
+export const IntervalType = mod.IntervalType;
+export const InvalidFieldNameException = mod.InvalidFieldNameException;
+export const IsolationLevel = mod.IsolationLevel;
+export const JoinType = mod.JoinType;
+export const JsonProperty = mod.JsonProperty;
+export const JsonType = mod.JsonType;
+export const Knex = mod.Knex;
+export const LoadStrategy = mod.LoadStrategy;
+export const LockMode = mod.LockMode;
+export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
+export const ManyToMany = mod.ManyToMany;
+export const ManyToOne = mod.ManyToOne;
+export const MediumIntType = mod.MediumIntType;
+export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
+export const MetadataDiscovery = mod.MetadataDiscovery;
+export const MetadataError = mod.MetadataError;
+export const MetadataProvider = mod.MetadataProvider;
+export const MetadataStorage = mod.MetadataStorage;
+export const MetadataValidator = mod.MetadataValidator;
+export const MikroORM = mod.MikroORM;
+export const MongoNamingStrategy = mod.MongoNamingStrategy;
+export const MonkeyPatchable = mod.MonkeyPatchable;
+export const NodeState = mod.NodeState;
+export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
+export const NotFoundError = mod.NotFoundError;
+export const NotNullConstraintViolationException = mod.NotNullConstraintViolationException;
+export const NullCacheAdapter = mod.NullCacheAdapter;
+export const NullHighlighter = mod.NullHighlighter;
+export const ObjectBindingPattern = mod.ObjectBindingPattern;
+export const ObjectCriteriaNode = mod.ObjectCriteriaNode;
+export const ObjectHydrator = mod.ObjectHydrator;
+export const OnInit = mod.OnInit;
+export const OnLoad = mod.OnLoad;
+export const OneToMany = mod.OneToMany;
+export const OneToOne = mod.OneToOne;
+export const OptimisticLockError = mod.OptimisticLockError;
+export const OptionalProps = mod.OptionalProps;
+export const PlainObject = mod.PlainObject;
+export const Platform = mod.Platform;
+export const PopulateHint = mod.PopulateHint;
+export const PrimaryKey = mod.PrimaryKey;
+export const PrimaryKeyProp = mod.PrimaryKeyProp;
+export const Property = mod.Property;
+export const QueryBuilder = mod.QueryBuilder;
+export const QueryBuilderHelper = mod.QueryBuilderHelper;
+export const QueryFlag = mod.QueryFlag;
+export const QueryHelper = mod.QueryHelper;
+export const QueryOperator = mod.QueryOperator;
+export const QueryOrder = mod.QueryOrder;
+export const QueryOrderNumeric = mod.QueryOrderNumeric;
+export const QueryType = mod.QueryType;
+export const RawQueryFragment = mod.RawQueryFragment;
+export const ReadOnlyException = mod.ReadOnlyException;
+export const Ref = mod.Ref;
+export const Reference = mod.Reference;
+export const ReferenceKind = mod.ReferenceKind;
+export const ReflectMetadataProvider = mod.ReflectMetadataProvider;
+export const RequestContext = mod.RequestContext;
+export const SCALAR_TYPES = mod.SCALAR_TYPES;
+export const ScalarCriteriaNode = mod.ScalarCriteriaNode;
+export const ScalarReference = mod.ScalarReference;
+export const SchemaComparator = mod.SchemaComparator;
+export const SchemaGenerator = mod.SchemaGenerator;
+export const SchemaHelper = mod.SchemaHelper;
+export const SerializationContext = mod.SerializationContext;
+export const SerializedPrimaryKey = mod.SerializedPrimaryKey;
+export const ServerException = mod.ServerException;
+export const SimpleLogger = mod.SimpleLogger;
+export const SmallIntType = mod.SmallIntType;
+export const SqlEntityManager = mod.SqlEntityManager;
+export const SqlEntityRepository = mod.SqlEntityRepository;
+export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
+export const SqliteConnection = mod.SqliteConnection;
+export const SqliteDriver = mod.SqliteDriver;
+export const SqliteExceptionConverter = mod.SqliteExceptionConverter;
+export const SqlitePlatform = mod.SqlitePlatform;
+export const SqliteSchemaHelper = mod.SqliteSchemaHelper;
+export const StringType = mod.StringType;
+export const SyntaxErrorException = mod.SyntaxErrorException;
+export const TableExistsException = mod.TableExistsException;
+export const TableNotFoundException = mod.TableNotFoundException;
+export const TextType = mod.TextType;
+export const TimeType = mod.TimeType;
+export const TinyIntType = mod.TinyIntType;
+export const TransactionContext = mod.TransactionContext;
+export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Type = mod.Type;
+export const Uint8ArrayType = mod.Uint8ArrayType;
+export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;
+export const Unique = mod.Unique;
+export const UniqueConstraintViolationException = mod.UniqueConstraintViolationException;
+export const UnitOfWork = mod.UnitOfWork;
+export const UnknownType = mod.UnknownType;
+export const Utils = mod.Utils;
+export const UuidType = mod.UuidType;
+export const ValidationError = mod.ValidationError;
+export const WrappedEntity = mod.WrappedEntity;
+export const assign = mod.assign;
+export const colors = mod.colors;
+export const compareArrays = mod.compareArrays;
+export const compareBooleans = mod.compareBooleans;
+export const compareBuffers = mod.compareBuffers;
+export const compareObjects = mod.compareObjects;
+export const createSqlFunction = mod.createSqlFunction;
+export const defineConfig = mod.defineConfig;
+export const equals = mod.equals;
+export const getOnConflictFields = mod.getOnConflictFields;
+export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
+export const helper = mod.helper;
+export const knex = mod.knex;
+export const parseJsonSafe = mod.parseJsonSafe;
+export const raw = mod.raw;
+export const ref = mod.ref;
+export const rel = mod.rel;
+export const serialize = mod.serialize;
+export const sql = mod.sql;
+export const t = mod.t;
+export const types = mod.types;
+export const wrap = mod.wrap;