An extension to use brainfuck code within the database

# BrainFuck Trusted Language Extension (TLE) for PostgreSQL

## Overview
The **BrainFuck TLE** is a Trusted Language Extension (TLE) for PostgreSQL that allows users to execute BrainFuck programs directly within their database. This extension provides a fun and unconventional way to integrate esoteric programming into PostgreSQL.

## Features
- Execute BrainFuck programs within SQL queries
- Supports standard BrainFuck operations (`+`, `-`, `<`, `>`, `[`, `]`, `,`, `.`)
- Sandbox execution within the PostgreSQL environment
- Compatible with Supabase and other PostgreSQL deployments with TLE support

## Prerequisites
Before installing the BrainFuck TLE, ensure that your PostgreSQL instance meets the following requirements:
- PostgreSQL 15+ with Trusted Language Extensions (TLE) enabled
- `pg_tle` extension installed
- `dbdev` extension installed
-  `plv8` extension installed

## Installation
### Step 1: Install TLE Dependencies
If you haven't already installed the necessary TLE components, run the following SQL commands:

```sql
CREATE EXTENSION IF NOT EXISTS http WITH SCHEMA extensions;
CREATE EXTENSION IF NOT EXISTS pg_tle;
drop extension if exists "supabase-dbdev";
select pgtle.uninstall_extension_if_exists('supabase-dbdev');
select
    pgtle.install_extension(
        'supabase-dbdev',
        resp.contents ->> 'version',
        'PostgreSQL package manager',
        resp.contents ->> 'sql'
    )
from http(
    (
        'GET',
        'https://api.database.dev/rest/v1/'
        || 'package_versions?select=sql,version'
        || '&package_name=eq.supabase-dbdev'
        || '&order=version.desc'
        || '&limit=1',
        array[
            ('apiKey', 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InhtdXB0cHBsZnZpaWZyYndtbXR2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE2ODAxMDczNzIsImV4cCI6MTk5NTY4MzM3Mn0.z2CN0mvO2No8wSi46Gw59DFGCTJrzM0AQKsu_5k134s')::http_header
        ],
        null,
        null
    )
) x,
lateral (
    select
        ((row_to_json(x) -> 'content') #>> '{}')::json -> 0
) resp(contents);
create extension "supabase-dbdev";
select dbdev.install('supabase-dbdev');
drop extension if exists "supabase-dbdev";
create extension "supabase-dbdev";
```

### Step 2: Install BrainFuck TLE
Once TLE is set up, install the BrainFuck extension:

```sql
SELECT dbdev.install('mansueli@brainfuck');
CREATE EXTENSION "mansueli@brainfuck"
    SCHEMA public -- You can change it here to something else
    VERSION '4.2.0';
```

## Usage
### Running a BrainFuck Program in PostgreSQL
You can execute a BrainFuck program using the provided functions:

```sql
SELECT brainfuck(',[.[-],]');
```

### Example: Hello World
To print "Hello World" using BrainFuck within PostgreSQL:

```sql
SELECT brainfuck('++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>.<<+++++++++++++++.>.+++.------.--------.>.>+.','');
```

## Uninstallation
If you need to remove the BrainFuck TLE, use the following command:

```sql
DROP EXTENSION "mansueli@brainfuck";
```

## Notes & Warnings
- This extension is experimental and should be used with caution in production environments.
- BrainFuck programs can be slow due to their esoteric nature.
- Running complex BrainFuck scripts may impact database performance.

## License
This project is licensed under the Apache-2.0 License. See the [LICENSE](https://github.com/mansueli/tle/tree/master?tab=Apache-2.0-1-ov-file#readme) file for details.

## Contributing
Contributions, issues, and feature requests are welcome! Feel free to open a PR or issue on [GitHub](https://github.com/mansueli/tle/tree/master/brainfuck).

## Acknowledgments
Special thanks to the PostgreSQL and TLE communities for making database extensibility more powerful and fun!


Simple Queue system for Postgres using pg_cron & pg_net

# supa_queue Extension for Postgres

## Overview

The `supa_queue` extension is a simple but robust message queue system designed to work seamlessly with Postgres. It allows you to manage and process asynchronous jobs efficiently within your Postgres database.
You can read the blog post explaining this system here: [Building a Queue System with Supabase and PostgreSQL](https://blog.mansueli.com/building-a-queue-system-with-supabase-and-postgresql)

## Features

- Simple message queue system.
- Support for various HTTP methods (GET, POST, DELETE).
- Retry mechanism for failed jobs.
- Concurrent processing using multiple workers.
- Integration with external services via HTTP requests.
- Flexible scheduling with `pg_cron` for optimal job management.

## Installation

To install the `supa_queue` extension, follow these steps:

1. Make sure you have Postgres installed and running.

1. Install the required extensions `pg_cron` and `pg_net` if not already installed.

1. Install [DB.DEV](https://database.dev/installer):
```sql
create extension if not exists http with schema extensions;
create extension if not exists pg_tle;
select pgtle.uninstall_extension_if_exists('supabase-dbdev');
drop extension if exists "supabase-dbdev";
select
    pgtle.install_extension(
        'supabase-dbdev',
        resp.contents ->> 'version',
        'PostgreSQL package manager',
        resp.contents ->> 'sql'
    )
from http(
    (
        'GET',
        'https://api.database.dev/rest/v1/'
        || 'package_versions?select=sql,version'
        || '&package_name=eq.supabase-dbdev'
        || '&order=version.desc'
        || '&limit=1',
        array[
            ('apiKey', 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InhtdXB0cHBsZnZpaWZyYndtbXR2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE2ODAxMDczNzIsImV4cCI6MTk5NTY4MzM3Mn0.z2CN0mvO2No8wSi46Gw59DFGCTJrzM0AQKsu_5k134s')::http_header
        ],
        null,
        null
    )
) x,
lateral (
    select
        ((row_to_json(x) -> 'content') #>> '{}')::json -> 0
) resp(contents);
create extension "supabase-dbdev";
select dbdev.install('supabase-dbdev');
drop extension if exists "supabase-dbdev";
create extension "supabase-dbdev";
```

1. Install supa_queue with the following code:

```sql
select dbdev.install('mansueli-supa_queue');
create extension "mansueli-supa_queue"
    version '1.0.4';
```

You can also install it in a different `schema` with:

```sql
create schema supa_queue;
select dbdev.install('mansueli-supa_queue');
create extension "mansueli-supa_queue"
    schema supa_queue
    version '1.0.4';
```

## Usage

### Inserting Jobs

To add a job to the queue, insert a new record into the `job_queue` table. Specify the HTTP verb (GET, POST, DELETE), payload, and other relevant information. The job will be processed asynchronously.

```sql
INSERT INTO job_queue (http_verb, payload, url_path) VALUES ('GET', '{"key": "value"}', '/api/resource');
```

### Processing Jobs

Jobs are processed automatically using the provided functions. The `process_job()` trigger function processes newly inserted jobs. The `process_current_jobs_if_unlocked()` function assigns jobs to available workers for execution.

### Retrying Failed Jobs

Failed jobs are automatically retried with the `retry_failed_jobs()` function, increasing job reliability. Jobs with a status of 'failed' and within the retry limit will be retried.

## Configuration

You can configure various aspects of the `supa_queue` extension by modifying the provided SQL functions and cron schedules to suit your specific use case.

Note that you'll need to set these values in Vault:

 - `service_role` key you can get this in the [dashboard](https://supabase.com/dashboard/project/_/settings/api).
 - `consumer_function` this is the URL of the Edge Function that will consume the tasks.
## License

This extension is provided under the [license](https://github.com/mansueli/supa_queue/blob/master/LICENSE) included in the repository.

## Contributing

If you'd like to contribute to this project or report issues, please visit the [GitHub repository](https://github.com/mansueli/supa_queue) for more information.


In database version control for postgres functions

# Function VC (Version Control)

Function VC is a set of functions that allow you to version control your Postgres functions in the database.

This is a Trusted language extension to allow for an easy install of the version control of Postgres functions that was published on this blog post: [Easy Deployment and Rollback of PostgreSQL Functions with Supabase](https://blog.mansueli.com/streamlining-postgresql-function-management-with-supabase).

## Installing FunctionVC

### Install Database.dev
<details>

<summary>(if you don't have it)</summary>

```sql
/*---------------------
---- install dbdev ----
----------------------
Requires:
  - pg_tle: https://github.com/aws/pg_tle
  - pgsql-http: https://github.com/pramsey/pgsql-http
*/
create extension if not exists http with schema extensions;
create extension if not exists pg_tle;
drop extension if exists "supabase-dbdev";
select pgtle.uninstall_extension_if_exists('supabase-dbdev');
select
    pgtle.install_extension(
        'supabase-dbdev',
        resp.contents ->> 'version',
        'PostgreSQL package manager',
        resp.contents ->> 'sql'
    )
from http(
    (
        'GET',
        'https://api.database.dev/rest/v1/'
        || 'package_versions?select=sql,version'
        || '&package_name=eq.supabase-dbdev'
        || '&order=version.desc'
        || '&limit=1',
        array[
            (
                'apiKey',
                'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJp'
                || 'c3MiOiJzdXBhYmFzZSIsInJlZiI6InhtdXB0cHBsZnZpaWZyY'
                || 'ndtbXR2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE2ODAxMDczNzI'
                || 'sImV4cCI6MTk5NTY4MzM3Mn0.z2CN0mvO2No8wSi46Gw59DFGCTJ'
                || 'rzM0AQKsu_5k134s'
            )::http_header
        ],
        null,
        null
    )
) x,
lateral (
    select
        ((row_to_json(x) -> 'content') #>> '{}')::json -> 0
) resp(contents);
create extension "supabase-dbdev";
select dbdev.install('supabase-dbdev');
drop extension if exists "supabase-dbdev";
create extension "supabase-dbdev";
```

</details>

### Installing Function VC

```sql
select dbdev.install('mansueli-function_vc');
create extension "mansueli-function_vc"
    version '1.0.1';
```

## Creating a function:

```sql
SELECT create_function_from_source(
$$
-- Note that you can just paste the function below:
CREATE OR REPLACE FUNCTION public.convert_to_uuid(input_value text)
 RETURNS uuid
AS $function$
DECLARE
  hash_hex text;
BEGIN
  -- Return null if input_value is null or an empty string
  IF input_value IS NULL OR NULLIF(input_value, '') IS NULL THEN
    RETURN NULL;
  END IF;
  hash_hex := substring(encode(digest(input_value::bytea, 'sha512'), 'hex'), 1, 36);
  RETURN (left(hash_hex, 8) || '-' || right(hash_hex, 4) || '-4' || right(hash_hex, 3) || '-a' || right(hash_hex, 3) || '-' || right(hash_hex, 12))::uuid;
END;
$function$
LANGUAGE plpgsql
IMMUTABLE
SECURITY DEFINER;
-- End of the function above
$$
);
```

Rolling back the latest version of a function:

```sql

SELECT rollback_function('convert_to_uuid');

```

Rolling back a specific version of a function:

```sql

SELECT rollback_function('convert_to_uuid', 2);

```

View the function history and versions

```sql

SELECT * from archive.function_history
  WHERE schema_name = 'public' 
  and function_name ='convert_to_uuid' ;

```

Check the current definition of a function

```sql

SELECT pg_get_functiondef((SELECT oid FROM pg_proc
  WHERE proname = 'convert_to_uuid'));

```

Storing all existing functions in the database:

```sql
SELECT archive.setup_function_history();
```

## Thanks to our contributors:
- [@imor](https://github.com/imor/)
- [@idea-garage](https://github.com/idea-garage/)


An extension to help with RLS policies within the database context

## RLS Helpers

This is an extension with convenience functions to help test and simulate RLS policies within the database.

You can use use it to get RLS context within direct database access or with Supavisor:

## Usage

You can simulate log in as an user with the following:

### Login as user:

```sql
BEGIN;
CALL auth.login_as_user('rodrigo@contoso.com');
SELECT * FROM profiles;
COMMIT;
```

### Anon access:
```sql
BEGIN;
CALL auth.login_as_anon();
SELECT * FROM profiles;
COMMIT;
```


### Logout:

```sql
BEGIN;
CALL auth.login_as_user('rodrigo@contoso.com');
SELECT * FROM profiles;
CALL auth.logout();
-- You are back to postgres role here:
SELECT * FROM profiles;
COMMIT;
```

A very powerful extension to use webhooks and interact with Supabase Edge Functions

# pgwebhook

`pgwebhook` is a PostgreSQL extension designed to facilitate the creation and management of webhooks directly from your database. It works seamlessly with the Supabase platform and leverages the `pghttp` extension for making HTTP requests. This extension is ideal for developers looking to integrate real-time data changes in PostgreSQL with external services and applications through webhooks.

## Prerequisites

- PostgreSQL 14 or newer
- `pghttp` extension (version 1.5.0 or newer recommended)

## Installation

For Supabase users or those with TLE (Trusted Language Extensions) installed, you can easily install `pgwebhook` using the following SQL commands:

```sql
SELECT dbdev.install('mansueli@pgwebhook');
CREATE EXTENSION "mansueli@pgwebhook" VERSION '0.1.1';
```

### Manual Installation

If you're not using Supabase or TLE, you can manually install `pgwebhook` by running the SQL script for the latest version (e.g., `pgwebhook--0.1.1.sql`). Ensure you have the `pgsql-http` extension installed on your PostgreSQL database. For detailed instructions, visit the [pgsql-http GitHub repository](https://github.com/pramsey/pgsql-http).

## Usage

This extension supports two main usage scenarios: direct calls to external services and webhook triggers.

### Direct Usage

#### Calling the Edge Functions Within the Database (e.g., pg_cron or through an RPC)

We believe that while this extension offers a lot of options, most projects will benefit from a wrapper that sets defaults around it. For example, let's say OpenAI restricts calls to allowed regions, or you need to keep your Edge Function calls within a few subregions for GDPR compliance.

```sql
-- Create wrapper function in the public schema
CREATE OR REPLACE FUNCTION public.euro_edge (func TEXT, data JSONB) RETURNS JSONB LANGUAGE plpgsql
AS $function$
DECLARE
    custom_headers JSONB;
    allowed_regions TEXT[] := ARRAY['eu-west-1', 'eu-west-2', 'eu-west-3', 'eu-north-1', 'eu-central-1'];
BEGIN
    -- Set headers with anon key and Content-Type
    custom_headers := jsonb_build_object('Authorization', vault.get_anon_key(bearer := true), 'Content-Type', 'application/json', 'x-region', allowed_regions);
    -- Call edge_wrapper function with default values
    RETURN hook.edge_wrapper(url := ('https://supanacho.supabase.co/functions/v1/' || func), headers := custom_headers, payload := data, max_retries := 5, allowed_regions := allowed_regions);
END;
$function$;
```

Then you can call this from the supabase-js client like:

```js
const { data, error } = await supabase.rpc('euro_edge', {
    func: 'hello-world',
    data: JSON.stringify({ name: 'John Doe' })
});
```

### Webhooks

#### Creating Webhook Triggers

To create a webhook trigger for a table, use the `hook.webhook_trigger` function as follows:

```sql
CREATE TRIGGER your_trigger_name
AFTER INSERT OR UPDATE OR DELETE ON your_table
FOR EACH ROW EXECUTE FUNCTION hook.webhook_trigger(
    'https://your-webhook-url.com',
    'POST',
    '{"Content-Type": "application/json"}',
    '{}',
    5000,
    'your_custom_handler'
);
```

#### Creating Edge Webhook Triggers

To create an edge webhook trigger that retries requests and handles regional headers, use the `hook.edgehook_trigger` function:

```sql
CREATE TRIGGER your_edge_trigger_name
AFTER INSERT OR UPDATE OR DELETE ON your_table
FOR EACH ROW EXECUTE FUNCTION hook.edgehook_trigger(
    'https://your-webhook-url.com',
    'POST',
    '{"Content-Type": "application/json"}',
    '{}',
    5000,
    ARRAY['region1', 'region2']
);
```

### Parameters

- **url**: The URL to send the webhook request to.
- **method**: HTTP method to use (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `HEAD`).
- **headers**: JSON object containing the headers for the HTTP request.
- **params**: JSON object containing the query parameters for the HTTP request.
- **timeout_ms**: Timeout in milliseconds for the HTTP request.
- **max_retries**: Maximum number of retries for the HTTP request in case of failures.
- **allowed_regions**: Array of allowed regions for edge triggers.
- **custom_handler**: Optional custom handler function for constructing the payload.

### List of Allowed Regions

- ap-northeast-1
- ap-northeast-2
- ap-south-1
- ap-southeast-1
- ap-southeast-2
- ca-central-1
- eu-central-1
- eu-west-1
- eu-west-2
- eu-west-3
- sa-east-1
- us-east-1
- us-west-1
- us-west-2

### Using Triggers on a Table

#### Create a Trigger Using a PL/pgSQL Custom Handler

```sql
CREATE OR REPLACE FUNCTION hook.custom_handler_function(payload jsonb)
RETURNS jsonb AS $$
DECLARE
    new_payload jsonb;
BEGIN
    -- Modify the payload as needed
    -- Example: Add a new field to the payload
    new_payload := payload || jsonb_build_object('additional_info', 'This is extra info');

    -- Example: Remove a sensitive field
    new_payload := new_payload - 'sensitive_field';

    -- Return the modified payload
    RETURN new_payload;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER your_trigger_name
AFTER INSERT OR UPDATE OR DELETE ON your_table
FOR EACH ROW EXECUTE FUNCTION hook.webhook_trigger(
    'https://your-webhook-url.com',
    'POST',
    '{"Content-Type": "application/json"}',
    '{}',
    5000,
    'hook.custom_handler_function'
);
```

#### Create a Trigger Using a PLv8 Custom Handler

```sql
CREATE OR REPLACE FUNCTION hook.custom_handler_function_js(payload jsonb)
RETURNS jsonb AS $$
var newPayload = payload;

// Modify the payload: Add new field and remove a sensitive field
newPayload.additional_info = 'This is extra info';
delete newPayload.sensitive_field;

return newPayload;
$$ LANGUAGE plv8;

CREATE TRIGGER your_trigger_name
AFTER INSERT OR UPDATE OR DELETE ON your_table
FOR EACH ROW EXECUTE FUNCTION hook.webhook_trigger(
    'https://your-webhook-url.com',
    'POST',
    '{"Content-Type": "application/json"}',
    '{}',
    5000,
    'hook.custom_handler_function_js'
);
```

## License

This code is licensed under the [Apache License 2.0](https://github.com/mansueli/tle/blob/main/LICENSE).


Signup email guard: Gmail normalization and disposable domain checks for Supabase Auth hooks

# email_guard

Trusted Language Extension (TLE) that guards Supabase Auth signups:
- Blocks disposable email domains.
- Normalizes Gmail addresses (remove dots and + tags) so each Gmail account can sign up only once.

Objects are created in the extension schema (`@extschema@`) so the package is relocatable.

## What’s inside

- Table: `@extschema@.disposable_email_domains(domain text primary key)`
- Function: `@extschema@.normalize_email(text)`
- Function: `@extschema@.is_disposable_email_domain(text)`
- Function: `@extschema@.is_disposable_email(text)`
- Hook helper: `@extschema@.hook_prevent_disposable_and_enforce_gmail_uniqueness(jsonb)`

Fresh installs and upgrades seed the full disposable-domain blocklist automatically; no extra seed scripts required.

## Install via database.dev (Supabase-friendly workflow)

You can publish this package as `mansueli@email_guard` and install it the same way you would install other dbdev TLEs.

### 1. Install dbdev & Supabase CLI (if needed)

- dbdev CLI: <https://supabase.github.io/dbdev/getting-started/>
- Supabase CLI: <https://supabase.com/docs/guides/cli>

Make sure your local project is connected to your Supabase database (`supabase link`). Supabase already has the `pg_tle` extension installed, which is the only prerequisite.

### 2. Generate a migration with dbdev

Use dbdev to pull version `0.11.0` (or newer) into your migrations folder. Example:

```bash
dbdev add \
  -o ./supabase/migrations/ \
  -v 0.11.0 \
  -s extensions \
  package \
  -n mansueli@email_guard
```

- `-s extensions` installs into the `extensions` schema (recommended on Supabase).
- Adjust the output folder if your project keeps migrations elsewhere.

### 3. Apply with Supabase CLI

Push the generated migration to your project database:

```bash
supabase db push
```

After the migration runs, the extension is installed and seeded in the target schema.

## Wire up the Supabase Auth hook

In the Supabase dashboard, add a **before-user-created** hook of type **Postgres Function** pointing to the schema and function you installed. For the example above (installed in `extensions`):

```
extensions.hook_prevent_disposable_and_enforce_gmail_uniqueness
```

Behavior:
- Disposable domains trigger a 403 with a helpful error message.
- Gmail/Googlemail addresses normalize to `gmail.com` with dots removed and `+tags` stripped; if a normalized Gmail already exists in `auth.users`, the hook raises a 409.
- Signups without an email (e.g., phone) are passed through unchanged.

## Keeping the blocklist current

This repo ships an automated workflow:
- Weekly job fetches the upstream disposable-email list.
- If there are changes, it bumps the minor version, creates the upgrade script, and commits both the new base version and control-file update.

To publish the updated version:

```bash
dbdev login        # paste your database.dev token
dbdev publish      # in the repo root or the email_guard folder
```

Upgrading your database to the new version pulls in the refreshed blocklist automatically.

## Handy queries

```sql
-- Check if an email domain is disposable
select extensions.is_disposable_email('user@mailinator.com');

-- Normalize a Gmail address
select extensions.normalize_email('e.xam.ple+promo@gmail.com');

-- Simulate hook behavior
select extensions.hook_prevent_disposable_and_enforce_gmail_uniqueness(
  '{"user": {"email": "e.xam.ple+1@gmail.com"}}'::jsonb
);
```

Replace `extensions` with the schema you chose if different.

## Notes

- The hook runs before the user is inserted, so only existing users are checked for Gmail duplicates.
- Domain matching walks up parent domains (`sub.mailinator.com` matches `mailinator.com`).
- The extension is relocatable; you can install it under any schema and reference it in the hook configuration.


# pgjwt

This is a fork of [pgjwt](https://github.com/michelp/pgjwt), to make it available on Database.dev. Below is the readme of the original package

## Original Description

This is a PostgreSQL implementation of [JSON Web Tokens](https://jwt.io/)

## Dependencies

This code requires the pgcrypto extension, included in most
distribution's "postgresql-contrib" package.  The tests require the
pgtap extension to run.

## Install

You will require sudo privledges and the postgres development
libraries for your operating system in most cases.  For ubuntu on
postgres 9.5 for example, you can install them with:

    sudo apt-get install postgresql-server-dev-9.5

Clone the repository and then run:

    'make install'

This creates a new extension that can be installed with 'CREATE
EXTENSION pgjwt;'

To run the tests install pgtap and run 'pg_prove test/test.sql'.
Another approach is to use the docker based test runner, but running
'./test.sh'.  This will require you have docker installed.

## Usage

Create a token.  The first argument must be valid json, the second argument any text:

    => select sign('{"sub":"1234567890","name":"John Doe","admin":true}', 'secret');
                                                                            sign
    -------------------------------------------------------------------------------------------------------------------------------------------------------
     eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

Verify a token:

    => select * from verify('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ', 'secret');
               header            |                       payload                       | valid
    -----------------------------+-----------------------------------------------------+-------
     {"alg":"HS256","typ":"JWT"} | {"sub":"1234567890","name":"John Doe","admin":true} | t

Algorithm
---------

sign() and verify() take an optional algorithm argument that can be
'HS256', 'HS384' or 'HS512'.  The default is 'HS256':

    => select sign('{"sub":"1234567890","name":"John Doe","admin":true}', 'secret', 'HS384'),



mansueli

Packages