Activer la création de comptes

Cette installation se fait une seule fois. Ensuite, depuis « Équipe et historique », un responsable pourra créer un compte avec une adresse e-mail et un mot de passe, choisir ses droits, le désactiver ou le réactiver.

Aucune commande SQL à exécuter. Vos réservations, paiements, factures et comptes existants sont conservés. Le code utilise les clés déjà fournies au serveur par Supabase : aucune clé secrète à copier dans le site.

1. Installer la fonction dans Supabase

Ouvrez votre projet bellay-gestion dans Supabase, puis Edge Functions.
Si bellay-admin existe déjà, ouvrez-la puis son éditeur de code. Sinon, choisissez Deploy a new function → Via Editor et donnez-lui exactement le nom bellay-admin.
Remplacez tout le contenu du fichier index.ts par le code ci-dessous, puis cliquez sur Deploy function ou Deploy updates, selon l’écran.
Dans les réglages de cette fonction, désactivez l’option Verify JWT / Enforce JWT Verification (parfois « Verify JWT with legacy secret »), puis enregistrez. Le code vérifie lui-même la session et le rôle Responsable avant chaque opération. La fonction n’autorise pas les visiteurs ni les comptes Réception à créer des accès.

Télécharger le code

import { createClient } from 'npm:@supabase/supabase-js@2.116.0';

// Server only: the administrator key is read from the Edge Function environment.
// Even with verify_jwt=false, every request must pass getUser AND the active
// administrator check in bellay_members. Grants are checked again by SQL.
const DEFAULT_ORIGIN = 'https://gestion-bellay.pages.dev';
function runtimeKey(single: string, multiple: string): string {
  const legacy = Deno.env.get(single);
  if (legacy) return legacy;
  try {
    const values = JSON.parse(Deno.env.get(multiple) || '{}');
    return values.default || Object.values(values).find(v => typeof v === 'string') || '';
  } catch { return ''; }
}

Deno.serve(async (request: Request) => {
  const origin = (Deno.env.get('SITE_ORIGIN') || DEFAULT_ORIGIN).replace(/\/$/, '');
  const headers = {
    'Access-Control-Allow-Origin': origin,
    'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
    'Access-Control-Allow-Methods': 'POST, OPTIONS',
    'Vary': 'Origin', 'Content-Type': 'application/json', 'Cache-Control': 'no-store'
  };
  const answer = (status: number, code: string, message: string, more = {}) =>
    new Response(JSON.stringify({code, message, ...more}), {status, headers});
  if (!/^https:\/\/[^/]+$/.test(origin) || request.headers.get('origin') !== origin)
    return answer(403, 'ORIGIN_DENIED', 'Ouvrez le site à son adresse officielle pour gérer les comptes.');
  if (request.method === 'OPTIONS') return new Response(null, {status: 204, headers});
  if (request.method !== 'POST') return answer(405, 'METHOD', 'Méthode non autorisée.');
  try {
    const url = Deno.env.get('SUPABASE_URL') || '';
    const publicKey = runtimeKey('SUPABASE_ANON_KEY', 'SUPABASE_PUBLISHABLE_KEYS');
    const secret = runtimeKey('SUPABASE_SERVICE_ROLE_KEY', 'SUPABASE_SECRET_KEYS');
    if (!url || !publicKey || !secret) return answer(503, 'CONFIGURATION', 'La fonction de gestion des comptes est incomplètement configurée. Consultez le guide d’installation.');
    const authorization = request.headers.get('Authorization') || '';
    if (!/^Bearer \S+$/i.test(authorization)) return answer(401, 'SESSION', 'Reconnectez-vous pour gérer les comptes.');
    const options = {auth: {persistSession: false, autoRefreshToken: false}};
    const caller = createClient(url, publicKey, {...options, global: {headers: {Authorization: authorization}}});
    const {data: identity, error: identityError} = await caller.auth.getUser(authorization.slice(7));
    if (identityError || !identity?.user) return answer(401, 'SESSION', 'Votre session a expiré. Reconnectez-vous.');
    const permission = await caller.rpc('bellay_members');
    if (permission.error) return answer(403, 'ADMIN_REQUIRED', 'Seul un responsable actif peut gérer les accès.');
    const raw = await request.text();
    if (raw.length > 4096) return answer(413, 'REQUEST_SIZE', 'Demande trop longue.');
    let body;
    try { body = JSON.parse(raw); } catch { return answer(400, 'REQUEST', 'Demande invalide.'); }
    if (!body || typeof body !== 'object' || Array.isArray(body)) return answer(400, 'REQUEST', 'Demande invalide.');
    if (body.action === 'status') return answer(200, 'READY', 'La création de comptes est disponible.', {version: 2, actions: ['create', 'attach', 'invite']});
    const email = typeof body.email === 'string' ? body.email.trim().toLowerCase() : '';
    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) || email.length > 254 ||
        !['admin', 'reception'].includes(body.role) || !['create', 'attach', 'invite'].includes(body.action))
      return answer(400, 'FIELDS', 'Vérifiez l’adresse e-mail, les droits et l’action.');
    if (body.action === 'create' && (typeof body.password !== 'string' || body.password.length < 12 || body.password.length > 128))
      return answer(400, 'PASSWORD', 'Choisissez un mot de passe de 12 à 128 caractères.');

    const privileged = createClient(url, secret, options);
    let userId: string | undefined;
    if (body.action === 'create') {
      // This is an explicit creation by the hotel administrator, not public signup.
      // No email is sent; the administrator hands the credentials to the person.
      const {data, error} = await privileged.auth.admin.createUser({email, password: body.password, email_confirm: true});
      if (error) {
        if (['email_exists', 'user_already_exists'].includes(error.code || '') || /already.*registered|already.*exist/i.test(error.message || ''))
          return answer(409, 'ACCOUNT_EXISTS', 'Cette adresse possède déjà un compte. Choisissez « Autoriser un compte existant » ; son mot de passe sera conservé.');
        if (error.code === 'weak_password') return answer(400, 'PASSWORD', 'Ce mot de passe ne respecte pas les règles du projet. Choisissez-en un plus robuste.');
        return answer(400, 'CREATE_FAILED', 'Le compte n’a pas pu être créé. Vérifiez l’adresse et le mot de passe, puis réessayez.');
      }
      userId = data.user?.id;
    } else if (body.action === 'invite') {
      const {data, error} = await privileged.auth.admin.inviteUserByEmail(email, {redirectTo: origin + '/'});
      if (error) return answer(400, 'MAIL_FAILED', 'L’invitation n’a pas pu être envoyée. Utilisez « Créer un compte avec mot de passe » ou vérifiez le service e-mail du projet.');
      userId = data.user?.id;
    } else {
      for (let page = 1; page <= 100; page++) {
        const {data, error} = await privileged.auth.admin.listUsers({page, perPage: 100});
        if (error) return answer(502, 'LOOKUP_FAILED', 'La recherche du compte est indisponible. Réessayez dans un instant.');
        const found = data.users.find(u => u.email?.toLowerCase() === email);
        if (found) {
          if (!found.email_confirmed_at) return answer(409, 'EMAIL_UNCONFIRMED', 'Ce compte existe, mais son adresse n’est pas confirmée. Le titulaire doit terminer sa confirmation avant de recevoir l’accès.');
          userId = found.id;
          break;
        }
        if (data.users.length < 100) break;
      }
      if (!userId) return answer(404, 'ACCOUNT_MISSING', 'Cette adresse n’a pas de compte. Choisissez « Créer un compte avec mot de passe ».');
    }
    if (!userId) return answer(502, 'AUTH_RESPONSE', 'La création n’a pas été confirmée. Vérifiez la liste des comptes avant de réessayer.');
    const grant = await caller.rpc('bellay_set_member', {p_user: userId, p_role: body.role, p_active: true});
    if (grant.error) return answer(409, 'ACCESS_PENDING', 'Le compte existe, mais son accès à l’hôtel n’est pas confirmé. Choisissez « Autoriser un compte existant » pour reprendre l’opération.');
    const message = body.action === 'create'
      ? 'Compte créé et accès accordé. Transmettez le mot de passe à la personne ; elle pourra le changer depuis le site.'
      : body.action === 'invite' ? 'Invitation envoyée et accès accordé.' : 'Accès accordé au compte existant. Son mot de passe est conservé.';
    return answer(200, 'SUCCESS', message);
  } catch {
    // Never reflect passwords, tokens, provider responses or internal errors.
    return answer(502, 'UNAVAILABLE', 'La demande n’a pas pu être confirmée. Actualisez la liste des accès avant de réessayer.');
  }
});

2. Vérifier depuis le site

Ouvrez gestion-bellay.pages.dev avec votre compte Responsable.
Ouvrez Équipe et historique, puis cliquez sur Vérifier l’installation dans la rubrique Installation et dépannage si nécessaire.
Lorsque « Prêt » s’affiche, choisissez Créer un compte avec mot de passe, renseignez l’adresse, les droits et le mot de passe. Conservez le mot de passe pour le transmettre à la personne avant de confirmer.
La personne se connecte à la même adresse du site et peut ensuite choisir Mot de passe pour le changer.

Si la vérification échoue

Fonction absente : vérifiez que son nom est exactement bellay-admin et que le déploiement a réussi.
Session refusée / Invalid JWT : vérifiez le réglage JWT de l’étape 1, puis reconnectez-vous au site.
Service inaccessible : ouvrez l’adresse officielle du site. Si un ancien secret SITE_ORIGIN est présent dans Edge Functions → Secrets, mettez sa valeur à https://gestion-bellay.pages.dev. Sans ce secret, le code utilise déjà cette adresse. Un lien de prévisualisation avec un préfixe différent n’est pas autorisé.
Adresse déjà utilisée : choisissez « Autoriser un compte existant ». Le mot de passe du compte existant ne sera pas remplacé.
Invitation par e-mail impossible : choisissez la création avec mot de passe. Seule l’invitation par e-mail nécessite la configuration d’un service SMTP.

Sources : Déployer une fonction depuis le tableau de bord · Création administrative de comptes · Clés et vérification de session.