Merge branch 'main' of github.com:drizzle-team/drizzle-orm-docs

Author: AndriiSherman

src/components/markdown/get-started/QueryDatabase.mdx

@@ -5,12 +5,13 @@ Let's **update** the `src/index.ts` file with queries to create, read, update, a
 <CodeWithProps dialect={props.dialect} env_variable={props.env_variable}>
 ```typescript copy filename="src/index.ts"
 import 'dotenv/config';
-import { drizzle, eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/$dialect$';
+import { eq } from 'drizzle-orm';
 import { usersTable } from './db/schema';
+  
+const db = drizzle(process.env.$env_variable$!);
 
 async function main() {
-  const db = await drizzle("$dialect$", process.env.$env_variable$!);
-
   const user: typeof usersTable.$inferInsert = {
     name: 'John',
     age: 30,

src/components/markdown/get-started/QueryDatabaseUpdated.mdx

@@ -3,12 +3,13 @@ import CodeWithProps from "@/components/markdown/CodeWithProps.astro";
 <CodeWithProps dialect={props.dialect} env_variable={props.env_variable}>
 ```typescript copy filename="src/index.ts"
 import 'dotenv/config';
-import { drizzle, eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/$dialect$';
+import { eq } from 'drizzle-orm';
 import { usersTable } from './db/schema';
 
-async function main() {
-  const db = await drizzle("$dialect$", process.env.$env_variable$!);
+const db = drizzle(process.env.$env_variable$!);
 
+async function main() {
   const user: typeof usersTable.$inferInsert = {
     name: 'John',
     age: 30,

src/components/markdown/get-started/mysql/ConnectMySQL.mdx

@@ -3,69 +3,45 @@ import CodeTabs from "@mdx/CodeTabs.astro";
 
 Create a `index.ts` file in the `src/db` directory and initialize the connection:
 
-<CodeTabs items={['mysql2', 'mysql2 with config']}>
+<CodeTabs items={['mysql2', 'mysql2 with config', 'your mysql2 driver']}>
 ```typescript copy
 import 'dotenv/config';
-import { drizzle } from "drizzle-orm/connect";
+import { drizzle } from "drizzle-orm/mysql2";
 
-async function main() {
-  const db = await drizzle("mysql2", process.env.DATABASE_URL);
-}
-
-main();
+const db = drizzle(process.env.DATABASE_URL);
 ```
 ```typescript copy
 import 'dotenv/config';
-import { drizzle } from "drizzle-orm/connect";
+import { drizzle } from "drizzle-orm/mysql2";
 
+// You can specify any property from the mysql2 connection options
+const db = drizzle({ connection: { uri: process.env.DATABASE_URL }});
+```
+```ts
+import 'dotenv/config';
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+  
+const poolConnection = mysql.createPool({
+  host: "host",
+  user: "user",
+  database: "database",
+});
+const db = drizzle({ client: poolConnection });
+
+// or if you need client connection
 async function main() {
-  // You can specify any property from the mysql2 connection options
-  const db = await drizzle("mysql2", { connection:{ uri: process.env.DATABASE_URL }});
+  const connection = await mysql.createConnection({
+    host: "host",
+    user: "user",
+    database: "database",
+  });
+  const db = drizzle({ client: connection });
 }
-
 main();
 ```
 </CodeTabs>
 
-If you need a synchronous connection, you can use our additional connection API, where you specify a driver connection and pass it to the Drizzle instance.
-There're two ways you can connect to the MySQL with `mysql2` driver, either single `client` connection or a `pool`.
-
-<CodeTabs items={['Client connection', 'Pool connection']}>
-  ```typescript copy
-  import 'dotenv/config';
-  import { drizzle } from "drizzle-orm/mysql2";
-  import mysql from "mysql2/promise";
-
-  async function main() {
-    const connection = await mysql.createConnection({
-      host: "host",
-      user: "user",
-      database: "database",
-    });
-
-    const db = drizzle(connection);
-  }
-
-  main();
-  ```
-  ```typescript copy
-  import 'dotenv/config';
-  import { drizzle } from "drizzle-orm/mysql2";
-  import mysql from "mysql2/promise";
-  async function main() {
-    const poolConnection = mysql.createPool({
-      host: "host",
-      user: "user",
-      database: "database",
-    });
-
-    const db = drizzle(poolConnection);
-  }
-
-  main();
-  ```
-</CodeTabs>
-
 <Callout type="warning" emoji="⚙️">
   For the built in `migrate` function with DDL migrations we and drivers strongly encourage you to use single `client` connection.  
 

src/components/markdown/get-started/mysql/ConnectPlanetScale.mdx

@@ -1,35 +1,25 @@
 Create a `index.ts` file in the `src/db` directory and initialize the connection:
 
-```typescript copy"
-import { drizzle } from "drizzle-orm/connect";
-
-async function main() {
-    const db = await drizzle('planetscale', { connection: {
-      host: process.env.DATABASE_HOST!,
-      username: process.env.DATABASE_USERNAME!,
-      password: process.env.DATABASE_PASSWORD!,
-    }});
-}
+```typescript copy
+import { drizzle } from "drizzle-orm/planetscale-serverless";
 
-main();
+const db = await drizzle({ connection: {
+  host: process.env.DATABASE_HOST!,
+  username: process.env.DATABASE_USERNAME!,
+  password: process.env.DATABASE_PASSWORD!,
+}});
 ```
 
-If you need a synchronous connection, you can use our additional connection API, 
-where you specify a driver connection and pass it to the Drizzle instance.
-
+If you need to provide your existing driver
 ```typescript copy"
 import { drizzle } from "drizzle-orm/planetscale-serverless";
 import { Client } from "@planetscale/database";
 
-async function main() {
-    const client = new Client({
-      host: process.env.DATABASE_HOST!,
-      username: process.env.DATABASE_USERNAME!,
-      password: process.env.DATABASE_PASSWORD!,
-    });
-
-    const db = drizzle(client);
-}
+const client = new Client({
+  host: process.env.DATABASE_HOST!,
+  username: process.env.DATABASE_USERNAME!,
+  password: process.env.DATABASE_PASSWORD!,
+});
 
-main();
+const db = drizzle({ client: client });
 ```

src/components/markdown/get-started/mysql/ConnectTiDB.mdx

@@ -1,26 +1,16 @@
 Create a `index.ts` file in the `src/db` directory and initialize the connection:
 
-```typescript copy filename="index.ts"
-import { drizzle } from 'drizzle-orm/connect';
-
-async function main() {
-    const db = await drizzle('tidb-serverless', process.env.DATABASE_URL!);
-}
+```typescript copy
+import { drizzle } from 'drizzle-orm/tidb-serverless';
 
-main();
+const db = drizzle(process.env.DATABASE_URL!);
 ```
 
-If you need a synchronous connection, you can use our additional connection API, 
-where you specify a driver connection and pass it to the Drizzle instance.
-
-```typescript copy"
+If you need to provide your existing driver:
+```typescript copy
 import { connect } from '@tidbcloud/serverless';
 import { drizzle } from 'drizzle-orm/tidb-serverless';
 
-async function main() {
-    const client = connect({ url: process.env.DATABASE_URL! });
-    const db = drizzle(client);
-}
-
-main();
+const client = connect({ url: process.env.DATABASE_URL! });
+const db = drizzle({ client: client });
 ```

src/components/markdown/get-started/mysql/QueryPlanetScale.mdx

@@ -2,19 +2,19 @@ import CodeWithProps from "@/components/markdown/CodeWithProps.astro";
 
 Let's **update** the `src/index.ts` file with queries to create, read, update, and delete users
 
-<CodeWithProps dialect={props.dialect} env_variable={props.env_variable}>
 ```typescript copy filename="src/index.ts"
 import 'dotenv/config';
-import { drizzle, eq } from 'drizzle-orm';
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/planetscale-serverless';
 import { usersTable } from './db/schema';
 
-async function main() {
-  const db = await drizzle('planetscale', { connection: {
-      host: process.env.DATABASE_HOST!,
-      username: process.env.DATABASE_USERNAME!,
-      password: process.env.DATABASE_PASSWORD!,
-    }});
+const db = drizzle({ connection: {
+  host: process.env.DATABASE_HOST!,
+  username: process.env.DATABASE_USERNAME!,
+  password: process.env.DATABASE_PASSWORD!,
+}});
 
+async function main() {
   const user: typeof usersTable.$inferInsert = {
     name: 'John',
     age: 30,
@@ -48,5 +48,4 @@ async function main() {
 }
 
 main();
-```
-</CodeWithProps>
+```

src/components/markdown/get-started/postgresql/ConnectNeon.mdx

@@ -5,26 +5,18 @@ import Section from "@mdx/Section.astro";
 Create a `index.ts` file in the `src/db` directory and initialize the connection:
 
 ```typescript
-import { drizzle } from 'drizzle-orm/connect';
-
-async function main() {
-    const db = await drizzle("neon-http", process.env.DATABASE_URL);
-}
+import { drizzle } from 'drizzle-orm/neon-http';
 
-main();
+const db = await drizzle("neon-http", process.env.DATABASE_URL);
 ```
 
 If you need a synchronous connection, you can use our additional connection API, 
 where you specify a driver connection and pass it to the Drizzle instance.
 
 ```typescript
 import { neon } from '@neondatabase/serverless';
-import { drizzle } from 'drizzle-orm/neon-http';
-
-async function main() {
-    const sql = neon(process.env.DATABASE_URL!);
-    const db = drizzle(sql);
-}
+import { drizzle } from 'drizzle-orm/neon-serverless';
 
-main();
+const sql = neon(process.env.DATABASE_URL!);
+const db = drizzle(sql);
 ```

src/components/markdown/get-started/postgresql/ConnectPostgreSQL.mdx

@@ -2,50 +2,34 @@ import CodeTabs from "@mdx/CodeTabs.astro";
 
 Create a `index.ts` file in the `src/db` directory and initialize the connection:
 
-<CodeTabs items={["node-postgres", "node-postgres with config"]}>
+<CodeTabs items={["node-postgres", "node-postgres with config", "your node-postgres driver"]}>
 ```typescript copy
 import 'dotenv/config';
-import { drizzle } from 'drizzle-orm/connect';
+import { drizzle } from 'drizzle-orm/node-postgres';
 
-async function main() {
-    const db = await drizzle("node-postgres", process.env.DATABASE_URL!);
-}
-
-main();
+const db = drizzle(process.env.DATABASE_URL!);
 ```
 ```typescript copy
 import 'dotenv/config';
-import { drizzle } from 'drizzle-orm/connect';
-
-async function main() {
-    // You can specify any property from the node-postgres connection options
-    const db = await drizzle("node-postgres", { 
-      connection: { 
-        connectionString: process.env.DATABASE_URL!,
-        ssl: true
-      }
-    });
-}
-
-main();
+import { drizzle } from 'drizzle-orm/node-postgres';
+
+// You can specify any property from the node-postgres connection options
+const db = await drizzle("node-postgres", { 
+  connection: { 
+    connectionString: process.env.DATABASE_URL!,
+    ssl: true
+  }
+});
 ```
-</CodeTabs>
-
-If you need a synchronous connection, you can use our additional connection API, 
-where you specify a driver connection and pass it to the Drizzle instance.
-
 ```typescript copy
 import 'dotenv/config';
 import { pgTable, serial, text, varchar } from "drizzle-orm/pg-core";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
 
-async function main() {
-    const pool = new Pool({
-      connectionString: process.env.DATABASE_URL!,
-    });
-    const db = drizzle(pool);
-}
-
-main();
-```
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL!,
+});
+const db = drizzle(pool);
+```
+</CodeTabs>