Deja de pensar “Registro del usuario”. Empiece a pensar “nuevo inquilino”

En cualquier producto SaaS de múltiples inquilinos, en el momento en que un nuevo usuario se registra es más que solo agregar una fila en una tabla de “usuarios”. Ese usuario representa un nuevo equipo, un nuevo límite de datos y una nueva estructura de permiso.

Tomamos una decisión consciente temprano: Trate la creación de cuentas como la raíz de la arquitectura.

En lugar de atacar a las organizaciones después de la creación de usuarios o almacenar datos de orgán como otro campo en el usuario, hicimos el cuenta el objeto primario. Los usuarios pertenecen a cuentas. Los datos pertenecen a cuentas. Los permisos derivan de las cuentas.

Ese encuadre influyó en cada pieza de nuestro backend desde el diseño del esquema hasta la lógica de facturación hasta RBAC.

Así es como lo construimos.

Repensar el registro: cuenta antes del usuario

La mayoría de las lógicas de incorporación de SaaS se ve así:

POST /signup → Create person → Later: create org / assign staff

Pero en SaaS de múltiples inquilinos, ese orden conduce a problemas sutiles … datos sin un hogar, permisos en el limbo y supuestos frágiles en toda su aplicación.

Entonces comenzamos con:

POST /signup → Create account → Create person inside account → Carried out

Este cambio puede parecer pequeño, pero dio forma a todo sobre nuestra arquitectura en el futuro.

El código se parece a esto:

export async perform registerAccount(payload: RegistrationDTO) {
  return withTransaction(async (session) => {
    const account = await AccountModel.create([{
      name: payload.company,
      active: true
    }], { session });

    const person = await UserModel.create([{
      accountId: account[0]._id,
      electronic mail: payload.electronic mail,
      function: 'admin'
    }], { session });

    return { account: account[0], person: person[0] };
  });
}

Al atar al usuario directamente a la cuenta desde el primer día y envolverla en una transacción, evitamos una larga lista de casos de borde que de otro modo se arrastran rápidamente.

Por qué importa: los datos pertenecen a los inquilinos

Esto es lo que aprendimos de la manera difícil: Los datos no son globales, es escolta de los inquilinos.

Cada consulta, verificación de permiso, puerta de función y management de la interfaz de usuario en su aplicación se comportarán de manera diferente dependiendo de Quién es el usuario y a que cuenta pertenecen.

Entonces hicimos una regla:

Todo lo importante lleva un accountId.

Eso incluye:

• Usuarios
• Tartamudez
• Permisos
• Suscripciones
• Registros de auditoría
• Feating Taggles

Mantenga las transacciones apretadas

Al construir el flujo de registro de la cuenta, uno de nuestros principios clave fue separar la validación de la persistencia y siendo intencional sobre dónde Utilizamos transacciones de bases de datos.

Así es como se ve en la práctica:

await ensureEmailFree(payload.electronic mail);
await ensureCompanyFree(payload.firm);

return withTransaction(async (session) => {
  // Solely the crucial writes occur right here
  const account = await Account.create([{ name: payload.company }], { session });
  const person = await Person.create([{ email: payload.email, accountId: account[0]._id }], { session });

  return { account: account[0], person: person[0] };
});

¿Por qué? Por lo tanto, la transacción se mantiene pequeña y rápida, más fácil de escalar, menos problemas de bloqueo y más fácil de recuperar de las fallas.

Bootstrap administradores, automáticamente

El primer usuario dentro de cualquier cuenta se convierte en su administrador. No hay lógica especial, sin flagela guide. Está construido directamente en el flujo.

Ese primer usuario puede:

• Invitar a su equipo
• Establecer roles y permisos
• Configurar la facturación
• Transferir los derechos de administrador si se van

Esto nos dio un camino de encendido limpio y sin duda que escalaba bien incluso en los primeros días.

Roles con cuentas que crecen contigo

No queríamos construir demasiado un sistema de roles, pero necesitábamos suficiente estructura para cubrir el 90% de los casos de uso de SaaS del mundo actual.

const ROLE_HIERARCHY = {
  admin: ['admin', 'manager', 'user'],
  supervisor: ['manager', 'user'],
  person: ['user']
};

perform hasPermission(userRole, requiredRole)  false;

Excopamos roles a las cuentas y utilizamos una herencia easy. No es elegante, pero funciona y es fácil de refactorizar más tarde en un modelo de política más granular si es necesario.

Suscripciones desde el primer día

Le dimos a cada cuenta un objeto de suscripción en la creación, incluso durante el juicio. Eso significaba banderas de características, límites de uso y indicaciones de actualización se vincularon directamente a la cuenta desde el principio.

const defaultSubscription = {
  tier: 'trial',
  standing: 'lively',
  limits: {
    maxUsers: 5,
    maxBattlecards: 10,
    aiBattlecardGeneration: true
  }
};

Usamos esto en las características de middleware a la puerta:

if (!account.subscription.limits.aiBattlecardGeneration) {
  return res.standing(402).json({ error: 'Improve required' });
}

Espacios de nombres, singularidad y aislamiento

Algunas cosas son globalmente únicas. Algunos son locales de inquilinos. Dibujamos la línea así:

Lo que tenemos bien (y lo que puedes robar)

Este pequeño cambio, Hacer la creación de cuentas el centro de incorporación, Pagó inmediatamente y continúa ahorrándonos tiempo hoy.

Ganar a corto plazo:

• Aislamiento de datos limpio
• Acceso basado en roles desde el primer día
• Lógica de bandera de funciones que realmente funciona
• Flujo de prueba completamente funcional

Payoffs a largo plazo:

• Las consultas son fáciles de alcanzar y optimizar
• La facturación y los permisos están desacoplados
• No se necesita una migración extraña cuando “agregue equipos más tarde”
• Valores más seguros en todas partes

Pensamientos finales: Comience con el modelo psychological correcto

La página de registro puede parecer easy, pero inicia la estructura más importante de su SaaS: el inquilino.

Así que construye como si importa.

Comience con la cuenta. Adjuntar todo lo demás. Haga cumplir los límites temprano. Todo lo demás, roles, permisos, facturación, encaja de manera más pure.

En lugar de pensar en “usuario primero” y, en su lugar, pensar “cuenta primero” nos dio una arquitectura en la que podríamos confiar … y construir.