Merge pull request #314 from drizzle-team/big-types-refactoring

Author: dankochetov

.eslintrc.cjs

@@ -2,7 +2,7 @@ module.exports = {
 	root: true,
 	extends: ['plugin:@typescript-eslint/base'],
 	parser: '@typescript-eslint/parser',
-	plugins: ['import'],
+	plugins: ['import', 'unused-imports'],
 	rules: {
 		'@typescript-eslint/consistent-type-imports': [
 			'error',
@@ -12,5 +12,10 @@ module.exports = {
 		],
 		'import/no-cycle': 'error',
 		'import/no-self-import': 'error',
+		'import/no-empty-named-blocks': 'error',
+		'unused-imports/no-unused-imports': 'error',
+		'import/no-useless-path-segments': 'error',
+		'import/newline-after-import': 'error',
+		'import/no-duplicates': 'error',
 	},
 };

.npmrc

@@ -1 +1,2 @@
 recursive-install = true
+prefer-workspace-packages = true

changelogs/drizzle-orm/0.23.0.md

@@ -0,0 +1,89 @@
+- 🎉 Added Knex and Kysely adapters! They allow you to manage the schemas and migrations with Drizzle and query the data with your favorite query builder. See documentation for more details:
+  - [Knex adapter](https://github.com/drizzle-team/drizzle-knex)
+  - [Kysely adapter](https://github.com/drizzle-team/drizzle-kysely)
+
+- 🎉 Added "type maps" to all entities. You can access them via the special `_` property. For example:
+
+  ```ts
+  const users = mysqlTable('users', {
+    id: int('id').primaryKey(),
+    name: text('name').notNull(),
+  });
+
+  type UserFields = typeof users['_']['columns'];
+  type InsertUser = typeof users['_']['model']['insert'];
+  ```
+
+  Full documentation on the type maps is coming soon.
+
+- 🎉 Added `.$type()` method to all column builders to allow overriding the data type. It also replaces the optional generics on columns.
+
+  ```ts
+  // Before
+  const test = mysqlTable('test', {
+    jsonField: json<Data>('json_field'),
+  });
+
+  // After
+  const test = mysqlTable('test', {
+    jsonField: json('json_field').$type<Data>(),
+  });
+  ```
+
+- ❗ Changed syntax for text-based enum columns:
+  
+    ```ts
+    // Before
+    const test = mysqlTable('test', {
+      role: text<'admin' | 'user'>('role'),
+    });
+  
+    // After
+    const test = mysqlTable('test', {
+      role: text('role', { enum: ['admin', 'user'] }),
+    });
+    ```
+
+- 🎉 Allowed passing an array of values into `.insert().values()` directly without spreading:
+
+  ```ts
+  const users = mysqlTable('users', {
+    id: int('id').primaryKey(),
+    name: text('name').notNull(),
+  });
+
+  await users.insert().values([
+    { name: 'John' },
+    { name: 'Jane' },
+  ]);
+  ```
+
+  The spread syntax is now deprecated and will be removed in one of the next releases.
+
+- 🎉 Added "table creators" to allow for table name customization:
+
+  ```ts
+  import { mysqlTableCreator } from 'drizzle-orm/mysql-core';
+
+  const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
+
+  const users = mysqlTable('users', {
+    id: int('id').primaryKey(),
+    name: text('name').notNull(),
+  });
+
+  // Users table is a normal table, but its name is `myprefix_users` in runtime
+  ```
+
+- 🎉 Implemented support for selecting/joining raw SQL expressions:
+  
+  ```ts
+  // select current_date + s.a as dates from generate_series(0,14,7) as s(a);
+  const result = await db
+    .select({
+      dates: sql`current_date + s.a`,
+    })
+    .from(sql`generate_series(0,14,7) as s(a)`);
+  ```
+
+- 🐛 Fixed a lot of bugs from user feedback on GitHub and Discord (thank you! ❤). Fixes #293 #301 #276 #269 #253 #311 #312

docs/custom-types.lite.md

@@ -204,7 +204,13 @@ export type CustomTypeValues = {
   /**
    * What config type should be used for {@link CustomTypeParams} `dataType` generation
    */
-  config?: Record<string, unknown>;
+  config?: unknown;
+
+  /**
+   * Whether the config argument should be required or not
+   * @default false
+   */
+  configRequired?: boolean;
 
   /**
    * If your custom data type should be notNull by default you can use `notNull: true`
@@ -231,7 +237,7 @@ export type CustomTypeValues = {
   default?: boolean;
 };
 
-export interface CustomTypeParams<T extends CustomTypeValues> {
+export interface CustomTypeParams<T extends Partial<CustomTypeValues>> {
   /**
    * Database data type string representation, that is used for migrations
    * @example
@@ -261,7 +267,7 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
    *   }
    * ```
    */
-  dataType: (config: T['config']) => string;
+  dataType: (config: T['config'] | (Equal<T['configRequired'], true> extends true ? never : undefined)) => string;
 
   /**
    * Optional mapping function, between user input and driver
@@ -273,7 +279,7 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
    * }
    * ```
    */
-  toDriver?: (value: T['data']) => T['driverData'];
+  toDriver?: (value: T['data']) => T['driverData'] | SQL;
 
   /**
    * Optional mapping function, that is responsible for data mapping from database to JS/TS code

docs/custom-types.md

@@ -30,17 +30,17 @@ Each type creation should use 2 classes:
 
 ```typescript
 export class PgTextBuilder<TData extends string = string>
-	extends PgColumnBuilder<
-		ColumnBuilderConfig<{ data: TData; driverParam: string }>
-	>
+  extends PgColumnBuilder<
+    ColumnBuilderConfig<{ data: TData; driverParam: string }>
+  >
 {
-	protected override $pgColumnBuilderBrand!: 'PgTextBuilder';
+  
 
-	build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgText<TTableName, TData> {
-		return new PgText(table, this.config);
-	}
+  build<TTableName extends string>(
+    table: AnyPgTable<{ name: TTableName }>,
+  ): PgText<TTableName, TData> {
+    return new PgText(table, this.config);
+  }
 }
 ```
 
@@ -62,7 +62,7 @@ Column class has set of types/functions, that could be overridden to get needed
 
 ```typescript
 override mapToDriverValue(value: TData): string {
-	return JSON.stringify(value);
+  return JSON.stringify(value);
 }
 ```
 
@@ -72,35 +72,35 @@ override mapToDriverValue(value: TData): string {
 
 ```typescript
 override mapFromDriverValue(value: number | string): number {
-	if (typeof value === 'string') {
-		return parseInt(value);
-	}
-	return value;
+  if (typeof value === 'string') {
+    return parseInt(value);
+  }
+  return value;
 }
 ```
 
 #### Column class example
 
 ```typescript
 export class PgText<TTableName extends string, TData extends string>
-	extends PgColumn<ColumnConfig<{ tableName: TTableName; data: TData; driverParam: string }>> {
-	protected override $pgColumnBrand!: 'PgText';
+  extends PgColumn<ColumnConfig<{ tableName: TTableName; data: TData; driverParam: string }>> {
+  
 
-	constructor(table: AnyPgTable<{ name: TTableName }>, builder: PgTextBuilder<TData>['config']) {
-		super(table, builder);
-	}
+  constructor(table: AnyPgTable<{ name: TTableName }>, builder: PgTextBuilder<TData>['config']) {
+    super(table, builder);
+  }
 
-	getSQLType(): string {
-		return 'text';
-	}
+  getSQLType(): string {
+    return 'text';
+  }
 
-	override mapFromDriverValue(value: string): TData {
-		return value as TData
-	}
+  override mapFromDriverValue(value: string): TData {
+    return value as TData
+  }
 
-	override mapToDriverValue(value: TData): string {
-		return value
-	}
+  override mapToDriverValue(value: TData): string {
+    return value
+  }
 }
 ```
 
@@ -122,42 +122,42 @@ import { AnyPgTable } from '~/table';
 import { PgColumn, PgColumnBuilder } from './common';
 
 export class PgTextBuilder<TData extends string = string>
-	extends PgColumnBuilder<
-		ColumnBuilderConfig<{ data: TData; driverParam: string }>
-	>
+  extends PgColumnBuilder<
+    ColumnBuilderConfig<{ data: TData; driverParam: string }>
+  >
 {
-	protected override $pgColumnBuilderBrand!: 'PgTextBuilder';
+  
 
-	build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgText<TTableName, TData> {
-		return new PgText(table, this.config);
-	}
+  build<TTableName extends string>(
+    table: AnyPgTable<{ name: TTableName }>,
+  ): PgText<TTableName, TData> {
+    return new PgText(table, this.config);
+  }
 }
 
 export class PgText<TTableName extends string, TData extends string>
-	extends PgColumn<
-		ColumnConfig<{ tableName: TTableName; data: TData; driverParam: string }>
-	>
+  extends PgColumn<
+    ColumnConfig<{ tableName: TTableName; data: TData; driverParam: string }>
+  >
 {
-	protected override $pgColumnBrand!: 'PgText';
-
-	constructor(
-		table: AnyPgTable<{ name: TTableName }>,
-		builder: PgTextBuilder<TData>['config'],
-	) {
-		super(table, builder);
-	}
-
-	getSQLType(): string {
-		return 'text';
-	}
+  
+
+  constructor(
+    table: AnyPgTable<{ name: TTableName }>,
+    builder: PgTextBuilder<TData>['config'],
+  ) {
+    super(table, builder);
+  }
+
+  getSQLType(): string {
+    return 'text';
+  }
 }
 
 export function text<T extends string = string>(
-	name: string,
+  name: string,
 ): PgTextBuilder<T> {
-	return new PgTextBuilder(name);
+  return new PgTextBuilder(name);
 }
 ```
 
@@ -181,40 +181,40 @@ export function text<T extends string = string>(
 
 ```typescript
 export class PgCITextBuilder<TData extends string = string> extends PgColumnBuilder<
-	ColumnBuilderConfig<{ data: TData; driverParam: string }>
+  ColumnBuilderConfig<{ data: TData; driverParam: string }>
 > {
   protected $pgColumnBuilderBrand: string = 'PgCITextBuilder';
 
-	build<TTableName extends string>(table: AnyPgTable<{ name: TTableName }>): PgCIText<TTableName, TData> {
-		return new PgCIText(table, this.config);
-	}
+  build<TTableName extends string>(table: AnyPgTable<{ name: TTableName }>): PgCIText<TTableName, TData> {
+    return new PgCIText(table, this.config);
+  }
 }
 
 export class PgCIText<TTableName extends string, TData extends string>
-	extends PgColumn<ColumnConfig<{ tableName: TTableName; data: TData; driverParam: string }>>
+  extends PgColumn<ColumnConfig<{ tableName: TTableName; data: TData; driverParam: string }>>
 {
-	protected override $pgColumnBrand!: 'PgCIText';
+  
 
-	constructor(table: AnyPgTable<{ name: TTableName }>, builder: PgCITextBuilder<TData>['config']) {
-		super(table, builder);
-	}
+  constructor(table: AnyPgTable<{ name: TTableName }>, builder: PgCITextBuilder<TData>['config']) {
+    super(table, builder);
+  }
 
-	getSQLType(): string {
-		return 'citext';
-	}
+  getSQLType(): string {
+    return 'citext';
+  }
 }
 
 export function citext<T extends string = string>(name: string): PgCITextBuilder<T> {
-	return new PgCITextBuilder(name);
+  return new PgCITextBuilder(name);
 }
 ```
 
 #### Usage example
 
 ```typescript
 const table = pgTable('table', {
-	id: integer('id').primaryKey(),
-	ciname: citext('ciname')
+  id: integer('id').primaryKey(),
+  ciname: citext('ciname')
 })
 ```