@plutocms/supabase 0.0.1-alpha.10 → 0.0.1-alpha.12

package/modules/pluto-migrations.ts

@@ -0,0 +1,71 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { defineNuxtModule, getLayerDirectories } from 'nuxt/kit'
+
+/**
+ * Discovers schema.[layerName].sql files across all Nuxt layers,
+ * reads their content at build time, and populates runtimeConfig
+ * so the migrations plugin can run them at server startup.
+ */
+export default defineNuxtModule({
+  meta: {
+    name: 'pluto-migrations',
+    configKey: 'plutoMigrations',
+  },
+
+  setup(_options, nuxt) {
+    const layerDirs = getLayerDirectories()
+    const layerSchemas: Record<string, string> = {}
+    const schemaPattern = /^schema\.(.+)\.sql$/
+
+    for (const layer of layerDirs) {
+      // Each layer may have a public/ directory with schema files
+      const publicDir = join(layer.root, 'public')
+
+      if (!existsSync(publicDir)) {
+        continue
+      }
+
+      let files: string[] = []
+      try {
+        files = readdirSync(publicDir, 'utf-8')
+      } catch {
+        continue
+      }
+
+      for (const file of files) {
+        // Skip the core schema
+        if (file === 'schema.sql') {
+          continue
+        }
+
+        const match = file.match(schemaPattern)
+        if (match?.[1]) {
+          const layerName = match[1]
+          // Read SQL content at build time
+          try {
+            layerSchemas[layerName] = readFileSync(
+              join(publicDir, file),
+              'utf-8'
+            )
+          } catch {
+            console.error(
+              `[pluto-migrations] Failed to read schema file: ${file}`
+            )
+          }
+        }
+      }
+    }
+
+    const layerNames = Object.keys(layerSchemas)
+
+    // Populate runtimeConfig with layer names and their SQL content
+    nuxt.options.runtimeConfig.plutoLayerSchemas = layerSchemas
+
+    if (layerNames.length > 0) {
+      console.warn(
+        `[pluto-migrations] Discovered layer schemas: ${layerNames.join(', ')}`
+      )
+    }
+  },
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@plutocms/supabase",
   "type": "module",
-  "version": "0.0.1-alpha.10",
+  "version": "0.0.1-alpha.12",
   "main": "./nuxt.config.ts",
   "scripts": {
     "build": "nuxt build",
@@ -15,6 +15,7 @@
     "supabase-types": "bun ./scripts/supabase-typegen.ts"
   },
   "dependencies": {
+    "@nuxt/ui": "^4.5.1",
     "@nuxtjs/supabase": "2.0.3",
     "@plutocms/pluto": "^0.0.1-alpha.4",
     "@plutocms/utils": "^0.0.1-alpha.5",
@@ -25,8 +26,7 @@
   "devDependencies": {
     "@antfu/eslint-config": "^6.2.0",
     "@nuxt/eslint": "^1.15.1",
-    "@nuxt/ui": "^4.4.0",
-    "@types/bun": "^1.3.9",
+    "@types/bun": "^1.3.10",
     "@vueuse/nuxt": "^14.2.1",
     "eslint": "^9.39.1",
     "nuxt": "^4.3.1",

package/public/schema.sql

@@ -199,3 +199,28 @@ begin
   end if;
 end
 $$;
+
+-- Migrations tracking
+create table if not exists public.pluto_migrations (
+  id bigint generated by default as identity primary key,
+  layer_name text not null,
+  applied_at timestamptz not null default now(),
+  constraint pluto_migrations_layer_key unique (layer_name)
+);
+
+alter table public.pluto_migrations enable row level security;
+
+-- Only authenticated users can read migrations
+do $$
+begin
+  if not exists (
+    select 1 from pg_policies where tablename = 'pluto_migrations' and policyname = 'Enable read access for authenticated users on pluto_migrations'
+  ) then
+    create policy "Enable read access for authenticated users on pluto_migrations"
+    on public.pluto_migrations
+    for select
+    to authenticated, dashboard_user
+    using (true);
+  end if;
+end
+$$;

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

@@ -1,92 +1,13 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
 import postgres from 'postgres'
+import { splitStatements } from '../../utils/sql'
 
 interface Payload {
   baseUrl: string
   connectionString: string
 }
 
-/**
- * Splits a SQL string into individual statements, correctly handling
- * $$ dollar-quoted blocks, single-quoted strings, and -- comments.
- */
-function splitStatements(sql: string): string[] {
-  const statements: string[] = []
-  let current = ''
-  let i = 0
-
-  while (i < sql.length) {
-    // Check for dollar-quoting ($$)
-    if (sql[i] === '$' && sql[i + 1] === '$') {
-      current += '$$'
-      i += 2
-      // Read until closing $$
-      while (i < sql.length) {
-        if (sql[i] === '$' && sql[i + 1] === '$') {
-          current += '$$'
-          i += 2
-          break
-        }
-        current += sql[i]
-        i++
-      }
-      continue
-    }
-
-    // Check for single-quoted strings (handle '' escapes)
-    if (sql[i] === `'`) {
-      current += sql[i]
-      i++
-      while (i < sql.length) {
-        if (sql[i] === `'` && sql[i + 1] === `'`) {
-          // Escaped quote
-          current += `''`
-          i += 2
-          continue
-        }
-        if (sql[i] === `'`) {
-          current += sql[i]
-          i++
-          break
-        }
-        current += sql[i]
-        i++
-      }
-      continue
-    }
-
-    // Check for single-line comments
-    if (sql[i] === '-' && sql[i + 1] === '-') {
-      while (i < sql.length && sql[i] !== '\n') {
-        current += sql[i]
-        i++
-      }
-      continue
-    }
-
-    // Statement terminator
-    if (sql[i] === ';') {
-      current += ';'
-      const trimmed = current.trim()
-      if (trimmed && trimmed !== ';') {
-        statements.push(trimmed)
-      }
-      current = ''
-      i++
-      continue
-    }
-
-    current += sql[i]
-    i++
-  }
-
-  const trimmed = current.trim()
-  if (trimmed && trimmed !== ';') {
-    statements.push(trimmed)
-  }
-
-  return statements
-}
-
 export default defineEventHandler(async (event) => {
   const body = await readBody<Payload>(event)
 
@@ -123,6 +44,37 @@ export default defineEventHandler(async (event) => {
       `UPDATE public.healthcheck SET config_value = 'false' WHERE config_name = 'first_setup'`
     )
 
+    // Record the core schema migration
+    await sql.unsafe(
+      `INSERT INTO public.pluto_migrations (layer_name)
+       VALUES ('core')
+       ON CONFLICT (layer_name) DO NOTHING`
+    )
+
+    // Persist connection string to .env for future layer migrations
+    const envPath = resolve(process.cwd(), '.env')
+    let envContent = ''
+    try {
+      envContent = await readFile(envPath, 'utf-8')
+    } catch {
+      // .env doesn't exist yet
+    }
+
+    if (envContent.includes('DATABASE_URL=')) {
+      envContent = envContent.replace(
+        /^DATABASE_URL=.*$/m,
+        `DATABASE_URL="${connectionString}"`
+      )
+    } else {
+      // Ensure there's a trailing newline before appending
+      if (envContent.length > 0 && !envContent.endsWith('\n')) {
+        envContent += '\n'
+      }
+      envContent += `DATABASE_URL="${connectionString}"\n`
+    }
+
+    await writeFile(envPath, envContent, 'utf-8')
+
     return {
       success: true,
       message: 'Database setup completed successfully.',

package/server/plugins/migrations.ts

@@ -0,0 +1,48 @@
+import { runLayerMigration } from '../utils/migrations'
+
+export default defineNitroPlugin(async () => {
+  // Only run if DATABASE_URL is configured (setup already completed)
+  if (!process.env.DATABASE_URL) {
+    return
+  }
+
+  const config = useRuntimeConfig()
+  const layerSchemas: Record<string, string> =
+    (config as any).plutoLayerSchemas ?? {}
+
+  const layerNames = Object.keys(layerSchemas)
+
+  if (layerNames.length === 0) {
+    return
+  }
+
+  for (const layerName of layerNames) {
+    const schemaSql = layerSchemas[layerName]
+
+    if (!schemaSql) {
+      continue
+    }
+
+    try {
+      const result = await runLayerMigration({
+        layerName,
+        schemaSql,
+      })
+
+      if (result.skipped) {
+        console.warn(
+          `[migrations] Layer "${layerName}" already applied, skipped.`
+        )
+      } else if (result.success) {
+        console.warn(`[migrations] Layer "${layerName}" migrated successfully.`)
+      } else {
+        console.error(`[migrations] Layer "${layerName}" failed:`, result.error)
+      }
+    } catch (error) {
+      console.error(
+        `[migrations] Error running migration for "${layerName}":`,
+        error
+      )
+    }
+  }
+})

package/server/utils/migrations.ts

@@ -0,0 +1,88 @@
+import postgres from 'postgres'
+import { splitStatements } from './sql'
+
+/**
+ * Retrieves the database connection string from environment variables.
+ * Stored in .env during initial setup.
+ */
+export function getConnectionString(): string | null {
+  return process.env.DATABASE_URL ?? null
+}
+
+/**
+ * Checks if a specific layer migration has already been applied.
+ */
+async function isMigrationApplied(
+  sql: postgres.Sql,
+  layerName: string
+): Promise<boolean> {
+  const result = await sql.unsafe(
+    `SELECT 1 FROM public.pluto_migrations WHERE layer_name = $1`,
+    [layerName]
+  )
+  return result.length > 0
+}
+
+/**
+ * Records a migration as applied.
+ */
+async function recordMigration(
+  sql: postgres.Sql,
+  layerName: string
+): Promise<void> {
+  await sql.unsafe(
+    `INSERT INTO public.pluto_migrations (layer_name)
+     VALUES ($1)
+     ON CONFLICT (layer_name) DO NOTHING`,
+    [layerName]
+  )
+}
+
+interface LayerMigrationResult {
+  success: boolean
+  skipped?: boolean
+  error?: string
+}
+
+/**
+ * Runs a layer's schema SQL if not already applied.
+ * Splits and executes statements, then records the migration.
+ */
+export async function runLayerMigration(opts: {
+  layerName: string
+  schemaSql: string
+  connectionString?: string
+}): Promise<LayerMigrationResult> {
+  const connStr = opts.connectionString ?? getConnectionString()
+
+  if (!connStr) {
+    return {
+      success: false,
+      error: 'No DATABASE_URL configured. Re-run setup or add it to .env.',
+    }
+  }
+
+  const sql = postgres(connStr)
+
+  try {
+    const applied = await isMigrationApplied(sql, opts.layerName)
+    if (applied) {
+      return { success: true, skipped: true }
+    }
+
+    const statements = splitStatements(opts.schemaSql)
+
+    for (const statement of statements) {
+      await sql.unsafe(statement)
+    }
+
+    await recordMigration(sql, opts.layerName)
+
+    return { success: true }
+  } catch (error: any) {
+    console.error(`Migration error [${opts.layerName}]:`, error)
+    return { success: false, error: error.message }
+  } finally {
+    await sql.end()
+  }
+}

package/server/utils/sql.ts

@@ -0,0 +1,81 @@
+/**
+ * Splits a SQL string into individual statements, correctly handling
+ * $$ dollar-quoted blocks, single-quoted strings, and -- comments.
+ */
+export function splitStatements(sql: string): string[] {
+  const statements: string[] = []
+  let current = ''
+  let i = 0
+
+  while (i < sql.length) {
+    // Check for dollar-quoting ($$)
+    if (sql[i] === '$' && sql[i + 1] === '$') {
+      current += '$$'
+      i += 2
+      // Read until closing $$
+      while (i < sql.length) {
+        if (sql[i] === '$' && sql[i + 1] === '$') {
+          current += '$$'
+          i += 2
+          break
+        }
+        current += sql[i]
+        i++
+      }
+      continue
+    }
+
+    // Check for single-quoted strings (handle '' escapes)
+    if (sql[i] === `'`) {
+      current += sql[i]
+      i++
+      while (i < sql.length) {
+        if (sql[i] === `'` && sql[i + 1] === `'`) {
+          // Escaped quote
+          current += `''`
+          i += 2
+          continue
+        }
+        if (sql[i] === `'`) {
+          current += sql[i]
+          i++
+          break
+        }
+        current += sql[i]
+        i++
+      }
+      continue
+    }
+
+    // Check for single-line comments
+    if (sql[i] === '-' && sql[i + 1] === '-') {
+      while (i < sql.length && sql[i] !== '\n') {
+        current += sql[i]
+        i++
+      }
+      continue
+    }
+
+    // Statement terminator
+    if (sql[i] === ';') {
+      current += ';'
+      const trimmed = current.trim()
+      if (trimmed && trimmed !== ';') {
+        statements.push(trimmed)
+      }
+      current = ''
+      i++
+      continue
+    }
+
+    current += sql[i]
+    i++
+  }
+
+  const trimmed = current.trim()
+  if (trimmed && trimmed !== ';') {
+    statements.push(trimmed)
+  }
+
+  return statements
+}