@aurabase/aurabase-js 0.5.3 → 0.6.0

package/dist/{AuraClient-K3hRdh9J.d.cts → AuraClient-5jDiXjrO.d.cts}

@@ -93,7 +93,7 @@ declare class AuraClient<Database = any, Schema extends GenericSchema = Database
      * const { data, error } = await aura.rpc('echo_test', { message: 'hello' })
      * ```
      */
-    rpc<T = any>(fn: string, args?: Record<string, unknown>, options?: any): any;
+    rpc<FnName extends string = string, Args extends Record<string, unknown> = Record<string, unknown>>(fn: FnName, args?: Args, options?: Parameters<DatabaseService<Database, Schema>['rpc']>[2]): ReturnType<DatabaseService<Database, Schema>['rpc']>;
     /**
      * Shortcut: create a realtime channel with Supabase-compatible API.
      * Equivalent to `aura.realtime.channel(name)`.

package/dist/{AuraClient-K3hRdh9J.d.ts → AuraClient-5jDiXjrO.d.ts}

@@ -93,7 +93,7 @@ declare class AuraClient<Database = any, Schema extends GenericSchema = Database
      * const { data, error } = await aura.rpc('echo_test', { message: 'hello' })
      * ```
      */
-    rpc<T = any>(fn: string, args?: Record<string, unknown>, options?: any): any;
+    rpc<FnName extends string = string, Args extends Record<string, unknown> = Record<string, unknown>>(fn: FnName, args?: Args, options?: Parameters<DatabaseService<Database, Schema>['rpc']>[2]): ReturnType<DatabaseService<Database, Schema>['rpc']>;
     /**
      * Shortcut: create a realtime channel with Supabase-compatible API.
      * Equivalent to `aura.realtime.channel(name)`.

package/dist/index.cjs

@@ -63,6 +63,11 @@ var AuraClient = class {
         "[aurabase] No API key provided. Most operations require an API key (apikey header). Only public auth routes (register, login, refresh) will work without one."
       );
     }
+    if (typeof console !== "undefined" && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/?$/.test(this.baseUrl)) {
+      console.warn(
+        "[aurabase] Attention : en local, l'URL du projet doit inclure le sous-domaine (ex: http://<slug>.localhost:8080) pour permettre la r\xE9solution automatique du projet par la passerelle."
+      );
+    }
     if (this.apiKey?.startsWith(SERVICE_ROLE_KEY_PREFIX) && isBrowserContext()) {
       const refuse = resolvedOptions?.refuseServiceRoleInBrowser ?? true;
       const message = "[aurabase] S\xC9CURIT\xC9 : une cl\xE9 service_role (aura_sk_\u2026) est fournie \xE0 createClient() dans un contexte navigateur. Cette cl\xE9 \xE0 privil\xE8ges \xE9lev\xE9s NE DOIT JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez une cl\xE9 anon (aura_anon_\u2026) c\xF4t\xE9 client, et createAdminClient() c\xF4t\xE9 serveur pour les op\xE9rations d'administration.";
@@ -80,7 +85,7 @@ var AuraClient = class {
       const g = globalThis;
       const proc = g?.process;
       const isTest = !!(proc?.env?.VITEST || proc?.env?.NODE_ENV === "test" || proc?.env?.JEST_WORKER_ID);
-      return isTest && g?.localStorage && typeof g.localStorage.getItem === "function";
+      return isTest && !!g?.localStorage && typeof g.localStorage.getItem === "function";
     })()) {
       this.authStore = new core.LocalAuthStore(`aura-${core.clientScope(this.baseUrl)}-auth`);
     } else {
@@ -158,7 +163,6 @@ var AuraClient = class {
     if (!this._notifications) this._notifications = new notifications.NotificationsService(this);
     return this._notifications;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   from(table) {
     return this.db.from(table);
   }
@@ -171,7 +175,6 @@ var AuraClient = class {
    * const { data, error } = await aura.rpc('echo_test', { message: 'hello' })
    * ```
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   rpc(fn, args, options) {
     return this.db.rpc(fn, args, options);
   }
@@ -265,10 +268,22 @@ Object.defineProperty(exports, "QueryBuilder", {
   enumerable: true,
   get: function () { return db.QueryBuilder; }
 });
+Object.defineProperty(exports, "FunctionsHttpError", {
+  enumerable: true,
+  get: function () { return functions.FunctionsHttpError; }
+});
+Object.defineProperty(exports, "FunctionsRelayError", {
+  enumerable: true,
+  get: function () { return functions.FunctionsRelayError; }
+});
 Object.defineProperty(exports, "FunctionsService", {
   enumerable: true,
   get: function () { return functions.FunctionsService; }
 });
+Object.defineProperty(exports, "isRelayStatus", {
+  enumerable: true,
+  get: function () { return functions.isRelayStatus; }
+});
 Object.defineProperty(exports, "NotificationsAdminService", {
   enumerable: true,
   get: function () { return notifications.NotificationsAdminService; }

package/dist/index.d.cts

@@ -3,11 +3,11 @@ export { AuthAdminService, AuthService, isMfaChallenge } from '@aurabase/auth';
 import { AuraClientOptions } from '@aurabase/core';
 export { AdminCreateUserRequest, AdminUpdateUserRequest, AdminUser, AuditLogEntry, AuraClientOptions, AuraError, AuraErrorCode, AuraObservabilityEvent, AuraResponse, AuthChangePayload, AuthEvent, AuthSettings, AuthSettingsUpdate, BaseAuthStore, BatchSendResponse, BroadcastFilter, BroadcastPayload, BroadcastSendStatus, ChannelConfig, ChatMessage, ChatResponse, CountMode, CreatePgFunctionRequest, CreatePgTriggerRequest, CronJob, EmailTemplateUpdate, EmbedRequest, EmbedResponse, FileEntry, FilterOp, FunctionDef, IdentityInfo, Job, LocalAuthStore, LoginResponse, MagicLinkRequest, Meta, MfaChallenge, MfaEnrollResponse, MfaVerifyRequest, Notification, NotificationAttempt, NotificationDeadLetter, NotificationEvent, NotificationProviderLog, NotificationQueueStats, NotificationRule, NotificationSettings, NotificationStats, NotificationTemplate, NotificationTemplatePreview, OAuthProviderSetting, OAuthSignInOptions, PasswordResetRequest, PgExecutableRole, PgFunctionInfo, PgTriggerInfo, PostgresChangesFilter, PresenceFilter, PresenceInfo, PresenceState, QueryFilter, QueryOptions, RagIngestRequest, RagIngestResponse, RagRequest, RagResponse, RealtimeEvent, RealtimeListenType, RealtimeSubscribeStatus, SchemaColumn, SchemaEnum, SchemaFunction, SchemaFunctionArg, SchemaTable, SemanticSearchResult, SendNotificationRequest, SessionInfo, SignInRequest, SignUpRequest, StorageBucket, TokenPair, UpdateUserRequest, UploadResult, User, isAuraError } from '@aurabase/core';
 export { DatabaseService, QueryBuilder } from '@aurabase/db';
-export { FunctionsService } from '@aurabase/functions';
+export { FunctionsHttpError, FunctionsRelayError, FunctionsResponseType, FunctionsService, isRelayStatus } from '@aurabase/functions';
 export { NotificationsAdminService, NotificationsService } from '@aurabase/notifications';
 export { AuraChannel, RealtimeService } from '@aurabase/realtime';
 export { StorageBucketClient, StorageService } from '@aurabase/storage';
-import { A as AuraClient } from './AuraClient-K3hRdh9J.cjs';
+import { A as AuraClient } from './AuraClient-5jDiXjrO.cjs';
 
 /**
  * Create a new Aurabase client instance.

package/dist/index.d.ts

@@ -3,11 +3,11 @@ export { AuthAdminService, AuthService, isMfaChallenge } from '@aurabase/auth';
 import { AuraClientOptions } from '@aurabase/core';
 export { AdminCreateUserRequest, AdminUpdateUserRequest, AdminUser, AuditLogEntry, AuraClientOptions, AuraError, AuraErrorCode, AuraObservabilityEvent, AuraResponse, AuthChangePayload, AuthEvent, AuthSettings, AuthSettingsUpdate, BaseAuthStore, BatchSendResponse, BroadcastFilter, BroadcastPayload, BroadcastSendStatus, ChannelConfig, ChatMessage, ChatResponse, CountMode, CreatePgFunctionRequest, CreatePgTriggerRequest, CronJob, EmailTemplateUpdate, EmbedRequest, EmbedResponse, FileEntry, FilterOp, FunctionDef, IdentityInfo, Job, LocalAuthStore, LoginResponse, MagicLinkRequest, Meta, MfaChallenge, MfaEnrollResponse, MfaVerifyRequest, Notification, NotificationAttempt, NotificationDeadLetter, NotificationEvent, NotificationProviderLog, NotificationQueueStats, NotificationRule, NotificationSettings, NotificationStats, NotificationTemplate, NotificationTemplatePreview, OAuthProviderSetting, OAuthSignInOptions, PasswordResetRequest, PgExecutableRole, PgFunctionInfo, PgTriggerInfo, PostgresChangesFilter, PresenceFilter, PresenceInfo, PresenceState, QueryFilter, QueryOptions, RagIngestRequest, RagIngestResponse, RagRequest, RagResponse, RealtimeEvent, RealtimeListenType, RealtimeSubscribeStatus, SchemaColumn, SchemaEnum, SchemaFunction, SchemaFunctionArg, SchemaTable, SemanticSearchResult, SendNotificationRequest, SessionInfo, SignInRequest, SignUpRequest, StorageBucket, TokenPair, UpdateUserRequest, UploadResult, User, isAuraError } from '@aurabase/core';
 export { DatabaseService, QueryBuilder } from '@aurabase/db';
-export { FunctionsService } from '@aurabase/functions';
+export { FunctionsHttpError, FunctionsRelayError, FunctionsResponseType, FunctionsService, isRelayStatus } from '@aurabase/functions';
 export { NotificationsAdminService, NotificationsService } from '@aurabase/notifications';
 export { AuraChannel, RealtimeService } from '@aurabase/realtime';
 export { StorageBucketClient, StorageService } from '@aurabase/storage';
-import { A as AuraClient } from './AuraClient-K3hRdh9J.js';
+import { A as AuraClient } from './AuraClient-5jDiXjrO.js';
 
 /**
  * Create a new Aurabase client instance.

package/dist/index.js

@@ -7,7 +7,7 @@ export { AuraError, BaseAuthStore, LocalAuthStore, isAuraError } from '@aurabase
 import { DatabaseService } from '@aurabase/db';
 export { DatabaseService, QueryBuilder } from '@aurabase/db';
 import { FunctionsService } from '@aurabase/functions';
-export { FunctionsService } from '@aurabase/functions';
+export { FunctionsHttpError, FunctionsRelayError, FunctionsService, isRelayStatus } from '@aurabase/functions';
 import { NotificationsService } from '@aurabase/notifications';
 export { NotificationsAdminService, NotificationsService } from '@aurabase/notifications';
 import { RealtimeService } from '@aurabase/realtime';
@@ -69,6 +69,11 @@ var AuraClient = class {
         "[aurabase] No API key provided. Most operations require an API key (apikey header). Only public auth routes (register, login, refresh) will work without one."
       );
     }
+    if (typeof console !== "undefined" && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/?$/.test(this.baseUrl)) {
+      console.warn(
+        "[aurabase] Attention : en local, l'URL du projet doit inclure le sous-domaine (ex: http://<slug>.localhost:8080) pour permettre la r\xE9solution automatique du projet par la passerelle."
+      );
+    }
     if (this.apiKey?.startsWith(SERVICE_ROLE_KEY_PREFIX) && isBrowserContext()) {
       const refuse = resolvedOptions?.refuseServiceRoleInBrowser ?? true;
       const message = "[aurabase] S\xC9CURIT\xC9 : une cl\xE9 service_role (aura_sk_\u2026) est fournie \xE0 createClient() dans un contexte navigateur. Cette cl\xE9 \xE0 privil\xE8ges \xE9lev\xE9s NE DOIT JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez une cl\xE9 anon (aura_anon_\u2026) c\xF4t\xE9 client, et createAdminClient() c\xF4t\xE9 serveur pour les op\xE9rations d'administration.";
@@ -86,7 +91,7 @@ var AuraClient = class {
       const g = globalThis;
       const proc = g?.process;
       const isTest = !!(proc?.env?.VITEST || proc?.env?.NODE_ENV === "test" || proc?.env?.JEST_WORKER_ID);
-      return isTest && g?.localStorage && typeof g.localStorage.getItem === "function";
+      return isTest && !!g?.localStorage && typeof g.localStorage.getItem === "function";
     })()) {
       this.authStore = new LocalAuthStore(`aura-${clientScope(this.baseUrl)}-auth`);
     } else {
@@ -164,7 +169,6 @@ var AuraClient = class {
     if (!this._notifications) this._notifications = new NotificationsService(this);
     return this._notifications;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   from(table) {
     return this.db.from(table);
   }
@@ -177,7 +181,6 @@ var AuraClient = class {
    * const { data, error } = await aura.rpc('echo_test', { message: 'hello' })
    * ```
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   rpc(fn, args, options) {
     return this.db.rpc(fn, args, options);
   }

package/dist/nextjs.cjs

@@ -0,0 +1,389 @@
+'use strict';
+
+var core = require('@aurabase/core');
+var ai = require('@aurabase/ai');
+var auth$1 = require('@aurabase/auth');
+var db = require('@aurabase/db');
+var functions = require('@aurabase/functions');
+var notifications = require('@aurabase/notifications');
+var realtime = require('@aurabase/realtime');
+var storage = require('@aurabase/storage');
+
+// src/ssr.ts
+function isBrowserContext() {
+  if (typeof window !== "undefined") return true;
+  const g = globalThis;
+  if (typeof g.DedicatedWorkerGlobalScope !== "undefined") return true;
+  if (typeof g.SharedWorkerGlobalScope !== "undefined") return true;
+  return false;
+}
+var SERVICE_ROLE_KEY_PREFIX = "aura_sk_";
+var AuraClient = class {
+  /** URL du projet (`https://<slug>.aurabase.cloud`), sans barre finale. */
+  baseUrl;
+  apiKey;
+  fetchFn;
+  authStore;
+  retryConfig;
+  /** Timeout par défaut (ms) des requêtes JSON sans signal. `undefined` → défaut core (30s). */
+  requestTimeoutMs;
+  /** Hook d'observabilité (LOT 3) — voir `AuraClientOptions.onEvent`. */
+  onEvent;
+  /** Journalise chaque `AuraObservabilityEvent` via `console.debug` — voir `AuraClientOptions.debug`. */
+  debug;
+  // Lazy-initialised service instances
+  _auth = null;
+  _db = null;
+  _storage = null;
+  _realtime = null;
+  _functions = null;
+  _ai = null;
+  _notifications = null;
+  _authAdmin = null;
+  _disposed = false;
+  _persistSession;
+  _autoRefresh;
+  _detectSessionInUrl;
+  /**
+   * @param baseUrl URL du projet (`https://<slug>.aurabase.cloud`).
+   * @param apiKey  Clé API du projet (`aura_anon_…`, `aura_auth_…`, `aura_sk_…`).
+   */
+  constructor(baseUrl, apiKey, options) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    const resolvedOptions = options;
+    this.apiKey = apiKey || null;
+    this.fetchFn = resolvedOptions?.fetch ?? globalThis.fetch.bind(globalThis);
+    const r = resolvedOptions?.retry;
+    this.retryConfig = r === false ? { enabled: false, maxRetries: 0 } : r === void 0 || r === true ? { enabled: true, maxRetries: core.DEFAULT_MAX_RETRIES } : { enabled: r.enabled ?? true, maxRetries: r.maxRetries ?? core.DEFAULT_MAX_RETRIES };
+    this.requestTimeoutMs = resolvedOptions?.requestTimeoutMs;
+    this.onEvent = resolvedOptions?.onEvent;
+    this.debug = resolvedOptions?.debug;
+    if (!this.apiKey && typeof console !== "undefined") {
+      console.warn(
+        "[aurabase] No API key provided. Most operations require an API key (apikey header). Only public auth routes (register, login, refresh) will work without one."
+      );
+    }
+    if (typeof console !== "undefined" && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/?$/.test(this.baseUrl)) {
+      console.warn(
+        "[aurabase] Attention : en local, l'URL du projet doit inclure le sous-domaine (ex: http://<slug>.localhost:8080) pour permettre la r\xE9solution automatique du projet par la passerelle."
+      );
+    }
+    if (this.apiKey?.startsWith(SERVICE_ROLE_KEY_PREFIX) && isBrowserContext()) {
+      const refuse = resolvedOptions?.refuseServiceRoleInBrowser ?? true;
+      const message = "[aurabase] S\xC9CURIT\xC9 : une cl\xE9 service_role (aura_sk_\u2026) est fournie \xE0 createClient() dans un contexte navigateur. Cette cl\xE9 \xE0 privil\xE8ges \xE9lev\xE9s NE DOIT JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez une cl\xE9 anon (aura_anon_\u2026) c\xF4t\xE9 client, et createAdminClient() c\xF4t\xE9 serveur pour les op\xE9rations d'administration.";
+      if (refuse) {
+        throw new Error(message);
+      } else if (typeof console !== "undefined") {
+        console.warn(message);
+      }
+    }
+    if (resolvedOptions?.auth?.storage) {
+      this.authStore = resolvedOptions.auth.storage;
+    } else if (resolvedOptions?.auth?.persistSession === false) {
+      this.authStore = new core.BaseAuthStore();
+    } else if (isBrowserContext() && typeof window.localStorage !== "undefined" || typeof globalThis !== "undefined" && (() => {
+      const g = globalThis;
+      const proc = g?.process;
+      const isTest = !!(proc?.env?.VITEST || proc?.env?.NODE_ENV === "test" || proc?.env?.JEST_WORKER_ID);
+      return isTest && !!g?.localStorage && typeof g.localStorage.getItem === "function";
+    })()) {
+      this.authStore = new core.LocalAuthStore(`aura-${core.clientScope(this.baseUrl)}-auth`);
+    } else {
+      this.authStore = new core.BaseAuthStore();
+    }
+    this.authStore.setObservabilityHook(this.onEvent, this.debug);
+    this._persistSession = resolvedOptions?.auth?.persistSession !== false;
+    this._autoRefresh = resolvedOptions?.auth?.autoRefresh ?? true;
+    this._detectSessionInUrl = resolvedOptions?.auth?.detectSessionInUrl;
+    if (this._autoRefresh && this._persistSession && typeof window !== "undefined") {
+      void this.auth;
+    }
+  }
+  /**
+   * Démonte le client : arrête le refresh proactif (ticker + visibilité + BroadcastChannel),
+   * déconnecte le realtime, vide les listeners d'auth. Idempotent. À appeler en teardown
+   * (React Strict Mode / HMR / tests).
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._auth?.dispose();
+    this._realtime?.disconnect();
+  }
+  // -- Lazy service getters ---------------------------------------------------
+  get auth() {
+    if (!this._auth) {
+      this._auth = new auth$1.AuthService(this, {
+        autoRefresh: this._autoRefresh,
+        persistSession: this._persistSession,
+        detectSessionInUrl: this._detectSessionInUrl
+      });
+      this._auth.onAuthStateChange(({ event, accessToken }) => {
+        if (this._realtime) {
+          if (accessToken) {
+            this._realtime.setAuth(accessToken);
+          } else if (event === "SIGNED_OUT") {
+            this._realtime.setAuth("");
+          }
+        }
+      });
+    }
+    return this._auth;
+  }
+  get authAdmin() {
+    if (isBrowserContext()) {
+      throw new Error(
+        "[aurabase] S\xC9CURIT\xC9 : authAdmin est inaccessible dans un contexte navigateur. L'API admin requiert une cl\xE9 service_role qui ne doit JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez createAdminClient() c\xF4t\xE9 serveur uniquement."
+      );
+    }
+    if (!this._authAdmin) this._authAdmin = new auth$1.AuthAdminService(this);
+    return this._authAdmin;
+  }
+  get db() {
+    if (!this._db) this._db = new db.DatabaseService(this);
+    return this._db;
+  }
+  get storage() {
+    if (!this._storage) this._storage = new storage.StorageService(this);
+    return this._storage;
+  }
+  get realtime() {
+    if (!this._realtime) this._realtime = new realtime.RealtimeService(this);
+    return this._realtime;
+  }
+  get functions() {
+    if (!this._functions) this._functions = new functions.FunctionsService(this);
+    return this._functions;
+  }
+  get ai() {
+    if (!this._ai) this._ai = new ai.AiService(this);
+    return this._ai;
+  }
+  get notifications() {
+    if (!this._notifications) this._notifications = new notifications.NotificationsService(this);
+    return this._notifications;
+  }
+  from(table) {
+    return this.db.from(table);
+  }
+  /**
+   * Shortcut: call a stored procedure / PostgreSQL function via RPC (Supabase-compatible API).
+   * Equivalent to `aura.db.rpc(fn, args, options)`.
+   *
+   * @example
+   * ```ts
+   * const { data, error } = await aura.rpc('echo_test', { message: 'hello' })
+   * ```
+   */
+  rpc(fn, args, options) {
+    return this.db.rpc(fn, args, options);
+  }
+  /**
+   * Shortcut: create a realtime channel with Supabase-compatible API.
+   * Equivalent to `aura.realtime.channel(name)`.
+   *
+   * @example
+   * ```ts
+   * const channel = aura.channel('room-1')
+   *   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, cb)
+   *   .subscribe()
+   * ```
+   */
+  channel(name, options) {
+    return this.realtime.channel(name, options);
+  }
+  /**
+   * Shortcut: remove a realtime channel by name or AuraChannel instance.
+   * Equivalent to `aura.realtime.removeChannel(channel)`.
+   */
+  removeChannel(channel) {
+    return this.realtime.removeChannel(channel);
+  }
+  /**
+   * Shortcut: remove all realtime channels and unsubscribe.
+   * Equivalent to `aura.realtime.removeAllChannels()`.
+   */
+  removeAllChannels() {
+    return this.realtime.removeAllChannels();
+  }
+  /**
+   * Shortcut: list all active realtime channels.
+   * Equivalent to `aura.realtime.getChannels()`.
+   */
+  getChannels() {
+    return this.realtime.getChannels();
+  }
+};
+var MAX_CHUNK_SIZE = 3600;
+function createServerClient(baseUrl, apiKey, options) {
+  const cookieName = `aura-${core.clientScope(baseUrl)}-auth`;
+  const store = new core.LocalAuthStore(cookieName);
+  const idxRe = new RegExp(`^${cookieName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.(\\d+)$`);
+  const incoming = options.cookies.getAll();
+  const numbered = incoming.filter((c) => idxRe.test(c.name)).sort((a, b) => Number(a.name.match(idxRe)[1]) - Number(b.name.match(idxRe)[1]));
+  const base = incoming.find((c) => c.name === cookieName);
+  const decodedValue = numbered.length > 0 ? numbered.map((c) => c.value).join("") : base?.value;
+  if (decodedValue) {
+    store.loadFromCookie(`${cookieName}=${encodeURIComponent(decodedValue)}`);
+  }
+  const initialNames = incoming.filter((c) => c.name === cookieName || idxRe.test(c.name)).map((c) => c.name);
+  const defaultCookieOpts = {
+    path: "/",
+    secure: baseUrl.startsWith("https://"),
+    sameSite: "Lax",
+    httpOnly: true,
+    maxAge: 60 * 60 * 24 * 30,
+    // 30 days
+    ...options.cookieOptions
+  };
+  store.onChange(() => {
+    const toSet = [];
+    const used = /* @__PURE__ */ new Set();
+    if (store.token) {
+      const cookieStr = store.exportToCookie();
+      const eqIdx = cookieStr.indexOf("=");
+      const rawEncoded = eqIdx >= 0 ? cookieStr.slice(eqIdx + 1).split(";")[0] : "";
+      const decoded = rawEncoded ? decodeURIComponent(rawEncoded) : "";
+      if (decoded.length <= MAX_CHUNK_SIZE) {
+        toSet.push({ name: cookieName, value: decoded, options: defaultCookieOpts });
+        used.add(cookieName);
+      } else {
+        let idx = 0;
+        for (let i = 0; i < decoded.length; i += MAX_CHUNK_SIZE, idx++) {
+          const name = `${cookieName}.${idx}`;
+          toSet.push({
+            name,
+            value: decoded.slice(i, i + MAX_CHUNK_SIZE),
+            options: defaultCookieOpts
+          });
+          used.add(name);
+        }
+      }
+    }
+    const expireOpts = { ...defaultCookieOpts, maxAge: 0 };
+    for (const name of initialNames) {
+      if (!used.has(name)) toSet.push({ name, value: "", options: expireOpts });
+    }
+    if (toSet.length > 0) options.cookies.setAll(toSet);
+  });
+  return new AuraClient(baseUrl, apiKey, {
+    auth: { persistSession: false, storage: store }
+  });
+}
+
+// src/nextjs.ts
+async function loadNextModule(specifier) {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      specifier
+    );
+    return mod;
+  } catch {
+    return null;
+  }
+}
+function createAuthMiddleware(options = {}) {
+  return async function middleware(request) {
+    const nextServer = await loadNextModule("next/server");
+    if (!nextServer?.NextResponse) {
+      throw new Error(
+        "[@aurabase/nextjs] Next.js n'est pas install\xE9. createAuthMiddleware n\xE9cessite next/server."
+      );
+    }
+    const { NextResponse } = nextServer;
+    const projectUrl = options.projectUrl ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.AURABASE_URL ?? "";
+    const anonKey = options.anonKey ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.AURABASE_ANON_KEY ?? "";
+    if (!projectUrl || !anonKey) {
+      console.warn(
+        "[@aurabase/nextjs] Variables d'environnement manquantes : NEXT_PUBLIC_AURABASE_URL ou NEXT_PUBLIC_AURABASE_ANON_KEY non d\xE9finies."
+      );
+      return NextResponse.next({ request });
+    }
+    const response = NextResponse.next({ request });
+    const cookieHandler = {
+      getAll: () => request.cookies.getAll(),
+      setAll: (cookiesToSet) => {
+        cookiesToSet.forEach(({ name, value, options: cookieOpts }) => {
+          request.cookies.set(name, value);
+          response.cookies.set(name, value, cookieOpts);
+        });
+      }
+    };
+    const client = createServerClient(projectUrl, anonKey, {
+      cookies: cookieHandler
+    });
+    const { data: sessionData } = await client.auth.getSession();
+    const session = sessionData?.session ?? null;
+    const user = session?.user ?? null;
+    const pathname = request.nextUrl.pathname;
+    const publicPatterns = options.publicRoutes ?? ["/", "/login", "/signup", "/auth/callback"];
+    const isPublic = publicPatterns.some((pattern) => {
+      if (pattern.endsWith("*")) {
+        return pathname.startsWith(pattern.slice(0, -1));
+      }
+      return pathname === pattern;
+    });
+    if (!isPublic && !user) {
+      const loginUrl = new URL(options.loginUrl ?? "/login", request.url);
+      loginUrl.searchParams.set("redirectTo", pathname);
+      return NextResponse.redirect(loginUrl);
+    }
+    if (options.onAuthenticated) {
+      const customResponse = await options.onAuthenticated({ user, session, request });
+      if (customResponse) return customResponse;
+    }
+    return response;
+  };
+}
+function createClientForServerComponent(cookieStore, projectUrl, apiKey) {
+  const url = projectUrl ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.AURABASE_URL ?? "";
+  const key = apiKey ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.AURABASE_ANON_KEY ?? "";
+  return createServerClient(url, key, {
+    cookies: {
+      getAll: () => cookieStore.getAll(),
+      setAll: () => {
+      }
+    }
+  });
+}
+function createClientForServerAction(cookieStore, projectUrl, apiKey) {
+  const url = projectUrl ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.AURABASE_URL ?? "";
+  const key = apiKey ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.AURABASE_ANON_KEY ?? "";
+  return createServerClient(url, key, {
+    cookies: {
+      getAll: () => cookieStore.getAll(),
+      setAll: (cookiesToSet) => {
+        cookiesToSet.forEach(({ name, value, options }) => {
+          cookieStore.set?.(name, value, options);
+        });
+      }
+    }
+  });
+}
+async function auth(options) {
+  const nextHeaders = await loadNextModule("next/headers");
+  if (!nextHeaders?.cookies) {
+    throw new Error("[@aurabase/nextjs] auth() ne peut \xEAtre appel\xE9 que dans un environnement Next.js App Router.");
+  }
+  const cookieStore = await nextHeaders.cookies();
+  const client = createClientForServerComponent(cookieStore, options?.projectUrl, options?.apiKey);
+  const { data } = await client.auth.getSession();
+  const session = data?.session ?? null;
+  const user = session?.user ?? null;
+  return {
+    userId: user?.id ?? null,
+    user,
+    session
+  };
+}
+async function currentUser(options) {
+  const { user } = await auth(options);
+  return user;
+}
+
+exports.auth = auth;
+exports.createAuthMiddleware = createAuthMiddleware;
+exports.createClientForServerAction = createClientForServerAction;
+exports.createClientForServerComponent = createClientForServerComponent;
+exports.currentUser = currentUser;

package/dist/nextjs.d.cts

@@ -0,0 +1,126 @@
+import { A as AuraClient } from './AuraClient-5jDiXjrO.cjs';
+import { User, Session } from '@aurabase/core';
+import '@aurabase/ai';
+import '@aurabase/auth';
+import '@aurabase/db';
+import '@aurabase/functions';
+import '@aurabase/notifications';
+import '@aurabase/realtime';
+import '@aurabase/storage';
+
+interface NextCookieItem {
+    name: string;
+    value: string;
+    options?: Record<string, unknown>;
+}
+interface NextRequestCookies {
+    getAll(): NextCookieItem[];
+    set(name: string, value: string): void;
+}
+interface NextUrlLike {
+    pathname: string;
+}
+interface NextRequestLike {
+    cookies: NextRequestCookies;
+    nextUrl: NextUrlLike;
+    url: string;
+}
+interface NextResponseCookies {
+    set(name: string, value: string, options?: Record<string, unknown>): void;
+}
+interface NextResponseLike {
+    cookies: NextResponseCookies;
+    headers?: unknown;
+}
+interface NextServerModule {
+    NextResponse: {
+        next(init?: {
+            request?: unknown;
+        }): NextResponseLike;
+        redirect(url: string | URL): NextResponseLike;
+    };
+}
+interface ReadonlyRequestCookiesLike {
+    getAll(): NextCookieItem[];
+    set?(name: string, value: string, options?: Record<string, unknown>): void;
+}
+interface NextHeadersModule {
+    cookies(): Promise<ReadonlyRequestCookiesLike> | ReadonlyRequestCookiesLike;
+}
+interface AuthContextParam {
+    user: User | null;
+    session: Session | null;
+    request: NextRequestLike;
+}
+interface AuthMiddlewareOptions {
+    /** Project URL (defaults to process.env.NEXT_PUBLIC_AURABASE_URL or process.env.AURABASE_URL). */
+    projectUrl?: string;
+    /** Anon API Key (defaults to process.env.NEXT_PUBLIC_AURABASE_ANON_KEY or process.env.AURABASE_ANON_KEY). */
+    anonKey?: string;
+    /** List of route patterns that do not require authentication (e.g. ['/', '/login', '/signup', '/auth/*']). */
+    publicRoutes?: string[];
+    /** URL to redirect unauthenticated users to (default: '/login'). */
+    loginUrl?: string;
+    /** Custom handler executed after session evaluation. */
+    onAuthenticated?: (authContext: AuthContextParam) => Promise<NextResponseLike | undefined | null | void> | NextResponseLike | undefined | null | void;
+}
+/**
+ * Creates a standard Next.js middleware that validates sessions and protects private routes.
+ *
+ * @example
+ * ```ts
+ * // middleware.ts
+ * import { createAuthMiddleware } from '@aurabase/aurabase-js/nextjs'
+ *
+ * export default createAuthMiddleware({
+ *   publicRoutes: ['/', '/login', '/signup', '/api/public'],
+ *   loginUrl: '/login',
+ * })
+ *
+ * export const config = {
+ *   matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+ * }
+ * ```
+ */
+declare function createAuthMiddleware(options?: AuthMiddlewareOptions): (request: NextRequestLike) => Promise<NextResponseLike>;
+/**
+ * Creates an Aurabase client optimized for React Server Components (RSC).
+ * Safe in read-only RSC context: prevents Next.js errors when evaluating tokens.
+ */
+declare function createClientForServerComponent(cookieStore: ReadonlyRequestCookiesLike, projectUrl?: string, apiKey?: string): AuraClient<any, any>;
+/**
+ * Creates an Aurabase client for Server Actions and Route Handlers.
+ * Full read-write cookie access for transparent session management.
+ */
+declare function createClientForServerAction(cookieStore: ReadonlyRequestCookiesLike, projectUrl?: string, apiKey?: string): AuraClient<any, any>;
+/**
+ * Server Component helper (Clerk-like API) to get the current authentication state.
+ *
+ * @example
+ * ```tsx
+ * import { auth } from '@aurabase/aurabase-js/nextjs'
+ *
+ * export default async function Page() {
+ *   const { userId, user } = await auth()
+ *   if (!userId) return <div>Non connecté</div>
+ *   return <div>Connecté en tant que {user?.email}</div>
+ * }
+ * ```
+ */
+declare function auth(options?: {
+    projectUrl?: string;
+    apiKey?: string;
+}): Promise<{
+    userId: string | null;
+    user: User | null;
+    session: Session | null;
+}>;
+/**
+ * Server Component helper to get the currently logged-in user profile.
+ */
+declare function currentUser(options?: {
+    projectUrl?: string;
+    apiKey?: string;
+}): Promise<User | null>;
+
+export { type AuthContextParam, type AuthMiddlewareOptions, type NextCookieItem, type NextHeadersModule, type NextRequestCookies, type NextRequestLike, type NextResponseCookies, type NextResponseLike, type NextServerModule, type NextUrlLike, type ReadonlyRequestCookiesLike, auth, createAuthMiddleware, createClientForServerAction, createClientForServerComponent, currentUser };