• Head over to the Supabase website.
• Log in or create a new account if you don't have one.
• Click on the "New Project" button to start a new project.
• Fill in the details like name, region, and password.
• After creating the project, you'll land on the project dashboard. Here, you'll find your API keys and other important info.

• If you haven't already, initialize your TypeScript project:

  ```bash
  npm init -y
  ```

• Install TypeScript as a development dependency:

  ```bash
  npm install typescript --save-dev
  ```

• Create a tsconfig.json file to configure TypeScript:

```bash
npx tsc --init
```

• Optional: For a smoother development experience, you might want to install Node.js types:

  ```bash
  npm install @types/node --save-dev
  ```

• Install the Supabase client library:

  ```bash
  npm install @supabase/supabase-js
  ```

• Create a .env file in your project's root directory and add your Supabase URL and API Key:

  ```plaintext
  SUPABASE_URL=https://your-project-id.supabase.co
  SUPABASE_KEY=your-anon-key
  ```

• To load these environment variables in your TypeScript project, install the dotenv package:

  ```bash
  npm install dotenv
  ```

• Add this snippet at the top of your main file (e.g., index.ts) to load the environment variables:

```typescript
import { config } from 'dotenv';
config();
```

• Import and initialize the Supabase client using the environment variables:

  ```typescript
  import { createClient } from '@supabase/supabase-js';

  const supabaseUrl = process.env.SUPABASE_URL || '';
  const supabaseKey = process.env.SUPABASE_KEY || '';
  const supabase = createClient(supabaseUrl, supabaseKey);
  ```

• You can now perform database operations like selecting, inserting, updating, and deleting data using type-safe methods. Here are some examples:

• Select Data:
  ```typescript
  const { data, error } = await supabase
  .from('your_table')
  .select('*');
  if (error) console.error(error);
  else console.log(data);
  ```

• Insert Data:

\`\`\`typescript
const { data, error } = await supabase
  .from('your\_table')
  .insert([
    { column1: 'value1', column2: 'value2' }
  ]);

if (error) console.error(error);
else console.log(data);
\`\`\`

• Update Data:
  ```typescript
  const { data, error } = await supabase
  .from('your_table')
  .update({ column1: 'new_value' })
  .eq('id', 'your_id');
  if (error) console.error(error);
  else console.log(data);
  ```

• Delete Data:
  ```typescript
  const { data, error } = await supabase
  .from('your_table')
  .delete()
  .eq('id', 'your_id');
  if (error) console.error(error);
  else console.log(data);
  ```

• Define types for your database tables to ensure type safety. Here's an example of defining a type for a table:

  ```typescript
  interface YourTable {
  id: string;
  column1: string;
  column2: number;
  }
  ```

• Use these types in your Supabase queries:

  ```typescript
  const { data, error } = await supabase
  .from('your_table')
  .select('*');

  if (error) console.error(error);
  else console.log(data);
  ```

This setup ensures type safety, leveraging TypeScript's capabilities while working with Supabase.