How to Create and Test a GitHub Action that Generates Supabase Database Types

Supabase, being built on open–source principles, offers a comprehensive set of tools specifically for working with databases. These tools include real–time data syncing, authentication features, and API generation, allowing developers to rapidly develop robust applications. Database types, or type definitions, are essential for understanding how data is organized within a database.

In this article, We will learn about How Creating a GitHub Action for generating Supabase database types involves setting up a development environment, installing dependencies, writing the GitHub Action code in TypeScript, and configuring the action to run with the necessary inputs.

What is Supabase?

• Supabase is built on open–source principles, meaning its source code is freely available to the public.
• Supabase offers a comprehensive set of tools designed specifically for working with databases.
• Supabase provides real-time data syncing capabilities, allowing applications to instantly update data across all connected clients.
• Supabase includes authentication features that enable developers to add user authentication and authorization to their applications.
• This allows users to securely log in, manage their accounts, and access protected resources.

What is Database Types?

• Database types are synonymous with type definitions in the context of databases.
• They provide a way to understand how data is organized within a database.
• They define the types of data that can be stored, constraints on that data (such as limits or required fields), and how different pieces of data relate to each other.
• They allow developers to work with the database in a way that ensures data is used in a manner consistent with its intended structure, reducing errors and improving the robustness of the application.

Creating a GitHub Action for Supabase Database Types

Now, let’s go through the process of creating a GitHub Action that automatically generates Supabase database types:

Step 1: Set Up our Development Environment

Ensure that we have Node.js and npm (Node Package Manager) installed on our system. Create a new directory for our GitHub Action project and initialize it with a package.json file.

# Create a new directory for our GitHub Action project
mkdir generate-supabase-types

# Change into the newly created directory
cd generate-supabase-types

# Initialize a new npm package in the directory with default values
npm init -y

Step 2: Install Dependencies

Install the necessary dependencies for our GitHub Action, including the Supabase client and TypeScript typings.

npm install @supabase/supabase-js typescript @types/node --save-dev

Step 3: Write the GitHub Action Code

Create a new TypeScript file (for example, index.ts) and write the code for our GitHub Action. The action should connect to our Supabase database, fetch the schema information, and generate TypeScript types based on the schema.

// index.ts

// Import the createClient function from the Supabase client library
import { createClient } from '@supabase/supabase-js';

// Define an asynchronous function to generate database types
async function generateDatabaseTypes() {
  // Retrieve the Supabase URL and key from environment variables
  const supabaseUrl = process.env.SUPABASE_URL;
  const supabaseKey = process.env.SUPABASE_KEY;

  // Ensure that the Supabase URL and key are provided
  if (!supabaseUrl || !supabaseKey) {
    throw new Error("Supabase URL and Supabase Key are required environment variables.");
  }

  // Create a Supabase client instance using the URL and key
  const supabase = createClient(supabaseUrl, supabaseKey);

  // Fetch database schema information using a stored procedure named 'export_schema'
  const { data: tables, error } = await supabase.rpc('export_schema');
  if (error) {
    throw new Error(`Failed to fetch database schema: ${error.message}`);
  }

  // Generate TypeScript types based on the fetched schema
  // Implement this part based on our requirements
}

// Call the generateDatabaseTypes function and handle any errors
generateDatabaseTypes().catch(error => {
  console.error(error);
  process.exit(1);
});

Explanation: This TypeScript code defines a function generateDatabaseTypes that, when executed, connects to a Supabase database using a URL and key obtained from environment variables. It then uses Supabase’s rpc method to fetch the database schema information.

If successful, this schema information can be used to generate TypeScript types, which is a crucial step in ensuring type safety when interacting with the database. If any errors occur during this process, they are caught and logged to the console, and the process exits with a non–zero exit code.

Step 4: Create GitHub Action Configuration

Create a YAML file (for example, action.yml) to define our GitHub Action configuration. Specify the name, description, inputs, and main entry point for our action.

# action.yml

# The name of the GitHub Action
name: Generate Supabase Types

# A brief description of what the GitHub Action does
description: Automatically generate TypeScript types for Supabase database.

# Define the inputs required by the GitHub Action
inputs:
  supabase-url:
    description: 'Supabase URL' # Description of the Supabase URL input
    required: true # The Supabase URL is a required input
  supabase-key:
    description: 'Supabase Key' # Description of the Supabase Key input
    required: true # The Supabase Key is a required input

# Specify how the GitHub Action should be executed
runs:
  using: 'node12' # Use Node.js version 12 to run the action
  main: 'index.js' # The entry point for the GitHub Action is the index.js file

Explanation: This action.yml file defines a GitHub Action named “Generate Supabase Types” that automatically generates TypeScript types for a Supabase database. It requires two inputs, supabase-url (the Supabase URL) and supabase-key (the Supabase key), both of which are mandatory.

The action is configured to run using Node.js version 12 (node12) and specifies index.js as the entry point for the action.

Step 5: Testing our GitHub Action

Before using our GitHub Action in a real project, it’s essential to test it locally. we can do this by simulating the environment variables required by the action and running it manually.

# Set the environment variables SUPABASE_URL and SUPABASE_KEY
# Replace <your-supabase-url> and <your-supabase-key> with your actual Supabase URL and key
SUPABASE_URL=<your-supabase-url> SUPABASE_KEY=<your-supabase-key> node index.js

Ensure that our action runs successfully and generates the expected TypeScript types based on our Supabase database schema.

Conclusion

Overall, By automating the generation of Supabase database types with a GitHub Action, developers can enhance productivity and code quality. This action simplifies the process of managing database schemas, ensuring consistency and reliability in database interactions. Leveraging the power of automation, developers can accelerate their development workflows and build innovative, robust applications with Supabase.