Merge branch 'beta' into improve-views

.github/workflows/release-feature-branch.yaml

@@ -16,6 +16,7 @@ jobs:
           - drizzle-orm
           - drizzle-kit
           - drizzle-zod
+          - drizzle-seed
           - drizzle-typebox
           - drizzle-valibot
           - eslint-plugin-drizzle

.github/workflows/release-latest.yaml

@@ -12,6 +12,7 @@ jobs:
           - drizzle-orm
           - drizzle-kit
           - drizzle-zod
+          - drizzle-seed
           - drizzle-typebox
           - drizzle-valibot
           - eslint-plugin-drizzle

.gitignore

@@ -12,3 +12,5 @@ dist-dts
 rollup.config-*.mjs
 *.log
 .DS_Store
+drizzle-seed/src/test.ts
+drizzle-seed/src/schemaTest.ts

changelogs/drizzle-kit/0.28.1.md

@@ -0,0 +1,4 @@
+# Bug fixes
+
+- Fixed typos in repository: thanks @armandsalle, @masto, @wackbyte, @Asher-JH, @MaxLeiter
+- [fix: wrong dialect set in mysql/sqlite introspect](https://github.com/drizzle-team/drizzle-orm/pull/2865)

changelogs/drizzle-kit/0.29.0.md

@@ -0,0 +1,40 @@
+# 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
+
+```ts
+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](https://orm.drizzle.team/docs/get-started/singlestore-new) 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](https://orm.drizzle.team/docs/get-started/do-new) Section
+
+```ts
+import 'dotenv/config';
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+  out: './drizzle',
+  schema: './src/db/schema.ts',
+  dialect: 'sqlite',
+  driver: 'durable-sqlite',
+});
+```

changelogs/drizzle-orm/0.36.1.md

@@ -3,4 +3,4 @@
 - [[BUG]: Using sql.placeholder with limit and/or offset for a prepared statement produces TS error](https://github.com/drizzle-team/drizzle-orm/issues/2146) - thanks @L-Mario564
 - [[BUG] If a query I am trying to modify with a dynamic query (....$dynamic()) contains any placeholders, I'm getting an error that says No value for placeholder.... provided](https://github.com/drizzle-team/drizzle-orm/issues/2272) - thanks @L-Mario564
 - [[BUG]: Error thrown when trying to insert an array of new rows using generatedAlwaysAsIdentity() for the id column](https://github.com/drizzle-team/drizzle-orm/issues/2849) - thanks @L-Mario564
-- [[BUG]: Unable to Use BigInt Types with Bun and Drizzle](https://github.com/drizzle-team/drizzle-orm/issues/2603) - thanks @L-Mario564
+- [[BUG]: Unable to Use BigInt Types with Bun and Drizzle](https://github.com/drizzle-team/drizzle-orm/issues/2603) - thanks @L-Mario564

changelogs/drizzle-orm/0.36.2.md

@@ -0,0 +1,15 @@
+# New Features
+
+- [Support more types in like, notLike, ilike and notIlike expressions](https://github.com/drizzle-team/drizzle-orm/pull/2805)
+
+
+# Bug and typo fixes
+
+- Fixed typos in repository: thanks @armandsalle, @masto, @wackbyte, @Asher-JH, @MaxLeiter
+
+- [Fixed .generated behavior with non-strict tsconfig](https://github.com/drizzle-team/drizzle-orm/pull/3542)
+- [Fix Drizzle ORM for expo-sqlite](https://github.com/drizzle-team/drizzle-orm/pull/3197)
+- [Fixed lack of schema name on columns in sql](https://github.com/drizzle-team/drizzle-orm/pull/3531)
+- [fix: Adjust neon http driver entity kind](https://github.com/drizzle-team/drizzle-orm/pull/3424)
+- [Export PgIntegerBuilderInitial type](https://github.com/drizzle-team/drizzle-orm/pull/2846)
+- [[MySQL] Correct $returningId() implementation to correctly store selected fields](https://github.com/drizzle-team/drizzle-orm/pull/2975)

changelogs/drizzle-orm/0.36.3.md

@@ -0,0 +1,154 @@
+# New Features
+
+## Support for `UPDATE ... FROM` in PostgreSQL and SQLite
+
+As the SQLite documentation mentions:
+
+> [!NOTE]
+> The UPDATE-FROM idea is an extension to SQL that allows an UPDATE statement to be driven by other tables in the database.
+The "target" table is the specific table that is being updated. With UPDATE-FROM you can join the target table
+against other tables in the database in order to help compute which rows need updating and what
+the new values should be on those rows
+
+Similarly, the PostgreSQL documentation states:
+
+> [!NOTE]
+> A table expression allowing columns from other tables to appear in the WHERE condition and update expressions
+
+Drizzle also supports this feature starting from this version
+
+For example, current query:
+
+```ts
+await db
+  .update(users)
+  .set({ cityId: cities.id })
+  .from(cities)
+  .where(and(eq(cities.name, 'Seattle'), eq(users.name, 'John')))
+```
+
+Will generate this sql
+
+```sql
+update "users" set "city_id" = "cities"."id" 
+from "cities" 
+where ("cities"."name" = $1 and "users"."name" = $2)
+
+-- params: [ 'Seattle', 'John' ]
+```
+
+You can also alias tables that are joined (in PG, you can also alias the updating table too).
+
+```ts
+const c = alias(cities, 'c');
+await db
+  .update(users)
+  .set({ cityId: c.id })
+  .from(c);
+```
+
+Will generate this sql
+
+```sql
+update "users" set "city_id" = "c"."id" 
+from "cities" "c"
+```
+
+In PostgreSQL, you can also return columns from the joined tables.
+
+```ts
+const updatedUsers = await db
+  .update(users)
+  .set({ cityId: cities.id })
+  .from(cities)
+  .returning({ id: users.id, cityName: cities.name });
+```
+
+Will generate this sql
+
+```sql
+update "users" set "city_id" = "cities"."id" 
+from "cities" 
+returning "users"."id", "cities"."name"
+```
+
+## Support for `INSERT INTO ... SELECT` in all dialects
+
+As the SQLite documentation mentions:
+
+> [!NOTE]
+> The second form of the INSERT statement contains a SELECT statement instead of a VALUES clause.
+A new entry is inserted into the table for each row of data returned by executing the SELECT statement.
+If a column-list is specified, the number of columns in the result of the SELECT must be the same as
+the number of items in the column-list. Otherwise, if no column-list is specified, the number of
+columns in the result of the SELECT must be the same as the number of columns in the table.
+Any SELECT statement, including compound SELECTs and SELECT statements with ORDER BY and/or LIMIT clauses,
+may be used in an INSERT statement of this form.
+
+> [!CAUTION]
+> To avoid a parsing ambiguity, the SELECT statement should always contain a WHERE clause, even if that clause is simply "WHERE true", if the upsert-clause is present. Without the WHERE clause, the parser does not know if the token "ON" is part of a join constraint on the SELECT, or the beginning of the upsert-clause.
+
+As the PostgreSQL documentation mentions:
+> [!NOTE]
+> A query (SELECT statement) that supplies the rows to be inserted
+
+And as the MySQL documentation mentions:
+
+> [!NOTE]
+> With INSERT ... SELECT, you can quickly insert many rows into a table from the result of a SELECT statement, which can select from one or many tables
+
+Drizzle supports the current syntax for all dialects, and all of them share the same syntax. Let's review some common scenarios and API usage.
+There are several ways to use select inside insert statements, allowing you to choose your preferred approach:
+
+- You can pass a query builder inside the select function.
+- You can use a query builder inside a callback.
+- You can pass an SQL template tag with any custom select query you want to use
+
+**Query Builder**
+
+```ts
+const insertedEmployees = await db
+  .insert(employees)
+  .select(
+    db.select({ name: users.name }).from(users).where(eq(users.role, 'employee'))
+  )
+  .returning({
+    id: employees.id,
+    name: employees.name
+  });
+```
+
+```ts
+const qb = new QueryBuilder();
+await db.insert(employees).select(
+    qb.select({ name: users.name }).from(users).where(eq(users.role, 'employee'))
+);
+```
+
+**Callback**
+
+```ts
+await db.insert(employees).select(
+    () => db.select({ name: users.name }).from(users).where(eq(users.role, 'employee'))
+);
+```
+
+```ts
+await db.insert(employees).select(
+    (qb) => qb.select({ name: users.name }).from(users).where(eq(users.role, 'employee'))
+);
+```
+
+**SQL template tag**
+
+```ts
+await db.insert(employees).select(
+    sql`select "users"."name" as "name" from "users" where "users"."role" = 'employee'`
+);
+```
+
+```ts
+await db.insert(employees).select(
+    () => sql`select "users"."name" as "name" from "users" where "users"."role" = 'employee'`
+);
+```

changelogs/drizzle-orm/0.36.4.md

@@ -0,0 +1,84 @@
+# New Package: `drizzle-seed`
+
+> [!NOTE]
+> `drizzle-seed` can only be used with `drizzle-orm@0.36.4` or higher. Versions lower than this may work at runtime but could have type issues and identity column issues, as this patch was introduced in `drizzle-orm@0.36.4`
+
+## Full Reference
+
+The full API reference and package overview can be found in our [official documentation](https://orm.drizzle.team/docs/seed-overview)
+
+## Basic Usage
+
+In this example we will create 10 users with random names and ids
+
+```ts {12}
+import { pgTable, integer, text } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { seed } from "drizzle-seed";
+
+const users = pgTable("users", {
+  id: integer().primaryKey(),
+  name: text().notNull(),
+});
+
+async function main() {
+  const db = drizzle(process.env.DATABASE_URL!);
+  await seed(db, { users });
+}
+
+main();
+```
+
+## Options
+
+**`count`**
+
+By default, the `seed` function will create 10 entities.
+However, if you need more for your tests, you can specify this in the seed options object
+
+```ts
+await seed(db, schema, { count: 1000 });
+```
+
+**`seed`**
+
+If you need a seed to generate a different set of values for all subsequent runs, you can define a different number
+in the `seed` option. Any new number will generate a unique set of values
+
+```ts
+await seed(db, schema, { seed: 12345 });
+```
+
+The full API reference and package overview can be found in our [official documentation](https://orm.drizzle.team/docs/seed-overview)
+
+# Features
+
+## Added `OVERRIDING SYSTEM VALUE` api to db.insert()
+
+If you want to force you own values for `GENERATED ALWAYS AS IDENTITY` columns, you can use `OVERRIDING SYSTEM VALUE`
+
+As PostgreSQL docs mentions
+> In an INSERT command, if ALWAYS is selected, a user-specified value is only accepted if the INSERT statement specifies OVERRIDING SYSTEM VALUE. If BY DEFAULT is selected, then the user-specified value takes precedence
+
+```ts
+await db.insert(identityColumnsTable).overridingSystemValue().values([
+  { alwaysAsIdentity: 2 },
+]);
+```
+
+## Added `.$withAuth()` API for Neon HTTP driver
+
+Using this API, Drizzle will send you an auth token to authorize your query. It can be used with any query available in Drizzle by simply adding `.$withAuth()` before it. This token will be used for a specific query
+
+Examples
+
+```ts
+const token = 'HdncFj1Nm'
+
+await db.$withAuth(token).select().from(usersTable);
+await db.$withAuth(token).update(usersTable).set({ name: 'CHANGED' }).where(eq(usersTable.name, 'TARGET'))
+```
+
+# Bug Fixes
+
+- [[BUG]: TypeScript error Please install '@neondatabase/serverless' to allow Drizzle ORM to connect to the database](https://github.com/drizzle-team/drizzle-orm/issues/3521)