+
+`dbdev` fills the same role for PostgreSQL as `npm` for JavaScript, `pip` for Python and `cargo` for Rust in that it enables publishing libraries and applications for repeatable deployment. We'll be releasing the tooling necessary for third-parties to publish `pglets` to the registry once we’ve collected some community feedback and incorporate any great new ideas. Our goal is to create an [open ecosystem](https://github.com/supabase/dbdev) for packaging and discovering SQL.
+
+The initial preview is compatible with [new projects](https://database.new) on the Supabase platform. It can also be installed on any PostgreSQL instance that support [`pg_tle`](https://github.com/aws/pg_tle) and [`pgsql-http`](https://github.com/pramsey/pgsql-http).
+
+## Get Started with dbdev
+
+The in-database client is the easiest way to get started. You can setup the installer by executing the SQL snippet available at [database.dev/installer](https://database.dev/installer).
+
+Once the `dbdev` client is present, `pglet`s can be installed from the registry as shown below:
+
+```sql
+-- Load the package from the package index
+select
+ dbdev.install ('olirice-asciiplot');
+
+-- Enable the extension
+create extension "olirice-asciiplot" version '0.2.1';
+```
+
+You can explore all available `pglet`s on [database.dev](https://database.dev).
+
+Notice that PostgreSQL sees the [`olirice-asciiplot`](https://database.dev/olirice/asciiplot) `pglet` as a native extension, rather than a raw snippet of SQL. That approach allows us to leverage PostgreSQL's builtin tooling for extension management.
+
+With our extension installed, you can use it like any other PostgreSQL extension. Continuing with the [`olirice-asciiplot`](https://database.dev/olirice/asciiplot) example, we can call the `scatter` function it provides to create an ASCII scatterplot:
+
+```sql
+select
+ scatter(
+ val::numeric, -- x
+ val::numeric, -- y
+ 'stonks!', -- title
+ 15, -- height
+ 50 -- width
+ )
+from
+ generate_series(1,10) z(val);
+/*
+ stonks!
+----------------------------------------------
+| *
+|
+| *
+| *
+|
+| *
+|
+| *
+| *
+|
+| *
+|
+| *
+| *
+*/
+```
+
+PostgreSQL's extension tooling is excellent, but it predates some practices learned from best-in-class package indexes like crates.io. To give developers a more modern development experience, we opted to layer additional strictness on top of what PostgreSQL imposes:
+
+### Versioning
+
+The extension system has full support for versioning and migrations. Officially, PostgreSQL has loose constraints for version names. We made the choice to enforce a lite version of [Semantic Versioning](https://semver.org) that restricts version numbers to `major.minor.patch` so authors can communicate bug-fixes, features, and breaking changes in a familiar way.
+
+### Namespaces
+
+Two common challenges faced by package indexes are name squatting and typo squatting.
+
+- Name squatting: reserving names for future use
+- Typo squatting: reserving misspelling of existing package
+
+The ethics of name squatting get dicey at scale while typo squatting is widely viewed as malicious behavior. To mitigate both issues, all `pglet`s published to [database.dev](https://database.dev) are namespaced to their owning organization or user’s handle. For example a `pglet` named [`olirice-index_advisor`](https://database.dev/olirice/index_advisor) was created by the account `olirice` under the name `index_advisor`. If another user, `some_user`, forks and republishes the project, it would be available under `some_user-index_advisor`. Problem solved ✅
+
+## Running on Supabase
+
+[database.dev](https://database.dev) is not coupled to the Supabase platform. `dbdev` can load SQL libraries on any PostgreSQL instance with the required base extensions. However, using `dbdev` in tandem with Supabase yields some extra possibilities.
+
+Supabase reflects APIs directly from your database’s structure, so a `pglet` can contain an entire stateful application, pre-configured with authentication, REST, GraphQL, and realtime change data capture all baked in!
+
+For example, our friends at [LangChain](https://python.langchain.com/en/latest/index.html) published a Supabase backend for their docs search tool that uses a hybrid of document embeddings and full text search to find relevant documents for a user’s query
+
+Its available at [`langchain-hybrid_search`](https://database.dev/langchain/hybrid_search) and here’s how you’d set it up:
+
+```sql
+select
+ dbdev.install ('langchain-hybrid_search');
+
+create extension if not exists vector;
+
+create extension "langchain-hybrid_search" schema public version '1.0.0';
+```
+
+That creates the relevant `documents` table and associated search functions. Then, you can immediately hit it from your front end for best-in-class document search.
+
+```jsx
+import { OpenAIEmbeddings } from 'langchain/embeddings/openai'
+import { createClient } from '@supabase/supabase-js'
+import { SupabaseHybridSearch } from 'langchain/retrievers/supabase'
+
+const privateKey = process.env.SUPABASE_PRIVATE_KEY
+if (!privateKey) throw new Error(`Expected env var SUPABASE_PRIVATE_KEY`)
+
+const url = process.env.SUPABASE_URL
+if (!url) throw new Error(`Expected env var SUPABASE_URL`)
+
+export const run = async () => {
+ const client = createClient(url, privateKey)
+
+ const embeddings = new OpenAIEmbeddings()
+
+ const retriever = new SupabaseHybridSearch(embeddings, {
+ client,
+ // Below are the defaults, expecting that you set up your supabase table and functions according to the guide above. Please change if necessary.
+ similarityK: 2,
+ keywordK: 2,
+ tableName: 'documents',
+ similarityQueryName: 'match_documents',
+ keywordQueryName: 'kw_match_documents',
+ })
+
+ const results = await retriever.getRelevantDocuments('hello bye')
+
+ console.log(results)
+}
+```
+
+## Package Highlights
+
+That's it for the [`dbdev`](http://database.new) announcement, but a package index is less interesting than what you can do with it! In that vein, the following highlights a few of packages I thought were interesting enough to callout:
+
+### burggraf-pg_headerkit
+
+[`burggraf-pg_headerkit`](https://database.dev/burggraf/pg_headerkit) is a toolkit for adding advanced features to PostgREST APIs (including Supabase REST):
+
+- rate limiting
+- IP allowlisting/denylisting
+- request logging
+
+and more.
+
+For example, you could apply a deny listing to your API using `hdr.in_deny_list()` in a row level security policy or view:
+
+```sql
+select
+ *
+from
+ app.memos
+where
+ not hdr.in_deny_list ();
+```
+
+### olirice-index_advisor
+
+[`olirice-index_advisor`](https://database.dev/olirice/index_advisor) is one of the projects we cut from [Launch Week 7](/launch-week). It is simple tool that takes a query and recommends indexes to minimize the “total_cost” according to the query’s [explain plan](https://www.postgresql.org/docs/current/using-explain.html).
+
+We ultimately ran out of time to squeeze the feature in, but the optimizer works just fine:
+
+```sql
+select dbdev.install('olirice-index_advisor');
+create extension if not exists hypopg;
+create extension "olirice-index_advisor";
+
+-- Create a dummy table
+create table account(
+ id int primary key,
+ name text
+);
+
+-- Search for indexes to optimize "select id from account where name = 'adsf'"
+select
+ *
+from
+ index_advisor($$select id from account where name = 'Foo'$$)
+```
+
+which shows
+
+```markdown
+| startup_cost_before | startup_cost_after | total_cost_before | total_cost_after | index_statements |
+| ------------------- | ------------------ | ----------------- | ---------------- | ----------------------------------------------------- |
+| 0.00 | 1.17 | 25.88 | 6.40 | {"CREATE INDEX ON public.account USING btree (name)"} |
+```
+
+In other words, it recommends the index `CREATE INDEX ON public.account USING btree (name)` which is expected to reduce the total cost from 25.88 to 6.40 for a 4x decrease.
+
+`olirice-index_advisor` is compatible with tables, views, and materialized views. It can also see through views to find relevant indexes on underlying tables, and supports generic query arguments. For example, `$1` in `select id from account where name = $1`, which makes it compatible with queries from `pg_stat_statements` and queries generated by the REST API.
+
+Keep an eye open for it in Launch Week 8.
+
+### michelp-adminpack
+
+[`michelp-adminpack`](https://database.dev/michelp/adminpack) is a collection of tools helpful for administrating your database that we often use internally at Supabase. It holds views for reviewing useful info for debugging and optimizing performance like duplicate indexes, index usage, and table size, to name a few.
+
+For example, to identify potentially unused indexes that can be dropped, you could use the `index_usage` view, which has columns for:
+
+| Column | Type |
+| --------------- | ------ |
+| schemaname | name |
+| tablename | name |
+| num_rows | bigint |
+| table_size | text |
+| index_name | name |
+| index_size | text |
+| unique | text |
+| number_of_scans | bigint |
+| tuples_read | bigint |
+| tuples_fetched | bigint |
+
+## Limitations
+
+There are several procedural languages (PL) that can be embedded in PostgreSQL and used to define functions. The ones that ship with stock PostgreSQL are `SQL`, and `pl/pgSQL` but there others that can be installed separately, including `pl/v8` for JavaScript, or `pl/perl` for Perl. A **trusted** language has been restricted to remove potentially hazardous functionality like access to the network stack and file system. `pl/v8` and `pl/perl` are examples of trusted languages. In contrast, `pl/python3u` is **untrusted**.
+
+A [Trusted Language Extension (TLE)](https://github.com/aws/pg_tle) is a [PostgreSQL extension](https://www.postgresql.org/docs/current/extend-extensions.html), written exclusively using trusted languages. In some ways that makes them less flexible than classic extensions, which can have C language components (more on that in a second). The advantage to TLEs is that they don't require direct access to the PostgreSQL server’s file system to install. That enables TLEs to be installed by end-users rather than by database administrators or hosting providers. TLEs are the enabling technology that allows a package manager like `dbdev` to function on hosted PostgreSQL platforms like Supabase.
+
+For a more in-depth explanation of Trusted Language Extensions checkout [AWS's pg_tle on Supabase blog post](https://aws.amazon.com/blogs/opensource/supabase-makes-extensions-easier-for-developers-with-trusted-language-extensions-for-postgresql/) or dive into the code at [github.com/aws/pg_tle](https://github.com/aws/pg_tle).
+
+A recent development in the PostgreSQL extension ecosystem is the 1.0 release of a new trusted language, [`pl/rust`](https://github.com/tcdi/plrust), allowing users to define SQL functions written in Rust. As a compiled language, `pl/rust` functions can execute an order of magnitude faster than `pl/pgSQL` for computationally heavy workloads. That closes the biggest capability gap between native extensions with C components and TLEs. `pl/rust` hasn’t released to Supabase yet, but we’re excited about rolling it out in the coming weeks.
+
+## Please Give Feedback
+
+As this is a preview, we anticipate that there may be a few rough edges. If you do take the time to explore `dbdev` at this stage, please contribute to its development at [github.com/supabase/dbdev](https://github.com/supabase/dbdev).
+
+We are particularly interested in hearing about:
+
+1. Any issues or bugs you encounter
+2. Feature requests and suggestions for improvement
+3. Contributions in the form of code, documentation, or testing
diff --git a/apps/www/_blog/2023-04-14-launch-week-7-community-highlights.mdx b/apps/www/_blog/2023-04-14-launch-week-7-community-highlights.mdx
new file mode 100644
index 00000000000..6e585199759
--- /dev/null
+++ b/apps/www/_blog/2023-04-14-launch-week-7-community-highlights.mdx
@@ -0,0 +1,199 @@
+---
+title: 'Launch Week 7 Community Highlights'
+launchweek: 7
+tags:
+ - launch-week
+date: '2023-04-14'
+published_at: '2023-04-14T07:00:00.000-07:00'
+toc_depth: 3
+author: paul_copplestone
+image: launch-week-7/day-5-community-highlights/day-5-community-highlights-og.jpg
+thumb: launch-week-7/day-5-community-highlights/day-5-community-highlights-thumb.jpg
+---
+
+Supabase is a collaborative company. We work with, sponsor, and support as many open source tools as possible. Here’s a few of this community highlights from the past 3 months.
+
+## Ecosystem Partners
+
+
+
+Our [Integrations Marketplace](/docs/guides/integrations) continues to grow. This past few months has brought a number of new partners and collaborations:
+
+### AWS RDS
+
+We’ve worked with the RDS team to build out the pg_tle extension and tooling and integrating it into Supabase. These changes are a stepping stone towards running the Supabase stack on AWS RDS. Special shoutout to [@jkatz](https://github.com/jkatz), who was an instrumental collaborator and the rest of the RDS team who have been helping to transition [PL/Rust](https://github.com/tcdi/plrust) into a Trusted Language.
+
+[Read the press announcement on Amazon.com.](https://aws.amazon.com/blogs/opensource/supabase-makes-extensions-easier-for-developers-with-trusted-language-extensions-for-postgresql/)
+
+[Read about pg_tle at Supabase and our collaboration with AWS.](https://www.notion.so/6f1bac83308846488ee7b01ae5c20200)
+
+[Read about our experimental database registry, database.dev.](/blog/dbdev)
+
+### Clickhouse
+
+Along with our new Clickhouse [Foreign Data Wrapper](https://supabase.github.io/wrappers/clickhouse/), our friends at Clickhouse created guides showing the bidirectional capabilities between Supabase Postgres and Clickhouse Cloud. This is a perfect pairing when you’re consolidating your operational data with your analytical data, or if you have long-running queries that you need to offload to an analytical database like Clickhouse.
+
+[Read the guide.](https://clickhouse.com/blog/migrating-data-between-clickhouse-postgres)
+
+### LangChain
+
+It’s always fun when two open source communities join forces. LangChain is an open source framework for developing applications powered by language models. This week, to support the Supabase AI Hackathon, they released a [Supabase x Langchain template](https://github.com/langchain-ai/langchain-template-supabase), one of the fastest ways to build AI applications. Their community recently made two contributions for Supabase: adding Supabase as a [Vector Store](https://js.langchain.com/docs/modules/indexes/vector_stores/integrations/supabase), and a neat [Hybrid Search](https://js.langchain.com/docs/modules/indexes/retrievers/supabase-hybrid) algorithm using Postgres’ Full Text Search. The also
+
+[Read the integration docs.](https://js.langchain.com/docs/modules/indexes/vector_stores/integrations/supabase)
+
+[Clone the template.](https://github.com/langchain-ai/langchain-template-supabase)
+
+### Vercel + OpenAI
+
+Do we even need to introduce Vercel and OpenAI? We have a new template in the [Vercel Marketplace](https://vercel.com/templates/next.js/openai-doc-search-starter) for creating GPT-search for your MDX files. The templates takes all the `.mdx` files in the `pages`directory and processes them to use as custom context within [OpenAI Text Completion](https://platform.openai.com/docs/guides/completion) prompts.
+
+[View the template.](https://vercel.com/templates/next.js/openai-doc-search-starter)
+
+### Doppler
+
+Doppler is a fully managed SecretOps platform that helps centralize, orchestrate, and rotate secrets in any environment. Your team can mitigate and remediate risks while using tools that fit natively into existing developer workflows.They just released an integration to automatically sync all of your team's secrets to Supabase.
+
+[Check out the docs.](https://docs.doppler.com/docs/supabase)
+
+### Redwood
+
+The RedwoodJS team has contributed a new framework [Quick Start](/docs/guides/getting-started/quickstarts/redwoodjs) to our docs that will get you from zero to fullstack app with Prisma in just 2 minutes. Big shoutout to [@dthyresson](https://github.com/dthyresson) who continues to be a valuable contributor across many open source communities.
+
+[Read the QuickStart.](/docs/guides/getting-started/quickstarts/redwoodjs)
+
+### Dart Edge for Supabase Edge Functions
+
+Dart Edge, built by [Invertase](https://invertase.io/), allows developers to write edge functions in Dart. Previously, Flutter developers had to use TypeScript for their edge functions, as it was the only supported language. However, with Dart Edge, Flutter developers can write backend code using their favorite programming language, Dart!
+
+[Check out the guide.](/docs/guides/functions/dart-edge)
+
+### **T3 Turbo x Supabase**
+
+T3 Turbo is a type-safe, full-stack template to create Next.js and Expo React Native applications. Using our recent [Mobile Auth updates](/blog/supabase-auth-sso-pkce), the T3 community has helped build the [Supabase Create T3 Turbo template](https://github.com/supabase-community/create-t3-turbo), the fastest and easiest way to get started with Supabase and the T3 Stack. Huge shout out to [Julius](https://twitter.com/jullerino) who single-handedly created the template!
+
+[Use the template.](https://github.com/supabase-community/create-t3-turbo)
+
+## Self-hosting with Digital Ocean and Stackgres
+
+
+
+This Launch Week had a big focus on self-hosting, adding support for self-hosted [Logs](/blog/supabase-logs-self-hosted) and [Edge Functions](/blog/edge-runtime-self-hosted-deno-functions). Along with our official [self-hosting guides](/docs/guides/self-hosting) (and existing community support for [AWS](https://github.com/supabase-community/supabase-on-aws), [k8s](https://github.com/supabase-community/supabase-kubernetes), [Traefik](https://github.com/supabase-community/supabase-traefik), and [Terraform](https://github.com/supabase-community/supabase-terraform)), we have a couple of new entrants into the community:
+
+- [Digital Ocean](https://supabase-on-do.product-docs.pages.dev/developer-center/hosting-supabase-on-digitalocean/)
+- [Stackgres](https://stackgres.io/blog/running-supabase-on-top-of-stackgres/)
+
+We’re looking for more self-hosting maintainers, especially for the self-hosted guides. Everything we do is MIT, Apache2, or PostgreSQL licensed, but our team is relatively small and we don’t have expertise for every deployment strategy that our community might want. If you are willing to help out on a regular basis please reach out!
+
+## Postgres Extensions and improvements
+
+
+
+The community continues to add and improve the extensions and configuration for our [Postgres image](https://github.com/supabase/postgres). Here are a few of the crowd favorites:
+
+### pgvector: Open-source vector similarity search for Postgres
+
+Just as it says on the label: `pgvector` enables vector functionality within Postgres. It’s been, by far, our most popular addition to date as it can be used to store OpenAI embeddings and serves as an alternative to Pinecone and Milvus.
+
+[Read the announcement.](/blog/openai-embeddings-postgres-vector)
+
+### **HypoPG: Hypothetical indexes**
+
+HypoPG allows you to create hypothetical indexes that are visible to the PostgreSQL query
+planner, with no resource cost (CPU, disk, memory). This allows users to “try out” an index without waiting for the server to build them. We have big plans for this extension - we’ll integrate this functionality into the dashboard with an Index Advisor to help you optimize slow-running queries.
+
+[Read the docs.](/docs/guides/database/extensions/hypopg)
+
+### pg_tle: Install your own extensions
+
+We’ve been working with the RDS team to make Postgres _even more_ extensible. While you typically need to wait for Cloud Providers to add extension support to their Postgres offering, pg*tle is a step towards making this \_user managed*. We’ve even built a proof-of-concept registry (similar to NPM or Cargo) where you can upload extensions and share them with the community.
+
+Link to blog post.
+
+### PGroonga v3.0
+
+PGroonga is an extension implementing full-text search in multiple languages. In v3, PGroonga becomes fully compatible with the Supabase _extensions_ schema deprecating the need to explicitly write a schema for operators. It also increases support for _text_ and _varchar_ array types. They just released this in time for Supabase Launch Week, so we’ll roll it out to the platform in the next month.
+
+[Read the announcement.](https://groonga.org/en/blog/2023/04/13/pgroonga-3.0.0.html)
+
+### LZ4 compression
+
+PG has supported LZ4 page and row compression since v14, with WAL compression added in v15. LZ4 is faster than the standard pglz method. Supabase is now fully-compatible with this option. This is especially useful for TOAST values and WAL compression.
+
+### ICU compatibility
+
+Supabase Postgres has been configured with ICU support. This makes it possible to use ICU locales as collation providers. ICU supports many languages and makes the ordering of text type attributes according to these language rules.
+
+## Client Libraries and utilities
+
+
+
+It’s becoming easier to build applications with any language.
+
+### Support for Swift, Python, and C#
+
+In the past few months, the community has rallied and shipped 3 new client libraries, complete with Docs:
+
+- Swift:
+ - [Documentation](/docs/reference/swift/introduction) | [Source Code](https://github.com/supabase-community/supabase-swift)
+ - Shout-out to: [grsouza](https://github.com/grsouza) & [@maail](https://github.com/maail)
+- Python:
+ - [Documentation](/docs/reference/python/initializing) | [Source Code](https://github.com/supabase-community/supabase-py)
+ - Shout-out to: @
+- C#
+ - [Documentation](/docs/reference/csharp/introduction) | [Source Code](https://github.com/supabase-community/supabase-csharp)
+ - Maintainers: [@acupofjose](https://github.com/acupofjose), [@veleek](https://github.com/veleek), and [@rhuanbarros](https://github.com/rhuanbarros)
+
+These libraries are in various stages of readiness, so if you find anything that can be improved don’t hesitate to jump into the source code and help out.
+
+### Supabase Cache Helpers
+
+[Philipp](https://github.com/psteinroe) just released 1.0 of “Supabase Cache Helpers”, a collection of cache utilities for Supabase. With just a line of code, you can simplify the logic of **f**etching, subscribing to updates, and mutating data as well as storage objects in your project, and have all the amazing features of SWR or React Query. The cache helpers parse queries into a unique and definite query keys, automatically populating the query cache with every mutation using implicit knowledge of the schema.
+
+[Check it out on GitHub.](https://github.com/psteinroe/supabase-cache-helpers)
+
+[Read the docs.](https://supabase-cache-helpers.vercel.app/)
+
+### SupaShim by Roboflow
+
+The team at [Roboflow](https://roboflow.com/) just released [`supashim`](https://github.com/roboflow/supashim), which hooks into the Firebase calls from your app and translates them into the Supabase equivalents. With supashim, you can take an existing Firebase app, swap out the `firebase` global for `supashim`, then point it to a self-hosted Supabase instance without changing any application code. Pretty neat!
+
+[Check it out on GitHub.](https://github.com/roboflow/supashim)
+
+## Giving back
+
+We’ve been upstreaming as many changes as possible for Supabase stack.
+
+### Postgres Patches
+
+We’ve submitted a number of patches to the Postgres Core:
+
+- Added the “USER SET” parameter values for `pg_db_role_setting`. This GUC variable lets ordinary roles set placeholder variables, when permission requirements are not known yet [[Patch](https://www.postgresql.org/message-id/flat/20230102154240.GL1153%40telsasoft.com#c04239ecde38752a3132236306784250)]
+- Added support for custom tuple slots in the custom executor nodes. This is useful for custom table access methods. [[Patch](https://www.postgresql.org/message-id/flat/CAPpHfduJUU6ToecvTyRE_yjxTS80FyPpct4OHaLFk3OEheMTNA%40mail.gmail.com)]
+- Optimizations for LWlock waiting queue scalability. Long LWlock wait queues were not effective at unlocking. We’ve submitted proposals to make the queue lockless (still under community consideration). [Discussion [one](https://www.postgresql.org/message-id/flat/CALT9ZEEz%2B%3DNepc5eti6x531q64Z6%2BDxtP3h-h_8O5HDdtkJcPw%40mail.gmail.com), [two](https://www.postgresql.org/message-id/flat/20221120204310.xywrhyxyytsajuuq%40awork3.anarazel.de), [three](https://www.postgresql.org/message-id/flat/20221027165914.2hofzp4cvutj6gin%40awork3.anarazel.de)]
+
+### OrioleDB Patches
+
+We continue to support the development of [OrioleDB](https://github.com/orioledb/orioledb), who are building scalable storage mechanisms for Postgres using table access methods. The OrioleDB extension is now version [Alpha12](https://github.com/orioledb/orioledb/releases/tag/alpha12) and compatible with Postgres 15.
+
+This release includes various improvements and fixes, including parallel sequential scan of OrioleDB relations. This allows multi-CPU systems to speed up select queries that involve sequential scans. It’s an analogue of heap parallel scan in Postgres core but for index-organized tables. With this base, we’re now implementing methods to build Orioledb indexes using many parallel workers.
+
+[Read the release notes.](https://github.com/orioledb/orioledb/releases/tag/alpha12)
+
+## Contributors
+
+We also want to highlight all the humans who have made meaningful contributions to the Supabase ecosystem since our last Launch Week:
+
+- [Gary](https://github.com/GaryAustin1) and [Olyno](https://github.com/olyno) - official moderators of our [Discord](https://discord.supabase.com) and overall incredibly helpful people. The community would not be the same without them
+- [Bruno D'Luka](https://github.com/bdlukaa) - Caring for the details of Flutter SDK so that we can provide the best DX for Flutter devs
+- [CodewithGuillaume](https://twitter.com/blackevilgoblin) - Creating a series of YouTube videos explaining different components of Supabase.
+- [Daniel Mossaband](https://github.com/DanMossa) - Worked on fixing bugs and adding features to bring the mobile auth to Supabase
+- [David Plugge](https://github.com/david-plugge) - Working on improving the [auth-helpers](https://github.com/supabase/auth-helpers) and fixing issues users report.
+- [Jonathan Wilke](https://twitter.com/jonathan_wilke) - built [SupaStarter.dev](https://supastarter.dev/). A SaaS for building SaaSes.
+- [grsouza](https://github.com/grsouza) & [Maail](https://github.com/maail) - Built the Swift libraries and documentation.
+- [Raphaël Moreau](https://twitter.com/rphlmr) - Built the [supa-stripe-stack](https://github.com/rphlmr/supa-stripe-stack) for Remix to get started building your SaaS in one command. Also the creator the [supa-fly-stack](https://github.com/rphlmr/supa-fly-stack) and [supa-remix-stack](https://github.com/rphlmr/supa-remix-stack)
+- [Vinzent](https://github.com/Vinzent03) - Constantly smashing it on the Flutter SDK adding major features such as MFA.
+- [Tiniscule](https://twitter.com/tiniscule) - for his open source [Supabase Starter kit](https://github.com/usebasejump/basejump).
+
+## Community
+
+And you, our community. Thank you for using Supabase, reading our blog posts, and showing your support. With [over 48,000 GitHub stars](https://github.com/supabase/supabase), we are now in the top 180 most-popular repositories in all of GitHub. We still have a long way to go, but it’s a lot more fun doing it collaboratively.
diff --git a/apps/www/_blog/2023-04-14-pg-tle.mdx b/apps/www/_blog/2023-04-14-pg-tle.mdx
new file mode 100644
index 00000000000..52aef363a48
--- /dev/null
+++ b/apps/www/_blog/2023-04-14-pg-tle.mdx
@@ -0,0 +1,60 @@
+---
+title: 'Trusted Language Extensions for Postgres'
+launchweek: 7
+tags:
+ - launch-week
+ - postgres
+date: '2023-04-14'
+published_at: '2023-04-14T07:00:00.000-07:00'
+to_depth: 3
+author: michel,daltjoh-aws
+image: launch-week-7/day-5-supabase-pg-tle/day-5-postgres-tle-thumb.jpg
+thumb: launch-week-7/day-5-supabase-pg-tle/day-5-postgres-tle-thumb.jpg
+---
+
+Most PostgreSQL cloud providers, such as Supabase and AWS RDS, do not allow users to install Postgres extensions into their databases until they have been rigorously vetted. Because of this, many useful Postgres extensions cannot be used on cloud platforms. To solve this, the RDS team has developed a new kind of extension called a **Trusted Language Extension** (TLE).
+
+A TLE is a Postgres extension that is written in a Trusted Language, and it can be installed in any Postgres provider that has the [pg_tle](https://github.com/aws/pg_tle) extension installed. The goal is to make more extensions available to developers, even if your database is hosted on the cloud.
+
+## How Postgres extensions work
+
+Before exploring what a Trusted Language Extension is, let’s cover the basics of Postgres Extensions and the notion of “Trusted Languages” in general.
+
+A Postgres Extension is a bundle of SQL and other code, primarily [Data Definition Language](https://www.postgresql.org/docs/current/ddl.html) (DDL) code installed into the server’s filesystem, and instantiated in a database with the [`CREATE EXTENSION`](https://www.postgresql.org/docs/current/sql-createextension.html) command. This code can contain any SQL, but almost always includes additional function objects created with the [`CREATE FUNCTION`](https://www.postgresql.org/docs/current/sql-createfunction.html) DDL statement that expose the core features of the extension to the database in some programming language, including an external library function written in C.
+
+Extensions provide a variety of additional functionality and allow third-party feature distribution without requiring changes to the Postgres database itself - including new data types, storage engines, helper functions, and even entire language runtimes like Javascript or Python.
+
+Some examples of popular Postgres extensions include:
+
+- [PostGIS](https://postgis.net/): for working with geospatial data
+- [Timescale DB](https://www.timescale.com/): for working with timeseries data
+- [Citus](https://www.citusdata.com/): for working with distributed tables
+- [plv8](https://plv8.github.io/): for running Node.js inside Postgres
+- [pgsodium](https://github.com/michelp/pgsodium): for accessing the libsodium encryption API
+
+Before extensions can be created, they must first be installed on the filesystem of the database server, which is an important security measure because in some cases extensions may require external libraries and can interact with Postgres internals. Their installation is something that requires careful consideration.
+
+## Trusted vs Untrusted
+
+Many extensions provide functions whose implementation is written in C, and creating them in a database means that the compiled C code is “dynamically linked” into your running Postgres process. These dynamically-loaded libraries can now access every aspect of your running database process, right down to raw memory. They are essentially database superusers on steroids. Because of this, C is an “untrusted language” and installing extensions written in C requires filesystem access.
+
+However there are several _trusted_ languages in Postgres that don’t provide raw access to process memory, the filesytem, or other system functions. These languages obey the security rules of Postgres. The most obvious example of these trusted languages is SQL itself. Another built-in trusted language in Postgres is called [pl/pgsql](https://www.postgresql.org/docs/current/plpgsql.html). It looks a lot like SQL but with some imperative programming features like `IF` blocks and `FOR` loops. The aforementioned plv8 is also a trusted language, as are the languages [pl/perl](https://www.postgresql.org/docs/current/plperl.html) and [pl/tcl](https://www.postgresql.org/docs/current/pltcl.html). Other languages like [pl/python](https://www.postgresql.org/docs/current/plpython.html) are **_not_** trusted because of the way they are integrated into Postgres, they do not obey the “rules” of Postgres security, and so are not included in most cloud provider platforms since they would allow database users to effectively act as a superuser.
+
+## Trusted Language Extensions
+
+Near the end of 2022, we got a surprise gift from the team at Amazon Web Services, a new Postgres extension called `pg_tle`, that allows you to **Trusted Language Extensions (TLEs).** A TLE is just like a regular Postgres extension, except that **does not need to be installed on the server filesystem** it is written in a **trusted language** you can install extensions from any database client using the function `pgtle.install_extension()`, just like you can create other objects like tables and views.
+
+Of course, TLEs _must_ be written in trusted languages as described above, hence the name, so no extensions that are written in C can be TLEs. There are still many extensions that are already written in trusted languages, and soon many more to come with some exciting progress in more performant trusted languages like [pl/rust](https://github.com/tcdi/plrust) which recently reached an official 1.0.0 version release. By removing the constraint that extensions must be installed on the server filesystem, TLEs open up a whole new world of possibilities for packaging and distributing new and modular functionality for Postgres.
+
+## Collaborating with AWS
+
+Because untrusted extensions are, by nature, able to break the security rules of Postgres, cloud providers are quite conservative about what extensions to provide to their customers. New extensions are rarely adopted quickly. This slows down the speed that new software can be created and shared. Open source requires opportunity and momentum, and by closing off the opportunity for Postgres users to quickly create, install, evaluate and iterate extensions, progress is slowed. TLEs offer an opportunity for open source developers to create and share code without having to wait for cloud providers or other gatekeepers to install it.
+
+When AWS released `pg_tle`, we realized immediately how powerful the tool is, and how it will change the way people release and install trusted extensions forever. We started collaborating with the TLE team at AWS, exchanging ideas and resources to further promote TLEs in both our database platform and theirs. By providing the TLE extension in both Supabase and AWS, we are unifying a standard package platform across two of the largest Postgres providers. We hope that other Postgres cloud providers will join the collaboration so that extension developers can leverage a large community base that greatly multiplies the reach of their efforts.
+
+## Installing TLEs with database.dev
+
+pg_tle is available on new Supabase projects and on Amazon RDS for Postgres 14.5 and higher. Supabase also includes an extension called [pgsql-http](https://github.com/pramsey/pgsql-http) for making HTTP calls from SQL to REST APIs. So, naturally putting two and two together, we thought it would be cool to see if it’s possible to install TLEs from a REST API using only SQL!
+
+We've created a new package registry, dbdev, that makes it easy to install extensions in your database migrations - as easy as: `select dbdev.install('langchain-embedding_search')`.
+You can read more about dbdev in our other blog post: [dbdev: a PostgreSQL Package Manager](/blog/dbdev).
diff --git a/apps/www/_blog/2023-04-14-supabase-studio-2.0.mdx b/apps/www/_blog/2023-04-14-supabase-studio-2.0.mdx
new file mode 100644
index 00000000000..09b7a540a01
--- /dev/null
+++ b/apps/www/_blog/2023-04-14-supabase-studio-2.0.mdx
@@ -0,0 +1,163 @@
+---
+title: 'Supabase Studio 2.0: help when you need it most'
+launchweek: 7
+tags:
+ - launch-week
+ - studio
+date: '2023-04-14'
+published_at: '2023-04-14T09:00:00.000-07:00'
+to_depth: 3
+author: alaister,joshenlim,jonny,saltcod
+image: launch-week-7/day-5-supabase-studio-2.0/day-5-supabase-studio-2.0-og.jpg
+thumb: launch-week-7/day-5-supabase-studio-2.0/day-5-supabase-studio-2.0-thumb.jpg
+---
+
+Today we're announcing Supabase Studio 2.0, packed with a ton of new stuff. We have features people have been asking for forever, and new capabilities that will change the way you work.
+
+
+
+
+
+Here's the birds-eye-view:
+
+-
+
- + [**Supabase AI**](#supabase-ai--assisted-database-development): ChatGPT, right in the Studio + +
- [**GraphiQL**](#graphiql): Query your database with GraphQL +
- [**Cascade deletes**](#cascade-deletes): Our #1 most requested feature from the community +
- [**Query Performance**](#query-performance): Investigate slow running queries +
- [**Foreign key Selector**](#foreign-key-selector): Look up a row in reference table +
- [**Postgres Roles**](#postgres-roles): Manage your Postgres roles and privileges +
- [**Database Webhooks**](#database-webhooks): Database triggers for Edge Functions +
- + [**Table/View definitions**](#tableview-definitions): View SQL definitions for tables and views + +
- [**API Autodocs**](#api-autodocs): View auto-generated docs right from the Table Editor +
- + [**Support for many tables**](#support-for-many-tables): Table Editor now supports 1000s of + tables + +
- [**JSON editing**](#json-editing): Improved JSON editing +
- [**Nullable columns**](#nullable-columns): Allow text/bool cells to be null or empty +
+
+📢 Many of the features and enhancements below came from user requests — [please keep them coming](https://github.com/orgs/supabase/discussions/categories/feature-requests)!
+
+
+
+## GraphiQL
+
+
+
+While GraphQL has been available in Supabase for just over a year, we haven't provided a visual tool for using it. You can now use the very popular GraphiQL directly from the Studio. GraphiQL is a browser tool for writing, validating, and testing GraphQL testing. Being able to use a fully integrated GraphQL IDE is a huge DX win.
+
+## Cascade deletes
+
+
+
+Cascade deletes are a core feature of Postgres, but have not been available in the Studio UI until now. This has been the #1 feature request from the community for a long time. You can now choose what you want to happen when deleting a referenced row in another table, right from Table Editor side panel.
+
+## Query Performance
+
+
+
+We've just released a new Query Performance tool to help you identify slow queries. Using this tool, along with our new [guide](https://supabase.com/docs/guides/platform/performance#examining-query-performance) should help you speed things up. These tools can help you uncover where you might have inefficient queries or schemas, or where you might need indexes or even additional compute resources.
+
+## Foreign key selector
+
+
+
+You can now select a referencing row from another table, rather than having to pass a value manually.
+You can also quickly jump to the row being referenced in another table with the _View referencing_ record
+button from the grid itself.
+
+## Postgres Roles
+
+
+
+The Roles page got a huge revision, making it easy for you to manage access control through users, groups, and permissions. It's now easy to see how many connections you're using and where they're coming from.
+
+## Database Webhooks
+
+
+
+We've wanted to improve the webhooks interface for a long time, and we've finally gotten to it. We now have full support for editing your webhooks, and you can now select an edge function to call instead of having to pass in a url. We're happy to roll this very common request out to the community.
+
+## Table/View definitions
+
+
+
+You can now see the SQL definitions for your tables and views, directly from the Table Editor. This is a great way to see how Supabase is translating your UI changes into SQL. This can be useful for creating migrations, getting help, or just for learning more about how Supabase and SQL works.
+
+## API Autodocs
+
+
+
+You can now view the auto-generated API docs right from the Table Editor. Grab the SQL and `supabase-js` code for all of the CRUD operations, straight from the table. You can also quickly generate and download a Typescript types file for your table, right from the editor.
+
+### Quality of life improvements
+
+#### Support for many tables
+
+Previously, the Table Editor would get slow and unresponsive when you had many tables. We've made a number of improvements to make it much faster and more responsive. Feel free to make all the tables you need!
+
+#### JSON editing
+
+You've always been able to use the JSON data type in your tables, but editing the data wasn't easy. We've improved the inline Table Editor, and also now allow you open json cells from the side panel for a more spacious editing experience. Next Launch Week we're hoping to decide if it's pronounced “Jason” or “Jay-sawn”. Stay tuned.
+
+#### Nullable columns
+
+Speaking of extremely common feature requests, we've gotten this one a lot in the past few months. You used to have to handle this manually, but now you can now allow text/boolean cells to be null or empty. Supabase, where productivity is more than just an empty (or null) promise.
+
+## Wrapping Up
+
+We hope you get a lot of value out of these new features and enhancements. As we mentioned earlier, many of the features listed here came directly from [Feature Requests](https://github.com/orgs/supabase/discussions/categories/feature-requests) on GitHub. Thanks to everyone who have taken the time to submit these, and encourage submissions for anything else you'd like to see.
diff --git a/apps/www/components/Favicons.tsx b/apps/www/components/Favicons.tsx
index ccdf07dd37a..0775ce24808 100644
--- a/apps/www/components/Favicons.tsx
+++ b/apps/www/components/Favicons.tsx
@@ -22,15 +22,15 @@ const Favicons = () => {
{/* prettier-ignore */}
{/* prettier-ignore */}
-
{/* prettier-ignore */}
-
{/* prettier-ignore */}
-
{/* prettier-ignore */}
-
{/* prettier-ignore */}
-
diff --git a/apps/www/components/ImageFadeStack.tsx b/apps/www/components/ImageFadeStack.tsx
new file mode 100644
index 00000000000..34075797046
--- /dev/null
+++ b/apps/www/components/ImageFadeStack.tsx
@@ -0,0 +1,81 @@
+import Image from 'next/image'
+import React, { useState, useEffect } from 'react'
+import { IconPauseCircle, IconPlayCircle } from 'ui'
+import { cn } from '~/../../packages/ui/src/utils/cn'
+
+interface ImageFadeStackProps {
+ autoplay?: boolean
+ images: string[]
+ height?: 'default'
+ delay?: number
+ altText?: string
+ showNavigation?: boolean
+}
+
+const ImageFadeStack = ({
+ images,
+ height = 'default',
+ delay = 3000,
+ autoplay = false,
+ altText = 'Image',
+ showNavigation = false,
+}: ImageFadeStackProps) => {
+ const [currentImageIndex, setCurrentImageIndex] = useState(0)
+ const [isPlaying, setIsPlaying] = useState(autoplay)
+
+ useEffect(() => {
+ if (isPlaying) {
+ const intervalId = setInterval(() => {
+ setCurrentImageIndex((prevIndex) => (prevIndex + 1) % images.length)
+ }, delay)
+
+ return () => clearInterval(intervalId)
+ }
+ }, [images, isPlaying])
+
+ function handleNavClick(index: number) {
+ setIsPlaying(false)
+ setCurrentImageIndex(index)
+ }
+
+ return (
+
+ {images.map((image, index) => (
+ <>
+
+ )
+}
+
+export default ImageFadeStack
diff --git a/apps/www/components/LaunchWeek/7/BlogLinks.tsx b/apps/www/components/LaunchWeek/7/BlogLinks.tsx
index d7087d7e3b9..41168f03550 100644
--- a/apps/www/components/LaunchWeek/7/BlogLinks.tsx
+++ b/apps/www/components/LaunchWeek/7/BlogLinks.tsx
@@ -13,68 +13,76 @@ const BlogLinks = () => {
+ {showNavigation &&
+ images.map((_, index) => (
+
+ ))}
+
+
+ More Launch Week 7
{activeDays.map((day) => - day.steps?.map((step) => ( -
-
- {step.thumb && (
-
- {step.title}
-
-
+
+ {step.thumb && (
+
+ {step.title}
+
+
diff --git a/apps/www/components/LaunchWeek/LaunchSection/TicketBrickWall.tsx b/apps/www/components/LaunchWeek/LaunchSection/TicketBrickWall.tsx
index 113c4d20d6f..b757f4cdeaf 100644
--- a/apps/www/components/LaunchWeek/LaunchSection/TicketBrickWall.tsx
+++ b/apps/www/components/LaunchWeek/LaunchSection/TicketBrickWall.tsx
@@ -1,7 +1,7 @@
import Link from 'next/link'
import React from 'react'
import { Button } from 'ui'
-import { useMobileViewport } from '../../../hooks/useMobileViewport'
+import { useBreakpoint } from 'common/hooks/useBreakpoint'
import { UserData } from '../Ticket/hooks/use-conf-data'
import { TicketBrickWallSlider } from './TicketBrickWallSlider'
@@ -12,7 +12,7 @@ interface Props {
}
export default function TicketBrickWall({ users }: Props) {
- const isMobile = useMobileViewport(768)
+ const isMobile = useBreakpoint(768)
return (
Blog post
-
New
diff --git a/apps/www/components/LaunchWeek/Releases/LW7/Day5.tsx b/apps/www/components/LaunchWeek/Releases/LW7/Day5.tsx
new file mode 100644
index 00000000000..b36d06f1c32
--- /dev/null
+++ b/apps/www/components/LaunchWeek/Releases/LW7/Day5.tsx
@@ -0,0 +1,742 @@
+import React from 'react'
+import Image from 'next/image'
+import { motion } from 'framer-motion'
+import { useBreakpoint } from 'common/hooks/useBreakpoint'
+import {
+ ArrowTopRightSvg,
+ CartTitle,
+ ChipLink,
+ MultistepSectionHeader,
+ SectionButtons,
+ StyledArticleBadge,
+} from './components'
+
+import { WeekDayProps } from '~/components/LaunchWeek/lw7_days'
+import { opacityVariant4, scaleOpacityVariant2 } from './LW7Releases'
+
+import styles from './day5.module.css'
+import Link from 'next/link'
+
+const getDay5Motion = (index: number) => {
+ switch (index) {
+ case 0:
+ return scaleOpacityVariant2
+ default:
+ return undefined
+ }
+}
+
+const getDay5omt01Motion = (index: number) => {
+ switch (index) {
+ case 2:
+ return opacityVariant4
+ default:
+ return undefined
+ }
+}
+const getDay5omt02Motion = (index: number) => {
+ switch (index) {
+ case 2:
+ return opacityVariant4
+ default:
+ return undefined
+ }
+}
+
+const Day5 = ({ day }: { day: WeekDayProps }) => {
+ const isMobile = useBreakpoint(767)
+ const isTablet = useBreakpoint(1023)
+ const isDesktop = useBreakpoint(1279)
+
+ return (
+ <>
+ {/* Community */}
+
+
+
+
+ )
+ )}
+
+
+ {/* Studio */}
+
+ {day.steps[0].steps[0].title}
+ New
+
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+
+
+
+ )
+ )}
+
+
+ {/* One More Thing */}
+
+ {day.steps[1].steps[0].title}
+
+ {day.steps[1].steps[0].bg_layers &&
+ day.steps[1].steps[0].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[4].badge}
+
+
+
+
+
+ {day.steps[1].steps[1].title}
+
+ {day.steps[1].steps[1].bg_layers &&
+ day.steps[1].steps[1].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+ {day.steps[1].steps[1].badge}
+
+
+
+
+ {day.steps[1].steps[2].title}
+
+ {day.steps[1].steps[2].bg_layers &&
+ day.steps[1].steps[2].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[2].badge}
+
+
+
+
+
+ {day.steps[1].steps[3].title}
+
+ {day.steps[1].steps[3].bg_layers &&
+ day.steps[1].steps[3].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[3].badge}
+
+
+
+
+
+ {day.steps[1].steps[4].title}
+
+ {day.steps[1].steps[4].bg_layers &&
+ day.steps[1].steps[4].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[4].badge}
+
+
+
+
+
+ {day.steps[1].steps[5].title}
+
+ {day.steps[1].steps[5].bg_layers &&
+ day.steps[1].steps[5].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[5].badge}
+
+
+
+
+
+ {day.steps[1].steps[6].title}
+
+ {day.steps[1].steps[6].bg_layers &&
+ day.steps[1].steps[6].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[6].badge}
+
+
+
+
+
+ {day.steps[1].steps[7].title}
+
+ {day.steps[1].steps[7].bg_layers &&
+ day.steps[1].steps[7].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[7].badge}
+
+
+
+
+
+ {day.steps[1].steps[8].title}
+
+ {day.steps[1].steps[8].bg_layers &&
+ day.steps[1].steps[8].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[8].badge}
+
+
+
+
+
+ {day.steps[1].steps[9].title}
+
+ {day.steps[1].steps[9].bg_layers &&
+ day.steps[1].steps[9].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[9].badge}
+
+
+
+
+
+ {day.steps[1].steps[10].title}
+
+ {day.steps[1].steps[10].bg_layers &&
+ day.steps[1].steps[10].bg_layers?.map(
+ (layer, i) =>
+ !!layer.img && (
+
+
+ {day.steps[1].steps[10].badge}
+
+
+
+
+
+
+
+
+ )
+ )}
+
+
+
+
+ )
+ )}
+
+
+
+ )
+}
+
+export default Day5
diff --git a/apps/www/components/LaunchWeek/Releases/LW7/LW7Releases.tsx b/apps/www/components/LaunchWeek/Releases/LW7/LW7Releases.tsx
index ed7d4ccc23f..bf6cf2c54be 100644
--- a/apps/www/components/LaunchWeek/Releases/LW7/LW7Releases.tsx
+++ b/apps/www/components/LaunchWeek/Releases/LW7/LW7Releases.tsx
@@ -15,14 +15,15 @@ import {
StyledArticleBadge,
} from './components'
-import { useMobileViewport } from '../../../../hooks/useMobileViewport'
+import { useBreakpoint } from 'common/hooks/useBreakpoint'
import { motion } from 'framer-motion'
+import Day5 from './Day5'
-const defaultEase = [0.25, 0.25, 0, 1]
-const defaultDuratonIn = 0.25
-const defaultDuratonOut = 0.1
+export const defaultEase = [0.25, 0.25, 0, 1]
+export const defaultDuratonIn = 0.25
+export const defaultDuratonOut = 0.1
-const opacityVariant = {
+export const opacityVariant = {
default: { opacity: 0.9, ease: defaultEase, duration: defaultDuratonOut },
hover: {
opacity: 1,
@@ -32,7 +33,7 @@ const opacityVariant = {
},
},
}
-const opacityVariant2 = {
+export const opacityVariant2 = {
default: { opacity: 0, ease: defaultEase, duration: defaultDuratonOut },
hover: {
opacity: 0.2,
@@ -42,7 +43,7 @@ const opacityVariant2 = {
},
},
}
-const opacityVariant3 = {
+export const opacityVariant3 = {
default: { opacity: 0, ease: defaultEase, duration: defaultDuratonOut },
hover: {
opacity: 1,
@@ -52,7 +53,7 @@ const opacityVariant3 = {
},
},
}
-const opacityVariant4 = {
+export const opacityVariant4 = {
default: { opacity: 0.3, ease: defaultEase, duration: defaultDuratonOut },
hover: {
opacity: 1,
@@ -62,7 +63,7 @@ const opacityVariant4 = {
},
},
}
-const scaleOpacityVariant = {
+export const scaleOpacityVariant = {
default: { scale: 1, opacity: 0.9, ease: defaultEase, duration: defaultDuratonOut },
hover: {
scale: 1.05,
@@ -73,13 +74,24 @@ const scaleOpacityVariant = {
},
},
}
-const aiImageMobileVariant = {
+export const scaleOpacityVariant2 = {
+ default: { scale: 1, opacity: 0.8, ease: defaultEase, duration: defaultDuratonOut },
+ hover: {
+ scale: 1.025,
+ opacity: 1,
+ transition: {
+ duration: defaultDuratonIn,
+ ease: defaultEase,
+ },
+ },
+}
+export const aiImageMobileVariant = {
default: { scale: 0.9 },
hover: {
scale: 0.9,
},
}
-const moveX10 = {
+export const moveX10 = {
default: { x: 0, ease: defaultEase, duration: defaultDuratonOut },
hover: {
x: 10,
@@ -132,8 +144,7 @@ const getDay4Motion = (index: number) => {
export default function LW7Releases() {
const [preRelease, day1, day2, day3, day4, day5] = days
- const isMobile = useMobileViewport(767)
- const isTablet = useMobileViewport(1023)
+ const isTablet = useBreakpoint(1023)
const showAll = false
const publishedSections =
days
@@ -183,13 +194,13 @@ export default function LW7Releases() {
+ {day.steps[2].steps[0].title}
+
+ {day.steps[2].steps[0].badge}
+
+
+
+ {day.steps[2].steps[1].title}
+ {day.steps[2].steps[1].badge}
+
+
- Supabase AI Hackathon has begun. Join now!
+ Supabase AI Hackathon
+
-
+
More info
@@ -412,7 +423,6 @@ export default function LW7Releases() {