chore(deps): update all non-major dependencies

[hywax-assistant]

This PR contains the following updates:

Package	Type	Update	Change
@iconify-json/simple-icons	devDependencies	patch	^1.2.9 -> ^1.2.10
@iconify/json (source)	devDependencies	patch	^2.2.264 -> ^2.2.266
@types/node (source)	devDependencies	patch	^22.8.1 -> ^22.8.6
@vueuse/core (source)	dependencies	minor	^11.1.0 -> ^11.2.0
drizzle-kit (source)	devDependencies	minor	^0.26.2 -> ^0.27.0
drizzle-orm (source)	dependencies	minor	^0.35.3 -> ^0.36.0
nanoid	dependencies	patch	^5.0.7 -> ^5.0.8
nodemailer (source)	dependencies	patch	^6.9.15 -> ^6.9.16
nuxt-auth-utils	dependencies	patch	^0.5.0 -> ^0.5.1
pnpm (source)	packageManager	patch	9.12.2 -> 9.12.3
vitepress (source)	devDependencies	patch	^1.4.1 -> ^1.4.3
vue-tsc (source)	devDependencies	patch	^2.1.8 -> ^2.1.10

---

Release Notes

iconify/icon-sets (@​iconify/json)

v2.2.266

Compare Source

v2.2.265

Compare Source

vueuse/vueuse (@​vueuse/core)

v11.2.0

Compare Source

   🚀 Features

• useBreakpoints: Add breakpoints for ElementUI/ElementPlus  -  by @​AAABingBing and Anthony Fu in https://github.com/vueuse/vueuse/issues/4238 (f71e5)
• useMediaControls: Add playback error event  -  by @​DarrenSG and Anthony Fu in https://github.com/vueuse/vueuse/issues/4253 (e1169)

   🐞 Bug Fixes

• useArrayReduce: InitialValue can be a function  -  by @​Mutter45 and Anthony Fu in https://github.com/vueuse/vueuse/issues/4243 (ae542)
• useDevicesList: Handle NotAllowedError on reject/close  -  by @​espensgr and Anthony Fu in https://github.com/vueuse/vueuse/issues/4246 (bf0f2)
• useDropZone: Remove file kind restriction  -  by @​jackcodetw in https://github.com/vueuse/vueuse/issues/4305 (1d661)
• useIntervalFn: Prevent timer being set after pause is called in cb  -  by @​laporchen and Anthony Fu in https://github.com/vueuse/vueuse/issues/4258 (59f8c)
• useManualRefHistory: canUndo and canRedo typing to be computed ref  -  by @​roydukkey and Anthony Fu in https://github.com/vueuse/vueuse/issues/4261 (b46d2)
• useWebSocket: Autoreconnect when ws close  -  by @​jackcodetw in https://github.com/vueuse/vueuse/issues/4314 (08412)

    View changes on GitHub

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

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 realtimeTopic = sql`realtime.topic()`;

This allows you to use it in your code, and Drizzle Kit will treat them as existing databases,
using them only as information to connect to other entities

import { foreignKey, pgPolicy, pgTable, text, uuid } from "drizzle-orm/pg-core";
import { sql } from "drizzle-orm/sql";
import { authenticatedRole, authUsers } from "drizzle-orm/supabase";

export const profiles = pgTable(
  "profiles",
  {
    id: uuid().primaryKey().notNull(),
    email: text().notNull(),
  },
  (table) => [
    foreignKey({
      columns: [table.id],
	  // reference to the auth table from Supabase
      foreignColumns: [authUsers.id],
      name: "profiles_id_fk",
    }).onDelete("cascade"),
    pgPolicy("authenticated can view all profiles", {
      for: "select",
	  // using predefined role from Supabase
      to: authenticatedRole,
      using: sql`true`,
    }),
  ]
);

Let's check an example of adding a policy to a table that exists in Supabase

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);

Bug fixes

• [BUG]: Studio + mysql default mode, wrong format related timezone
• [BUG]: Drizzle Studio CORS error
• [BUG]: TIMESTAMPS showing up incorrectly on drizzle studio

ai/nanoid (nanoid)

v5.0.8

Compare Source

• Reduced customAlphabet size (by @​kirillgroshkov).

nodemailer/nodemailer (nodemailer)

v6.9.16

Compare Source

Bug Fixes

• addressparser: Correctly detect if user local part is attached to domain part (f2096c5)

atinux/nuxt-auth-utils (nuxt-auth-utils)

v0.5.1

Compare Source

compare changes

🩹 Fixes

• useWebAuthn composable registration & fix allowCredentials / excludeCredentials option (#​266)

🏡 Chore

• release: V0.5.0 (404acc6)
• Update deps (8947e40)

❤️ Contributors

• Sébastien Chopin (@​atinux)
• Gerben Mulder <github.undergo381@​passmail.net>

pnpm/pnpm (pnpm)

v9.12.3

Compare Source

Patch Changes

• Don't purge node_modules, when typing "n" in the prompt that asks whether to remove node_modules before installation #​8655.
• Fix a bug causing pnpm to infinitely spawn itself when manage-package-manager-versions=true is set and the .tools directory is corrupt.
• Use crypto.hash, when available, for improved performance #​8629.
• Fixed a race condition in temporary file creation in the store by including worker thread ID in filename. Previously, multiple worker threads could attempt to use the same temporary file. Temporary files now include both process ID and thread ID for uniqueness #​8703.
• All commands should read settings from the package.json at the root of the workspace #​8667.
• When manage-package-manager-versions is set to true, errors spawning a self-managed version of pnpm will now be shown (instead of being silent).
• Pass the find command to npm, it is an alias for npm search

vuejs/vitepress (vitepress)

v1.4.3

Compare Source

Performance Improvements

• lazy load shiki languages (#​4326) (8299778)

v1.4.2

Compare Source

Bug Fixes

• cache markdown-it instance and properly dispose shiki on config reload (#​4321) (45968cd) (acfe97f)
• regression: hmr not working with markdown includes due to wrong cache key (615aed5), closes #​4289 #​4303
• remove explicit chinese fonts (#​4286) (668e9f7) (b893550), closes #​4286
• theme/a11y: don't select search result unless mouse is actually moved (e638d85), closes #​4297
• theme: add types for VPLink, VPSocialLink and VPSocialLinks exports (#​4284) (fcae4d5)
• theme: don't escape html in siteTitle (#​4308) (bd690d6)

vuejs/language-tools (vue-tsc)

v2.1.10

Compare Source

Features

• language-service: auto insert const props = with props completion (#​4942) - Thanks to @​KazariEX!

Bug Fixes

• language-core: revert #​4902
• language-core: inject as assertion of useCssModule into correct location (#​4952) - Thanks to @​KazariEX!
• language-core: hold prev track id correctly (#​4961) - Thanks to @​KazariEX!
• language-core: generate style modules type as needed (#​4953) - Thanks to @​KazariEX!
• language-core: reference global types file with relative path (#​4966)

Refactors

• vscode: rewrite with Reactive VSCode (#​4945) - Thanks to @​KazariEX, @​KermanX!

---

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), 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 if that's undesired.

---

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

---

This PR has been generated by Hywax Assistant.