New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

drizzle-orm-pg

Package Overview
Dependencies
Maintainers
3
Versions
170
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

drizzle-orm-pg - npm Package Compare versions

Comparing version 0.14.1 to 0.14.2-3793d78

2

package.json
{
"name": "drizzle-orm-pg",
"version": "0.14.1",
"version": "0.14.2-3793d78",
"description": "Drizzle ORM package for PostgreSQL database",

@@ -5,0 +5,0 @@ "main": "index.js",

592

README.md

@@ -1,43 +0,49 @@

<div align="center">
<h1>Drizzle ORM | PostgreSQL</h1>
<a href="https://www.npmjs.com/package/drizzle-orm-pg"><img alt="" src="https://img.shields.io/npm/v/drizzle-orm-pg"></a>
<img alt="npm peer dependency version" src="https://img.shields.io/npm/dependency-version/drizzle-orm-pg/peer/pg">
<img alt="" src="https://img.shields.io/npm/dw/drizzle-orm-pg">
<img alt="npm bundle size" src="https://img.shields.io/bundlephobia/min/drizzle-orm-pg">
<img alt="Discord" src="https://img.shields.io/discord/1043890932593987624">
<a href="https://github.com/drizzle-team/drizzle-orm/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/drizzle-team/drizzle-orm"></a>
<hr />
<div align='center'>
<h1>Drizzle ORM | PostgreSQL <a href=''><img alt='npm' src='https://img.shields.io/npm/v/drizzle-orm-pg?label='></a></h1>
<img alt='npm' src='https://img.shields.io/npm/dw/drizzle-orm-pg'>
<img alt='pg version' src='https://img.shields.io/npm/dependency-version/drizzle-orm-pg/peer/pg'>
<img alt='npm bundle size' src='https://img.shields.io/bundlephobia/min/drizzle-orm-pg'>
<a href='https://discord.gg/yfjTbVXMW4'><img alt='Discord' src='https://img.shields.io/discord/1043890932593987624'></a>
<img alt='NPM' src='https://img.shields.io/npm/l/drizzle-orm-pg'>
<h6><i>If you know SQL, you know Drizzle ORM</i></h6>
<hr />
</div>
Drizzle ORM is a TypeScript ORM library with a [drizzle-kit](#migrations) CLI companion for automatic SQL migrations generation.
Here you can find extensive docs for PostgreSQL module.
Drizzle ORM is a TypeScript ORM for SQL databases designed with maximum type safety in mind. It comes with a [drizzle-kit](https://github.com/drizzle-team/drizzle-kit-mirror) CLI companion for automatic SQL migrations generation. This is the documentation for Drizzle ORM version for PostgreSQL.
### Installation
## Installation
```bash
# npm
npm install drizzle-orm drizzle-orm-pg
npm install -D drizzle-kit
npm i drizzle-orm drizzle-orm-pg pg
npm i -D @types/pg
npm i -D drizzle-kit
# yarn
yarn add drizzle-orm drizzle-orm-pg
yarn add drizzle-orm drizzle-orm-pg pg
yarn add -D @types/pg
yarn add -D drizzle-kit
# pnpm
pnpm add drizzle-orm drizzle-orm-pg
pnpm add drizzle-orm drizzle-orm-pg pg
pnpm add -D @types/pg
pnpm add -D drizzle-kit
```
### SQL schema declaration
## SQL schema declaration
With `drizzle-orm` you declare SQL schema in TypeScript. You can have either one `schema.ts` file with all declarations or you can group them logically in multiple files. We prefer to use single file schema.
### Single schema file example
```
# Single file
📦 <project root>
└ 📂 src
└ 📂 db
└ 📜 schema.ts
# Multiple files
└ 📜schema.ts
```
### Multiple schema files example
```
📦 <project root>

@@ -47,19 +53,16 @@ └ 📂 src

└ 📂 schema
├ 📜 users.ts
├ 📜 countries.ts
├ 📜 cities.ts
├ 📜 products.ts
├ 📜 clients.ts
├ 📜 enums.ts
└ 📜 etc.ts
├ 📜users.ts
├ 📜countries.ts
├ 📜cities.ts
├ 📜products.ts
├ 📜clients.ts
├ 📜enums.ts
└ 📜etc.ts
```
### Quick start
## Quick start
```typescript
import { pgTable, serial, text, varchar } from "drizzle-orm-pg";
import { drizzle } from "drizzle-orm-pg/node";
import { Pool } from "pg";
const users = pgTable("users", {
// schema.ts
export const users = pgTable('users', {
id: serial('id').primaryKey(),

@@ -69,158 +72,136 @@ fullName: text('full_name'),

});
const pool = new Pool({ connectionString: "postgres://user:password@host:port/db" });
const db = drizzle(pool);
const users = await db.select(users);
```
### Connecting to database using a pool (recommended)
### Connect using node-postgres Pool (recommended)
```typescript
import { PgConnector } from "drizzle-orm-pg";
import { Pool } from "pg";
// db.ts
import { pgTable, serial, text, varchar } from 'drizzle-orm-pg';
import { drizzle } from 'drizzle-orm-pg/node';
import { Pool } from 'pg';
const pool = new Pool({ connectionString: "postgres://postgres:password@127.0.0.1:5432/postgres" });
import { users } from './schema';
const pool = new Pool({ connectionString: 'postgres://user:password@host:port/db' });
// or
const pool = new Pool({
host: "127.0.0.1",
host: '127.0.0.1',
port: 5432,
user: "postgres",
password: "password",
database: "db_name",
user: 'postgres',
password: 'password',
database: 'db_name',
});
const db = drizzle(pool);
const allUsers = await db.select(users);
```
### Connecting to database using a client
### Connect using node-postgres Client
```typescript
import { PgConnector } from "drizzle-orm-pg";
import { Client } from "pg";
// db.ts
import { pgTable, serial, text, varchar } from 'drizzle-orm-pg';
import { drizzle } from 'drizzle-orm-pg/node';
import { Client } from 'pg';
const client = new Client({ connectionString: "postgres://postgres:
import { users } from './schema';
const db = drizzle(pool);
const client = new Client({ connectionString: 'postgres://user:password@host:port/db' });
// or
const client = new Client({
host: '127.0.0.1',
port: 5432,
user: 'postgres',
password: 'password',
database: 'db_name',
});
await client.connect();
const db = drizzle(client);
const allUsers = await db.select(users);
```
## Schema declaration
This is how you declare SQL schema in `schema.ts`. You can declare tables, indexes and constraints, foreign keys and enums. Please pay attention to `export` keyword, they are mandatory if you'll be using [drizzle-kit SQL migrations generator](#migrations).
```typescript
import { pgEnum, pgTable, serial, varchar, uniqueIndex } from 'drizzle-orm-pg';
// declaring enum in database
export const popularityEnum = pgEnum("popularity", ["unknown", "known",
"popular"]);
export const popularityEnum = pgEnum('popularity', ['unknown', 'known',
'popular']);
export const countries = pgTable("countries", {
id: serial("id").primaryKey(),
name: varchar("name", 256),
}, (table) => ({
nameIndex: index("name_idx", table.name, { unique: true });
})
export const countries = pgTable('countries', {
id: serial('id').primaryKey(),
name: varchar('name', 256),
}, (countries) => ({
nameIndex: uniqueIndex('name_idx').on(countries.name),
}),
);
export const cities = pgTable("cities", {
id: serial("id").primaryKey(),
name: varchar("name", 256),
countryId: integer("country_id").references(() => countries.id),
popularity: popularityEnum("popularity"),
export const cities = pgTable('cities', {
id: serial('id').primaryKey(),
name: varchar('name', 256),
countryId: integer('country_id').references(() => countries.id),
popularity: popularityEnum('popularity'),
})
```
Database and table entity types
### Database and table entity types
```typescript
import { PgConnector, PgDatabase, pgTable, InferModel, serial, text, varchar } from "drizzle-orm-pg";
import { PgDatabase, pgTable, InferModel, serial, text, varchar } from 'drizzle-orm-pg';
import { drizzle } from 'drizzle-orm-pg';
const users = pgTable("users", {
const users = pgTable('users', {
id: serial('id').primaryKey(),
fullName: text('full_name'),
phone: varchar('phone', { length: 256 }),
})
});
export type User = InferModel<typeof users> // return type when queried
export type InsertUser = InferModel<typeof users, "insert"> // insert type
export type User = InferModel<typeof users>; // return type when queried
export type NewUser = InferModel<typeof users, 'insert'>; // insert type
...
const connector = new PgConnector(pool);
const db: PgDatabase = await connector.connect();
// init node-postgres Pool or Client
const pool = new Pool(...);
const result: User[] = await db.select(users)
export const db: PgDatabase = drizzle(pool);
const insertUser = (user: InsertUser) => {
return db.insert(users).values(user)
const result: User[] = await db.select(users);
export async function insertUser(user: NewUser): Promise<User> {
return db.insert(users).values(user).returning();
}
```
The list of all column types. You can also create custom types - !!see here!!.
### Declaring indexes and foreign keys
```typescript
export const popularityEnum = pgEnum("popularity", ["unknown", "known", "popular"]);
popularityEnum("column_name") // declare enum column
import { foreignKey, index, uniqueIndex, integer, pgTable, serial, varchar } from 'drizzle-orm-pg';
smallint("...")
integer("...")
bigint("...", { mode: "number" | "bigint" })
boolean("...")
text("...");
text<"one" | "two" | "three">("...");
varchar("...");
varchar<"one" | "two" | "three">("...");
varchar("...", { length: 256 }); // with length limit
serial("...");
bigserial("...", { mode: "number" | "bigint" });
decimal("...", { precision: 100, scale: 2 });
numeric("...", { precision: 100, scale: 2 });
real("...")
doublePrecision("...")
json<...>("...");
json<string[]>("...");
jsonb<...>("...");
jsonb<string[]>("...");
time("...")
time("...", { precision: 6, withTimezone: true })
timestamp("...")
timestamp("...", { mode: "date" | "string", precision: 0..6, withTimezone: true })
timestamp("...").defaultNow()
date("...")
date("...", { mode: "string" | "date" })
interval("...")
interval("...", { fields: "day" | "month" | "..." , precision: 0..6 })
column.primaryKey()
column.notNull()
column.defaultValue(...)
```
Declaring indexes and foreign keys
```typescript
import { foreignKey, index, integer, pgTable, serial, varchar } from "drizzle-orm-pg";
export const countries = pgTable("countries", {
id: serial("id").primaryKey(),
name: varchar("name", { length: 256 }),
population: integer("population"),
export const countries = pgTable('countries', {
id: serial('id').primaryKey(),
name: varchar('name', { length: 256 }),
population: integer('population'),
}, (table) => ({
nameIdx: index("name_idx", table.name), // one column
namePopulationIdx: index("name_population_idx", [table.name, table.population]), // multiple columns
uniqueIdx: index("unique_idx", table.name, { unique: true }), // unique index
nameIdx: index('name_idx').on(table.name), // one column
namePopulationIdx: index('name_population_idx').on(table.name, table.population), // multiple columns
uniqueIdx: uniqueIndex('unique_idx').on(table.name), // unique index
})
);
export const cities = pgTable("cities", {
id: serial("id").primaryKey(),
name: varchar("name", { length: 256 }),
countryId: integer("country_id").references(() => countries.id), // inline foreign key
countryName: varchar("country_id"),
}, (table) => ({
export const cities = pgTable('cities', {
id: serial('id').primaryKey(),
name: varchar('name', { length: 256 }),
countryId: integer('country_id').references(() => countries.id), // inline foreign key
countryName: varchar('country_id'),
}, (cities) => ({
// explicit foreign key with 1 column
countryFk: foreignKey(() => ({
columns: [table.countryId],
columns: [cities.countryId],
foreignColumns: [countries.id],

@@ -230,3 +211,3 @@ })),

countryIdNameFk: foreignKey(() => ({
columns: [table.countryId, table.countryName],
columns: [cities.countryId, cities.countryName],
foreignColumns: [countries.id, countries.name],

@@ -236,14 +217,68 @@ })),

// list of all index params
unique?: boolean;
concurrently?: boolean;
only?: boolean;
using?: sql``; // sql expression
order?: 'asc' | 'desc';
nulls?: 'first' | 'last';
where?: sql``; // sql expression
// Index declaration reference
index('name')
.on(table.column1, table.column2, ...)
.onOnly(table.column1, table.column2, ...)
.concurrently()
.using(sql``) // sql expression
.asc()
.desc()
.nullsFirst()
.nullsLast()
.where(sql``) // sql expression
```
### Create Read Update Delete
## Column types
```typescript
export const popularityEnum = pgEnum('popularity', ['unknown', 'known', 'popular']); // declare enum type
popularityEnum('column_name') // declare enum column
smallint('...')
integer('...')
bigint('...', { mode: 'number' | 'bigint' })
boolean('...')
text('...');
text<'one' | 'two' | 'three'>('...');
varchar('...');
varchar<'one' | 'two' | 'three'>('...');
varchar('...', { length: 256 }); // with length limit
serial('...');
bigserial('...', { mode: 'number' | 'bigint' });
decimal('...', { precision: 100, scale: 2 });
numeric('...', { precision: 100, scale: 2 });
real('...')
doublePrecision('...')
json<...>('...');
json<string[]>('...');
jsonb<...>('...');
jsonb<string[]>('...');
time('...')
time('...', { precision: 6, withTimezone: true })
timestamp('...')
timestamp('...', { mode: 'date' | 'string', precision: 0..6, withTimezone: true })
timestamp('...').defaultNow()
date('...')
date('...', { mode: 'string' | 'date' })
interval('...')
interval('...', { fields: 'day' | 'month' | '...' , precision: 0..6 })
column.primaryKey()
column.notNull()
column.defaultValue(...)
timeColumn.defaultNow()
uuidColumn.defaultRandom()
```
## Select, Insert, Update, Delete
### Select
Querying, sorting and filtering. We also support partial select.

@@ -253,12 +288,12 @@

...
import { PgConnector, pgTable, serial, text, varchar } from "drizzle-orm-pg";
import { and, asc, desc, eq, or } from "drizzle-orm/expressions";
import { pgTable, serial, text, varchar } from 'drizzle-orm-pg';
import { drizzle } from 'drizzle-orm-pg/node';
import { and, asc, desc, eq, or } from 'drizzle-orm/expressions';
const users = pgTable("users", {
id: serial("id").primaryKey(),
name: text("full_name"),
const users = pgTable('users', {
id: serial('id').primaryKey(),
name: text('full_name'),
});
const connector = new PgConnector(...);
const db = await connector.connect();
const db = drizzle(...);

@@ -270,3 +305,3 @@ await db.select(users);

await db.select(users)
.where(and(eq(users.id, 42), eq(users.name, "Dan")));
.where(and(eq(users.id, 42), eq(users.name, 'Dan')));

@@ -283,3 +318,3 @@ await db.select(users)

// limit offset & order by
// limit, offset & order by
await db.select(users).limit(10).offset(10);

@@ -331,23 +366,25 @@ await db.select(users).orderBy(asc(users.name));

and(exressions: Expr[])
or(exressions: Expr[])
and(expressions: SQL[])
or(expressions: SQL[])
```
Inserting
### Insert
```typescript
import { PgConnector, pgTable, serial, text, timestamp } from "drizzle-orm-pg";
import { pgTable, serial, text, timestamp, InferModel } from 'drizzle-orm-pg';
import { drizzle } from 'drizzle-orm-pg/node';
const users = pgTable("users", {
id: serial("id").primaryKey(),
name: text("name"),
createdAt: timestamp("created_at"),
const users = pgTable('users', {
id: serial('id').primaryKey(),
name: text('name'),
createdAt: timestamp('created_at'),
});
const connector = new PgConnector(...);
const db = await connector.connect();
type NewUser = InferModel<typeof users>;
await db.insert(users
const db = drizzle(...);
await db.insert(users)
.values({
name: "Andrew",
name: 'Andrew',
createdAt: new Date(),

@@ -360,25 +397,26 @@ });

{
name: "Andrew",
name: 'Andrew',
createdAt: new Date(),
},
{
name: "Dan",
name: 'Dan',
createdAt: new Date(),
},
));
);
await db.insert(users)
.values(...[
{
name: "Andrew",
const newUsers: NewUser[] = [
{
name: 'Andrew',
createdAt: new Date(),
},
{
name: "Dan",
createdAt: new Date(),
},
]);
},
{
name: 'Dan',
createdAt: new Date(),
},
];
await db.insert(users).values(...newUsers);
```
Update and Delete
### Update and Delete

@@ -388,6 +426,6 @@ ```typescript

.set({ name: 'Mr. Dan' })
.where(eq(usersTable.name, 'Dan'));
.where(eq(users.name, 'Dan'));
await db.delete(users)
.where(eq(usersTable.name, 'Dan'));
.where(eq(users.name, 'Dan'));
```

@@ -399,48 +437,40 @@

### Many-to-one
#### Many-to-one
```typescript
import { PgConnector, pgTable, serial, text, timestamp } from "drizzle-orm-pg";
const cities = pgTable("cities", {
id: serial("id").primaryKey(),
name: text("name"),
const cities = pgTable('cities', {
id: serial('id').primaryKey(),
name: text('name'),
});
const users = pgTable("users", {
id: serial("id").primaryKey(),
name: text("name"),
cityId: integer("city_id").references(() => cities.id)
const users = pgTable('users', {
id: serial('id').primaryKey(),
name: text('name'),
cityId: integer('city_id').references(() => cities.id)
});
const connector = new PgConnector(...);
const db = await connector.connect();
const result = db.select(cities).leftJoin(users, eq(cities2.id, users2.cityId))
const result = db.select(cities)
.leftJoin(users, eq(cities2.id, users2.cityId));
```
### Many-to-many
#### Many-to-many
```typescript
const users = pgTable("users", {
id: serial("id").primaryKey(),
name: text("name"),
const users = pgTable('users', {
id: serial('id').primaryKey(),
name: text('name'),
});
const chatGroups = pgTable("chat_groups", {
id: serial("id").primaryKey(),
name: text("name"),
const chatGroups = pgTable('chat_groups', {
id: serial('id').primaryKey(),
name: text('name'),
});
const usersToChatGroups = pgTable("usersToChatGroups", {
userId: integer("user_id").notNull().references(() => users.id),
groupId: integer("group_id").notNull().references(() => chatGroups.id),
const usersToChatGroups = pgTable('usersToChatGroups', {
userId: integer('user_id').notNull().references(() => users.id),
groupId: integer('group_id').notNull().references(() => chatGroups.id),
});
...
const connector = new PgConnector(...);
const db = await connector.connect();
// querying user group with id 1 and all the participants(users)
db.select(usersToChatGroups)
const result = await db.select(usersToChatGroups)
.leftJoin(users, eq(usersToChatGroups.userId, users.id))

@@ -451,35 +481,73 @@ .leftJoin(chatGroups, eq(usersToChatGroups.groupId, chatGroups.id))

### Join aliases and selfjoins
#### Join aliases and self-joins
```typescript
import { ..., alias } from "drizzle-orm-pg";
import { ..., alias } from 'drizzle-orm-pg';
export const files = pgTable("folders", {
name: text("name").notNull(),
parent: text("parent_folder")
export const files = pgTable('folders', {
name: text('name').notNull(),
parent: text('parent_folder')
})
...
const connector = new PgConnector(...);
const db = await connector.connect();
const nestedFiles = alias(files, 'nested_files');
const nestedFiles = alias(files, "nested_files");
await db.select(files)
// will return files and folders and nested files for each folder at root dir
const result = await db.select(files)
.leftJoin(nestedFiles, eq(files.name, nestedFiles.name))
.where(eq(files.parent, "/"));
// will return files and folers and nested files for each folder at root dir
.where(eq(files.parent, '/'));
```
### Join using partial field select
#### Join using partial select
Join Cities with Users getting only needed fields form request
```typescript
await db.select(cities).fields({
id: cities.id,
// Select user ID and city ID and name
const result1 = await db.select(cities).fields({
userId: users.id,
cityId: cities.id,
cityName: cities.name
}).leftJoin(users, eq(users.cityId, cities.id));
// Select all fields from users and only id and name from cities
const result2 = await db.select(cities).fields({
// Supports any level of nesting!
user: users,
city: {
id: cities.id,
name: cities.name
},
}).leftJoin(users, eq(users.cityId, cities.id));
```
## Prepared statements
```typescript
const query = db.select(users)
.where(eq(users.name, 'Dan'))
.prepare();
const result = await query.execute();
```
### Prepared statements with parameters
```typescript
import { placeholder } from 'drizzle-orm-pg';
const query = db.select(users)
.where(eq(users.name, placeholder('name')))
.prepare();
const result = await query.execute({ name: 'Dan' });
```
## Raw queries execution
If you have some complex queries to execute and drizzle-orm can't handle them yet, you can use the `db.execute` method to execute raw queries.
```typescript
// it will automatically run a parametrized query!
const res: QueryResult<{ id: number, name: string }> = await db.execute<{ id: number, name: string }>(sql`select * from ${users} where ${users.id} = ${userId}`);
```
## Migrations

@@ -489,3 +557,4 @@

[DrizzleKit](https://www.npmjs.com/package/drizzle-kit) - is a CLI migrator tool for DrizzleORM. It is probably one and only tool that lets you completely automatically generate SQL migrations and covers ~95% of the common cases like delitions and renames by prompting user input.\
[DrizzleKit](https://www.npmjs.com/package/drizzle-kit) - is a CLI migrator tool for DrizzleORM. It is probably one and only tool that lets you completely automatically generate SQL migrations and covers ~95% of the common cases like deletions and renames by prompting user input.
Check out the [docs for DrizzleKit](https://github.com/drizzle-team/drizzle-kit-mirror)

@@ -496,15 +565,15 @@

```typescript
import { index, integer, pgTable, serial, varchar } from "drizzle-orm-pg";
import { index, integer, pgTable, serial, varchar } from 'drizzle-orm-pg';
export const users = pgTable("users", {
id: serial("id").primaryKey(),
fullName: varchar("full_name", { length: 256 }),
}, (table)=>({
nameIdx: index("name_idx", table.fullName),
export const users = pgTable('users', {
id: serial('id').primaryKey(),
fullName: varchar('full_name', { length: 256 }),
}, (users) => ({
nameIdx: index('name_idx').on(users.fullName),
}));
export const authOtps = pgTable("auth_otp", {
id: serial("id").primaryKey(),
phone: varchar("phone", { length: 256 }),
userId: integer("user_id").references(() => users.id),
export const authOtps = pgTable('auth_otp', {
id: serial('id').primaryKey(),
phone: varchar('phone', { length: 256 }),
userId: integer('user_id').references(() => users.id),
}

@@ -517,14 +586,14 @@ ```

CREATE TABLE IF NOT EXISTS auth_otp (
"id" SERIAL PRIMARY KEY,
"phone" character varying(256),
"user_id" INT
'id' SERIAL PRIMARY KEY,
'phone' character varying(256),
'user_id' INT
);
CREATE TABLE IF NOT EXISTS users (
"id" SERIAL PRIMARY KEY,
"full_name" character varying(256)
'id' SERIAL PRIMARY KEY,
'full_name' character varying(256)
);
DO $$ BEGIN
ALTER TABLE auth_otp ADD CONSTRAINT auth_otp_user_id_fkey FOREIGN KEY ("user_id") REFERENCES users(id);
ALTER TABLE auth_otp ADD CONSTRAINT auth_otp_user_id_fkey FOREIGN KEY ('user_id') REFERENCES users(id);
EXCEPTION

@@ -540,22 +609,11 @@ WHEN duplicate_object THEN null;

```typescript
import { PgConnector } from "drizzle-orm-pg";
import { Pool } from "pg";
import { drizzle } from 'drizzle-orm-pg/node';
import { migrate } from 'drizzle-orm-pg/node/migrator';
import { Pool } from 'pg';
const pool = new Pool({ connectionString: "postgres://user:password@host:port/db" });
const connector = new PgConnector(pool);
const db = await connector.connect();
const pool = new Pool({ connectionString: 'postgres://user:password@host:port/db' });
const db = drizzle(pool);
// this will automatically run needed migrations on the database
await connector.migrate({ migrationsFolder: "./drizzle" })
await migrate(db, { migrationsFolder: './drizzle' })
```
## Raw query usage
#### If you have some complex queries to execute and drizzle-orm can't handle them yet, then you could use `rawQuery` execution
### Execute custom raw query
```typescript
// it will automatically run a parametrized query!
const res: QueryResult<any> = await db.execute(sql`SELECT * FROM users WHERE user.id = ${userId}`)
```
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc