@mikro-orm/sql 7.3.0-dev.10 → 7.3.0-dev.11

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -37,6 +37,7 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type: string): Type<unknown>;
     isNumericColumn(mappedType: Type<unknown>): boolean;
     supportsUnsigned(): boolean;
+    supportsAutoincrementIncrement(): boolean;
     /** MySQL/MariaDB identifier limit. */
     getMaxIdentifierLength(): number;
     getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence' | 'check'): string;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -90,6 +90,9 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsUnsigned() {
         return true;
     }
+    supportsAutoincrementIncrement() {
+        return false;
+    }
     /** MySQL/MariaDB identifier limit. */
     getMaxIdentifierLength() {
         return 64;

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -20,6 +20,8 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
     getListViewsSQL(): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -42,12 +42,25 @@ export class MySqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL() {
         return 'set foreign_key_checks = 1;';
     }
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        return `alter table ${this.quote(this.getTableName(tableName, schemaName))} auto_increment = ${startWith}`;
+    }
+    getAddColumnsSQL(table, columns) {
+        const [sql, ...rest] = super.getAddColumnsSQL(table, columns);
+        const startWith = columns.find(column => column.autoincrement)?.sequence?.startWith;
+        // the table option numbers the existing rows of the added column from the declared start too
+        return [startWith != null ? `${sql}, auto_increment = ${startWith}` : sql, ...rest];
+    }
     finalizeTable(table, charset, collate) {
         let sql = ` default character set ${charset}`;
         if (collate) {
             sql += ` collate ${collate}`;
         }
         sql += ' engine = InnoDB';
+        const startWith = table.getColumns().find(column => column.autoincrement)?.sequence?.startWith;
+        if (startWith != null) {
+            sql += ` auto_increment = ${startWith}`;
+        }
         if (table.comment) {
             sql += ` comment = ${this.platform.quoteValue(table.comment)}`;
         }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -29,6 +29,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
     createTable(table: DatabaseTable, alter?: boolean): string[];
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
     dropMaterializedViewIfExists(name: string, schema?: string): string;
     refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
@@ -134,6 +135,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     castColumn(name: string, type: string): string;
     dropForeignKey(tableName: string, constraintName: string): string;
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     private getAlterColumnAutoincrement;
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     alterTableComment(table: DatabaseTable, comment?: string): string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -106,10 +106,23 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     }
     createTable(table, alter) {
         const partitioning = table.getPartitioning();
+        const [createTable, ...rest] = super.createTable(table, alter);
+        // `serial` columns can't declare sequence options inline, so alter the implicit sequence right after creating the table
+        const sequences = table
+            .getColumns()
+            .filter(column => column.autoincrement && !column.generated && this.getSequenceOptionsSQL(column))
+            .map(column => {
+            const sequence = `pg_get_serial_sequence(${this.platform.quoteValue(table.getQuotedName())}, ${this.platform.quoteValue(column.name)})`;
+            const { startWith = -1, incrementBy = 1 } = column.sequence;
+            // `alter sequence` keeps the ascending bounds of the serial, so a descending one gets the bounds and start of a fresh sequence
+            const options = incrementBy < 0
+                ? `no minvalue maxvalue ${Math.max(startWith, -1)} start with ${startWith} increment by ${incrementBy}`
+                : this.getSequenceOptionsSQL(column);
+            return `do $$ begin execute format('alter sequence %s ${options} restart', ${sequence}); end $$`;
+        });
         if (!partitioning) {
-            return super.createTable(table, alter);
+            return [createTable, ...sequences, ...rest];
         }
-        const [createTable, ...rest] = super.createTable(table, alter);
         const partitions = partitioning.partitions.map(partition => {
             const partitionName = this.quote(this.getTableName(partition.name, partition.schema ?? table.schema));
             return `create table ${partitionName} partition of ${table.getQuotedName()} ${partition.bound}`;
@@ -119,7 +132,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         // regex replacement tokens like `$$`, `$&`, or `$1` inside user-supplied expressions (e.g., a
         // callback that returns a dollar-quoted literal) are not interpreted as back-references.
         const spliced = `${createTable.slice(0, -1)} partition by ${partitioning.definition};`;
-        return [spliced, ...rest, ...partitions];
+        return [spliced, ...sequences, ...rest, ...partitions];
+    }
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        const table = this.platform.quoteValue(this.quote(this.getTableName(tableName, schemaName)));
+        // `truncate … restart identity` goes back to the start the sequence was created with, which the metadata may not match
+        return `select setval(pg_get_serial_sequence(${table}, ${this.platform.quoteValue(columnName)}), ${startWith}, false)`;
     }
     dropMaterializedViewIfExists(name, schema) {
         return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
@@ -387,15 +405,16 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       data_type,
       is_identity,
       identity_generation,
-      identity_start,
-      identity_increment,
       generation_expression,
       pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
-      coll.collname as collation_name
+      coll.collname as collation_name,
+      seq.seqstart as sequence_start,
+      seq.seqincrement as sequence_increment
       from information_schema.columns cols
       join pg_class pgc on cols.table_name = pgc.relname
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
       left join pg_collation coll on pga.attcollation = coll.oid and coll.collname <> 'default'
+      left join pg_sequence seq on seq.seqrelid = pg_get_serial_sequence(quote_ident(cols.table_schema) || '.' || quote_ident(cols.table_name), cols.column_name)::regclass
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
@@ -435,14 +454,6 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 type += `(${col.numeric_precision},${col.numeric_scale})`;
             }
             const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
-            // a descending sequence starts at -1 by default
-            const defaultIdentityStart = col.identity_increment?.startsWith('-') ? '-1' : '1';
-            // read back non-default identity options, so `identity (start with 1000)` does not diff against plain `identity`
-            const identityOptions = [
-                col.identity_start !== defaultIdentityStart && `start with ${col.identity_start}`,
-                col.identity_increment !== '1' && `increment by ${col.identity_increment}`,
-            ].filter(Boolean);
-            const identitySuffix = identityOptions.length > 0 ? ` (${identityOptions.join(' ')})` : '';
             const column = {
                 name: col.column_name,
                 type,
@@ -454,8 +465,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 default: str(this.normalizeDefaultValue(col.column_default, col.length)),
                 unsigned: increments,
                 autoincrement: increments,
+                sequence: increments ? this.getIntrospectedSequence(col.sequence_start, col.sequence_increment) : undefined,
                 generated: col.is_identity === 'YES'
-                    ? (col.identity_generation === 'BY DEFAULT' ? 'by default as identity' : 'identity') + identitySuffix
+                    ? col.identity_generation === 'BY DEFAULT'
+                        ? 'by default as identity'
+                        : 'identity'
                     : col.generation_expression
                         ? col.generation_expression + ' stored'
                         : undefined,
@@ -1040,11 +1054,15 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     columnType = this.quote(columnType);
                 }
             }
-            if (column.generated?.startsWith('by default as identity')) {
-                columnType += ` generated ${column.generated}`;
+            const sequenceOptions = this.getSequenceOptionsSQL(column);
+            const generated = sequenceOptions && /^(by default as )?identity$/.test(column.generated ?? '')
+                ? `${column.generated} (${sequenceOptions})`
+                : column.generated;
+            if (generated?.startsWith('by default as identity')) {
+                columnType += ` generated ${generated}`;
             }
-            else if (column.generated) {
-                columnType += ` generated always as ${column.generated}`;
+            else if (generated) {
+                columnType += ` generated always as ${generated}`;
             }
             col.push(columnType);
             Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
@@ -1201,14 +1219,50 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    getAddColumnsSQL(table, columns) {
+        const compositePK = table.getPrimaryKey()?.composite;
+        const before = [];
+        const after = [];
+        const adds = columns.map(column => {
+            const sequenceOptions = this.getSequenceOptionsSQL(column);
+            if (!sequenceOptions || !column.autoincrement || column.generated) {
+                return column;
+            }
+            // a `serial` column numbers the existing rows right away, so expand it to a sequence created with the options upfront
+            const seqName = this.quote(this.getTableName(this.platform.getIndexName(table.name, [column.name], 'sequence'), table.schema));
+            before.push(`create sequence ${seqName} ${sequenceOptions}`);
+            after.push(`alter sequence ${seqName} owned by ${table.getQuotedName()}.${this.quote(column.name)}`);
+            // the expanded column has no inline `primary key`, which `alterTable` expects from an added autoincrement PK
+            if (column.primary && !compositePK && !this.hasNonDefaultPrimaryKeyName(table)) {
+                after.push(`alter table ${table.getQuotedName()} add primary key (${this.quote(column.name)})`);
+            }
+            return {
+                ...column,
+                type: column.mappedType.getColumnType({ autoincrement: false }, this.platform),
+                autoincrement: false,
+                nullable: false,
+                default: `nextval('${seqName}')`,
+            };
+        });
+        return [...before, ...super.getAddColumnsSQL(table, adds), ...after];
+    }
     getAlterColumnAutoincrement(tableName, column, schemaName) {
         const ret = [];
         /* v8 ignore next */
         const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
         if (column.autoincrement) {
             const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
-            ret.push(`create sequence if not exists ${this.quote(seqName)}`);
-            ret.push(`select setval('${seqName}', (select max(${this.quote(column.name)}) from ${this.quote(name)}))`);
+            const sequenceOptions = this.getSequenceOptionsSQL(column);
+            const { incrementBy = 1, startWith = incrementBy < 0 ? -1 : 1 } = column.sequence ?? {};
+            const lastValue = `(select ${incrementBy < 0 ? 'min' : 'max'}(${this.quote(column.name)}) from ${this.quote(name)})`;
+            ret.push(`create sequence if not exists ${this.quote(seqName)}${sequenceOptions ? ` ${sequenceOptions}` : ''}`);
+            if (sequenceOptions) {
+                // continue after the existing values, but never before the declared start
+                ret.push(`select setval('${seqName}', ${incrementBy < 0 ? 'least' : 'greatest'}(${lastValue} + ${incrementBy}, ${startWith}), false)`);
+            }
+            else {
+                ret.push(`select setval('${seqName}', ${lastValue})`);
+            }
             ret.push(`alter table ${this.quote(name)} alter column ${this.quote(column.name)} set default nextval('${seqName}')`);
         }
         return ret;

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -14,6 +14,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     usesReturningStatement(): boolean;
     usesEnumCheckConstraints(): boolean;
     supportsComments(): boolean;
+    supportsAutoincrementIncrement(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {
         length: number;

package/dialects/sqlite/SqlitePlatform.js

@@ -26,6 +26,9 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     supportsComments() {
         return false;
     }
+    supportsAutoincrementIncrement() {
+        return false;
+    }
     getCurrentTimestampSQL(length) {
         return `(strftime('%s', 'now') * 1000)`;
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -21,6 +21,7 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     getDropDatabaseSQL(name: string): string;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     createTable(table: DatabaseTable, alter?: boolean): string[];
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
     createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
     getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
     dropForeignKey(tableName: string, constraintName: string): string;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -144,6 +144,13 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         const ret = [];
         this.append(ret, sql);
+        const startWith = columns.find(column => column.autoincrement)?.sequence?.startWith;
+        if (startWith != null) {
+            // a table rebuild renames the counter row of the temp table over, so only seed it when missing
+            const sequenceTable = this.quote(this.getTableName('sqlite_sequence', table.schema));
+            const name = this.platform.quoteValue(table.name);
+            this.append(ret, `insert into ${sequenceTable} (name, seq) select ${name}, ${startWith - 1} where not exists (select 1 from ${sequenceTable} where name = ${name})`);
+        }
         for (const index of table.getIndexes()) {
             this.append(ret, this.createIndex(index, table));
         }
@@ -152,6 +159,12 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        const sequenceTable = this.quote(this.getTableName('sqlite_sequence', schemaName));
+        const name = this.platform.quoteValue(tableName);
+        // the counter row does not exist before the first insert when the table was created without `sequence`
+        return `delete from ${sequenceTable} where name = ${name};\ninsert into ${sequenceTable} (name, seq) values (${name}, ${startWith - 1})`;
+    }
     createTableColumn(column, table, _changedProperties) {
         const col = [this.quote(column.name)];
         const checks = table.getChecks();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.3.0-dev.10",
+  "version": "7.3.0-dev.11",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.2.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.10"
+    "@mikro-orm/core": "7.3.0-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseTable.js

@@ -155,6 +155,7 @@ export class DatabaseTable {
                 comment: prop.comment,
                 collation: prop.collation,
                 extra: prop.extra,
+                sequence: prop.sequence,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
             this.#columns[field].unsigned ??= this.#columns[field].autoincrement;
@@ -796,6 +797,7 @@ export class DatabaseTable {
             nullable: column.nullable,
             primary: column.primary && persist,
             autoincrement: column.autoincrement,
+            sequence: column.sequence,
             fieldName: column.name,
             unsigned: column.unsigned,
             length: column.length,

package/schema/SchemaComparator.js

@@ -708,7 +708,9 @@ export class SchemaComparator {
             log(`'nullable' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('nullable');
         }
-        if (this.diffExpression(fromColumn.generated, toColumn.generated)) {
+        // identity options (start/increment) are applied on create only, same as the `sequence` option
+        const withoutIdentityOptions = (generated) => generated?.replace(/^((?:by default as )?identity)\s*\(.*\)$/is, '$1');
+        if (this.diffExpression(withoutIdentityOptions(fromColumn.generated), withoutIdentityOptions(toColumn.generated))) {
             log(`'generated' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('generated');
         }

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment } from '@mikro-orm/core';
+import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment, type SequenceOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../typings.js';
@@ -45,6 +45,12 @@ export declare abstract class SchemaHelper {
     resolveMigrationSchema(schema: string | undefined): string | undefined;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     appendComments(table: DatabaseTable): string[];
+    /** Returns SQL that moves the autoincrement counter back to `sequence.startWith` after `clear()` truncated the table. */
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
+    /** Maps the introspected start and increment of an autoincrement column to its `sequence` option, omitting defaults. */
+    protected getIntrospectedSequence(start: unknown, increment: unknown): SequenceOptions | undefined;
+    /** Renders the `start with … increment by …` clause for the `sequence` option of an autoincrement column. */
+    protected getSequenceOptionsSQL(column: Column): string;
     supportsSchemaConstraints(): boolean;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     inferLengthFromColumnType(type: string): number | undefined;

package/schema/SchemaHelper.js

@@ -91,6 +91,38 @@ export class SchemaHelper {
     appendComments(table) {
         return [];
     }
+    /** Returns SQL that moves the autoincrement counter back to `sequence.startWith` after `clear()` truncated the table. */
+    /* v8 ignore next */
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        return '';
+    }
+    /** Maps the introspected start and increment of an autoincrement column to its `sequence` option, omitting defaults. */
+    getIntrospectedSequence(start, increment) {
+        if (start == null) {
+            return undefined;
+        }
+        const incrementBy = Number(increment ?? 1);
+        const startWith = Number(start);
+        const sequence = {};
+        if (startWith !== (incrementBy < 0 ? -1 : 1)) {
+            sequence.startWith = startWith;
+        }
+        if (incrementBy !== 1) {
+            sequence.incrementBy = incrementBy;
+        }
+        return Utils.hasObjectKeys(sequence) ? sequence : undefined;
+    }
+    /** Renders the `start with … increment by …` clause for the `sequence` option of an autoincrement column. */
+    getSequenceOptionsSQL(column) {
+        const { startWith, incrementBy } = column.sequence ?? {};
+        const descending = incrementBy != null && incrementBy < 0;
+        // a sequence is bounded by 1 (ascending) or -1 (descending) by default, a start beyond that has to move the bound
+        const bound = startWith != null &&
+            (descending ? startWith > -1 && `maxvalue ${startWith}` : startWith < 1 && `minvalue ${startWith}`);
+        return [startWith != null && `start with ${startWith}`, incrementBy != null && `increment by ${incrementBy}`, bound]
+            .filter(Boolean)
+            .join(' ');
+    }
     supportsSchemaConstraints() {
         return true;
     }

package/schema/SqlSchemaGenerator.js

@@ -141,6 +141,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                     .withSchema(schema)
                     .truncate()
                     .execute();
+                // the counters of a TPT child's inherited columns (PK included) belong to the parent table
+                const props = meta.tptParent ? (meta.ownProps ?? []) : meta.props;
+                for (const prop of props.filter(prop => prop.autoincrement && prop.sequence?.startWith != null)) {
+                    const sql = this.helper.getResetSequenceSQL(meta.tableName, this.getSchemaName(meta, { schema }), prop.fieldNames[0], prop.sequence.startWith);
+                    if (sql) {
+                        await this.execute(sql, { ctx: this.em?.getTransactionContext() });
+                    }
+                }
             }
             catch (e) {
                 if (this.platform.getExceptionConverter().convertException(e) instanceof TableNotFoundException) {

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityMetadata, EntityProperty, EntitySchemaWithMeta, ExtractDefineEntityProperties, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, Type } from '@mikro-orm/core';
+import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityMetadata, EntityProperty, EntitySchemaWithMeta, ExtractDefineEntityProperties, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, SequenceOptions, Type } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
@@ -37,6 +37,8 @@ export interface Column {
     mappedType: Type<unknown>;
     unsigned?: boolean;
     autoincrement?: boolean;
+    /** applied only when the column is created, never diffed */
+    sequence?: SequenceOptions;
     nullable?: boolean;
     length?: number;
     precision?: number;