@plutocms/supabase 0.0.1-alpha.1

package/eslint.config.mjs

@@ -0,0 +1,88 @@
+// @ts-check
+import antfu from '@antfu/eslint-config'
+import withNuxt from './.nuxt/eslint.config.mjs'
+
+// See: https://eslint.vuejs.org/rules
+export default withNuxt(
+  // @ts-ignore - Antfu's config is ESM only, but Nuxt's ESLint config is CJS --- IGNORE ---
+  antfu({
+    rules: {
+      'node/prefer-global/process': ['off', 'never'],
+
+      'style/indent-binary-ops': 'off',
+      'style/arrow-parens': ['warn', 'always'],
+      'style/brace-style': ['warn', '1tbs'],
+
+      'vue/block-order': [
+        'warn',
+        {
+          order: ['script', 'template', 'style'],
+        },
+      ],
+
+      'vue/multiline-html-element-content-newline': 'off',
+      'vue/html-closing-bracket-newline': 'off',
+
+      'vue/html-self-closing': [
+        'warn',
+        {
+          html: {
+            void: 'always',
+            normal: 'always',
+            component: 'always',
+          },
+          svg: 'always',
+          math: 'always',
+        },
+      ],
+
+      'vue/attributes-order': [
+        'warn',
+        {
+          order: [
+            'DEFINITION',
+            'LIST_RENDERING',
+            'CONDITIONALS',
+            'RENDER_MODIFIERS',
+            'GLOBAL',
+            'UNIQUE',
+            'TWO_WAY_BINDING',
+            'SLOT',
+            'OTHER_DIRECTIVES',
+            'ATTR_DYNAMIC',
+            'ATTR_STATIC',
+            'ATTR_SHORTHAND_BOOL',
+            'EVENTS',
+            'CONTENT',
+          ],
+        },
+      ],
+
+      'vue/multi-word-component-names': 'off',
+
+      'vue/eqeqeq': ['error', 'always'],
+
+      'style/comma-dangle': [
+        'warn',
+        {
+          arrays: 'always-multiline',
+          objects: 'always-multiline',
+          functions: 'never',
+        },
+      ],
+
+      'vue/comma-dangle': [
+        'warn',
+        {
+          arrays: 'always-multiline',
+          objects: 'always-multiline',
+          functions: 'never',
+        },
+      ],
+
+      'style/operator-linebreak': 'off',
+
+      'vue/singleline-html-element-content-newline': 'off',
+    },
+  })
+)

package/nuxt.config.ts

@@ -0,0 +1,55 @@
+const cwd = process.cwd()
+
+const isDev = cwd.includes('supabase')
+
+export default defineNuxtConfig({
+  extends: [['@plutocms/pluto', { install: true }], '@plutocms/utils'],
+
+  modules: ['@nuxt/eslint', '@nuxtjs/supabase'],
+
+  $meta: {
+    name: 'supabase',
+  },
+
+  runtimeConfig: {
+    supabaseUrl: process.env.SUPABASE_URL,
+    supabaseKey: process.env.SUPABASE_KEY,
+  },
+
+  alias: {
+    cookie: 'cookie-es',
+  },
+
+  ignore: ['./scripts/**', './supabase/**'],
+
+  nitro: {
+    alias: {
+      cookie: 'cookie-es',
+    },
+  },
+
+  eslint: {
+    config: {
+      nuxt: {
+        sortConfigKeys: true,
+      },
+      standalone: false,
+    },
+  },
+
+  supabase: !isDev
+    ? {
+        types: '#shared',
+        cookiePrefix: 'access_token',
+
+        redirectOptions: {
+          login: '/admin/login',
+          callback: '/auth/confirm',
+          include: ['/admin/signup'],
+          saveRedirectToCookie: false,
+        },
+
+        redirect: false,
+      }
+    : undefined,
+})

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@plutocms/supabase",
+  "type": "module",
+  "version": "0.0.1-alpha.1",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "build": "nuxt build",
+    "dev": "nuxt dev",
+    "generate": "nuxt generate",
+    "preview": "nuxt preview",
+    "postinstall": "nuxt prepare",
+    "prettier": "prettier --write .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix && prettier --write .",
+    "supabase-types": "bun ./scripts/supabase-typegen.ts"
+  },
+  "dependencies": {
+    "@nuxtjs/supabase": "2.0.3",
+    "postgres": "^3.4.8",
+    "supabase": "^2.76.15",
+    "yup": "1.7.1"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^6.2.0",
+    "@nuxt/eslint": "^1.15.1",
+    "@nuxt/ui": "^4.4.0",
+    "@plutocms/pluto": "^0.0.1-alpha.3",
+    "@plutocms/utils": "^0.0.1-alpha.4",
+    "@types/bun": "^1.3.9",
+    "@vueuse/nuxt": "^14.2.1",
+    "eslint": "^9.39.1",
+    "nuxt": "^4.3.1",
+    "prettier": "^3.8.1",
+    "vue": "^3.5.28",
+    "vue-router": "^5.0.2"
+  },
+  "trustedDependencies": [
+    "@parcel/watcher",
+    "esbuild",
+    "supabase",
+    "unrs-resolver",
+    "vue-demi"
+  ]
+}

package/public/schema.sql

@@ -0,0 +1,103 @@
+-- Supabase Schema SQL
+-- Settings
+--- Create enum type for settings
+do $$
+begin
+  if not exists (select 1 from pg_type where typname = 'tsettings') then
+    create type TSettings as enum (
+      'website_title',
+      'website_url',
+      'website_description'
+    );
+  end if;
+end
+$$;
+
+--- Create settings table
+create table public.settings (
+  id bigint generated by default as identity not null,
+  setting_name public.TSettings not null,
+  setting_value text not null,
+  constraint settings_pkey primary key (id),
+  constraint settings_setting_name_key unique (setting_name)
+) TABLESPACE pg_default;
+
+--- Insert default settings (website_title, website_url, website_description)
+insert into public.settings (setting_name, setting_value) values
+('website_title', 'My Website'),
+('website_url', 'https://mywebsite.test'),
+('website_description', 'This is my website.');
+
+alter table public.settings enable row level security;
+
+-- Policies for settings table
+create policy "Enable insert for authenticated users only"
+on public.settings
+to authenticated, dashboard_user
+with check (true);
+
+--- Create enum type for healthcheck names
+do $$
+begin
+  if not exists (select 1 from pg_type where typname = 'thealthcheck') then
+    create type Healthcheck as enum (
+      'first_setup'
+    );
+  end if;
+end
+$$;
+
+--- Create healthcheck table (name/value format like settings)
+create table public.healthcheck (
+  id bigint generated by default as identity not null,
+  check_name public.Healthcheck not null,
+  check_value text not null,
+  constraint healthcheck_pkey primary key (id),
+  constraint healthcheck_check_name_key unique (check_name)
+) TABLESPACE pg_default;
+
+--- Insert default healthcheck values
+insert into public.healthcheck (check_name, check_value) values
+('first_setup', 'true');
+
+alter table public.healthcheck enable row level security;
+
+-- Allow read access to healthcheck for public and dashboard_user (no login required)
+create policy "Enable read access for healthcheck to public and dashboard_user"
+on public.healthcheck
+for select
+to public, dashboard_user
+using (true);
+
+-- Profiles
+create table profiles (
+  id uuid references auth.users on delete cascade not null primary key,
+  updated_at timestamp with time zone,
+  first_name text,
+  last_name text,
+  constraint first_name_length check (char_length(first_name) >= 3)
+);
+
+alter table public.profiles enable row level security;
+
+create policy "Enable read access for authenticated users"
+on public.profiles
+to authenticated, dashboard_user
+for select using (true);
+
+--- inserts a row into public.profiles
+create function public.handle_new_user()
+returns trigger
+language plpgsql
+security definer set search_path = ''
+as $$
+begin
+  insert into public.profiles (id, first_name, last_name)
+  values (new.id, new.raw_user_meta_data ->> 'first_name', new.raw_user_meta_data ->> 'last_name');
+  return new;
+end;
+$$;
+--- trigger the function every time a user is created
+create trigger on_auth_user_created
+  after insert on auth.users
+  for each row execute procedure public.handle_new_user();

package/scripts/supabase-typegen.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { cwd } from 'node:process'
+import { $ } from 'bun'
+import { consola } from 'consola'
+
+const projectUrl = process.env.SUPABASE_URL
+const projectId = projectUrl?.split('.supabase.co')[0]?.replace('https://', '')
+const _path = path
+  .resolve(cwd(), './shared/types/supabase.ts')
+  .replace(/\\/g, '/')
+
+;(async () => {
+  consola.info(`Generating Supabase types for project: ${projectId}`)
+
+  // Create file if it doesn't exist
+  if (!fs.existsSync(_path)) {
+    consola.info('Types file does not exist. Creating a new one.')
+
+    fs.mkdirSync(path.dirname(_path), { recursive: true })
+    fs.writeFileSync(_path, '', 'utf-8')
+  }
+
+  const args = [
+    `--project-id=${projectId || ''}`,
+    '--schema=public',
+    '>',
+    `"${_path}"`,
+  ]
+
+  try {
+    await $`bunx supabase gen types typescript ${{ raw: args.join(' ') }}`
+  } catch (error) {
+    consola.error('Unhandled error:', error)
+  }
+})()

package/server/api/category/list.get.ts

@@ -0,0 +1,9 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const { data } = await client.from('categories').select('*')
+
+  return { data }
+})

package/server/api/category/new.post.ts

@@ -0,0 +1,31 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const body = await readBody(event)
+
+  if (!body) {
+    throw createError({
+      message: 'No file sent.',
+    })
+  }
+
+  const { data, error } = await client
+    .from('categories')
+    .insert(body)
+    .select()
+    .single()
+
+  if (error) {
+    throw createError({
+      message: error.message,
+    })
+  }
+
+  if (error) {
+    throw createError({ message: 'error' })
+  }
+
+  return { data }
+})

package/server/api/settings/first_setup.get.ts

@@ -0,0 +1,39 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+type HealthcheckSettingKey =
+  Database['public']['Tables']['healthcheck']['Row']['config_name']
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const { data, error } = await client.from('healthcheck').select('*')
+
+  if (error) {
+    return {
+      success: false,
+      message: 'Error retrieving healthcheck settings',
+      error: error.message,
+    }
+  }
+
+  // @ts-expect-error: Object.fromEntries may not infer the correct type
+  const isFirstSetup: Record<HealthcheckSettingKey, string> = {
+    ...Object.fromEntries(
+      data?.map((item) => [item.config_name, item.config_value]) || []
+    ),
+  }
+
+  data?.forEach((item) => {
+    if (!item.config_name || !item.config_value) {
+      return
+    }
+
+    isFirstSetup[item.config_name] = item.config_value
+  })
+
+  return {
+    success: true,
+    message: 'Healthcheck settings retrieved successfully',
+    is_first_setup: isFirstSetup.first_setup === 'true',
+  }
+})

package/server/api/settings/index.get.ts

@@ -0,0 +1,27 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const { data } = await client.from('settings').select('*')
+
+  type SettingsKey =
+    Database['public']['Tables']['settings']['Row']['setting_name']
+
+  // @ts-expect-error: Object.fromEntries may not infer the correct type for settings
+  const settings: Record<SettingsKey, string> = {
+    ...Object.fromEntries(
+      data?.map((item) => [item.setting_name, item.setting_value]) || []
+    ),
+  }
+
+  data?.forEach((item) => {
+    if (!item.setting_name || !item.setting_value) {
+      return
+    }
+
+    settings[item.setting_name] = item.setting_value
+  })
+
+  return { settings }
+})

package/server/api/settings/update.post.ts

@@ -0,0 +1,36 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  type SettingName =
+    Database['public']['Tables']['settings']['Insert']['setting_name']
+  type FormBody = Record<SettingName, string>
+
+  const client = await serverSupabaseClient<Database>(event)
+  const body = await readBody<FormBody>(event)
+
+  if (!body) {
+    throw createError({ statusMessage: 'No payload sent.' })
+  }
+
+  const transformed = [
+    ...Object.entries(body).map(([key, value]) => ({
+      setting_name: key as SettingName,
+      setting_value: value,
+    })),
+  ]
+
+  const { data, error } = await client
+    .from('settings')
+    .upsert(transformed, { onConflict: 'setting_name' })
+    .select()
+
+  if (error) {
+    throw createError({ statusMessage: error.message })
+  }
+
+  return {
+    message: 'Settings updated successfully.',
+    statusCode: 200,
+    data,
+  }
+})

package/server/api/setup/create.post.ts

@@ -0,0 +1,58 @@
+import postgres from 'postgres'
+
+interface Payload {
+  baseUrl: string
+  connectionString: string
+}
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody<Payload>(event)
+
+  let schema = await $fetch<string | Blob>('/schema.sql', {
+    baseURL: body.baseUrl,
+  })
+
+  if (typeof schema !== 'string') {
+    schema = await schema.text()
+  }
+
+  const supabaseUrl = process.env.SUPABASE_URL
+  const supabaseKey = process.env.SUPABASE_KEY
+
+  if (!supabaseUrl || !supabaseKey) {
+    throw new Error(
+      'Supabase URL or Key is not defined in environment variables.'
+    )
+  }
+
+  const connectionString = body.connectionString
+
+  const sql = postgres(connectionString)
+
+  try {
+    /* await sql.begin(async (sql) => {
+      await sql.unsafe(schema)
+    }) */
+
+    // Set the first_setup flag in the healthcheck table to false
+    await sql`
+      UPDATE healthcheck
+      SET config_value = 'false'
+      WHERE config_name = 'first_setup';
+    `
+
+    return {
+      success: true,
+      message: 'Database setup completed successfully.',
+    }
+  } catch (error: any) {
+    console.error('Error setting up database:', error)
+
+    return {
+      success: false,
+      error: error.message,
+    }
+  } finally {
+    sql.end()
+  }
+})

package/server/api/signup.post.ts

@@ -0,0 +1,28 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const body = await readBody(event)
+
+  const { data, error } = await client.auth.signUp({
+    email: body.email,
+    password: body.password,
+    options: {
+      data: {
+        first_name: body.first_name,
+        last_name: body.last_name,
+      },
+    },
+  })
+
+  if (error) {
+    throw createError({
+      statusCode: Number.parseInt(error.code ?? '500'),
+      cause: error.cause,
+      message: error.message,
+    })
+  }
+
+  return { message: 'User registered successfully', data }
+})

package/server/api/users/[id].get.ts

@@ -0,0 +1,21 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const id = event.context.params?.id as string
+
+  const { data: user, error } = await client
+    .from('profiles')
+    .select('*')
+    .eq('id', id)
+
+  if (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Error fetching user: ${error.message}`,
+    })
+  }
+
+  return user
+})

package/server/api/users/index.get.ts

@@ -0,0 +1,16 @@
+import { serverSupabaseClient } from '#supabase/server'
+
+export default defineEventHandler(async (event) => {
+  const client = await serverSupabaseClient<Database>(event)
+
+  const { data: users, error } = await client.from('profiles').select('*')
+
+  if (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Error fetching users: ${error.message}`,
+    })
+  }
+
+  return users
+})