Skip to main content
Cette page fait partie d’une compétence d’agent de code IA et est écrite pour les agents, pas pour les humains. Pour la documentation Base44 lisible par un humain, consultez la documentation développeur.

​
Configuration du client

Comment créer et configurer le client Base44.

​
Sommaire

​
Dans les applications générées par Base44

Dans une application Base44, le client est automatiquement créé et configuré. Importez-le depuis @/api/base44Client et utilisez-le comme base44 : 
const tasks = await base44.entities.Task.list();

​
Dans les applications externes

Lorsque vous utilisez Base44 comme backend depuis une application externe, installez le SDK et créez un client en appelant createClient() directement : 
npm install @base44/sdk

import { createClient } from "@base44/sdk";

// IMPORTANT: The parameter name is 'appId' (NOT 'clientId', NOT 'id')
// IMPORTANT: onError must be nested inside 'options' object
const base44 = createClient({
  appId: "your-app-id",          // Required: Use 'appId' parameter
  token: "optional-user-token",  // Optional: for pre-authenticated requests
  options: {                      // Optional: configuration options
    onError: (error) => {         // Optional: error handler (must be in options)
      console.error("Base44 error:", error);
    }
  }
});
Erreurs courantes :
  • ❌ createClient({ clientId: "..." }) - MAUVAIS nom de paramètre
  • ❌ createClient({ id: "..." }) - MAUVAIS nom de paramètre
  • ❌ createClient({ appId: "...", onError: ... }) - MAUVAIS : onError doit être dans options
  • ✅ createClient({ appId: "..." }) - CORRECT nom de paramètre
  • ✅ createClient({ appId: "...", options: { onError: ... } }) - CORRECT : onError dans options

​
Dans les fonctions backend

createClientFromRequest() est conçu pour les fonctions backend hébergées par Base44. Il extrait l’authentification depuis les en-têtes de requête que Base44 injecte et retourne un client qui inclut l’accès service role (base44.asServiceRole). Pour les front-ends et backends externes, utilisez createClient() à la place. 
import { createClientFromRequest } from "@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // Client inherits authentication from the request
  const user = await base44.auth.me();
  
  return Response.json({ user });
});

​
Modes d’authentification

ModeComment l’obtenirPermissions
AnonymecreateClient({ appId }) sans tokenDonnées publiques uniquement
UtilisateurAprès loginViaEmailPassword() ou via createClientFromRequestDonnées propres de l’utilisateur
Service Rolebase44.asServiceRole.* dans le backendAccès administrateur complet

​
Mode anonyme

Aucune authentification. Ne peut accéder qu’aux ressources publiques. 
const base44 = createClient({ appId: "your-app-id" });

// Only works if Task entity allows anonymous read
const publicTasks = await base44.entities.Task.list();

​
Mode utilisateur

Après la connexion de l’utilisateur, le client inclut automatiquement son token. 
const base44 = createClient({ appId: "your-app-id" });

// Login sets the token
await base44.auth.loginViaEmailPassword("user@example.com", "password");

// Subsequent requests are authenticated
const user = await base44.auth.me();
const myTasks = await base44.entities.Task.list();  // filtered by permissions

​
Mode Service Role

Accès niveau administrateur. Backend uniquement. 
// Inside a backend function
Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // User mode - respects permissions
  const myTasks = await base44.entities.Task.list();
  
  // Service role - bypasses permissions
  const allTasks = await base44.asServiceRole.entities.Task.list();
  const allUsers = await base44.asServiceRole.entities.User.list();
  const oauthToken = await base44.asServiceRole.connectors.getAccessToken("slack");
  
  return Response.json({ myTasks, allTasks });
});

​
Modules disponibles

Le client expose ces modules : 
base44.agents        // AI conversations
base44.analytics     // Event tracking
base44.appLogs       // App usage logging
base44.auth          // Authentication
base44.connectors    // Per-user OAuth flows (UserConnectorsModule)
base44.entities      // CRUD operations
base44.functions     // Backend function invocation
base44.integrations  // Third-party services
base44.users         // User invitations

// Service role only (backend)
base44.asServiceRole.agents
base44.asServiceRole.appLogs
base44.asServiceRole.connectors  // App-scoped OAuth tokens (ConnectorsModule)
base44.asServiceRole.entities
base44.asServiceRole.functions
base44.asServiceRole.integrations
base44.asServiceRole.sso         // SSO token generation

​
Méthodes du client

Le client fournit ces méthodes : 
// Set authentication token for all subsequent requests
base44.setToken(newToken);

// Cleanup WebSocket connections (call when done with client)
base44.cleanup();

​
setToken

Met à jour le token d’authentification pour toutes les requêtes API et connexions WebSocket suivantes. 
// After receiving a token (e.g., from external auth)
base44.setToken("new-jwt-token");

​
cleanup

Déconnecte les connexions WebSocket. Appelez lorsque vous avez terminé avec le client ou lorsque le composant est démonté. 
// Cleanup on component unmount (React example)
useEffect(() => {
  return () => base44.cleanup();
}, []);

​
Options de configuration du client

createClient({
  appId: "your-app-id",      // Required: MUST use 'appId' (not 'clientId' or 'id')
  token: "jwt-token",        // Optional: pre-set auth token
  options: {                 // Optional: configuration options
    onError: (error) => {}   // Optional: global error handler (must be in options)
  }
});
⚠️ Critique :
  • Le nom du paramètre est appId, pas clientId ni id. Utiliser le mauvais nom de paramètre causera des erreurs.
  • Le gestionnaire onError doit être imbriqué dans l’objet options, pas au niveau supérieur.

​
Définitions de types

​
CreateClientConfig

/** Configuration for creating a Base44 client. */
interface CreateClientConfig {
  /** The Base44 app ID (required). */
  appId: string;
  /** User authentication token. Used to authenticate as a specific user. */
  token?: string;
  /** @internal Service role token; only set automatically in Base44-hosted backend functions. */
  serviceToken?: string;
  /** Additional client options. */
  options?: CreateClientOptions;
}

/** Options for creating a Base44 client. */
interface CreateClientOptions {
  /** Optional error handler called whenever an API error occurs. */
  onError?: (error: Error) => void;
}

​
Base44Client

/** The Base44 client instance. */
interface Base44Client {
  /** Agents module for managing AI agent conversations. */
  agents: AgentsModule;
  /** Analytics module for tracking custom events. */
  analytics: AnalyticsModule;
  /** App logs module for tracking app usage. */
  appLogs: AppLogsModule;
  /** Auth module for user authentication and management. */
  auth: AuthModule;
  /** Entities module for CRUD operations on your data models. */
  entities: EntitiesModule;
  /** Functions module for invoking custom backend functions. */
  functions: FunctionsModule;
  /** Integrations module for calling pre-built integration methods. */
  integrations: IntegrationsModule;

  /** Cleanup function to disconnect WebSocket connections. */
  cleanup(): void;

  /** Sets a new authentication token for all subsequent requests. */
  setToken(newToken: string): void;

  /** Per-user OAuth flows. Each end user has their own connection. */
  connectors: UserConnectorsModule;

  /** Provides access to modules with elevated service role permissions (backend only). */
  readonly asServiceRole: {
    agents: AgentsModule;
    appLogs: AppLogsModule;
    /** App-scoped OAuth tokens. All users share the same connected account. */
    connectors: ConnectorsModule;
    entities: EntitiesModule;
    functions: FunctionsModule;
    integrations: IntegrationsModule;
    /** SSO token generation for users. */
    sso: SsoModule;
    cleanup(): void;
  };
}
Cette page a été traduite à l’aide de l’IA. Pour les informations les plus précises et à jour, consultez la version anglaise.