Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix(deps): update all non-major dependencies #2

Open
wants to merge 1 commit into
base: trunk
Choose a base branch
from

Conversation

renovate[bot]
Copy link

@renovate renovate bot commented Feb 16, 2024

This PR contains the following updates:

Package Change Age Adoption Passing Confidence
@libsql/client ^0.4.0-pre.7 -> ^0.14.0 age adoption passing confidence
drizzle-kit (source) ^0.20.13 -> ^0.30.0 age adoption passing confidence
drizzle-orm (source) ^0.29.3 -> ^0.38.0 age adoption passing confidence

Release Notes

libsql/libsql-client-ts (@​libsql/client)

v0.14.0

Compare Source

v0.13.0

Compare Source

v0.12.0

Compare Source

v0.11.0

Compare Source

v0.10.0

Compare Source

  • Add a migrate() API that can be used to do migrations on both schema databases and regular databases. It is mostly dedicated to schema migration tools.

v0.9.0

Compare Source

v0.8.1

Compare Source

  • Fix embedded replica sync WAL index path name , which caused "No such file or directory" for local sync in some cases (#​244).

v0.8.0

Compare Source

  • No changes from 0.8.0-pre.1.

v0.7.0

Compare Source

  • Add configurable concurrency limit for parallel query execution
    (defaults to 20) to address socket hangup errors.

v0.6.2

Compare Source

  • Fix compatibility issue with libSQL server versions that don't have migrations endpoint.

v0.6.1

Compare Source

  • Add an option to batch() to wait for schema changes to finish when using shared schema.

v0.6.0

Compare Source

  • Bump hrana client to 0.6.0, which uses native Node fetch(). Note that
    @libsql/client now requires Node 18 or later.

v0.5.6

Compare Source

  • Bump libsql package dependency to 0.3.10 that adds wasm32 as
    supported CPU, which is needed for StackBlitz compatibility.

v0.5.5

Compare Source

  • Bump @libsql/libsql-wasm-experimental" dependency to 0.0.2, which
    fixes a broken sqlite3_get_autocommit() export.

v0.5.4

Compare Source

  • Bump libsql dependency to 0.3.9, which fixes symbol not found errors on Alpine.

v0.5.3

Compare Source

  • Add syncInterval config option to enable periodic sync.
  • Bump libsql dependency to 0.3.7, which switches default encryption cipher to aes256cbs.

v0.5.2

Compare Source

  • Disable SQL statemen tracing in Wasm.

v0.5.1

Compare Source

  • Update libsql package to 0.3.2, add encryptionCipher option, and switch default cipher to SQLCipher.

v0.5.0

Compare Source

  • Add a encryptionKey config option, which enables encryption at rest for local database files.
drizzle-team/drizzle-orm (drizzle-kit)

v0.30.0

Compare Source

Breaking Changes

The Postgres timestamp mapping has been changed to align all drivers with the same behavior.

❗ We've modified the postgres.js driver instance to always return strings for dates, and then Drizzle will provide you with either strings of mapped dates, depending on the selected mode. The only issue you may encounter is that once you provide the `postgres.js`` driver instance inside Drizzle, the behavior of this object will change for dates, which will always be strings.

We've made this change as a minor release, just as a warning, that:

  • If you were using timestamps and were waiting for a specific response, the behavior will now be changed.
    When mapping to the driver, we will always use .toISOString for both timestamps with timezone and without timezone.

  • If you were using the postgres.js driver outside of Drizzle, all postgres.js clients passed to Drizzle will have mutated behavior for dates. All dates will be strings in the response.

Parsers that were changed for postgres.js.

const transparentParser = (val: any) => val;

// Override postgres.js default date parsers: https://github.com/porsager/postgres/discussions/761
for (const type of ['1184', '1082', '1083', '1114']) {
	client.options.parsers[type as any] = transparentParser;
	client.options.serializers[type as any] = transparentParser;
}

Ideally, as is the case with almost all other drivers, we should have the possibility to mutate mappings on a per-query basis, which means that the driver client won't be mutated. We will be reaching out to the creator of the postgres.js library to inquire about the possibility of specifying per-query mapping interceptors and making this flow even better for all users.

If we've overlooked this capability and it is already available with `postgres.js``, please ping us in our Discord!

A few more references for timestamps without and with timezones can be found in our docs

Bug fixed in this release

Big thanks to @​Angelelz!

  • [BUG]: timestamp with mode string is returned as Date object instead of string - #​806
  • [BUG]: Dates are always dates #​971
  • [BUG]: Inconsistencies when working with timestamps and corresponding datetime objects in javascript. #​1176
  • [BUG]: timestamp columns showing string type, however actually returning a Date object. #​1185
  • [BUG]: Wrong data type for postgres date colum #​1407
  • [BUG]: invalid timestamp conversion when using PostgreSQL with TimeZone set to UTC #​1587
  • [BUG]: Postgres insert into timestamp with time zone removes milliseconds #​1061
  • [BUG]: update timestamp field (using AWS Data API) #​1164
  • [BUG]: Invalid date from relational queries #​895

v0.29.1

Compare Source

Fixes
New Features/Helpers
🎉 Detailed JSDoc for all query builders in all dialects - thanks @​realmikesolo

You can now access more information, hints, documentation links, etc. while developing and using JSDoc right in your IDE. Previously, we had them only for filter expressions, but now you can see them for all parts of the Drizzle query builder

🎉 New helpers for aggregate functions in SQL - thanks @​L-Mario564

Remember, aggregation functions are often used with the GROUP BY clause of the SELECT statement. So if you are selecting using aggregating functions and other columns in one query,
be sure to use the .groupBy clause

Here is a list of functions and equivalent using sql template

count

await db.select({ value: count() }).from(users);
await db.select({ value: count(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`count('*'))`.mapWith(Number) 
}).from(users);
await db.select({ 
  value: sql`count(${users.id})`.mapWith(Number) 
}).from(users);

countDistinct

await db.select({ value: countDistinct(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`count(${users.id})`.mapWith(Number) 
}).from(users);

avg

await db.select({ value: avg(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`avg(${users.id})`.mapWith(String) 
}).from(users);

avgDistinct

await db.select({ value: avgDistinct(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`avg(distinct ${users.id})`.mapWith(String) 
}).from(users);

sum

await db.select({ value: sum(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`sum(${users.id})`.mapWith(String) 
}).from(users);

sumDistinct

await db.select({ value: sumDistinct(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`sum(distinct ${users.id})`.mapWith(String) 
}).from(users);

max

await db.select({ value: max(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`max(${expression})`.mapWith(users.id) 
}).from(users);

min

await db.select({ value: min(users.id) }).from(users);

// It's equivalent to writing
await db.select({ 
  value: sql`min(${users.id})`.mapWith(users.id) 
}).from(users);
New Packages
🎉 ESLint Drizzle Plugin

For cases where it's impossible to perform type checks for specific scenarios, or where it's possible but error messages would be challenging to understand, we've decided to create an ESLint package with recommended rules. This package aims to assist developers in handling crucial scenarios during development

Big thanks to @​Angelelz for initiating the development of this package and transferring it to the Drizzle Team's npm

Install
[ npm | yarn | pnpm | bun ] install eslint eslint-plugin-drizzle

You can install those packages for typescript support in your IDE

[ npm | yarn | pnpm | bun ] install @​typescript-eslint/eslint-plugin @​typescript-eslint/parser
Usage

Create a .eslintrc.yml file, add drizzle to the plugins, and specify the rules you want to use. You can find a list of all existing rules below

root: true
parser: '@​typescript-eslint/parser'
parserOptions:
  project: './tsconfig.json'
plugins:
  - drizzle
rules:
  'drizzle/enforce-delete-with-where': "error"
  'drizzle/enforce-update-with-where': "error"
All config

This plugin exports an all config that makes use of all rules (except for deprecated ones).

root: true
extends:
  - "plugin:drizzle/all"
parser: '@​typescript-eslint/parser'
parserOptions:
  project: './tsconfig.json'
plugins:
  - drizzle

At the moment, all is equivalent to recommended

root: true
extends:
  - "plugin:drizzle/recommended"
parser: '@​typescript-eslint/parser'
parserOptions:
  project: './tsconfig.json'
plugins:
  - drizzle
Rules

enforce-delete-with-where: Enforce using delete with the.where() clause in the .delete() statement. Most of the time, you don't need to delete all rows in the table and require some kind of WHERE statements.

Error Message:

Without `.where(...)` you will delete all the rows in a table. If you didn't want to do it, please use `db.delete(...).where(...)` instead. Otherwise you can ignore this rule here

Optionally, you can define a drizzleObjectName in the plugin options that accept a string or string[]. This is useful when you have objects or classes with a delete method that's not from Drizzle. Such a delete method will trigger the ESLint rule. To avoid that, you can define the name of the Drizzle object that you use in your codebase (like db) so that the rule would only trigger if the delete method comes from this object:

Example, config 1:

"rules": {
  "drizzle/enforce-delete-with-where": ["error"]
}
class MyClass {
  public delete() {
    return {}
  }
}

const myClassObj = new MyClass();

// ---> Will be triggered by ESLint Rule
myClassObj.delete()

const db = drizzle(...)
// ---> Will be triggered by ESLint Rule
db.delete()

Example, config 2:

"rules": {
  "drizzle/enforce-delete-with-where": ["error", { "drizzleObjectName": ["db"] }],
}
class MyClass {
  public delete() {
    return {}
  }
}

const myClassObj = new MyClass();

// ---> Will NOT be triggered by ESLint Rule
myClassObj.delete()

const db = drizzle(...)
// ---> Will be triggered by ESLint Rule
db.delete()

enforce-update-with-where: Enforce using update with the.where() clause in the .update() statement. Most of the time, you don't need to update all rows in the table and require some kind of WHERE statements.

Error Message:

Without `.where(...)` you will update all the rows in a table. If you didn't want to do it, please use `db.update(...).set(...).where(...)` instead. Otherwise you can ignore this rule here

Optionally, you can define a drizzleObjectName in the plugin options that accept a string or string[]. This is useful when you have objects or classes with a delete method that's not from Drizzle. Such as update method will trigger the ESLint rule. To avoid that, you can define the name of the Drizzle object that you use in your codebase (like db) so that the rule would only trigger if the delete method comes from this object:

Example, config 1:

"rules": {
  "drizzle/enforce-update-with-where": ["error"]
}
class MyClass {
  public update() {
    return {}
  }
}

const myClassObj = new MyClass();

// ---> Will be triggered by ESLint Rule
myClassObj.update()

const db = drizzle(...)
// ---> Will be triggered by ESLint Rule
db.update()

Example, config 2:

"rules": {
  "drizzle/enforce-update-with-where": ["error", { "drizzleObjectName": ["db"] }],
}
class MyClass {
  public update() {
    return {}
  }
}

const myClassObj = new MyClass();

// ---> Will NOT be triggered by ESLint Rule
myClassObj.update()

const db = drizzle(...)
// ---> Will be triggered by ESLint Rule
db.update()

v0.29.0

Compare Source

New Dialects

🎉 SingleStore dialect is now available in Drizzle

Thanks to the SingleStore team for creating a PR with all the necessary changes to support the MySQL-compatible part of SingleStore. You can already start using it with Drizzle. The SingleStore team will also help us iterate through updates and make more SingleStore-specific features available in Drizzle

import 'dotenv/config';
import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  dialect: 'singlestore',
  out: './drizzle',
  schema: './src/db/schema.ts',
  dbCredentials: {
    url: process.env.DATABASE_URL!,
  },
});

You can check out our Getting started guides to try SingleStore!

New Drivers

🎉 SQLite Durable Objects driver is now available in Drizzle

You can now query SQLite Durable Objects in Drizzle!

For the full example, please check our Get Started Section

import 'dotenv/config';
import { defineConfig } from 'drizzle-kit';
export default defineConfig({
  out: './drizzle',
  schema: './src/db/schema.ts',
  dialect: 'sqlite',
  driver: 'durable-sqlite',
});

v0.28.1

Compare Source

Bug fixes

v0.28.0

Compare Source

Improvements

Bug Fixes

v0.27.2

Compare Source

v0.27.1

Compare Source

import { neon, neonConfig } from '@​neondatabase/serverless';
import { drizzle } from 'drizzle-orm/neon-http';

neonConfig.fetchConnectionCache = true;

const sql = neon(process.env.DRIZZLE_DATABASE_URL!);
const db = drizzle(sql);

db.select(...)

v0.27.0

Compare Source

Correct behavior when installed in a monorepo (multiple Drizzle instances)

Replacing all instanceof statements with a custom is() function allowed us to handle multiple Drizzle packages interacting properly.

It also fixes one of our biggest Discord tickets: maximum call stack exceeded 🎉

You should now use is() instead of instanceof to check if specific objects are instances of specific Drizzle types. It might be useful if you are building something on top of the Drizzle API.

import { is, Column } from 'drizzle-orm'

if (is(value, Column)) {
  // value's type is narrowed to Column
}

distinct clause support

await db.selectDistinct().from(usersDistinctTable).orderBy(
  usersDistinctTable.id,
  usersDistinctTable.name,
);

Also, distinct on clause is available for PostgreSQL:

await db.selectDistinctOn([usersDistinctTable.id]).from(usersDistinctTable).orderBy(
  usersDistinctTable.id,
);

await db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
  usersDistinctTable,
).orderBy(usersDistinctTable.name);

bigint and boolean support for SQLite

Contributed by @​MrRahulRamkumar (#​558), @​raducristianpopa (#​411) and @​meech-ward (#​725)

const users = sqliteTable('users', {
  bigintCol: blob('bigint', { mode: 'bigint' }).notNull(),
  boolCol: integer('bool', { mode: 'boolean' }).notNull(),
});

DX improvements

  • Added verbose type error when relational queries are used on a database type without a schema generic
  • Fix where callback in RQB for tables without relations

Various docs improvements

v0.26.2

Compare Source

  • Updated internal versions for the drizzle-kit and drizzle-orm packages. Changes were introduced in the last minor release, and you are required to upgrade both packages to ensure they work as expected

v0.26.1

Compare Source

  • Fix data is malformed for views

v0.26.0

Compare Source

While writing this update, we found one bug that may occur with views in MySQL and SQLite, so please use the [email protected] release

New Features

Checks support in drizzle-kit

You can use drizzle-kit to manage your check constraint defined in drizzle-orm schema definition

For example current drizzle table:

import { sql } from "drizzle-orm";
import { check, pgTable } from "drizzle-orm/pg-core";

export const users = pgTable(
  "users",
  (c) => ({
    id: c.uuid().defaultRandom().primaryKey(),
    username: c.text().notNull(),
    age: c.integer(),
  }),
  (table) => ({
    checkConstraint: check("age_check", sql`${table.age} > 21`),
  })
);

will be generated into

CREATE TABLE IF NOT EXISTS "users" (
  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
  "username" text NOT NULL,
  "age" integer,
  CONSTRAINT "age_check" CHECK ("users"."age" > 21)
);

The same is supported in all dialects

Limitations
  • generate will work as expected for all check constraint changes.
  • push will detect only check renames and will recreate the constraint. All other changes to SQL won't be detected and will be ignored.

So, if you want to change the constraint's SQL definition using only push, you would need to manually comment out the constraint, push, then put it back with the new SQL definition and push one more time.

Views support in drizzle-kit

You can use drizzle-kit to manage your views defined in drizzle-orm schema definition. It will work with all existing dialects and view options

PostgreSQL

For example current drizzle table:

import { sql } from "drizzle-orm";
import {
  check,
  pgMaterializedView,
  pgTable,
  pgView,
} from "drizzle-orm/pg-core";

export const users = pgTable(
  "users",
  (c) => ({
    id: c.uuid().defaultRandom().primaryKey(),
    username: c.text().notNull(),
    age: c.integer(),
  }),
  (table) => ({
    checkConstraint: check("age_check", sql`${table.age} > 21`),
  })
);

export const simpleView = pgView("simple_users_view").as((qb) =>
  qb.select().from(users)
);

export const materializedView = pgMaterializedView(
  "materialized_users_view"
).as((qb) => qb.select().from(users));

will be generated into

CREATE TABLE IF NOT EXISTS "users" (
  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
  "username" text NOT NULL,
  "age" integer,
  CONSTRAINT "age_check" CHECK ("users"."age" > 21)
);

CREATE VIEW "public"."simple_users_view" AS (select "id", "username", "age" from "users");

CREATE MATERIALIZED VIEW "public"."materialized_users_view" AS (select "id", "username", "age" from "users");

Views supported in all dialects, but materialized views are supported only in PostgreSQL

Limitations
  • generate will work as expected for all view changes
  • push limitations:
  1. If you want to change the view's SQL definition using only push, you would need to manually comment out the view, push, then put it back with the new SQL definition and push one more time.

Updates for PostgreSQL enums behavior

We've updated enum behavior in Drizzle with PostgreSQL:

  • Add value after or before in enum: With this change, Drizzle will now respect the order of values in the enum and allow adding new values after or before a specific one.

  • Support for dropping a value from an enum: In this case, Drizzle will attempt to alter all columns using the enum to text, then drop the existing enum and create a new one with the updated set of values. After that, all columns previously using the enum will be altered back to the new enum.

If the deleted enum value was used by a column, this process will result in a database error.

  • Support for dropping an enum

  • Support for moving enums between schemas

  • Support for renaming enums

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.

  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:
npm i @​libsql/client@latest
  1. 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
  1. The Drizzle Kit CLI was not working properly for the introspect command.
  2. Added the ability to use column names with special characters for all dialects.
  3. Included PostgreSQL sequences in the introspection process.
  4. Reworked array type introspection and added all test cases.
  5. Fixed all (we hope) default issues in PostgreSQL, where ::<type> was included in the introspected output.
  6. 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:

  • 🎉 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

v0.22.8

Compare Source

v0.22.7

Compare Source

v0.22.6

Compare Source

v0.22.5

Compare Source

v0.22.4

Compare Source

v0.22.3

Compare Source

v0.22.2

Compare Source

v0.22.1

Compare Source

v0.22.0

Compare Source

  • 🎉 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 PostgreS

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 is behind base branch, or you tick the rebase/retry checkbox.

👻 Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.


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

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

@renovate renovate bot force-pushed the renovate/all-minor-patch branch 2 times, most recently from 3ec7439 to b75ae10 Compare March 8, 2024 20:42
@renovate renovate bot changed the title fix(deps): update dependency @libsql/client to ^0.5.0 fix(deps): update all non-major dependencies Mar 8, 2024
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from b75ae10 to b97b0dc Compare March 29, 2024 17:46
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from b97b0dc to 642b6d0 Compare May 9, 2024 23:39
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from 642b6d0 to fe89c49 Compare June 1, 2024 08:45
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from fe89c49 to 8725368 Compare June 25, 2024 23:54
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from 8725368 to b1d8b66 Compare July 11, 2024 23:44
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from b1d8b66 to 788a113 Compare July 31, 2024 08:42
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from 788a113 to ebc23fe Compare August 9, 2024 23:49
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from ebc23fe to 419b7ad Compare August 27, 2024 02:16
@renovate renovate bot force-pushed the renovate/all-minor-patch branch 3 times, most recently from 8fdc7b4 to 6586680 Compare September 20, 2024 11:41
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from 6586680 to 08566f4 Compare September 21, 2024 14:51
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from 08566f4 to 00df663 Compare October 8, 2024 02:56
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from 00df663 to 7591835 Compare October 16, 2024 05:48
@renovate renovate bot force-pushed the renovate/all-minor-patch branch 2 times, most recently from ad1e61f to c49c2bd Compare November 6, 2024 23:37
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from c49c2bd to b10e5b2 Compare December 4, 2024 08:55
@renovate renovate bot force-pushed the renovate/all-minor-patch branch from b10e5b2 to 1c59edc Compare December 11, 2024 05:47
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

0 participants