create-nextblock 0.2.77 → 0.8.0

package/templates/nextblock-template/tools/configure-supabase-auth.js

@@ -0,0 +1,282 @@
+const fs = require('fs');
+const path = require('path');
+const dotenv = require('dotenv');
+
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+};
+
+const TEMPLATE_FILES = {
+  confirmation: 'confirmation.html',
+  recovery: 'recovery.html',
+  magic_link: 'magic_link.html',
+  invite: 'invite.html',
+  email_change: 'email_change.html',
+  reauthentication: 'reauthentication.html',
+};
+
+const TEMPLATE_SUBJECTS = {
+  confirmation: 'Confirm your email',
+  recovery: 'Reset your password',
+  magic_link: 'Your sign-in link',
+  invite: "You're invited",
+  email_change: 'Confirm your email change',
+  reauthentication: "Confirm it's you",
+};
+
+function getEnv(name) {
+  return (process.env[name] || '').trim();
+}
+
+function loadEnvFiles() {
+  const candidates = [
+    path.join(process.cwd(), '.env.local'),
+    path.join(process.cwd(), '.env'),
+  ];
+
+  for (const envPath of candidates) {
+    if (fs.existsSync(envPath)) {
+      dotenv.config({ path: envPath, override: false, quiet: true });
+    }
+  }
+}
+
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/, '');
+}
+
+function resolveSupabaseDir() {
+  const candidates = [
+    path.join(process.cwd(), 'supabase'),
+    path.join(process.cwd(), 'libs', 'db', 'src', 'supabase'),
+    path.resolve(__dirname, '..', '..', '..', 'libs', 'db', 'src', 'supabase'),
+    path.resolve(__dirname, '..', 'supabase'),
+  ];
+
+  for (const candidate of candidates) {
+    if (
+      fs.existsSync(candidate) &&
+      fs.existsSync(path.join(candidate, 'templates'))
+    ) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function readTemplate(supabaseDir, fileName) {
+  return fs.readFileSync(
+    path.join(supabaseDir, 'templates', fileName),
+    'utf8',
+  );
+}
+
+function getTemplateConfig(supabaseDir) {
+  return {
+    mailer_subjects_confirmation: TEMPLATE_SUBJECTS.confirmation,
+    mailer_subjects_recovery: TEMPLATE_SUBJECTS.recovery,
+    mailer_subjects_magic_link: TEMPLATE_SUBJECTS.magic_link,
+    mailer_subjects_invite: TEMPLATE_SUBJECTS.invite,
+    mailer_subjects_email_change: TEMPLATE_SUBJECTS.email_change,
+    mailer_subjects_reauthentication: TEMPLATE_SUBJECTS.reauthentication,
+    mailer_templates_confirmation_content: readTemplate(
+      supabaseDir,
+      TEMPLATE_FILES.confirmation,
+    ),
+    mailer_templates_recovery_content: readTemplate(
+      supabaseDir,
+      TEMPLATE_FILES.recovery,
+    ),
+    mailer_templates_magic_link_content: readTemplate(
+      supabaseDir,
+      TEMPLATE_FILES.magic_link,
+    ),
+    mailer_templates_invite_content: readTemplate(
+      supabaseDir,
+      TEMPLATE_FILES.invite,
+    ),
+    mailer_templates_email_change_content: readTemplate(
+      supabaseDir,
+      TEMPLATE_FILES.email_change,
+    ),
+    mailer_templates_reauthentication_content: readTemplate(
+      supabaseDir,
+      TEMPLATE_FILES.reauthentication,
+    ),
+  };
+}
+
+function getSmtpConfig() {
+  const smtp = {
+    smtp_host: getEnv('SMTP_HOST'),
+    smtp_port: getEnv('SMTP_PORT'),
+    smtp_user: getEnv('SMTP_USER'),
+    smtp_pass: getEnv('SMTP_PASS'),
+    smtp_admin_email: getEnv('SMTP_FROM_EMAIL'),
+    smtp_sender_name: getEnv('SMTP_FROM_NAME'),
+  };
+
+  const requiredKeys = [
+    'smtp_host',
+    'smtp_port',
+    'smtp_user',
+    'smtp_pass',
+    'smtp_admin_email',
+  ];
+
+  const missingKeys = requiredKeys.filter((key) => !smtp[key]);
+  const hasAnyValue = Object.values(smtp).some(Boolean);
+
+  if (missingKeys.length === 0) {
+    return {
+      isConfigured: true,
+      config: {
+        ...smtp,
+        smtp_port: String(smtp.smtp_port),
+        external_email_enabled: true,
+      },
+    };
+  }
+
+  return {
+    isConfigured: false,
+    hasAnyValue,
+    missingKeys,
+    config: null,
+  };
+}
+
+function getRateLimitConfig(smtpConfigured) {
+  const value = getEnv('SUPABASE_AUTH_RATE_LIMIT_EMAIL_SENT');
+  if (!value) {
+    return smtpConfigured
+      ? {
+          rate_limit_email_sent: 30,
+        }
+      : {};
+  }
+
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(
+      'SUPABASE_AUTH_RATE_LIMIT_EMAIL_SENT must be a positive number when provided.',
+    );
+  }
+
+  return {
+    rate_limit_email_sent: parsed,
+  };
+}
+
+function buildPayload(supabaseDir) {
+  const siteUrl = stripTrailingSlash(getEnv('NEXT_PUBLIC_URL'));
+  if (!siteUrl) {
+    throw new Error('NEXT_PUBLIC_URL is required to configure Supabase Auth.');
+  }
+
+  const smtp = getSmtpConfig();
+  const payload = {
+    site_url: siteUrl,
+    ...getTemplateConfig(supabaseDir),
+    ...getRateLimitConfig(smtp.isConfigured),
+  };
+  if (smtp.isConfigured) {
+    Object.assign(payload, smtp.config);
+  }
+
+  return {
+    payload,
+    smtp,
+  };
+}
+
+async function patchAuthConfig(projectRef, accessToken, payload) {
+  const response = await fetch(
+    `https://api.supabase.com/v1/projects/${projectRef}/config/auth`,
+    {
+      method: 'PATCH',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(payload),
+    },
+  );
+
+  if (!response.ok) {
+    const bodyText = await response.text();
+    throw new Error(
+      `Supabase Management API returned ${response.status}: ${bodyText}`,
+    );
+  }
+}
+
+async function main() {
+  loadEnvFiles();
+
+  const dryRun = process.argv.includes('--dry-run');
+  const projectRef = getEnv('SUPABASE_PROJECT_ID');
+  const accessToken = getEnv('SUPABASE_ACCESS_TOKEN');
+
+  if (!projectRef || !accessToken) {
+    console.log(
+      `${colors.yellow}Skipping Supabase Auth configuration: SUPABASE_PROJECT_ID or SUPABASE_ACCESS_TOKEN is missing.${colors.reset}`,
+    );
+    process.exit(0);
+  }
+
+  const supabaseDir = resolveSupabaseDir();
+  if (!supabaseDir) {
+    throw new Error(
+      'Could not locate a Supabase directory with auth email templates.',
+    );
+  }
+
+  const { payload, smtp } = buildPayload(supabaseDir);
+
+  console.log(
+    `${colors.green}Configuring Supabase Auth for project ${projectRef}...${colors.reset}`,
+  );
+  console.log(
+    `${colors.blue}Using template source: ${path.relative(process.cwd(), supabaseDir) || supabaseDir}${colors.reset}`,
+  );
+
+  if (smtp.isConfigured) {
+    console.log(
+      `${colors.blue}Custom SMTP detected. Syncing SMTP settings and branded templates.${colors.reset}`,
+    );
+  } else if (smtp.hasAnyValue) {
+    console.log(
+      `${colors.yellow}SMTP values are incomplete. Syncing branded templates only. Missing: ${smtp.missingKeys.join(', ')}${colors.reset}`,
+    );
+  } else {
+    console.log(
+      `${colors.yellow}No SMTP values found. Syncing branded templates only.${colors.reset}`,
+    );
+  }
+
+  if (dryRun) {
+    console.log(
+      `${colors.green}Dry run only. Payload keys:${colors.reset} ${Object.keys(payload).join(', ')}`,
+    );
+    process.exit(0);
+  }
+
+  await patchAuthConfig(projectRef, accessToken, payload);
+
+  console.log(
+    `${colors.green}Supabase Auth configuration updated successfully.${colors.reset}`,
+  );
+}
+
+main().catch((error) => {
+  console.error(
+    `${colors.red}Failed to configure Supabase Auth:${colors.reset} ${error.message}`,
+  );
+  process.exit(1);
+});

package/templates/nextblock-template/tools/deploy-supabase.js

@@ -1,8 +1,8 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const dotenv = require('dotenv');
 
-// Colors for console output
 const colors = {
   reset: '\x1b[0m',
   green: '\x1b[32m',
@@ -11,18 +11,33 @@ const colors = {
   blue: '\x1b[34m',
 };
 
+function loadEnvFiles() {
+  const candidates = [
+    path.join(process.cwd(), '.env.local'),
+    path.join(process.cwd(), '.env'),
+  ];
+
+  for (const envPath of candidates) {
+    if (fs.existsSync(envPath)) {
+      dotenv.config({ path: envPath, override: false, quiet: true });
+    }
+  }
+}
+
 function getDbPassword() {
   if (process.env.SUPABASE_DB_PASSWORD) {
     return process.env.SUPABASE_DB_PASSWORD;
   }
+
   if (process.env.POSTGRES_URL) {
     try {
       const url = new URL(process.env.POSTGRES_URL);
       return url.password;
-    } catch (e) {
+    } catch {
       return null;
     }
   }
+
   return null;
 }
 
@@ -46,13 +61,14 @@ function checkEnv() {
 
   if (missing.length > 0) {
     console.log(
-      `${colors.yellow}⚠️  Skipping Supabase deployment: Missing environment variables: ${missing.join(', ')}${colors.reset}`,
+      `${colors.yellow}Skipping Supabase deployment: Missing environment variables: ${missing.join(', ')}${colors.reset}`,
     );
     console.log(
-      `${colors.yellow}   This is expected for Pull Requests or forks without secrets configured.${colors.reset}`,
+      `${colors.yellow}This is expected for pull requests or forks without secrets configured.${colors.reset}`,
     );
     return false;
   }
+
   return true;
 }
 
@@ -60,102 +76,84 @@ function runCommand(command) {
   try {
     console.log(`${colors.blue}Running: ${command}${colors.reset}`);
     execSync(command, { stdio: 'inherit' });
-  } catch (error) {
-    console.error(`${colors.red}❌ Command failed: ${command}${colors.reset}`);
+  } catch {
+    console.error(`${colors.red}Command failed: ${command}${colors.reset}`);
     process.exit(1);
   }
 }
 
-async function deploy() {
-  console.log(
-    `${colors.green}🚀 Starting Supabase Deployment...${colors.reset}`,
+function detectWorkDirFlag() {
+  const monorepoDbPath = path.join(
+    process.cwd(),
+    '../../libs/db/src/supabase/config.toml',
   );
+  const standaloneDbPath = path.join(process.cwd(), 'supabase/config.toml');
+  const rootDbPath = path.join(process.cwd(), 'libs/db/src/supabase/config.toml');
 
-  if (!checkEnv()) {
-    process.exit(0);
+  if (fs.existsSync(monorepoDbPath)) {
+    console.log(
+      `${colors.blue}Detected monorepo environment (../../libs/db/src).${colors.reset}`,
+    );
+    return '--workdir ../../libs/db/src';
   }
 
-  const dbPassword = getDbPassword();
-  if (!dbPassword) {
-    console.error(
-      `${colors.red}❌ Could not determine database password.${colors.reset}`,
+  if (fs.existsSync(standaloneDbPath)) {
+    console.log(
+      `${colors.blue}Detected standalone environment (./supabase).${colors.reset}`,
     );
-    process.exit(1);
+    return '';
   }
 
-  // Detect Supabase location
-  // 1. Monorepo Dev (apps/nextblock -> libs/db/src)
-  // 2. Standalone (root -> supabase)
-  let workDirFlag = '';
+  if (fs.existsSync(rootDbPath)) {
+    console.log(
+      `${colors.blue}Detected monorepo workspace root (libs/db/src).${colors.reset}`,
+    );
+    return '--workdir libs/db/src';
+  }
 
-  // Check if we are in monorepo structure relative to this script
-  // Script is in apps/nextblock/tools/deploy-supabase.js
-  // So monorepo root is ../../../
-  // libs/db/src is ../../../libs/db/src
+  return '';
+}
 
-  // More robust check: check if libs/db/src/supabase/config.toml exists
-  // We assume the command is run from the project root (process.cwd())
+async function deploy() {
+  loadEnvFiles();
 
-  // If running from apps/nextblock root (monorepo dev)
-  const monorepoDbPath = path.join(
-    process.cwd(),
-    '../../libs/db/src/supabase/config.toml',
-  );
+  console.log(`${colors.green}Starting Supabase deployment...${colors.reset}`);
 
-  // If running from workspace root (standalone)
-  const standaloneDbPath = path.join(process.cwd(), 'supabase/config.toml');
+  if (!checkEnv()) {
+    process.exit(0);
+  }
 
-  if (fs.existsSync(monorepoDbPath)) {
-    console.log(
-      `${colors.blue}ℹ️  Detected Monorepo environment (libs/db/src)${colors.reset}`,
-    );
-    workDirFlag = '--workdir ../../libs/db/src';
-  } else if (fs.existsSync(standaloneDbPath)) {
-    console.log(
-      `${colors.blue}ℹ️  Detected Standalone environment (./supabase)${colors.reset}`,
-    );
-    workDirFlag = '';
-  } else {
-    // Fallback or maybe we are running from root of monorepo?
-    const rootDbPath = path.join(
-      process.cwd(),
-      'libs/db/src/supabase/config.toml',
+  const dbPassword = getDbPassword();
+  if (!dbPassword) {
+    console.error(
+      `${colors.red}Could not determine database password.${colors.reset}`,
     );
-    if (fs.existsSync(rootDbPath)) {
-      workDirFlag = '--workdir libs/db/src';
-    }
+    process.exit(1);
   }
 
-  console.log(
-    `${colors.green}🔗 Linking to Supabase project...${colors.reset}`,
-  );
+  const workDirFlag = detectWorkDirFlag();
+
+  console.log(`${colors.green}Linking to Supabase project...${colors.reset}`);
   runCommand(
-    `npx supabase link --project-ref ${process.env.SUPABASE_PROJECT_ID} --password ${dbPassword} ${workDirFlag}`,
+    `npx supabase link --project-ref ${process.env.SUPABASE_PROJECT_ID} --password ${dbPassword} ${workDirFlag} --yes`.trim(),
   );
 
   console.log(
-    `${colors.green}📦 Pushing database migrations...${colors.reset}`,
+    `${colors.green}Pushing database migrations...${colors.reset}`,
   );
-  runCommand(`npx supabase db push --include-all ${workDirFlag}`, {
-    stdio: 'inherit',
-  }); // db push input 'y' handled?
-  // npx supabase db push usually asks for confirmation if destructive. --include-all might implies force? using input 'y' might be safer or --force if avail.
-  // Actually, CI usually needs --no-interactive or equivalent if prompts exist.
-  // But our previous script used just db push without input 'y' and relied on process.stdin or just worked.
-  // Wait, in create-nextblock.js we piped 'y\n'.
-  // In deploy-supabase.js we are using inherit stdio, so it might prompt if strictly necessary, but usually db push to remote is fine unless destructive.
-  // However, I previously wrote `npx supabase db push ...` and it seemed fine.
+  runCommand(`npx supabase db push --password ${dbPassword} --yes ${workDirFlag}`.trim());
 
-  // Re-reading previous script: runCommand used `execSync(command, { stdio: 'inherit' });`
-
-  // Let's stick to the previous working command.
+  console.log(
+    `${colors.green}Pushing Supabase config (Site URL: ${process.env.NEXT_PUBLIC_URL})...${colors.reset}`,
+  );
+  runCommand(`npx supabase config push ${workDirFlag} --yes`.trim());
 
   console.log(
-    `${colors.green}⚙️  Pushing Supabase config (Site URL: ${process.env.NEXT_PUBLIC_URL})...${colors.reset}`,
+    `${colors.green}Syncing Supabase Auth SMTP + email templates...${colors.reset}`,
   );
-  runCommand(`npx supabase config push ${workDirFlag}`);
+  runCommand('node tools/configure-supabase-auth.js');
 
-  console.log(`${colors.green}✅ Supabase deployment complete!${colors.reset}`);
+  console.log(`${colors.green}Supabase deployment complete!${colors.reset}`);
 }
 
 deploy();

package/templates/nextblock-template/tsconfig.json

@@ -1,66 +1,52 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "types": [
-      "node",
-      "react",
-      "react-dom"
-    ],
-    "target": "ES2017",
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
-    "module": "esnext",
-    "moduleResolution": "bundler"
-  },
-  "include": [
-    "**/*.ts",
-    "**/*.tsx",
-    "**/*.js",
-    "**/*.jsx",
-    "next-env.d.ts",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts",
-    "../../libs/ui/tailwind.config.js"
-  ],
-  "exclude": [
-    "node_modules",
-    "jest.config.ts",
-    "**/*.spec.ts",
-    "**/*.test.ts"
-  ],
-  "references": [
-    {
-      "path": "../../libs/db/tsconfig.lib.json"
-    },
-    {
-      "path": "../../libs/editor/tsconfig.lib.json"
-    },
-    {
-      "path": "../../libs/ui/tsconfig.lib.json"
-    },
-    {
-      "path": "../../libs/utils/tsconfig.json"
-    },
-    {
-      "path": "../../libs/sdk/tsconfig.lib.json"
-    }
-  ]
-}
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "allowJs": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "composite": false,
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "types": [
+      "node",
+      "react",
+      "react-dom"
+    ],
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "module": "esnext",
+    "moduleResolution": "bundler"
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "next-env.d.ts",
+    ".next/types/**/*.ts",
+    "../../libs/ui/tailwind.config.js",
+    "../../libs/**/*.ts",
+    "../../libs/**/*.tsx",
+    "../../schemas/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "jest.config.ts",
+    "**/*.spec.ts",
+    "**/*.test.ts"
+  ]
+}