@mikro-orm/sql 7.0.2-dev.12 → 7.0.2-dev.14

package/AbstractSqlConnection.d.ts

@@ -2,13 +2,17 @@ import { type ControlledTransaction, type Dialect, Kysely } from 'kysely';
 import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LogContext, type LoggingOptions, type MaybePromise, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/** Base class for SQL database connections, built on top of Kysely. */
 export declare abstract class AbstractSqlConnection extends Connection {
     #private;
     protected platform: AbstractSqlPlatform;
+    /** Creates a Kysely dialect instance with driver-specific configuration. */
     abstract createKyselyDialect(overrides: Dictionary): MaybePromise<Dialect>;
+    /** Establishes the database connection and runs the onConnect hook. */
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<void>;
+    /** Initializes the Kysely client from driver options or a user-provided Kysely instance. */
     createKysely(): MaybePromise<void>;
     /**
      * @inheritDoc
@@ -28,8 +32,11 @@ export declare abstract class AbstractSqlConnection extends Connection {
         reason: string;
         error?: Error;
     }>;
+    /** Returns the underlying Kysely client, creating it synchronously if needed. */
     getClient<T = any>(): Kysely<T>;
+    /** Ensures the Kysely client is initialized, creating it asynchronously if needed. */
     initClient(): Promise<void>;
+    /** Executes a callback within a transaction, committing on success and rolling back on error. */
     transactional<T>(cb: (trx: Transaction<ControlledTransaction<any, any>>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
@@ -37,6 +44,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<T>;
+    /** Begins a new transaction or creates a savepoint if a transaction context already exists. */
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
@@ -44,10 +52,14 @@ export declare abstract class AbstractSqlConnection extends Connection {
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<ControlledTransaction<any, any>>;
+    /** Commits the transaction or releases the savepoint. */
     commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    /** Rolls back the transaction or rolls back to the savepoint. */
     rollback(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     private prepareQuery;
+    /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
+    /** Executes a SQL query and returns an async iterable that yields results row by row. */
     stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
     /** @inheritDoc */
     executeDump(dump: string): Promise<void>;

package/AbstractSqlConnection.js

@@ -1,8 +1,10 @@
 import { CompiledQuery, Kysely } from 'kysely';
 import { Connection, EventType, RawQueryFragment, Utils, } from '@mikro-orm/core';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/** Base class for SQL database connections, built on top of Kysely. */
 export class AbstractSqlConnection extends Connection {
     #client;
+    /** Establishes the database connection and runs the onConnect hook. */
     async connect(options) {
         await this.initClient();
         this.connected = true;
@@ -10,6 +12,7 @@ export class AbstractSqlConnection extends Connection {
             await this.onConnect();
         }
     }
+    /** Initializes the Kysely client from driver options or a user-provided Kysely instance. */
     createKysely() {
         let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
         if (typeof driverOptions === 'function') {
@@ -64,6 +67,7 @@ export class AbstractSqlConnection extends Connection {
             return { ok: false, reason: error.message, error };
         }
     }
+    /** Returns the underlying Kysely client, creating it synchronously if needed. */
     getClient() {
         if (!this.#client) {
             const maybePromise = this.createKysely();
@@ -74,11 +78,13 @@ export class AbstractSqlConnection extends Connection {
         }
         return this.#client;
     }
+    /** Ensures the Kysely client is initialized, creating it asynchronously if needed. */
     async initClient() {
         if (!this.#client) {
             await this.createKysely();
         }
     }
+    /** Executes a callback within a transaction, committing on success and rolling back on error. */
     async transactional(cb, options = {}) {
         const trx = await this.begin(options);
         try {
@@ -91,6 +97,7 @@ export class AbstractSqlConnection extends Connection {
             throw error;
         }
     }
+    /** Begins a new transaction or creates a savepoint if a transaction context already exists. */
     async begin(options = {}) {
         if (options.ctx) {
             const ctx = options.ctx;
@@ -130,6 +137,7 @@ export class AbstractSqlConnection extends Connection {
         await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
         return trx;
     }
+    /** Commits the transaction or releases the savepoint. */
     async commit(ctx, eventBroadcaster, loggerContext) {
         if (ctx.isRolledBack) {
             return;
@@ -145,6 +153,7 @@ export class AbstractSqlConnection extends Connection {
         }
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
     }
+    /** Rolls back the transaction or rolls back to the savepoint. */
     async rollback(ctx, eventBroadcaster, loggerContext) {
         await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
         if ('savepointName' in ctx) {
@@ -169,6 +178,7 @@ export class AbstractSqlConnection extends Connection {
         const formatted = this.platform.formatQuery(query, params);
         return { query, params, formatted };
     }
+    /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
     async execute(query, params = [], method = 'all', ctx, loggerContext) {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
@@ -179,6 +189,7 @@ export class AbstractSqlConnection extends Connection {
             return this.transformRawResult(res, method);
         }, { ...q, ...loggerContext });
     }
+    /** Executes a SQL query and returns an async iterable that yields results row by row. */
     async *stream(query, params = [], ctx, loggerContext) {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);

package/AbstractSqlDriver.d.ts

@@ -6,6 +6,7 @@ import { type NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 import { QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
 import type { InternalField } from './typings.js';
+/** Base class for SQL database drivers, implementing find/insert/update/delete using QueryBuilder. */
 export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
     [EntityManagerType]: SqlEntityManager<this>;
     protected readonly connection: Connection;

package/AbstractSqlDriver.js

@@ -3,6 +3,7 @@ import { QueryBuilder } from './query/QueryBuilder.js';
 import { JoinType, QueryType } from './query/enums.js';
 import { SqlEntityManager } from './SqlEntityManager.js';
 import { PivotCollectionPersister } from './PivotCollectionPersister.js';
+/** Base class for SQL database drivers, implementing find/insert/update/delete using QueryBuilder. */
 export class AbstractSqlDriver extends DatabaseDriver {
     [EntityManagerType];
     connection;

package/AbstractSqlPlatform.d.ts

@@ -3,6 +3,7 @@ import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
 import { type SchemaHelper } from './schema/SchemaHelper.js';
 import type { IndexDef } from './typings.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/** Base class for SQL database platforms, providing SQL generation and quoting utilities. */
 export declare abstract class AbstractSqlPlatform extends Platform {
     #private;
     protected readonly schemaHelper?: SchemaHelper;

package/AbstractSqlPlatform.js

@@ -2,6 +2,7 @@ import { isRaw, JsonProperty, Platform, raw, Utils, } from '@mikro-orm/core';
 import { SqlEntityRepository } from './SqlEntityRepository.js';
 import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/** Base class for SQL database platforms, providing SQL generation and quoting utilities. */
 export class AbstractSqlPlatform extends Platform {
     static #JSON_PROPERTY_NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
     schemaHelper;

package/SqlEntityManager.d.ts

@@ -6,7 +6,9 @@ import type { SqlEntityRepository } from './SqlEntityRepository.js';
 import type { Kysely } from 'kysely';
 import type { InferClassEntityDB, InferKyselyDB } from './typings.js';
 import { type MikroKyselyPluginOptions } from './plugin/index.js';
+/** Options for `SqlEntityManager.getKysely()`. */
 export interface GetKyselyOptions extends MikroKyselyPluginOptions {
+    /** Connection type to use (`'read'` or `'write'`). */
     type?: ConnectionType;
 }
 /**
@@ -25,6 +27,7 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
      * Returns configured Kysely instance.
      */
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> & InferClassEntityDB<AllEntitiesFromManager<this>, TOptions> : TDB>;
+    /** Executes a raw SQL query, using the current transaction context if available. */
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;

package/SqlEntityManager.js

@@ -31,6 +31,7 @@ export class SqlEntityManager extends EntityManager {
         }
         return kysely;
     }
+    /** Executes a raw SQL query, using the current transaction context if available. */
     async execute(query, params = [], method = 'all', loggerContext) {
         return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);
     }

package/SqlEntityRepository.d.ts

@@ -1,6 +1,7 @@
 import { EntityRepository, type EntityName } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager.js';
 import type { QueryBuilder } from './query/QueryBuilder.js';
+/** SQL-specific entity repository with QueryBuilder support. */
 export declare class SqlEntityRepository<Entity extends object> extends EntityRepository<Entity> {
     protected readonly em: SqlEntityManager;
     constructor(em: SqlEntityManager, entityName: EntityName<Entity>);

package/SqlEntityRepository.js

@@ -1,4 +1,5 @@
 import { EntityRepository } from '@mikro-orm/core';
+/** SQL-specific entity repository with QueryBuilder support. */
 export class SqlEntityRepository extends EntityRepository {
     em;
     constructor(em, entityName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.2-dev.12",
+  "version": "7.0.2-dev.14",
   "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.0.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.2-dev.12"
+    "@mikro-orm/core": "7.0.2-dev.14"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/index.d.ts

@@ -1,5 +1,6 @@
 import { type KyselyPlugin, type PluginTransformQueryArgs, type PluginTransformResultArgs, type QueryResult, type RootOperationNode, type UnknownRow } from 'kysely';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
+/** Configuration options for the MikroKyselyPlugin. */
 export interface MikroKyselyPluginOptions {
     /**
      * Use database table names ('table') or entity names ('entity') in queries.
@@ -32,6 +33,7 @@ export interface MikroKyselyPluginOptions {
      */
     convertValues?: boolean;
 }
+/** Kysely plugin that transforms queries and results to use MikroORM entity/property naming conventions. */
 export declare class MikroKyselyPlugin implements KyselyPlugin {
     #private;
     constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);

package/plugin/index.js

@@ -1,5 +1,6 @@
 import { SelectQueryNode as SelectQueryNodeClass, InsertQueryNode as InsertQueryNodeClass, UpdateQueryNode as UpdateQueryNodeClass, DeleteQueryNode as DeleteQueryNodeClass, } from 'kysely';
 import { MikroTransformer } from './transformer.js';
+/** Kysely plugin that transforms queries and results to use MikroORM entity/property naming conventions. */
 export class MikroKyselyPlugin {
     static #queryNodeCache = new WeakMap();
     #transformer;

package/query/NativeQueryBuilder.d.ts

@@ -1,7 +1,9 @@
 import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment, type Subquery } from '@mikro-orm/core';
 import { QueryType } from './enums.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+/** Options for Common Table Expression (CTE) definitions. */
 export interface CteOptions {
+    /** Column names for the CTE. */
     columns?: string[];
     /** PostgreSQL: MATERIALIZED / NOT MATERIALIZED */
     materialized?: boolean;
@@ -45,6 +47,7 @@ interface Options {
     wrap?: [prefix: string, suffix: string];
     ctes?: CteClause[];
 }
+/** Options for specifying the target table in FROM/INTO clauses. */
 export interface TableOptions {
     schema?: string;
     indexHint?: string;

package/query/enums.d.ts

@@ -1,3 +1,4 @@
+/** Type of SQL query to be generated. */
 export declare enum QueryType {
     TRUNCATE = "TRUNCATE",
     SELECT = "SELECT",
@@ -9,6 +10,7 @@ export declare enum QueryType {
 }
 /** Operators that apply to the embedded array column itself, not to individual elements. */
 export declare const EMBEDDABLE_ARRAY_OPS: string[];
+/** Type of SQL JOIN clause. */
 export declare enum JoinType {
     leftJoin = "left join",
     innerJoin = "inner join",

package/query/enums.js

@@ -1,3 +1,4 @@
+/** Type of SQL query to be generated. */
 export var QueryType;
 (function (QueryType) {
     QueryType["TRUNCATE"] = "TRUNCATE";
@@ -10,6 +11,7 @@ export var QueryType;
 })(QueryType || (QueryType = {}));
 /** Operators that apply to the embedded array column itself, not to individual elements. */
 export const EMBEDDABLE_ARRAY_OPS = ['$contains', '$contained', '$overlap'];
+/** Type of SQL JOIN clause. */
 export var JoinType;
 (function (JoinType) {
     JoinType["leftJoin"] = "left join";

package/schema/SchemaHelper.d.ts

@@ -4,12 +4,17 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
+/** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
     constructor(platform: AbstractSqlPlatform);
+    /** Returns SQL to prepend to schema migration scripts (e.g., disabling FK checks). */
     getSchemaBeginning(_charset: string, disableForeignKeys?: boolean): string;
+    /** Returns SQL to disable foreign key checks. */
     disableForeignKeysSQL(): string;
+    /** Returns SQL to re-enable foreign key checks. */
     enableForeignKeysSQL(): string;
+    /** Returns SQL to append to schema migration scripts (e.g., re-enabling FK checks). */
     getSchemaEnd(disableForeignKeys?: boolean): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     appendComments(table: DatabaseTable): string[];
@@ -20,12 +25,17 @@ export declare abstract class SchemaHelper {
     getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
+    /** Loads table metadata (columns, indexes, foreign keys) from the database information schema. */
     abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    /** Returns the SQL query to list all tables in the database. */
     getListTablesSQL(): string;
+    /** Retrieves all tables from the database. */
     getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    /** Returns SQL to rename a column in a table. */
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
+    /** Returns SQL to create an index on a table. */
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
     /**
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
@@ -36,9 +46,12 @@ export declare abstract class SchemaHelper {
      * Note: Prefix length is only supported by MySQL/MariaDB which override this method.
      */
     protected getIndexColumns(index: IndexDef): string;
+    /** Returns SQL to drop an index. */
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+    /** Returns SQL statements to apply a table difference (add/drop/alter columns, indexes, foreign keys). */
     alterTable(diff: TableDifference, safe?: boolean): string[];
+    /** Returns SQL to add columns to an existing table. */
     getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
@@ -62,8 +75,10 @@ export declare abstract class SchemaHelper {
     getDefaultEmptyString(): string;
     databaseExists(connection: Connection, name: string): Promise<boolean>;
     append(array: string[], sql: string | string[], pad?: boolean): void;
+    /** Returns SQL statements to create a table with all its columns, primary key, indexes, and checks. */
     createTable(table: DatabaseTable, alter?: boolean): string[];
     alterTableComment(table: DatabaseTable, comment?: string): string;
+    /** Returns SQL to create a foreign key constraint on a table. */
     createForeignKey(table: DatabaseTable, foreignKey: ForeignKey, alterTable?: boolean, inline?: boolean): string;
     splitTableName(name: string, skipDefaultSchema?: boolean): [string | undefined, string];
     getReferencedTableName(referencedTableName: string, schema?: string): string;
@@ -77,6 +92,7 @@ export declare abstract class SchemaHelper {
     dropForeignKey(tableName: string, constraintName: string): string;
     dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
     dropConstraint(table: string, name: string): string;
+    /** Returns SQL to drop a table if it exists. */
     dropTableIfExists(name: string, schema?: string): string;
     createView(name: string, schema: string | undefined, definition: string): string;
     dropViewIfExists(name: string, schema?: string): string;

package/schema/SchemaHelper.js

@@ -1,21 +1,26 @@
 import { RawQueryFragment, Utils } from '@mikro-orm/core';
+/** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export class SchemaHelper {
     platform;
     constructor(platform) {
         this.platform = platform;
     }
+    /** Returns SQL to prepend to schema migration scripts (e.g., disabling FK checks). */
     getSchemaBeginning(_charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `${this.disableForeignKeysSQL()}\n`;
         }
         return '';
     }
+    /** Returns SQL to disable foreign key checks. */
     disableForeignKeysSQL() {
         return '';
     }
+    /** Returns SQL to re-enable foreign key checks. */
     enableForeignKeysSQL() {
         return '';
     }
+    /** Returns SQL to append to schema migration scripts (e.g., re-enabling FK checks). */
     getSchemaEnd(disableForeignKeys) {
         if (disableForeignKeys) {
             return `${this.enableForeignKeysSQL()}\n`;
@@ -62,9 +67,11 @@ export class SchemaHelper {
     getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         throw new Error('Not supported by given driver');
     }
+    /** Returns the SQL query to list all tables in the database. */
     getListTablesSQL() {
         throw new Error('Not supported by given driver');
     }
+    /** Retrieves all tables from the database. */
     async getAllTables(connection, schemas) {
         return connection.execute(this.getListTablesSQL());
     }
@@ -74,6 +81,7 @@ export class SchemaHelper {
     async loadViews(schema, connection, schemaName) {
         throw new Error('Not supported by given driver');
     }
+    /** Returns SQL to rename a column in a table. */
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
         tableName = this.quote(tableName);
         oldColumnName = this.quote(oldColumnName);
@@ -82,6 +90,7 @@ export class SchemaHelper {
         const tableReference = schemaReference + tableName;
         return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
+    /** Returns SQL to create an index on a table. */
     getCreateIndexSQL(tableName, index) {
         /* v8 ignore next */
         if (index.expression) {
@@ -145,6 +154,7 @@ export class SchemaHelper {
         }
         return index.columnNames.map(c => this.quote(c)).join(', ');
     }
+    /** Returns SQL to drop an index. */
     getDropIndexSQL(tableName, index) {
         return `drop index ${this.quote(index.keyName)}`;
     }
@@ -154,6 +164,7 @@ export class SchemaHelper {
             this.getCreateIndexSQL(tableName, index),
         ];
     }
+    /** Returns SQL statements to apply a table difference (add/drop/alter columns, indexes, foreign keys). */
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);
@@ -257,6 +268,7 @@ export class SchemaHelper {
         }
         return ret;
     }
+    /** Returns SQL to add columns to an existing table. */
     getAddColumnsSQL(table, columns) {
         const adds = columns
             .map(column => {
@@ -472,6 +484,7 @@ export class SchemaHelper {
             array.push('');
         }
     }
+    /** Returns SQL statements to create a table with all its columns, primary key, indexes, and checks. */
     createTable(table, alter) {
         let sql = `create table ${table.getQuotedName()} (`;
         const columns = table.getColumns();
@@ -507,6 +520,7 @@ export class SchemaHelper {
     alterTableComment(table, comment) {
         return `alter table ${table.getQuotedName()} comment = ${this.platform.quoteValue(comment ?? '')}`;
     }
+    /** Returns SQL to create a foreign key constraint on a table. */
     createForeignKey(table, foreignKey, alterTable = true, inline = false) {
         if (!this.options.createForeignKeyConstraints) {
             return '';
@@ -617,6 +631,7 @@ export class SchemaHelper {
     dropConstraint(table, name) {
         return `alter table ${this.quote(table)} drop constraint ${this.quote(name)}`;
     }
+    /** Returns SQL to drop a table if it exists. */
     dropTableIfExists(name, schema) {
         let sql = `drop table if exists ${this.quote(this.getTableName(name, schema))}`;
         if (this.platform.usesCascadeStatement()) {

package/schema/SqlSchemaGenerator.d.ts

@@ -4,6 +4,7 @@ import type { SchemaDifference } from '../typings.js';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import type { SchemaHelper } from './SchemaHelper.js';
+/** Generates and manages SQL database schemas based on entity metadata. Supports create, update, and drop operations. */
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
     protected readonly helper: SchemaHelper;
     protected readonly options: NonNullable<Options['schemaGenerator']>;

package/schema/SqlSchemaGenerator.js

@@ -2,6 +2,7 @@ import { CommitOrderCalculator, TableNotFoundException, Utils, } from '@mikro-or
 import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import { SchemaComparator } from './SchemaComparator.js';
+/** Generates and manages SQL database schemas based on entity metadata. Supports create, update, and drop operations. */
 export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     helper = this.platform.getSchemaHelper();
     options = this.config.get('schemaGenerator');