fix(deps): update all non-major dependencies by renovate[bot] · Pull Request #10 · NezuChan/postgrestify

renovate · 2024-05-31T19:19:43Z

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Type	Update
@swc/cli	`^0.3.12` → `^0.8.1`	devDependencies	minor
@swc/core (source)	`^1.5.24` → `^1.15.33`	devDependencies	minor
@types/node (source)	`^20.12.13` → `^20.19.39`	devDependencies	minor
@types/pg (source)	`^8.11.6` → `^8.20.0`	devDependencies	minor
dotenv	`^16.4.5` → `^16.6.1`	devDependencies	minor
drizzle-kit (source)	`^0.22.7` → `^0.31.10`	devDependencies	minor
ghcr.io/hazmi35/node	`20` → `20.20.0`	final	minor
ghcr.io/hazmi35/node	`20-dev` → `20.20.0-dev`	stage	minor
hyper-express	`^6.16.2` → `^6.17.3`	dependencies	minor
pg (source)	`^8.11.5` → `^8.20.0`	dependencies	minor
pino (source)	`^9.1.0` → `^9.14.0`	dependencies	minor
pino-pretty	`^11.1.0` → `^11.3.0`	dependencies	minor
rimraf	`^6.0.1` → `^6.1.3`	devDependencies	minor

Release Notes

swc-project/swc (@swc/core)

`v1.15.33`

Compare Source

Bug Fixes

(ci) Update rand lockfile entries (#11827) (7988966)
(es/minifier) Fold unary bool nullish coalescing (#11826) (e39ae3d)
(es/minifier) Preserve for-init sequence order (#11837) (16a56d0)
(es/parser) Parse empty Flow exact object type (#11836) (3d18a26)

Features

Move swc ast explorer into workspace (#11831) (02a8f81)

`v1.15.32`

Compare Source

Bug Fixes

(es/flow) Fix Flow type-only modules in script transforms (#11817) (be38316)
(es/flow) Avoid restoring module context when flow syntax is enabled (#11819) (3ed7243)
(es/minifier) Preserve frozen spread registry keys (#11825) (347181c)
(es/parser) Align Flow generic arrow JSX disambiguation (#11821) (28a7fad)

Features

(es) Add jsc.preserveSymlinks to swc::Options (#11813) (fe38342)

`v1.15.30`

Compare Source

Bug Fixes

(deploy) Fix musl binding test workflow (#11804) (c30a522)
(deploy) Build package ts before Linux GNU binding tests (#11806) (a3d3ef3)
(es/jsx) Preserve quoted JSX attribute newlines (#11796) (9fe56c8)
(es/minifier) Support full ES version parsing in minify (#11800) (af1f08f)
(es/module) Add opt-in symlink-preserving resolver (#11801) (6028240)
(es/parser) Allow return type annotation on Flow constructors (#11790) (d66b29c)
(es/parser) Support Flow anonymous keyof indexers (#11792) (452c4e5)
(es/parser) Add Flow strip RN and RNW regression corpus (#11799) (23a9109)

Documentation

Require PR template for pull requests (#11793) (3a1084a)

Features

(es/minify) Support extracting comments (#11798) (5986411)

motdotla/dotenv (dotenv)

`v16.6.1`

Compare Source

Changed

Default quiet to true – hiding the runtime log message (#874)
NOTICE: 17.0.0 will be released with quiet defaulting to false. Use config({ quiet: true }) to suppress.
And check out the new dotenvx. As coding workflows evolve and agents increasingly handle secrets, encrypted .env files offer a much safer way to deploy both agents and code together with secure secrets. Simply switch require('dotenv').config() for require('@dotenvx/dotenvx').config().

`v16.6.0`

Compare Source

Added

Default log helpful message [dotenv@16.6.0] injecting env (1) from .env (#870)
Use { quiet: true } to suppress
Aligns dotenv more closely with dotenvx.

`v16.5.0`

Compare Source

Added

🎉 Added new sponsor Graphite - the AI developer productivity platform helping teams on GitHub ship higher quality software, faster.

[!TIP]
Become a sponsor

The dotenvx README is viewed thousands of times DAILY on GitHub and NPM.
Sponsoring dotenv is a great way to get in front of developers and give back to the developer community at the same time.

Changed

Remove _log method. Use _debug #862

`v16.4.7`

Compare Source

Changed

Ignore .tap folder when publishing. (oops, sorry about that everyone. - @motdotla) #848

`v16.4.6`

Compare Source

Changed

Clean up stale dev dependencies #847
Various README updates clarifying usage and alternative solutions using dotenvx

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

`v0.31.10`

Compare Source

Updated to hanji@0.0.8 - native bun stringWidth, stripANSI support, errors for non-TTY environments
We've migrated away from esbuild-register to tsx loader, it will now allow to use drizzle-kit seamlessly with both ESM and CJS modules
We've also added native Bun and Deno launch support, which will not trigger tsx loader and utilise native bun and deno imports capabilities and faster startup times

`v0.31.9`

Compare Source

drizzle-kit api improvements for D1 connections

`v0.31.8`

Compare Source

Bug fixes

Fixed algorythm => algorithm typo.
Fixed external dependencies in build configuration.

`v0.31.7`: drizzle-kit@0.31.7

Compare Source

Bug fixes

[BUG]: Drizzle Kit push to Postgres 18 produces unecessary DROP SQL when the schema was NOT changed

`v0.31.6`

Compare Source

Bug fixes

[BUG]: Importing drizzle-kit/api fails in ESM modules

`v0.31.5`

Compare Source

Add casing support to studio configuration and related functions

`v0.31.4`

Compare Source

Fixed halfvec, bit and sparsevec type generation bug in drizzle-kit

`v0.31.3`

Compare Source

Internal changes to Studio context. Added databaseName and packageName properties for Studio

`v0.31.2`

Compare Source

Bug fixes

Fixed relations extraction to not interfere with Drizzle Studio.

`v0.31.1`

Compare Source

Fixed `drizzle-kit pull` bugs when using Gel extensions.

Because Gel extensions create schema names containing :: (for example, ext::auth), Drizzle previously handled these names incorrectly. Starting with this release, you can use Gel extensions without any problems. Here’s what you should do:

Enable extensions schemas in drizzle.config.ts

import  { defineConfig } from "drizzle-kit";

export default defineConfig({
  dialect: 'gel',
  schemaFilter: ['ext::auth', 'public']
});

Run drizzle-kit pull
Done!

`v0.31.0`

Compare Source

Features and improvements

Enum DDL improvements

For situations where you drop an enum value or reorder values in an enum, there is no native way to do this in PostgreSQL. To handle these cases, drizzle-kit used to:

Change the column data types from the enum to text
Drop the old enum
Add the new enum
Change the column data types back to the new enum

However, there were a few scenarios that weren’t covered: PostgreSQL wasn’t updating default expressions for columns when their data types changed

Therefore, for cases where you either change a column’s data type from an enum to some other type, drop an enum value, or reorder enum values, we now do the following:

Change the column data types from the enum to text
Set the default using the ::text expression
Drop the old enum
Add the new enum
Change the column data types back to the new enum
Set the default using the ::<new_enum> expression

`esbuild` version upgrade

For drizzle-kit we upgraded the version to latest (0.25.2), thanks @paulmarsicloud

Bug fixes

`v0.30.6`

Compare Source

Bug fixes

[BUG]: d1 push locally is not working - thanks @mabels and @RomanNabukhotnyi
[BUG] Cloudflare D1: drizzle-kit push is not working (error 7500 SQLITE_AUTH) - thanks @mabels and @RomanNabukhotnyi

`v0.30.5`

Compare Source

New Features

Added `Gel` dialect support and `gel-js` client support

Drizzle is getting a new Gel dialect with its own types and Gel-specific logic. In this first iteration, almost all query-building features have been copied from the PostgreSQL dialect since Gel is fully PostgreSQL-compatible. The only change in this iteration is the data types. The Gel dialect has a different set of available data types, and all mappings for these types have been designed to avoid any extra conversions on Drizzle's side. This means you will insert and select exactly the same data as supported by the Gel protocol.

Drizzle + Gel integration will work only through drizzle-kit pull. Drizzle won't support generate, migrate, or push features in this case. Instead, drizzle-kit is used solely to pull the Drizzle schema from the Gel database, which can then be used in your drizzle-orm queries.

The Gel + Drizzle workflow:

Use the gel CLI to manage your schema.
Use the gel CLI to generate and apply migrations to the database.
Use drizzle-kit to pull the Gel database schema into a Drizzle schema.
Use drizzle-orm with gel-js to query the Gel database.

On the drizzle-kit side you can now use dialect: "gel"

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

export default defineConfig({
  dialect: 'gel',
});

For a complete Get Started tutorial you can use our new guides:

`v0.30.4`

Compare Source

Fix bug that generates incorrect syntax when introspect in mysql
Fix a bug that caused incorrect syntax output when introspect in unsigned columns

`v0.30.3`

Compare Source

SingleStore `push` and `generate` improvements

As SingleStore did not support certain DDL statements before this release, you might encounter an error indicating that some schema changes cannot be applied due to a database issue. Starting from this version, drizzle-kit will detect such cases and initiate table recreation with data transfer between the tables

Bug fixes

[BUG] If the index name is the same as the generated name, it will be empty and a type error will occur

`v0.30.2`

Compare Source

Fix certificates generation utility for Drizzle Studio; [BUG]: [drizzle-kit]: drizzle-kit dependency on drizzle-studio perms error

`v0.30.1`

Compare Source

New Features

`drizzle-kit export`

To make drizzle-kit integration with other migration tools, like Atlas much easier, we've prepared a new command called export. It will translate your drizzle schema in SQL representation(DDL) statements and outputs to the console

// schema.ts
import { pgTable, serial, text } from 'drizzle-orm/pg-core'

export const users = pgTable('users', {
	id: serial('id').primaryKey(),
	email: text('email').notNull(),
	name: text('name')
});

Running

npx drizzle-kit export

will output this string to console

CREATE TABLE "users" (
        "id" serial PRIMARY KEY NOT NULL,
        "email" text NOT NULL,
        "name" text
);

By default, the only option for now is --sql, so the output format will be SQL DDL statements. In the future, we will support additional output formats to accommodate more migration tools

npx drizzle-kit export --sql

`v0.30.0`

Compare Source

Starting from this update, the PostgreSQL dialect will align with the behavior of all other dialects. It will no longer include IF NOT EXISTS, $DO, or similar statements, which could cause incorrect DDL statements to not fail when an object already exists in the database and should actually fail.

This change marks our first step toward several major upgrades we are preparing:

An updated and improved migration workflow featuring commutative migrations, a revised folder structure, and enhanced collaboration capabilities for migrations.
Better support for Xata migrations.
Compatibility with CockroachDB (achieving full compatibility will only require removing serial fields from the migration folder).

`v0.29.1`

Compare Source

Fix SingleStore generate migrations command

`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

Fixed typos in repository: thanks @armandsalle, @masto, @wackbyte, @Asher-JH, @MaxLeiter
fix: wrong dialect set in mysql/sqlite introspect

`v0.28.0`

Compare Source

Improvements

Added an OHM static imports checker to identify unexpected imports within a chain of imports in the drizzle-kit repo. For example, it checks if drizzle-orm is imported before drizzle-kit and verifies if the drizzle-orm import is available in your project.
Adding more columns to Supabase auth.users table schema - thanks @nicholasdly

Bug Fixes

`v0.27.2`

Compare Source

Fix [BUG]: Undefined properties when using drizzle-kit push
Fix TypeError: Cannot read properties of undefined (reading 'isRLSEnabled')
Fix push bugs, when pushing a schema with linked policy to a table from drizzle-orm/supabase

`v0.27.1`

Compare Source

Fix: [BUG]: When using RLS policies and Views, the view is the last clause generated

`v0.27.0`

Compare Source

This version of drizzle-jit requires drizzle-orm@0.36.0 to enable all new features

New Features

Row-Level Security (RLS)

With Drizzle, you can enable Row-Level Security (RLS) for any Postgres table, create policies with various options, and define and manage the roles those policies apply to.

Drizzle supports a raw representation of Postgres policies and roles that can be used in any way you want. This works with popular Postgres database providers such as Neon and Supabase.

In Drizzle, we have specific predefined RLS roles and functions for RLS with both database providers, but you can also define your own logic.

Enable RLS

If you just want to enable RLS on a table without adding policies, you can use .enableRLS()

As mentioned in the PostgreSQL documentation:

If no policy exists for the table, a default-deny policy is used, meaning that no rows are visible or can be modified.
Operations that apply to the whole table, such as TRUNCATE and REFERENCES, are not subject to row security.

import { integer, pgTable } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
	id: integer(),
}).enableRLS();

If you add a policy to a table, RLS will be enabled automatically. So, there’s no need to explicitly enable RLS when adding policies to a table.

Roles

Currently, Drizzle supports defining roles with a few different options, as shown below. Support for more options will be added in a future release.

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

export const admin = pgRole('admin', { createRole: true, createDb: true, inherit: true });

If a role already exists in your database, and you don’t want drizzle-kit to ‘see’ it or include it in migrations, you can mark the role as existing.

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

export const admin = pgRole('admin').existing();

Policies

To fully leverage RLS, you can define policies within a Drizzle table.

In PostgreSQL, policies should be linked to an existing table. Since policies are always associated with a specific table, we decided that policy definitions should be defined as a parameter of pgTable

Example of pgPolicy with all available properties

import { sql } from 'drizzle-orm';
import { integer, pgPolicy, pgRole, pgTable } from 'drizzle-orm/pg-core';

export const admin = pgRole('admin');

export const users = pgTable('users', {
	id: integer(),
}, (t) => [
	pgPolicy('policy', {
		as: 'permissive',
		to: admin,
		for: 'delete',
		using: sql``,
		withCheck: sql``,
	}),
]);

Link Policy to an existing table

There are situations where you need to link a policy to an existing table in your database.
The most common use case is with database providers like Neon or Supabase, where you need to add a policy
to their existing tables. In this case, you can use the .link() API

import { sql } from "drizzle-orm";
import { pgPolicy } from "drizzle-orm/pg-core";
import { authenticatedRole, realtimeMessages } from "drizzle-orm/supabase";

export const policy = pgPolicy("authenticated role insert policy", {
  for: "insert",
  to: authenticatedRole,
  using: sql``,
}).link(realtimeMessages);

Migrations

If you are using drizzle-kit to manage your schema and roles, there may be situations where you want to refer to roles that are not defined in your Drizzle schema. In such cases, you may want drizzle-kit to skip managing these roles without having to define each role in your drizzle schema and marking it with .existing().

In these cases, you can use entities.roles in drizzle.config.ts. For a complete reference, refer to the the drizzle.config.ts documentation.

By default, drizzle-kit does not manage roles for you, so you will need to enable this feature in drizzle.config.ts.

// drizzle.config.ts
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  dialect: 'postgresql',
  schema: "./drizzle/schema.ts",
  dbCredentials: {
    url: process.env.DATABASE_URL!
  },
  verbose: true,
  strict: true,
  entities: {
    roles: true
  }
});

In case you need additional configuration options, let's take a look at a few more examples.

You have an admin role and want to exclude it from the list of manageable roles

// drizzle.config.ts
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  ...
  entities: {
    roles: {
      exclude: ['admin']
    }
  }
});

You have an admin role and want to include it in the list of manageable roles

// drizzle.config.ts
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  ...
  entities: {
    roles: {
      include: ['admin']
    }
  }
});

If you are using Neon and want to exclude Neon-defined roles, you can use the provider option

// drizzle.config.ts
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  ...
  entities: {
    roles: {
      provider: 'neon'
    }
  }
});

If you are using Supabase and want to exclude Supabase-defined roles, you can use the provider option

// drizzle.config.ts
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  ...
  entities: {
    roles: {
      provider: 'supabase'
    }
  }
});

You may encounter situations where Drizzle is slightly outdated compared to new roles specified by your database provider.
In such cases, you can use the provider option and exclude additional roles:

// drizzle.config.ts
import { defineConfig } from "drizzle-kit";

export default defineConfig({
  ...
  entities: {
    roles: {
      provider: 'supabase',
      exclude: ['new_supabase_role']
    }
  }
});

RLS on views

With Drizzle, you can also specify RLS policies on views. For this, you need to use security_invoker in the view's WITH options. Here is a small example:

...

export const roomsUsersProfiles = pgView("rooms_users_profiles")
  .with({
    securityInvoker: true,
  })
  .as((qb) =>
    qb
      .select({
        ...getTableColumns(roomsUsers),
        email: profiles.email,
      })
      .from(roomsUsers)
      .innerJoin(profiles, eq(roomsUsers.userId, profiles.id))
  );

Using with Neon

The Neon Team helped us implement their vision of a wrapper on top of our raw policies API. We defined a specific
/neon import with the crudPolicy function that includes predefined functions and Neon's default roles.

Here's an example of how to use the crudPolicy function:

import { crudPolicy } from 'drizzle-orm/neon';
import { integer, pgRole, pgTable } from 'drizzle-orm/pg-core';

export const admin = pgRole('admin');

export const users = pgTable('users', {
	id: integer(),
}, (t) => [
	crudPolicy({ role: admin, read: true, modify: false }),
]);

This policy is equivalent to:

import { sql } from 'drizzle-orm';
import { integer, pgPolicy, pgRole, pgTable } from 'drizzle-orm/pg-core';

export const admin = pgRole('admin');

export const users = pgTable('users', {
	id: integer(),
}, (t) => [
	pgPolicy(`crud-${admin.name}-policy-insert`, {
		for: 'insert',
		to: admin,
		withCheck: sql`false`,
	}),
	pgPolicy(`crud-${admin.name}-policy-update`, {
		for: 'update',
		to: admin,
		using: sql`false`,
		withCheck: sql`false`,
	}),
	pgPolicy(`crud-${admin.name}-policy-delete`, {
		for: 'delete',
		to: admin,
		using: sql`false`,
	}),
	pgPolicy(`crud-${admin.name}-policy-select`, {
		for: 'select',
		to: admin,
		using: sql`true`,
	}),
]);

Neon exposes predefined authenticated and anaonymous roles and related functions. If you are using Neon for RLS, you can use these roles, which are marked as existing, and the related functions in your RLS queries.

// drizzle-orm/neon
export const authenticatedRole = pgRole('authenticated').existing();
export const anonymousRole = pgRole('anonymous').existing();

export const authUid = (userIdColumn: AnyPgColumn) => sql`(select auth.user_id() = ${userIdColumn})`;

For example, you can use the Neon predefined roles and functions like this:

import { sql } from 'drizzle-orm';
import { authenticatedRole } from 'drizzle-orm/neon';
import { integer, pgPolicy, pgRole, pgTable } from 'drizzle-orm/pg-core';

export const admin = pgRole('admin');

export const users = pgTable('users', {
	id: integer(),
}, (t) => [
	pgPolicy(`policy-insert`, {
		for: 'insert',
		to: authenticatedRole,
		withCheck: sql`false`,
	}),
]);

Using with Supabase

We also have a /supabase import with a set of predefined roles marked as existing, which you can use in your schema.
This import will be extended in a future release with more functions and helpers to make using RLS and Supabase simpler.

// drizzle-orm/supabase
export const anonRole = pgRole('anon').existing();
export const authenticatedRole = pgRole('authenticated').existing();
export const serviceRole = pgRole('service_role').existing();
export const postgresRole = pgRole('postgres_role').existing();
export const supabaseAuthAdminRole = pgRole('supabase_auth_admin').existing();

For example, you can use the Supabase predefined roles like this:

import { sql } from 'drizzle-orm';
import { serviceRole } from 'drizzle-orm/supabase';
import { integer, pgPolicy, pgRole, pgTable } from 'drizzle-orm/pg-core';

export const admin = pgRole('admin');

export const users = pgTable('users', {
	id: integer(),
}, (t) => [
	pgPolicy(`policy-insert`, {
		for: 'insert',
		to: serviceRole,
		withCheck: sql`false`,
	}),
]);

The /supabase import also includes predefined tables and functions that you can use in your application

// drizzle-orm/supabase

const auth = pgSchema('auth');
export const authUsers = auth.table('users', {
	id: uuid().primaryKey().notNull(),
});

const realtime = pgSchema('realtime');
export const realtimeMessages = realtime.table(
	'messages',
	{
		id: bigserial({ mode: 'bigint' }).primaryKey(),
		topic: text().notNull(),
		extension: text({
			enum: ['presence', 'broadcast', 'postgres_changes'],
		}).notNull(),
	},
);

export const authUid = sql`(select auth.uid())`;
export const real

> ✂ **Note**
> 
> PR body was truncated to here.


</details>

---

### Configuration

📅 **Schedule**: (in timezone Asia/Jakarta)

- Branch creation
  - "before 6am"
- Automerge
  - At any time (no schedule defined)

🚦 **Automerge**: Enabled.

♻ **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](https://redirect.github.com/renovatebot/renovate/discussions) if that's undesired.

---

 - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box

---

This PR was generated by [Mend Renovate](https://mend.io/renovate/). View the [repository job log](https://developer.mend.io/github/NezuChan/postgrestify).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzNy4zNzcuOCIsInVwZGF0ZWRJblZlciI6IjQzLjE1OS4yIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6WyJtZXRhOiBkZXBlbmRlbmNpZXMiXX0=-->

renovate Bot added the meta: dependencies label May 31, 2024

renovate Bot force-pushed the renovate/all-minor-patch branch 3 times, most recently from be0fb65 to 5b94780 Compare June 2, 2024 11:12

renovate Bot changed the title ~~chore(deps): update all non-major dependencies~~ fix(deps): update all non-major dependencies Jun 2, 2024

renovate Bot force-pushed the renovate/all-minor-patch branch from 5b94780 to 410768d Compare June 2, 2024 11:46

renovate Bot changed the title ~~fix(deps): update all non-major dependencies~~ chore(deps): update all non-major dependencies Jun 2, 2024

renovate Bot force-pushed the renovate/all-minor-patch branch 11 times, most recently from 59d18d1 to c9a6954 Compare June 8, 2024 12:53

renovate Bot force-pushed the renovate/all-minor-patch branch 9 times, most recently from 6409fd0 to 28ffcb4 Compare June 16, 2024 10:08

renovate Bot force-pushed the renovate/all-minor-patch branch 3 times, most recently from 6fabeca to e58c10c Compare June 18, 2024 10:04

renovate Bot force-pushed the renovate/all-minor-patch branch 10 times, most recently from df59de4 to 6b36430 Compare July 10, 2024 14:28

renovate Bot force-pushed the renovate/all-minor-patch branch 3 times, most recently from 34bdea1 to e241612 Compare July 18, 2024 05:10

renovate Bot force-pushed the renovate/all-minor-patch branch 7 times, most recently from 5a770b6 to 2a4be06 Compare July 28, 2024 12:51

renovate Bot force-pushed the renovate/all-minor-patch branch 7 times, most recently from 439e1ec to 9813391 Compare August 5, 2024 17:11

renovate Bot force-pushed the renovate/all-minor-patch branch 2 times, most recently from fc9dfbb to d5e1b2a Compare August 8, 2024 16:08

fix(deps): update all non-major dependencies

b57fb2a

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

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

fix(deps): update all non-major dependencies#10
renovate[bot] wants to merge 1 commit intomainfrom
renovate/all-minor-patch

renovate Bot commented May 31, 2024 •

edited

Loading

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

Conversation

renovate Bot commented May 31, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Release Notes

Bug Fixes

Features

Bug Fixes

Features

Bug Fixes

Documentation

Features

Changed

Added

Added

Changed

Changed

Changed

Bug fixes

v0.31.7: drizzle-kit@0.31.7

Bug fixes

Bug fixes

renovate Bot commented May 31, 2024 •

edited

Loading

`v0.31.7`: drizzle-kit@0.31.7