Implementation using generics

Typing within the system

Typing in the User's ORM System is implemented using generics, which enhance flexibility and safety when working with different databases. Generics allow for defining data types at compile time, preventing many errors and ensuring more accurate operations with various databases.

Using Generics for Typing

Generics are a powerful TypeScript feature that allows creating components with support for different data types. This is achieved by passing types as parameters to classes, interfaces, or functions. In the context of the user's ORM system, generics provide support for different databases (e.g., PostgreSQL, MySQL) and enable the creation of more flexible and type-safe interfaces for working with them.

Polymorphism and Adaptation to Different Databases

Generics enable achieving polymorphism in the ORM by allowing the creation of typed interfaces and classes for different databases. For example, the DropTableInterface<DT> interface adapts to the specifics of a particular database, providing different approaches depending on the type of database. This allows maintaining a common interface while applying database-specific implementations.

export interface DropTableInterface<DT extends DatabasesTypes> =
	DT extends DatabasesTypes.POSTGRES ? DropTablePostgresInterface :
		DT extends DatabasesTypes.MYSQL ? DropTableMysqlInterface :
			CommonDropTableInterface;

This example demonstrates how generics allow adapting the interface to different databases. For PostgreSQL, the DropTableInterface will use the specific DropTablePostgresInterface type, while for MySQL, the DropTableMysqlInterface will be used. This allows supporting various databases within a single interface, providing high type safety and ease of use.

Example of Generics in the System

Consider the TableManipulationInterface interface, which uses the DT generic to ensure typing for table operations for different databases:

export interface TableManipulationInterface<DT extends DatabasesTypes> {
	alterTable(tableName: string, getQueryString: boolean): AlterTableResultInterface<DT>;
}

This interface defines the alterTable method, which returns a result of type AlterTableResultInterface, also using the DT generic. This ensures type consistency and guarantees that all table manipulations will be type-safe and specific to the particular database.

Another example of how generics are used for typing and ensuring polymorphism in the user's ORM system is the AlterTableResultInterface. This interface defines various methods for table manipulations, adapting them to the specific database using the DT generic.

export interface AlterTableResultInterface<DT extends DatabasesTypes> {
	addColumn: (parameters: AddColumnInterface<DT>) => Promise<Object | string>;
	deleteColumn: (parameters: DeleteColumnInterface<DT>) => Promise<Object | string>;
	addDefaultValue: (parameters: AddDefaultValueInterface) => Promise<Object | string>;
	dropDefaultValue: (parameters: DropDefaultValueInterface) => Promise<Object | string>;
	changeDataTypeOfColumn: (parameters: ChangeColumnDatatypeInterface) => Promise<Object | string>;
	addNotNullToColumn: (parameters: AddNotNullToColumnInterface) => Promise<Object | string>;
	dropNotNullFromColumn: (parameters: DropNotNullFromColumnInterface) => Promise<Object | string>;
	addUniqueToColumn: (parameters: AddUniqueToColumnInterface<DT>) => Promise<Object | string>;
	renameColumn: (parameters: RenameColumnInterface) => Promise<Object | string>;
	renameTable: (parameters: RenameTableInterface) => Promise<Object | string>;
	addCheckConstraintToColumn: (parameters: AddCheckConstraintToColumnInterface) => Promise<Object | string>;
	deleteCheckConstraintOfColumn: (parameters: DeleteCheckConstraintOfColumnInterface) => Promise<Object | string>;
	dropConstraint: (parameters: DropConstraintInterface) => Promise<Object | string>;
	deleteUniqueFromColumn: (parameters: DeleteUniqueFromColumnInterface) => Promise<Object | string>;
	addPrimaryGeneratedColumn: (parameters: AddPrimaryGeneratedColumnInterface<DT>) => Promise<Object | string>;
	addForeignKey: (parameters: AddForeignKeyInterface) => Promise<Object | string>;
	addComputedColumn: (parameters: AddComputedColumnInterface<DT>) => Promise<Object | string>;
	dropTable: (parameters: DropTableInterface<DT>) => Promise<Object | string>;
}

This interface uses the DT generic, representing the database type (e.g., DatabasesTypes.POSTGRES or DatabasesTypes.MYSQL). Each method in the interface defines an operation on a table, such as adding a column or changing a column's data type.

Using Generics in the User's ORM System allows for high flexibility and safety. It reduces the risk of errors, increases reliability, and ensures more accurate interactions with different databases, which is crucial for complex and distributed systems. Generics enable the creation of polymorphic interfaces that adapt to the specifics of different databases while maintaining a common approach and providing a high level of type safety.