Rebase/drizzle main (#33)

* Initial implementation for optional column alias in PG * Move line and point types into `postgis_extensions` folder * Update PG column exports * Update PG column types that don't have config param * Update postgis column types * Update PG vector column types * Update the rest of PG columns * Improve types * Add type tests * Update MySQL columns * Update PG custom column * Fix issue with undefined config * Add MySQL type and integration tests * Update SQLite columns * Eliminate duplicate code * Add type and integration tests to SQLite * Slightly simplify column type definitions * Remove unnecessary `any` casts * Fix lint error * Format * Moved `line` and `point` back to `columns` folder in PG * Fix import * LibSQL improvements Added: - handling alteting columns in libsql - new json statement for recreation table for sqlite and libsql - push updated for sqlite and libsql - tests * - updated tests - added handling create reference and create column for sqlite and libsql * - handled foreign keys for recreate table - handled alter column with unique keys - made more tests - updated recreate sql statements order * changed package json to prev state * updated tests * Test implementation * Type-level implementation * Added functional runtimes for node-pg, aws-data-api-pg [custom drizzle config WIP] * Resolved bun type related build issues * Implemented extra drivers * Setup common casing config * Implement casing cache in PG * Update PG driver configs and inits * Update AWS Data API driver * Add additional PG tests * Remove raw SQL test cases from PG * Add set operator tests to PG * Rename PG test files * Implement MySQL casing cache * Update MySQL drivers config and init * Expose casing transformation functions * Complete runtime implementations [TO BE TESTED] * Prototype implementation * switched bun to dynamic imports * Removed static imports, removed promise wrapper * Returned async imports due to conflicts * More comnprehensive import errors * Add additional MySQL and PG tests * Update SQLite drivers * Remove manual casing caching * Update test names * Implement SQLite casing cache * Add ability to define column types without imports (callback fn) * Format * Changed error messge * Improved params destructurization * Functional prototype of SQLite $count * Added pg, mysql; Added tests, type tests for $count * Added alternate config for better-sqlite3, bun:sqlite; Renamed bun-sqlite to bun:sqlite; Fixed schema inferrence issue (no schema would resrresult in `unknown`, expected: `Record<string, never>`) * - moved 'turso' driver to dialect - rewrote tests * fixed dialects in introspect musql, psql, sqlite updated packages * updated tests and removed pragma from push in libsql * removed console.log * Added monomigrator * Changed style of monodriver, monomigrator function args * Fixed overload order for better autocomplete * Removed garbage * updated pull config update migrate function in drizzle-orm * removed driver * Added missing postgres.js to monomigrator * Fixed missing defaults in templates * updated sqlite connection to libsql * Improved types, matched supported instances of monodriver and monomigrator, fixed pg withReplicas type's schema inferrence, fixed lack of [entityKind] on some instances, fixed migrators not accepting string as a config * Fixed invalid [entityKind] call * Added `:memory:` autocomplete * Removed leftover code from overloads, added `assertUnreachable` * Added missing runtime tests * Exposed db drivers from monodriver * Fixed test tables using already existing names * Fixed faulty test cases; Fixed lack of count type conversion in mysql; added all method functionality to pg proxy driver; added websocket instance to monodriver neon serverless config * Switched mysql count to execute * Added cast to embedded * Switched to `.execute` for mysql, pg; reverted pg proxy session changes; fixed misplaced mysql tests; removed unused args * Moved type conversion drom db to ORM; improved types * Moved pg, mysql counts to sessions to resolve return shape conflicts * Fixed neon-http, planetscale; removed leftover lines; switched sqlite to session-based count * changed console.log outputs for connection to Sqlite returned removed console.log in mysql push * Add draft for beta release * Improved types optional params arg where connection isn ot required; fixed vercel instance asking for client * Improved types, added `Turso` alias for `libsql` * Fixed incorrect order of ws assignment on neon-serverless, added ability to specify connection as string to multiple drivers that didn't support it by assigning passed string as connectionString or url inside the driver * Removed monodriver node-pg due to incompatibility with import() * Add release notes for orm and kit * Returned node-postgres * Removed outdated migration config string type * Update release notes * Monodriver improvements, added $client to all compatible drizzle instances, fixed Drizzle D1 not accepting miniflare D1 on type level * Add kit casing for pg * Export `int.common.ts` in `columns/index.ts` * String as execute input * Remove cirucular deps * Format * Fixed version * Update introspect pg * Update roadmap * Add introspect for cases to mysql and sqlite * Add pglite to monodriver * Add pglite to monomigrator * Fix language * Serialize with casing * Add PG casing tests * Update schemaDiffer.ts file * Add casing tests to MySQL * Add SQLite casing serialization tests * Format * Fix api.ts file errors * Update tests * Update tests * Update tests * Change literals for CasingType type * Update tests * Fixed count builders imports importing modules from index instead of dedicated locations * Additional import fixes * Fixed type imports being imported as entities * Removed monodriver, monomigrator to `\/connect` * Fixed lack of file extensions in imports * Fix types for index.ts * Update release notes * Add Xata workaround for identity columns * fix: add import extensions to async imports * fix fix-imports.ts * bump to 0.34.1 --------- Co-authored-by: Mario564 <[email protected]> Co-authored-by: Aleksandr Sherman <[email protected]> Co-authored-by: Sukairo-02 <[email protected]> Co-authored-by: Andrii Sherman <[email protected]> Co-authored-by: w3cj <[email protected]> Co-authored-by: Alex Blokh <[email protected]>
singlestore-labs · Oct 15, 2024 · b6338f8 · b6338f8
1 parent 42758b9
commit b6338f8
Show file tree

Hide file tree

Showing 237 changed files with 16,812 additions and 1,884 deletions.
diff --git a/changelogs/drizzle-kit/0.25.0.md b/changelogs/drizzle-kit/0.25.0.md
@@ -0,0 +1,180 @@
+## Breaking changes and migrate guide for Turso users
+
+If you are using Turso and libsql, you will need to upgrade your `drizzle.config` and `@libsql/client` package.
+
+1. This version of drizzle-orm will only work with `@libsql/[email protected]` or higher if you are using the `migrate` function. For other use cases, you can continue using previous versions(But the suggestion is to upgrade)
+To install the latest version, use the command:
+
+```bash
+npm i @libsql/client@latest
+```
+
+2. Previously, we had a common `drizzle.config` for SQLite and Turso users, which allowed a shared strategy for both dialects. Starting with this release, we are introducing the turso dialect in drizzle-kit. We will evolve and improve Turso as a separate dialect with its own migration strategies.
+
+**Before**
+
+```ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: "database.db",
+  },
+  breakpoints: true,
+  verbose: true,
+  strict: true,
+});
+```
+
+**After**
+
+```ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "turso",
+  schema: "./schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: "database.db",
+  },
+  breakpoints: true,
+  verbose: true,
+  strict: true,
+});
+```
+
+If you are using only SQLite, you can use `dialect: "sqlite"`
+
+## LibSQL/Turso and Sqlite migration updates
+
+### SQLite "generate" and "push" statements updates
+
+Starting from this release, we will no longer generate comments like this:
+
+```sql
+      '/*\n SQLite does not support "Changing existing column type" out of the box, we do not generate automatic migration for that, so it has to be done manually'
+      + '\n Please refer to: https://www.techonthenet.com/sqlite/tables/alter_table.php'
+      + '\n                  https://www.sqlite.org/lang_altertable.html'
+      + '\n                  https://stackoverflow.com/questions/2083543/modify-a-columns-type-in-sqlite3'
+      + "\n\n Due to that we don't generate migration automatically and it has to be done manually"
+      + '\n*/'
+```
+
+We will generate a set of statements, and you can decide if it's appropriate to create data-moving statements instead. Here is an example of the SQL file you'll receive now:
+
+```sql
+PRAGMA foreign_keys=OFF;
+--> statement-breakpoint
+CREATE TABLE `__new_worker` (
+  `id` integer PRIMARY KEY NOT NULL,
+  `name` text NOT NULL,
+  `salary` text NOT NULL,
+  `job_id` integer,
+  FOREIGN KEY (`job_id`) REFERENCES `job`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+INSERT INTO `__new_worker`("id", "name", "salary", "job_id") SELECT "id", "name", "salary", "job_id" FROM `worker`;
+--> statement-breakpoint
+DROP TABLE `worker`;
+--> statement-breakpoint
+ALTER TABLE `__new_worker` RENAME TO `worker`;
+--> statement-breakpoint
+PRAGMA foreign_keys=ON;
+```
+
+### LibSQL/Turso "generate" and "push" statements updates
+
+Since LibSQL supports more ALTER statements than SQLite, we can generate more statements without recreating your schema and moving all the data, which can be potentially dangerous for production environments.
+
+LibSQL and Turso will now have a separate dialect in the Drizzle config file, meaning that we will evolve Turso and LibSQL independently from SQLite and will aim to support as many features as Turso/LibSQL offer.
+
+With the updated LibSQL migration strategy, you will have the ability to:
+
+- **Change Data Type**: Set a new data type for existing columns.
+- **Set and Drop Default Values**: Add or remove default values for existing columns.
+- **Set and Drop NOT NULL**: Add or remove the NOT NULL constraint on existing columns.
+- **Add References to Existing Columns**: Add foreign key references to existing columns
+
+You can find more information in the [LibSQL documentation](https://github.com/tursodatabase/libsql/blob/main/libsql-sqlite3/doc/libsql_extensions.md#altering-columns)
+
+### LIMITATIONS
+
+- Dropping or altering an index will cause table recreation.
+
+This is because LibSQL/Turso does not support dropping this type of index.
+
+```sql
+CREATE TABLE `users` (
+  `id` integer NOT NULL,
+  `name` integer,
+  `age` integer PRIMARY KEY NOT NULL
+  FOREIGN KEY (`name`) REFERENCES `users1`("id") ON UPDATE no action ON DELETE no action
+);
+```
+
+- If the table has indexes, altering columns will cause table recreation.
+- Drizzle-Kit will drop the indexes, modify the columns, and then recreate the indexes.
+- Adding or dropping composite foreign keys is not supported and will cause table recreation
+
+### NOTES
+
+- You can create a reference on any column type, but if you want to insert values, the referenced column must have a unique index or primary key.
+
+```sql
+CREATE TABLE parent(a PRIMARY KEY, b UNIQUE, c, d, e, f);
+CREATE UNIQUE INDEX i1 ON parent(c, d);
+CREATE INDEX i2 ON parent(e);
+CREATE UNIQUE INDEX i3 ON parent(f COLLATE nocase);
+
+CREATE TABLE child1(f, g REFERENCES parent(a));                        -- Ok
+CREATE TABLE child2(h, i REFERENCES parent(b));                        -- Ok
+CREATE TABLE child3(j, k, FOREIGN KEY(j, k) REFERENCES parent(c, d));  -- Ok
+CREATE TABLE child4(l, m REFERENCES parent(e));                        -- Error!
+CREATE TABLE child5(n, o REFERENCES parent(f));                        -- Error!
+CREATE TABLE child6(p, q, FOREIGN KEY(p, q) REFERENCES parent(b, c));  -- Error!
+CREATE TABLE child7(r REFERENCES parent(c));                           -- Error!
+```
+
+> **NOTE**: The foreign key for the table child5 is an error because, although the parent key column has a unique index, the index uses a different collating sequence.
+
+See more: https://www.sqlite.org/foreignkeys.html
+
+## New `casing` param in `drizzle-orm` and `drizzle-kit`
+
+There are more improvements you can make to your schema definition. The most common way to name your variables in a database and in TypeScript code is usually `snake_case` in the database and `camelCase` in the code. For this case, in Drizzle, you can now define a naming strategy in your database to help Drizzle map column keys automatically. Let's take a table from the previous example and make it work with the new casing API in Drizzle
+
+Table can now become:
+```ts
+import { pgTable } from "drizzle-orm/pg-core";
+
+export const ingredients = pgTable("ingredients", (t) => ({
+  id: t.uuid().defaultRandom().primaryKey(),
+  name: t.text().notNull(),
+  description: t.text(),
+  inStock: t.boolean().default(true),
+}));
+```
+As you can see, `inStock` doesn't have a database name alias, but by defining the casing configuration at the connection level, all queries will automatically map it to `snake_case`
+
+```ts
+const db = await drizzle('node-postgres', { connection: '', casing: 'snake_case' })
+```
+
+For `drizzle-kit` migrations generation you should also specify `casing` param in drizzle config, so you can be sure you casing strategy will be applied to drizzle-kit as well
+
+```ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./schema.ts",
+  dbCredentials: {
+    url: "postgresql://postgres:password@localhost:5432/db",
+  },
+  casing: "snake_case",
+});
+```