@mikro-orm/core 6.2.10-dev.9 → 6.2.10-dev.91

package/index.mjs

@@ -25,6 +25,7 @@ export const ChangeSet = mod.ChangeSet;
 export const ChangeSetComputer = mod.ChangeSetComputer;
 export const ChangeSetPersister = mod.ChangeSetPersister;
 export const ChangeSetType = mod.ChangeSetType;
+export const CharacterType = mod.CharacterType;
 export const Check = mod.Check;
 export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
 export const Collection = mod.Collection;

package/metadata/MetadataDiscovery.js

@@ -109,7 +109,7 @@ class MetadataDiscovery {
                 }
             }
         }
-        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initIndexes(prop)));
+        filtered.forEach(meta => Object.values(meta.properties).forEach(prop => this.initIndexes(meta, prop)));
         filtered.forEach(meta => this.autoWireBidirectionalProperties(meta));
         filtered.forEach(meta => this.findReferencingProperties(meta, filtered));
         for (const meta of filtered) {
@@ -1147,7 +1147,8 @@ class MetadataDiscovery {
                 && !SCALAR_TYPES.includes(prop.type)
                 // or it might be inferred via ts-morph to some generic type alias
                 && !prop.type.match(/[<>:"';{}]/)) {
-                prop.columnTypes = [prop.type];
+                const type = prop.length != null && !prop.type.endsWith(`(${prop.length})`) ? `${prop.type}(${prop.length})` : prop.type;
+                prop.columnTypes = [type];
             }
             else {
                 prop.columnTypes = [mappedType.getColumnType(prop, this.platform)];
@@ -1204,8 +1205,9 @@ class MetadataDiscovery {
         }
         prop.unsigned ??= (prop.primary || prop.unsigned) && this.isNumericProperty(prop) && this.platform.supportsUnsigned();
     }
-    initIndexes(prop) {
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && this.platform.indexForeignKeys()) {
+    initIndexes(meta, prop) {
+        const hasIndex = meta.indexes.some(idx => idx.properties?.length === 1 && idx.properties[0] === prop.name);
+        if (prop.kind === enums_1.ReferenceKind.MANY_TO_ONE && this.platform.indexForeignKeys() && !hasIndex) {
             prop.index ??= true;
         }
     }

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -1,4 +1,5 @@
 import type { NamingStrategy } from './NamingStrategy';
+import { type ReferenceKind } from '../enums';
 export declare abstract class AbstractNamingStrategy implements NamingStrategy {
     getClassName(file: string, separator?: string): string;
     classToMigrationName(timestamp: string, customMigrationName?: string): string;
@@ -8,7 +9,19 @@ export declare abstract class AbstractNamingStrategy implements NamingStrategy {
      */
     getEntityName(tableName: string, schemaName?: string): string;
     columnNameToProperty(columnName: string): string;
+    /**
+     * @inheritDoc
+     */
+    getEnumClassName(columnName: string, tableName: string, schemaName?: string): string;
+    /**
+     * @inheritDoc
+     */
+    enumValueToEnumProperty(enumValue: string, columnName: string, tableName: string, schemaName?: string): string;
     aliasName(entityName: string, index: number): string;
+    /**
+     * @inheritDoc
+     */
+    inverseSideName(entityName: string, propertyName: string, kind: ReferenceKind): string;
     abstract classToTableName(entityName: string): string;
     abstract joinColumnName(propertyName: string): string;
     abstract joinKeyColumnName(entityName: string, referencedColumnName?: string): string;

package/naming-strategy/AbstractNamingStrategy.js

@@ -47,9 +47,34 @@ class AbstractNamingStrategy {
         }
         return propName;
     }
+    /**
+     * @inheritDoc
+     */
+    getEnumClassName(columnName, tableName, schemaName) {
+        return this.getEntityName(`${tableName}_${columnName}`, schemaName);
+    }
+    /**
+     * @inheritDoc
+     */
+    enumValueToEnumProperty(enumValue, columnName, tableName, schemaName) {
+        return enumValue.toUpperCase();
+    }
     aliasName(entityName, index) {
         // Take only the first letter of the prefix to keep character counts down since some engines have character limits
         return entityName.charAt(0).toLowerCase() + index;
     }
+    /**
+     * @inheritDoc
+     */
+    inverseSideName(entityName, propertyName, kind) {
+        if (kind === 'm:n') {
+            return propertyName + 'Inverse';
+        }
+        const suffix = kind === '1:m' && !entityName.endsWith('Collection') ? 'Collection' : '';
+        if (entityName.length === 1) {
+            return entityName[0].toLowerCase() + suffix;
+        }
+        return entityName[0].toLowerCase() + entityName.substring(1) + suffix;
+    }
 }
 exports.AbstractNamingStrategy = AbstractNamingStrategy;

package/naming-strategy/NamingStrategy.d.ts

@@ -1,3 +1,4 @@
+import type { ReferenceKind } from '../enums';
 export interface NamingStrategy {
     /**
      * Return a name of the class based on its file name
@@ -15,6 +16,27 @@ export interface NamingStrategy {
      * Return a column name for a property
      */
     propertyToColumnName(propertyName: string, object?: boolean): string;
+    /**
+     * Get an enum class name.
+     *
+     * @param columnName The column name which has the enum.
+     * @param tableName The table name of the column.
+     * @param schemaName The schema name of the column.
+     *
+     * @return A new class name that will be used for the enum.
+     */
+    getEnumClassName(columnName: string, tableName: string, schemaName?: string): string;
+    /**
+     * Get an enum option name for a given enum value.
+     *
+     * @param enumValue The enum value to generate a name for.
+     * @param columnName The column name which has the enum.
+     * @param tableName The table name of the column.
+     * @param schemaName The schema name of the column.
+     *
+     * @return The name of the enum property that will hold the value.
+     */
+    enumValueToEnumProperty(enumValue: string, columnName: string, tableName: string, schemaName?: string): string;
     /**
      * Return a name of the entity class based on database table name (used in `EntityGenerator`).
      * Default implementation ignores the schema name.
@@ -41,7 +63,7 @@ export interface NamingStrategy {
      */
     joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
     /**
-     * Returns key/constraint name for given type. Some drivers might not support all the types (e.g. mysql and sqlite enforce the PK name).
+     * Returns key/constraint name for the given type. Some drivers might not support all the types (e.g. mysql and sqlite enforce the PK name).
      */
     indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check'): string;
     /**
@@ -49,4 +71,8 @@ export interface NamingStrategy {
      * ensured via appended index parameter. It is optional to use it as long as you ensure it will be unique.
      */
     aliasName(entityName: string, index: number): string;
+    /**
+     * Returns the name of the inverse side property. Used in the `EntityGenerator` with `bidirectionalRelations` option.
+     */
+    inverseSideName(entityName: string, propertyName: string, kind: ReferenceKind): string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.2.10-dev.9",
+  "version": "6.2.10-dev.91",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.2.10-dev.9",
+    "mikro-orm": "6.2.10-dev.91",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -58,6 +58,8 @@ export declare abstract class Platform {
         length?: number;
     }): string;
     getDefaultDateTimeLength(): number;
+    getDefaultVarcharLength(): number;
+    getDefaultCharLength(): number;
     getDateTypeDeclarationSQL(length?: number): string;
     getTimeTypeDeclarationSQL(length?: number): string;
     getRegExpOperator(val?: unknown, flags?: string): string;
@@ -69,7 +71,6 @@ export declare abstract class Platform {
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
     getDefaultVersionLength(): number;
     allowsComparingTuples(): boolean;
-    allowsUniqueBatchUpdates(): boolean;
     isBigIntProperty(prop: EntityProperty): boolean;
     isRaw(value: any): boolean;
     getDefaultSchemaName(): string | undefined;
@@ -99,6 +100,9 @@ export declare abstract class Platform {
         unsigned?: boolean;
         autoincrement?: boolean;
     }): string;
+    getCharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;
@@ -144,7 +148,7 @@ export declare abstract class Platform {
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-    convertJsonToJSValue(value: unknown): unknown;
+    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;

package/platforms/Platform.js

@@ -96,6 +96,12 @@ class Platform {
     getDefaultDateTimeLength() {
         return 0;
     }
+    getDefaultVarcharLength() {
+        return 255;
+    }
+    getDefaultCharLength() {
+        return 1;
+    }
     getDateTypeDeclarationSQL(length) {
         return 'date' + (length ? `(${length})` : '');
     }
@@ -123,9 +129,6 @@ class Platform {
     allowsComparingTuples() {
         return true;
     }
-    allowsUniqueBatchUpdates() {
-        return true;
-    }
     isBigIntProperty(prop) {
         return prop.columnTypes && prop.columnTypes[0] === 'bigint';
     }
@@ -153,8 +156,11 @@ class Platform {
     getBigIntTypeDeclarationSQL(column) {
         return 'bigint';
     }
+    getCharTypeDeclarationSQL(column) {
+        return `char(${column.length ?? this.getDefaultCharLength()})`;
+    }
     getVarcharTypeDeclarationSQL(column) {
-        return `varchar(${column.length ?? 255})`;
+        return `varchar(${column.length ?? this.getDefaultVarcharLength()})`;
     }
     getIntervalTypeDeclarationSQL(column) {
         return 'interval' + (column.length ? `(${column.length})` : '');
@@ -195,6 +201,8 @@ class Platform {
             return types_1.Type.getType(types_1.ArrayType);
         }
         switch (this.extractSimpleType(type)) {
+            case 'character':
+            case 'char': return types_1.Type.getType(types_1.CharacterType);
             case 'string':
             case 'varchar': return types_1.Type.getType(types_1.StringType);
             case 'interval': return types_1.Type.getType(types_1.IntervalType);
@@ -274,7 +282,11 @@ class Platform {
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);
     }
-    convertJsonToJSValue(value) {
+    convertJsonToJSValue(value, prop) {
+        const isObjectEmbedded = prop.embedded && prop.object;
+        if ((this.convertsJsonAutomatically() || isObjectEmbedded) && ['json', 'jsonb', this.getJsonDeclarationSQL()].includes(prop.columnTypes[0])) {
+            return value;
+        }
         return (0, Utils_1.parseJsonSafe)(value);
     }
     convertDateToJSValue(value) {

package/serialization/EntitySerializer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serialize = exports.EntitySerializer = void 0;
+exports.EntitySerializer = void 0;
+exports.serialize = serialize;
 const wrap_1 = require("../entity/wrap");
 const Utils_1 = require("../utils/Utils");
 const enums_1 = require("../enums");
@@ -210,4 +211,3 @@ function serialize(entities, options) {
     }
     return EntitySerializer.serialize(entities, options);
 }
-exports.serialize = serialize;

package/serialization/SerializationContext.d.ts

@@ -5,7 +5,7 @@ import type { Configuration } from '../utils/Configuration';
  * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
-export declare class SerializationContext<T> {
+export declare class SerializationContext<T extends object> {
     private readonly config;
     private readonly populate;
     private readonly fields?;
@@ -23,7 +23,7 @@ export declare class SerializationContext<T> {
     /**
      * When initializing new context, we need to propagate it to the whole entity graph recursively.
      */
-    static propagate(root: SerializationContext<AnyEntity>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
+    static propagate(root: SerializationContext<any>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
     isMarkedAsPopulated(entityName: string, prop: string): boolean;
     isPartiallyLoaded(entityName: string, prop: string): boolean;
     private register;

package/types/BigIntType.d.ts

@@ -6,8 +6,8 @@ import type { EntityProperty } from '../typings';
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
  */
 export declare class BigIntType extends Type<string | bigint | number | null | undefined, string | null | undefined> {
-    mode?: "string" | "number" | "bigint" | undefined;
-    constructor(mode?: "string" | "number" | "bigint" | undefined);
+    mode?: ("bigint" | "number" | "string") | undefined;
+    constructor(mode?: ("bigint" | "number" | "string") | undefined);
     convertToDatabaseValue(value: string | bigint | null | undefined): string | null | undefined;
     convertToJSValue(value: string | bigint | null | undefined): bigint | number | string | null | undefined;
     toJSON(value: string | bigint | null | undefined): string | bigint | null | undefined;

package/types/BigIntType.js

@@ -29,7 +29,7 @@ class BigIntType extends Type_1.Type {
                 return String(value);
             case 'bigint':
             default:
-                return BigInt(value);
+                return BigInt(String(value));
         }
     }
     toJSON(value) {

package/types/BlobType.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Uint8ArrayType } from './Uint8ArrayType';
 import type { Platform } from '../platforms';
 import type { EntityProperty } from '../typings';

package/types/CharacterType.d.ts

@@ -0,0 +1,7 @@
+import { StringType } from './StringType';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class CharacterType extends StringType {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    getDefaultLength(platform: Platform): number;
+}

package/types/CharacterType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CharacterType = void 0;
+const StringType_1 = require("./StringType");
+class CharacterType extends StringType_1.StringType {
+    getColumnType(prop, platform) {
+        return platform.getCharTypeDeclarationSQL(prop);
+    }
+    getDefaultLength(platform) {
+        return platform.getDefaultCharLength();
+    }
+}
+exports.CharacterType = CharacterType;

package/types/DateTimeType.d.ts

@@ -6,4 +6,5 @@ export declare class DateTimeType extends Type<Date, string> {
     compareAsType(): string;
     get runtimeType(): string;
     ensureComparable(): boolean;
+    getDefaultLength(platform: Platform): number;
 }

package/types/DateTimeType.js

@@ -15,5 +15,8 @@ class DateTimeType extends Type_1.Type {
     ensureComparable() {
         return false;
     }
+    getDefaultLength(platform) {
+        return platform.getDefaultDateTimeLength();
+    }
 }
 exports.DateTimeType = DateTimeType;

package/types/DateType.d.ts

@@ -6,4 +6,5 @@ export declare class DateType extends Type<string | null | undefined, string | n
     ensureComparable(): boolean;
     convertToJSValue(value: any, platform: Platform): string | null | undefined;
     getColumnType(prop: EntityProperty, platform: Platform): string;
+    getDefaultLength(platform: Platform): number;
 }

package/types/DateType.js

@@ -15,5 +15,8 @@ class DateType extends Type_1.Type {
     getColumnType(prop, platform) {
         return platform.getDateTypeDeclarationSQL(prop.length);
     }
+    getDefaultLength(platform) {
+        return 0;
+    }
 }
 exports.DateType = DateType;

package/types/DecimalType.d.ts

@@ -5,8 +5,8 @@ import type { EntityProperty } from '../typings';
  * Type that maps an SQL DECIMAL to a JS string or number.
  */
 export declare class DecimalType extends Type<string | number, string> {
-    mode?: "string" | "number" | undefined;
-    constructor(mode?: "string" | "number" | undefined);
+    mode?: ("number" | "string") | undefined;
+    constructor(mode?: ("number" | "string") | undefined);
     convertToJSValue(value: string): number | string;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;

package/types/IntervalType.d.ts

@@ -5,4 +5,5 @@ export declare class IntervalType extends Type<string | null | undefined, string
     getColumnType(prop: EntityProperty, platform: Platform): string;
     convertToJSValue(value: string | null | undefined, platform: Platform): string | null | undefined;
     convertToDatabaseValue(value: string | null | undefined, platform: Platform): string | null | undefined;
+    getDefaultLength(platform: Platform): number;
 }

package/types/IntervalType.js

@@ -12,5 +12,8 @@ class IntervalType extends Type_1.Type {
     convertToDatabaseValue(value, platform) {
         return platform.convertIntervalToDatabaseValue(value);
     }
+    getDefaultLength(platform) {
+        return platform.getDefaultDateTimeLength();
+    }
 }
 exports.IntervalType = IntervalType;

package/types/JsonType.js

@@ -16,7 +16,7 @@ class JsonType extends Type_1.Type {
         return key + platform.castColumn(this.prop);
     }
     convertToJSValue(value, platform) {
-        return platform.convertJsonToJSValue(value);
+        return platform.convertJsonToJSValue(value, this.prop);
     }
     getColumnType(prop, platform) {
         return platform.getJsonDeclarationSQL();

package/types/StringType.d.ts

@@ -5,4 +5,5 @@ export declare class StringType extends Type<string | null | undefined, string |
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
     ensureComparable(): boolean;
+    getDefaultLength(platform: Platform): number;
 }

package/types/StringType.js

@@ -12,5 +12,8 @@ class StringType extends Type_1.Type {
     ensureComparable() {
         return false;
     }
+    getDefaultLength(platform) {
+        return platform.getDefaultVarcharLength();
+    }
 }
 exports.StringType = StringType;

package/types/TimeType.d.ts

@@ -6,4 +6,5 @@ export declare class TimeType extends Type {
     compareAsType(): string;
     ensureComparable(): boolean;
     getColumnType(prop: EntityProperty, platform: Platform): string;
+    getDefaultLength(platform: Platform): number;
 }

package/types/TimeType.js

@@ -19,5 +19,8 @@ class TimeType extends Type_1.Type {
     getColumnType(prop, platform) {
         return platform.getTimeTypeDeclarationSQL(prop.length);
     }
+    getDefaultLength(platform) {
+        return platform.getDefaultDateTimeLength();
+    }
 }
 exports.TimeType = TimeType;

package/types/Type.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import type { Platform } from '../platforms';
 import type { Constructor, EntityMetadata, EntityProperty } from '../typings';
@@ -59,7 +58,22 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
      * Gets the SQL declaration snippet for a field of this type.
      */
     getColumnType(prop: EntityProperty, platform: Platform): string;
-    static getType<JSType, DBType = JSType>(cls: Constructor<Type<JSType, DBType>>): Type<JSType, DBType>;
+    /**
+     * Get the default length for values of this type
+     *
+     * When doing schema generation, if neither "length" nor "columnType" option is provided,
+     * the length will be defaulted to this value.
+     *
+     * When doing entity generation, if the type is recognized to this type, and the inferred length is this value,
+     * the length option will be omitted in the output. If this method is not defined, length is always outputted
+     * based on what is in the database metadata.
+     *
+     * @param platform The platform the default will be used for.
+     *
+     * @return The default value for the given platform.
+     */
+    getDefaultLength?(platform: Platform): number;
+    static getType<JSType, DBType = JSType, TypeClass extends Constructor<Type<JSType, DBType>> = Constructor<Type<JSType, DBType>>>(cls: TypeClass): InstanceType<TypeClass>;
     /**
      * Checks whether the argument is instance of `Type`.
      */

package/types/Uint8ArrayType.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Type } from './Type';
 import type { Platform } from '../platforms';
 import type { EntityProperty } from '../typings';

package/types/index.d.ts

@@ -1,28 +1,29 @@
-import { Type, TransformContext, IType } from './Type';
-import { DateType } from './DateType';
-import { TimeType } from './TimeType';
-import { DateTimeType } from './DateTimeType';
+import { ArrayType } from './ArrayType';
 import { BigIntType } from './BigIntType';
 import { BlobType } from './BlobType';
-import { Uint8ArrayType } from './Uint8ArrayType';
-import { ArrayType } from './ArrayType';
+import { BooleanType } from './BooleanType';
+import { DateTimeType } from './DateTimeType';
+import { DateType } from './DateType';
+import { DecimalType } from './DecimalType';
+import { DoubleType } from './DoubleType';
 import { EnumArrayType } from './EnumArrayType';
 import { EnumType } from './EnumType';
-import { JsonType } from './JsonType';
+import { CharacterType } from './CharacterType';
+import { FloatType } from './FloatType';
 import { IntegerType } from './IntegerType';
-import { SmallIntType } from './SmallIntType';
-import { TinyIntType } from './TinyIntType';
+import { IntervalType } from './IntervalType';
+import { JsonType } from './JsonType';
 import { MediumIntType } from './MediumIntType';
-import { FloatType } from './FloatType';
-import { DoubleType } from './DoubleType';
-import { BooleanType } from './BooleanType';
-import { DecimalType } from './DecimalType';
+import { SmallIntType } from './SmallIntType';
 import { StringType } from './StringType';
-import { UuidType } from './UuidType';
 import { TextType } from './TextType';
-import { IntervalType } from './IntervalType';
+import { TimeType } from './TimeType';
+import { TinyIntType } from './TinyIntType';
+import { IType, TransformContext, Type } from './Type';
+import { Uint8ArrayType } from './Uint8ArrayType';
 import { UnknownType } from './UnknownType';
-export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, TransformContext, IntervalType, IType, };
+import { UuidType } from './UuidType';
+export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, TransformContext, IntervalType, IType, CharacterType, };
 export declare const types: {
     readonly date: typeof DateType;
     readonly time: typeof TimeType;
@@ -42,6 +43,7 @@ export declare const types: {
     readonly double: typeof DoubleType;
     readonly boolean: typeof BooleanType;
     readonly decimal: typeof DecimalType;
+    readonly character: typeof CharacterType;
     readonly string: typeof StringType;
     readonly uuid: typeof UuidType;
     readonly text: typeof TextType;
@@ -67,6 +69,7 @@ export declare const t: {
     readonly double: typeof DoubleType;
     readonly boolean: typeof BooleanType;
     readonly decimal: typeof DecimalType;
+    readonly character: typeof CharacterType;
     readonly string: typeof StringType;
     readonly uuid: typeof UuidType;
     readonly text: typeof TextType;