@mikro-orm/core 7.3.0-dev.10 → 7.3.0-dev.12

package/entity/defineEntity.d.ts

@@ -1,5 +1,5 @@
 import type { EntityManager } from '../EntityManager.js';
-import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions } from '../metadata/types.js';
+import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions, SequenceOptions } from '../metadata/types.js';
 import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, LazyRef, IndexCallback, TriggerCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise, IndexHints, OptionalProps, ExtractDefineEntityProperties } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
@@ -130,6 +130,7 @@ export interface PropertyChain<in out Value, in out Options> {
     unique(unique?: boolean): PropertyChain<Value, Options>;
     comment(comment: string): PropertyChain<Value, Options>;
     collation(collation: string): PropertyChain<Value, Options>;
+    sequence(sequence: SequenceOptions | number): PropertyChain<Value, Options>;
     accessor(accessor?: string | boolean): PropertyChain<Value, Options>;
     eager(eager?: boolean): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     cascade(...cascade: Cascade[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
@@ -486,6 +487,12 @@ export declare class UniversalPropertyOptionsBuilder<in out Value, in out Option
      * Emits a `COLLATE` clause on the column definition; the accepted collation names are dialect-specific.
      */
     collation(collation: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    /**
+     * Set the start value and increment of an autoincrement column. (SQL only)
+     * A number is a shorthand for `{ startWith }`.
+     * Applied only when the column is created (and by `orm.schema.clear()`), never diffed by the schema generator.
+     */
+    sequence(sequence: SequenceOptions | number): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** mysql only */
     extra(extra: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**

package/entity/defineEntity.js

@@ -323,6 +323,14 @@ export class UniversalPropertyOptionsBuilder {
     collation(collation) {
         return this.assignOptions({ collation });
     }
+    /**
+     * Set the start value and increment of an autoincrement column. (SQL only)
+     * A number is a shorthand for `{ startWith }`.
+     * Applied only when the column is created (and by `orm.schema.clear()`), never diffed by the schema generator.
+     */
+    sequence(sequence) {
+        return this.assignOptions({ sequence: typeof sequence === 'number' ? { startWith: sequence } : sequence });
+    }
     /** mysql only */
     extra(extra) {
         return this.assignOptions({ extra });

package/errors.d.ts

@@ -91,6 +91,12 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static triggersNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     /** Thrown when row level security is declared on an entity using a driver that does not support it. */
     static rowLevelSecurityNotSupportedByDriver(meta: EntityMetadata): MetadataError;
+    /** Thrown when the `sequence` option is declared on a property that is not autoincrement. */
+    static sequenceWithoutAutoincrement(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    /** Thrown when the `sequence` option is combined with an identity option list in `generated`. */
+    static sequenceWithIdentityOptions(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    /** Thrown when `sequence.incrementBy` is declared on a platform without a per-column increment. */
+    static sequenceIncrementNotSupported(meta: EntityMetadata, prop: EntityProperty, platform: string): MetadataError;
     /** Thrown when row level security is declared on a non-root entity of an STI hierarchy. */
     static rowLevelSecurityOnNonRootStiEntity(meta: EntityMetadata): MetadataError;
     /** Thrown when two policies on the same entity are given the same explicit name. */

package/errors.js

@@ -296,6 +296,18 @@ export class MetadataError extends ValidationError {
     static rowLevelSecurityNotSupportedByDriver(meta) {
         return new MetadataError(`Entity ${meta.className} declares row level security which is not supported by the current driver. Row level security is only available with the PostgreSQL driver. To test a PostgreSQL app without a server, use the \`@mikro-orm/pglite\` driver instead of sqlite.`);
     }
+    /** Thrown when the `sequence` option is declared on a property that is not autoincrement. */
+    static sequenceWithoutAutoincrement(meta, prop) {
+        return MetadataError.fromMessage(meta, prop, `defines the 'sequence' option, but is not an autoincrement property`);
+    }
+    /** Thrown when the `sequence` option is combined with an identity option list in `generated`. */
+    static sequenceWithIdentityOptions(meta, prop) {
+        return MetadataError.fromMessage(meta, prop, `defines the 'sequence' option together with identity options in 'generated', use only one of them`);
+    }
+    /** Thrown when `sequence.incrementBy` is declared on a platform without a per-column increment. */
+    static sequenceIncrementNotSupported(meta, prop, platform) {
+        return MetadataError.fromMessage(meta, prop, `defines 'sequence.incrementBy', but ${platform} does not support a per-column increment`);
+    }
     /** Thrown when row level security is declared on a non-root entity of an STI hierarchy. */
     static rowLevelSecurityOnNonRootStiEntity(meta) {
         return new MetadataError(`Entity ${meta.className} declares row level security, but it is part of a single table inheritance hierarchy. Declare policies on the root entity ${meta.root.className} instead, as the whole hierarchy shares a single table.`);

package/metadata/types.d.ts

@@ -176,6 +176,12 @@ export interface PropertyOptions<Owner> {
      * Explicitly specify the auto increment of the primary key.
      */
     autoincrement?: boolean;
+    /**
+     * Start value and increment of an autoincrement column. (SQL only)
+     * Applied only when the column is created (and by `orm.schema.clear()`), never diffed by the schema generator.
+     * `incrementBy` is not supported on MySQL, MariaDB and SQLite.
+     */
+    sequence?: SequenceOptions;
     /**
      * Add the property to the `returning` clause of inserts, updates and upserts, reloading the database value into the entity.
      */
@@ -587,6 +593,12 @@ export interface EnumOptions<T> extends PropertyOptions<T> {
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName?: string;
 }
+export interface SequenceOptions {
+    /** The first value the autoincrement column generates. */
+    startWith?: number;
+    /** The step between generated values. Not supported on MySQL, MariaDB and SQLite. */
+    incrementBy?: number;
+}
 export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.3.0-dev.10",
+  "version": "7.3.0-dev.12",
   "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.",
   "keywords": [
     "data-mapper",

package/platforms/Platform.d.ts

@@ -325,6 +325,8 @@ export declare abstract class Platform {
     supportsDownMigrations(): boolean;
     /** Whether the platform supports deferred unique constraints. */
     supportsDeferredUniqueConstraints(): boolean;
+    /** Whether autoincrement columns support a per-column increment (`sequence.incrementBy`). */
+    supportsAutoincrementIncrement(): boolean;
     /** Whether the platform supports row level security (PostgreSQL). */
     supportsRowLevelSecurity(): boolean;
     /** Whether the driver can apply the session context on every pooled connection acquire (`sessionContext: 'connection'`). */

package/platforms/Platform.js

@@ -738,6 +738,10 @@ export class Platform {
     supportsDeferredUniqueConstraints() {
         return true;
     }
+    /** Whether autoincrement columns support a per-column increment (`sequence.incrementBy`). */
+    supportsAutoincrementIncrement() {
+        return true;
+    }
     /** Whether the platform supports row level security (PostgreSQL). */
     supportsRowLevelSecurity() {
         return false;
@@ -758,6 +762,20 @@ export class Platform {
         if (meta.partitionBy && !this.supportsPartitionedTables()) {
             throw new MetadataError(`Entity ${meta.className} uses partitionBy, but ${this.constructor.name} does not support partitioned tables`);
         }
+        for (const prop of Object.values(meta.properties)) {
+            if (!prop.sequence) {
+                continue;
+            }
+            if (!prop.autoincrement) {
+                throw MetadataError.sequenceWithoutAutoincrement(meta, prop);
+            }
+            if (typeof prop.generated === 'string' && /identity\s*\(/i.test(prop.generated)) {
+                throw MetadataError.sequenceWithIdentityOptions(meta, prop);
+            }
+            if (prop.sequence.incrementBy != null && !this.supportsAutoincrementIncrement()) {
+                throw MetadataError.sequenceIncrementNotSupported(meta, prop, this.constructor.name);
+            }
+        }
         const declaresRls = meta.policies.length > 0 || !!meta.rowLevelSecurity;
         if (declaresRls && !this.supportsRowLevelSecurity()) {
             throw MetadataError.rowLevelSecurityNotSupportedByDriver(meta);

package/types/DecimalType.js

@@ -1,4 +1,24 @@
 import { Type } from './Type.js';
+/** Scales a plain decimal string to an integer rounded half away from zero at `scale`, like the DB does. */
+function toScaledInteger(value, scale) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const negative = value.startsWith('-');
+    const [int, fraction = ''] = (negative ? value.slice(1) : value).split('.');
+    const digits = int + fraction;
+    for (let i = 0; i < digits.length; i++) {
+        const code = digits.charCodeAt(i);
+        if (code < 48 || code > 57) {
+            return undefined;
+        }
+    }
+    let scaled = BigInt('0' + int + fraction.slice(0, scale).padEnd(scale, '0'));
+    if (fraction.charCodeAt(scale) >= 53) {
+        scaled++;
+    }
+    return negative ? -scaled : scaled;
+}
 /**
  * Type that maps an SQL DECIMAL to a JS string or number.
  */
@@ -16,7 +36,20 @@ export class DecimalType extends Type {
         return String(value);
     }
     compareValues(a, b) {
-        return this.platform.formatDecimal(a, this.prop?.scale) === this.platform.formatDecimal(b, this.prop?.scale);
+        if (a === b) {
+            return true;
+        }
+        const scale = this.prop?.scale;
+        if (this.platform.formatDecimal(a, scale) !== this.platform.formatDecimal(b, scale)) {
+            return false;
+        }
+        // doubles are exact only up to 15 significant digits, so only higher precision strings can differ past the numeric check
+        if ((this.prop?.precision ?? 0) <= 15 || this.compareAsType() !== 'string') {
+            return true;
+        }
+        const scaledA = toScaledInteger(a, scale ?? 0);
+        const scaledB = toScaledInteger(b, scale ?? 0);
+        return scaledA == null || scaledB == null || scaledA === scaledB;
     }
     getColumnType(prop, platform) {
         return platform.getDecimalTypeDeclarationSQL(prop);

package/typings.d.ts

@@ -12,7 +12,7 @@ import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { Routine } from './metadata/Routine.js';
 import type { EntitySchema } from './metadata/EntitySchema.js';
-import type { EntityPartitionBy, IndexColumnOptions } from './metadata/types.js';
+import type { EntityPartitionBy, IndexColumnOptions, SequenceOptions } from './metadata/types.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
@@ -986,6 +986,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     hasConvertToJSValueSQL: boolean;
     hasConvertToDatabaseValueSQL: boolean;
     autoincrement?: boolean;
+    sequence?: SequenceOptions;
     returning?: boolean;
     primary?: boolean;
     serializedPrimaryKey: boolean;

package/utils/Utils.js

@@ -153,7 +153,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.3.0-dev.10';
+    static #ORM_VERSION = '7.3.0-dev.12';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;