chore(deps): update dependency drizzle-kit to ^0.26.0 #27

renovate · 2023-11-09T21:31:59Z

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
drizzle-kit (source)	`^0.19.13` -> `^0.26.0`

Release Notes

drizzle-team/drizzle-orm (drizzle-kit)

`v0.26.2`

Compare Source

🐛 Fixed upsert targeting composite keys for SQLite (#521)
🐛 AWS Data API+Postgres: fixed adding of typings when merging queries (#517)
🐛 Fixed "on conflict" with "where" clause for Postgres (#651)
🐛 Various GitHub docs community fixes and improvements ♥ (#547, #548, #587, #606, #609, #625)
Experimental: added OpenTelemetry support for Postgres

`v0.26.1`

Compare Source

🐛 Fixed including multiple relations on the same level in RQB (#599)
🐛 Updated migrators for relational queries support (#601)
🐛 Fixed invoking .findMany() without arguments

`v0.26.0`

Compare Source

Drizzle ORM 0.26.0 is here 🎉

README docs are fully transferred to web

The documentation has been completely reworked and updated with additional examples and explanations. You can find it here: https://orm.drizzle.team.

Furthermore, the entire documentation has been made open source, allowing you to edit and add any information you deem important for the community.

Visit https://github.com/drizzle-team/drizzle-orm-docs to access the open-sourced documentation.

Additionally, you can create specific documentation issues in this repository

New Features

Introducing our first helper built on top of Drizzle Core API syntax: the Relational Queries! 🎉

With Drizzle RQ you can do:

Any amount of relations that will be mapped for you
Including or excluding! specific columns. You can also combine these options
Harness the flexibility of the where statements, allowing you to define custom conditions beyond the predefined ones available in the Drizzle Core API.
Expand the functionality by incorporating additional extras columns using SQL templates. For more examples, refer to the documentation.

Most importantly, regardless of the size of your query, Drizzle will always generate a SINGLE optimized query.

This efficiency extends to the usage of Prepared Statements, which are fully supported within the Relational Query Builder.

For more info: Prepared Statements in Relational Query Builder

Example of setting one-to-many relations

As you can observe, relations are a distinct concept that coexists alongside the main Drizzle schema. You have the flexibility to opt-in or opt-out of them at any time without affecting the drizzle-kit migrations or the logic for Core API's types and runtime.

import { integer, serial, text, pgTable } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';
 
export const users = pgTable('users', {
	id: serial('id').primaryKey(),
	name: text('name').notNull(),
});
 
export const usersConfig = relations(users, ({ many }) => ({
	posts: many(posts),
}));
 
export const posts = pgTable('posts', {
	id: serial('id').primaryKey(),
	content: text('content').notNull(),
	authorId: integer('author_id').notNull(),
});
 
export const postsConfig = relations(posts, ({ one }) => ({
	author: one(users, { fields: [posts.authorId], references: [users.id] }),
}));

Example of querying you database

Step 1: Provide all tables and relations to drizzle function

drizzle import depends on the database driver you're using

import * as schema from './schema';
import { drizzle } from 'drizzle-orm/...';
 
const db = drizzle(client, { schema });
 
await db.query.users.findMany(...);

If you have schema in multiple files

import * as schema1 from './schema1';
import * as schema2 from './schema2';
import { drizzle } from 'drizzle-orm/...';
 
const db = drizzle(client, { schema: { ...schema1, ...schema2 } });
 
await db.query.users.findMany(...);

Step 2: Query your database with Relational Query Builder

Select all users

const users = await db.query.users.findMany();

Select first users

.findFirst() will add limit 1 to the query

const user = await db.query.users.findFirst();

Select all users
Get all posts with just id, content and include comments

const posts = await db.query.posts.findMany({
	columns: {
		id: true,
		content: true,
	},
	with: {
		comments: true,
	}
});

Select all posts excluding content column

const posts = await db.query.posts.findMany({
	columns: {
		content: false,
	},
});

For more examples you can check full docs for Relational Queries

Bug fixes

🐛 Fixed partial joins with prefixed tables (#542)

Drizzle Kit updates

New ways to define drizzle config file

You can now specify the configuration not only in the .json format but also in .ts and .js formats.

TypeScript example

import { Config } from "drizzle-kit";

export default {
  schema: "",
  connectionString: process.env.DB_URL,
  out: "",
  breakpoints: true
} satisfies Config;

JavaScript example

/** @&#8203;type { import("drizzle-kit").Config } */
export default {
    schema: "",
  connectionString: "",
  out: "",
  breakpoints: true
};

New commands 🎉

`drizzle-kit push:mysql`

You can now push your MySQL schema directly to the database without the need to create and manage migration files. This feature proves to be particularly useful for rapid local development and when working with PlanetScale databases.

By pushing the MySQL schema directly to the database, you can streamline the development process and avoid the overhead of managing migration files. This allows for more efficient iteration and quick deployment of schema changes during local development.

How to setup your codebase for drizzle-kit push feature?

For this feature, you need to create a drizzle.config.[ts|js|json] file. We recommend using .ts or .js files as they allow you to easily provide the database connection information as secret variables

You'll need to specify schema and connectionString(or db, port, host, password, etc.) to make drizzle-kit push:mysql work

drizzle.config.ts example

import { Config } from "src";

export default {
  schema: "./schema.ts",
  connectionString: process.env.DB_URL,
} satisfies Config;

Run drizzle-kit push:mysql
If Drizzle detects any potential data-loss issues during a migration, it will prompt you to approve whether the data should be truncated or not in order to ensure a successful migration
Approve or reject the action that Drizzle needs to perform in order to push your schema changes to the database.
Done ✅

`v0.25.0`

Compare Source

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.

This version of drizzle-orm will only work with @libsql/client@0.10.0 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:

npm i @&#8203;libsql/client@latest

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

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

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:

      '/*\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:

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

LIMITATIONS

Dropping foreign key will cause table recreation.

This is because LibSQL/Turso does not support dropping this type of foreign key.

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 index recreation:
Drizzle-Kit will drop the indexes, modify the columns, and then create the indexes.
Adding or dropping composite foreign keys is not supported and will cause table recreation.
Primary key columns can not be altered and will cause table recreation.
Altering columns that are part of foreign key 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.

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:

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

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

import { defineConfig } from "drizzle-kit";

export default defineConfig({
  dialect: "postgresql",
  schema: "./schema.ts",
  dbCredentials: {
    url: "postgresql://postgres:password@localhost:5432/db",
  },
  casing: "snake_case",
});

`v0.24.2`

Compare Source

New Features

🎉 Support for `pglite` driver

You can now use pglite with all drizzle-kit commands, including Drizzle Studio!

import { defineConfig } from "drizzle-kit";

export default defineConfig({
  dialect: "postgresql",
  driver: "pglite",
  schema: "./schema.ts",
  dbCredentials: {
    url: "local-pg.db",
  },
  verbose: true,
  strict: true,
});

Bug fixes

mysql-kit: fix GENERATED ALWAYS AS ... NOT NULL - #2824

`v0.24.1`

Compare Source

Bug fixes

Big thanks to @L-Mario564 for his PR. It conflicted in most cases with a PR that was merged, but we incorporated some of his logic. Merging it would have caused more problems and taken more time to resolve, so we just took a few things from his PR, like removing "::" mappings in introspect and some array type default handlers

What was fixed

The Drizzle Kit CLI was not working properly for the introspect command.
Added the ability to use column names with special characters for all dialects.
Included PostgreSQL sequences in the introspection process.
Reworked array type introspection and added all test cases.
Fixed all (we hope) default issues in PostgreSQL, where ::<type> was included in the introspected output.
preserve casing option was broken

Tickets that were closed

`v0.24.0`

Compare Source

🎉 Added iterator support to mysql2 (sponsored by @rizen ❤). Read more in the docs
❗ .prepare() in MySQL no longer requires a name argument

`v0.23.2`

Compare Source

Fixed a bug in PostgreSQL with push and introspect where the schemaFilter object was passed. It was detecting enums even in schemas that were not defined in the schemaFilter.
Fixed the drizzle-kit up command to work as expected, starting from the sequences release.

`v0.23.1`

Compare Source

🐛 Re-export InferModel from drizzle-orm

`v0.23.0`

Compare Source

🎉 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
- Kysely adapter

🎉 Added "type maps" to all entities. You can access them via the special _ property. For example:

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.

// 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:

// 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:

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:

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:

// 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

🎉 Introduced a standalone query builder that can be used without a DB connection:

import { queryBuilder as qb } from 'drizzle-orm/pg-core';

const query = qb.select().from(users).where(eq(users.name, 'Dan'));
const { sql, params } = query.toSQL();

🎉 Improved WITH ... SELECT subquery creation syntax to more resemble SQL:

Before:

const regionalSales = db
  .select({
    region: orders.region,
    totalSales: sql`sum(${orders.amount})`.as<number>('total_sales'),
})
.from(orders)
.groupBy(orders.region)
.prepareWithSubquery('regional_sales');

await db.with(regionalSales).select(...).from(...);

After:

const regionalSales = db
  .$with('regional_sales')
  .as(
    db
      .select({
        region: orders.region,
        totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
      })
      .from(orders)
      .groupBy(orders.region),
  );

await db.with(regionalSales).select(...).from(...);

`v0.21.4`

Compare Source

`v0.21.3`

Compare Source

`v0.21.2`

Compare Source

`v0.21.1`

Compare Source

🎉 Added support for HAVING clause

🎉 Added support for referencing selected fields in .where(), .having(), .groupBy() and .orderBy() using an optional callback:

await db
  .select({
    id: citiesTable.id,
    name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
    usersCount: sql<number>`count(${users2Table.id})::int`.as('users_count'),
  })
  .from(citiesTable)
  .leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
  .where(({ name }) => sql`length(${name}) >= 3`)
  .groupBy(citiesTable.id)
  .having(({ usersCount }) => sql`${usersCount} > 0`)
  .orderBy(({ name }) => name);

`v0.21.0`

Compare Source

Drizzle ORM 0.21.0 was released 🎉

Added support for new migration folder structure and breakpoints feature, described in drizzle-kit release section
Fix onUpdateNow() expression generation for default migration statement

Support for PostgreSQL array types

export const salEmp = pgTable('sal_emp', {
  name: text('name').notNull(),
  payByQuarter: integer('pay_by_quarter').array(),
  schedule: text('schedule').array().array(),
});

export const tictactoe = pgTable('tictactoe', {
  squares: integer('squares').array(3).array(3),
});

drizzle kit will generate

CREATE TABLE sal_emp (
  name            text,
  pay_by_quarter  integer[],
  schedule        text[][]
);

CREATE TABLE tictactoe (
  squares   integer[3][3]
);

Added composite primary key support to PostgreSQL and MySQL

PostgreSQL

import { primaryKey } from 'drizzle-orm/pg-core';

export const cpkTable = pgTable('table', {
  column1: integer('column1').default(10).notNull(),
  column2: integer('column2'),
  column3: integer('column3'),
}, (table) => ({
  cpk: primaryKey(table.column1, table.column2),
}));

MySQL

import { primaryKey } from 'drizzle-orm/mysql-core';

export const cpkTable = mysqlTable('table', {
  simple: int('simple'),
  columnNotNull: int('column_not_null').notNull(),
  columnDefault: int('column_default').default(100),
}, (table) => ({
  cpk: primaryKey(table.simple, table.columnDefault),
}));

Drizzle Kit 0.17.0 was released 🎉

Breaking changes

Folder structure was migrated to newer version

Before running any new migrations drizzle-kit will ask you to upgrade in a first place

Migration file structure < 0.17.0

📦 <project root>
 └ 📂 migrations
    └ 📂 20221207174503
       ├ 📜 migration.sql
       ├ 📜 snapshot.json
    └ 📂 20230101104503
       ├ 📜 migration.sql
       ├ 📜 snapshot.json

Migration file structure >= 0.17.0

📦 <project root>
 └ 📂 migrations
    └ 📂 meta
      ├ 📜 _journal.json
      ├ 📜 0000_snapshot.json
      ├ 📜 0001_snapshot.json
    └ 📜 0000_icy_stranger.sql
    └ 📜 0001_strange_avengers.sql

Upgrading to 0.17.0

To easily migrate from previous folder structure to new you need to run up command in drizzle kit. It's a great helper to upgrade your migrations to new format on each drizzle kit major update

drizzle-kit up:<dialect> # dialects: `pg`, `mysql`, `sqlite`

### example for pg
drizzle-kit up:pg

New Features

New `drizzle-kit` command called `drop`

In a case you think some of migrations were generated in a wrong way or you have made migration simultaneously with other developers you can easily rollback it by running simple command

Warning:
Make sure you are dropping migrations that were not applied to your database

drizzle-kit drop

This command will show you a list of all migrations you have and you'll need just to choose migration you want to drop. After that drizzle-kit will do all the hard work on deleting migration files

New `drizzle-kit` option `--breakpoints` for `generate` and `introspect` commands

If particular driver doesn't support running multiple quries in 1 execution you can use --breakpoints.

drizzle-kit will generate current sql

CREATE TABLE `users` (
  `id` int PRIMARY KEY NOT NULL,
  `full_name` text NOT NULL,
);
--> statement-breakpoint
CREATE TABLE `table` (
  `id` int PRIMARY KEY NOT NULL,
  `phone` int,
);

Using it drizzle-orm will split all sql files by statements and execute them separately

Add `drizzle-kit introspect` for MySQL dialect

You can introspect your mysql database using introspect:mysql command

drizzle-kit introspect:mysql --out ./migrations --connectionString mysql://user:password@127.0.0.1:3306/database

Support for glob patterns for schema path

Usage example in cli

drizzle-kit generate:pg --out ./migrations --schema ./core/**/*.ts ./database/schema.ts

Usage example in drizzle.config

{
  "out: "./migrations", 
  "schema": ["./core/**/*.ts", "./database/schema.ts"]
}

Bug Fixes and improvements

Postgres dialect

GitHub issue fixes

[pg] char is undefined during introspection #9
when unknown type is detected, would be nice to emit a TODO comment instead of undefined #8
"post_id" integer DEFAULT currval('posts_id_seq'::regclass) generates invalid TS #7
"ip" INET NOT NULL is not supported #6
"id" UUID NOT NULL DEFAULT uuid_generate_v4() type is not supported #5
array fields end up as "undefined" in the schema #4
timestamp is not in the import statement in schema.ts #3
generated enums are not camel cased #2

Introspect improvements

Add support for composite PK's generation;
Add support for cidr, inet, macaddr, macaddr8, smallserial
Add interval fields generation in schema, such as minute to second, day to hour, etc.
Add default values for numerics
Add default values for enums

MySQL dialect

Migration generation improvements

Add autoincrement create, delete and update handling
Add on update current_timestamp handling for timestamps
Add data type changing, using modify
Add not null changing, using modify
Add default drop and create statements
Fix defaults generation bugs, such as escaping, date strings, expressions, etc

Introspect improvements

Add autoincrement to all supported types
Add fsp for time based data types
Add precision and scale for double
Make time { mode: "string" } by default
Add defaults to json, decimal and binary datatypes
Add enum data type generation

`v0.20.18`

Compare Source

`v0.20.17`

Compare Source

`v0.20.16`

Compare Source

`v0.20.15`

Compare Source

`v0.20.14`

Compare Source

`v0.20.13`

Compare Source

`v0.20.12`

Compare Source

`v0.20.11`

Compare Source

`v0.20.10`

Compare Source

`v0.20.9`

Compare Source

`v0.20.8`

Compare Source

`v0.20.7`

Compare Source

`v0.20.6`

Compare Source

`v0.20.5`

Compare Source

`v0.20.4`

Compare Source

`v0.20.3`

Compare Source

🎉 Added support for locking clauses in SELECT (SELECT ... FOR UPDATE):

PostgreSQL

await db
  .select()
  .from(users)
  .for('update')
  .for('no key update', { of: users })
  .for('no key update', { of: users, skipLocked: true })
  .for('share', { of: users, noWait: true });

MySQL

await db.select().from(users).for('update');
await db.select().from(users).for('share', { skipLocked: true });
await db.select().from(users).for('update', { noWait: true });

🎉🐛 Custom column types now support returning SQL from toDriver() method in addition to the driverData type from generic.

`v0.20.2`

Compare Source

🎉 Added PostgreSQL network data types:
- inet
- cidr
- macaddr
- macaddr8

`v0.20.1`

Compare Source

🎉 Added { logger: true } shorthand to drizzle() to enable query logging. See logging docs for detailed logging configuration.

`v0.20.0`

Compare Source

🎉 Implemented support for WITH clause (docs). Example usage:

const sq = db
  .select()
  .from(users)
  .prepareWithSubquery('sq');

const result = await db
  .with(sq)
  .select({
    id: sq.id,
    name: sq.name,
    total: sql<number>`count(${sq.id})::int`(),
  })
  .from(sq)
  .groupBy(sq.id, sq.name);

🐛 Fixed various bugs with selecting/joining of subqueries.
❗ Renamed .subquery('alias') to .as('alias').
❗ sql`query`.as<type>() is now sql<type>`query`(). Old syntax is still supported, but is deprecated and will be removed in one of the next releases.

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

cloudflare-workers-and-pages · 2023-11-09T21:32:00Z

Deploying cash-register with Cloudflare Pages

Latest commit:	`9827aee`
Status:	✅ Deploy successful!
Preview URL:	https://e7a0d75e.cash-register-3az.pages.dev
Branch Preview URL:	https://renovate-drizzle-kit-0-x.cash-register-3az.pages.dev

View logs

renovate bot force-pushed the renovate/drizzle-kit-0.x branch from 203bb30 to 2b773b7 Compare May 9, 2024 16:07

renovate bot changed the title ~~chore(deps): update dependency drizzle-kit to ^0.20.0~~ chore(deps): update dependency drizzle-kit to ^0.21.0 May 9, 2024

renovate bot force-pushed the renovate/drizzle-kit-0.x branch from 2b773b7 to 562862f Compare May 31, 2024 09:35

renovate bot changed the title ~~chore(deps): update dependency drizzle-kit to ^0.21.0~~ chore(deps): update dependency drizzle-kit to ^0.22.0 May 31, 2024

renovate bot force-pushed the renovate/drizzle-kit-0.x branch from 562862f to 69bed7c Compare July 10, 2024 13:20

renovate bot changed the title ~~chore(deps): update dependency drizzle-kit to ^0.22.0~~ chore(deps): update dependency drizzle-kit to ^0.23.0 Jul 10, 2024

renovate bot force-pushed the renovate/drizzle-kit-0.x branch from 69bed7c to b2df585 Compare August 8, 2024 17:45

renovate bot changed the title ~~chore(deps): update dependency drizzle-kit to ^0.23.0~~ chore(deps): update dependency drizzle-kit to ^0.24.0 Aug 8, 2024

renovate bot force-pushed the renovate/drizzle-kit-0.x branch from b2df585 to bd63d76 Compare October 7, 2024 15:38

renovate bot changed the title ~~chore(deps): update dependency drizzle-kit to ^0.24.0~~ chore(deps): update dependency drizzle-kit to ^0.25.0 Oct 7, 2024

chore(deps): update dependency drizzle-kit to ^0.26.0

9827aee

renovate bot force-pushed the renovate/drizzle-kit-0.x branch from bd63d76 to 9827aee Compare October 15, 2024 20:45

renovate bot changed the title ~~chore(deps): update dependency drizzle-kit to ^0.25.0~~ chore(deps): update dependency drizzle-kit to ^0.26.0 Oct 15, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

chore(deps): update dependency drizzle-kit to ^0.26.0 #27

chore(deps): update dependency drizzle-kit to ^0.26.0 #27

renovate bot commented Nov 9, 2023 •

edited

Loading

cloudflare-workers-and-pages bot commented Nov 9, 2023 •

edited

Loading

chore(deps): update dependency drizzle-kit to ^0.26.0 #27

Are you sure you want to change the base?

chore(deps): update dependency drizzle-kit to ^0.26.0 #27

Conversation

renovate bot commented Nov 9, 2023 • edited Loading

Release Notes

Drizzle ORM 0.26.0 is here 🎉

README docs are fully transferred to web

New Features

Bug fixes

Drizzle Kit updates

New ways to define drizzle config file

New commands 🎉

drizzle-kit push:mysql

How to setup your codebase for drizzle-kit push feature?

Breaking changes and migrate guide for Turso users

LibSQL/Turso and Sqlite migration updates

SQLite "generate" and "push" statements updates

LibSQL/Turso "generate" and "push" statements updates

LIMITATIONS

NOTES

New casing param in drizzle-orm and drizzle-kit

New Features

🎉 Support for pglite driver

Bug fixes

Bug fixes

What was fixed

Tickets that were closed

Drizzle ORM 0.21.0 was released 🎉

Support for PostgreSQL array types

Added composite primary key support to PostgreSQL and MySQL

Drizzle Kit 0.17.0 was released 🎉

Breaking changes

Folder structure was migrated to newer version

Upgrading to 0.17.0

New Features

New drizzle-kit command called drop

New drizzle-kit option --breakpoints for generate and introspect commands

Add drizzle-kit introspect for MySQL dialect

Support for glob patterns for schema path

Bug Fixes and improvements

Postgres dialect

MySQL dialect

Configuration

cloudflare-workers-and-pages bot commented Nov 9, 2023 • edited Loading

Deploying cash-register with Cloudflare Pages

renovate bot commented Nov 9, 2023 •

edited

Loading

`drizzle-kit push:mysql`

New `casing` param in `drizzle-orm` and `drizzle-kit`

🎉 Support for `pglite` driver

New `drizzle-kit` command called `drop`

New `drizzle-kit` option `--breakpoints` for `generate` and `introspect` commands

Add `drizzle-kit introspect` for MySQL dialect

cloudflare-workers-and-pages bot commented Nov 9, 2023 •

edited

Loading