fauxbase 0.1.2 → 0.5.0

package/dist/index.cjs

@@ -38,6 +38,29 @@ var ForbiddenError = class extends FauxbaseError {
     this.name = "ForbiddenError";
   }
 };
+var NetworkError = class extends FauxbaseError {
+  constructor(message = "Network request failed") {
+    super(message, "NETWORK");
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends FauxbaseError {
+  constructor(message = "Request timed out") {
+    super(message, "TIMEOUT");
+    this.name = "TimeoutError";
+  }
+};
+var HttpError = class extends FauxbaseError {
+  status;
+  constructor(message, status, details) {
+    super(message, "HTTP", details);
+    this.name = "HttpError";
+    this.status = status;
+  }
+  toJSON() {
+    return { ...super.toJSON(), status: this.status };
+  }
+};
 
 // src/registry.ts
 var fieldRegistry = /* @__PURE__ */ new Map();
@@ -159,11 +182,18 @@ function afterUpdate() {
 var Service = class {
   driver;
   resourceName;
+  client;
+  /** @internal */
+  _eventBus;
   /** @internal — called by createClient to wire the service */
   _init(driver, resourceName) {
     this.driver = driver;
     this.resourceName = resourceName;
   }
+  /** @internal — called by createClient to give services access to the client */
+  _setClient(client) {
+    this.client = client;
+  }
   async list(query = {}) {
     return this.driver.list(this.resourceName, query);
   }
@@ -175,27 +205,56 @@ var Service = class {
     await this.runHooks("beforeCreate", data, allItems);
     const result = await this.driver.create(this.resourceName, data);
     await this.runHooks("afterCreate", result.data);
+    this.emitEvent("created", { data: result.data, id: result.data.id });
     return result;
   }
   async update(id, data) {
     await this.runHooks("beforeUpdate", id, data);
     const result = await this.driver.update(this.resourceName, id, data);
     await this.runHooks("afterUpdate", result.data);
+    this.emitEvent("updated", { data: result.data, id });
     return result;
   }
   async delete(id) {
-    return this.driver.delete(this.resourceName, id);
+    const result = await this.driver.delete(this.resourceName, id);
+    this.emitEvent("deleted", { data: result.data, id });
+    return result;
   }
   async count(filter) {
     return this.driver.count(this.resourceName, filter);
   }
   get bulk() {
+    const self = this;
     return {
-      create: (items) => this.driver.bulkCreate(this.resourceName, items),
-      update: (updates) => this.driver.bulkUpdate(this.resourceName, updates),
-      delete: (ids) => this.driver.bulkDelete(this.resourceName, ids)
+      async create(items) {
+        const result = await self.driver.bulkCreate(self.resourceName, items);
+        self.emitEvent("bulkCreated", { data: result.data });
+        return result;
+      },
+      async update(updates) {
+        const result = await self.driver.bulkUpdate(self.resourceName, updates);
+        self.emitEvent("bulkUpdated", { data: result.data, ids: updates.map((u) => u.id) });
+        return result;
+      },
+      async delete(ids) {
+        const result = await self.driver.bulkDelete(self.resourceName, ids);
+        self.emitEvent("bulkDeleted", { ids });
+        return result;
+      }
     };
   }
+  emitEvent(action, extra) {
+    if (!this._eventBus) return;
+    this._eventBus.emit({
+      action,
+      resource: this.resourceName,
+      data: extra.data,
+      id: extra.id,
+      ids: extra.ids,
+      timestamp: Date.now(),
+      source: "local"
+    });
+  }
   async runHooks(hookType, ...args) {
     const methods = getHooks(this.constructor, hookType);
     for (const methodName of methods) {
@@ -204,6 +263,173 @@ var Service = class {
   }
 };
 
+// src/auth.ts
+var AuthService = class extends Service {
+  authState = null;
+  saveState = null;
+  httpDriver = null;
+  /** @internal — called by createClient to wire persistence */
+  _initAuth(loadState, saveState) {
+    this.saveState = saveState;
+    this.authState = loadState();
+  }
+  /** @internal — called by createClient when using HttpDriver */
+  _setHttpMode(driver) {
+    this.httpDriver = driver;
+  }
+  async login(credentials) {
+    if (this.httpDriver) {
+      return this.httpLogin(credentials);
+    }
+    return this.localLogin(credentials);
+  }
+  async register(data) {
+    if (this.httpDriver) {
+      return this.httpRegister(data);
+    }
+    return this.localRegister(data);
+  }
+  logout() {
+    this.authState = null;
+    this.persistState();
+  }
+  get currentUser() {
+    return this.authState ? { id: this.authState.userId, email: this.authState.email } : null;
+  }
+  get isLoggedIn() {
+    return this.authState !== null;
+  }
+  get token() {
+    return this.authState?.token ?? null;
+  }
+  hasRole(role) {
+    return this.authState?.role === role;
+  }
+  getAuthContext() {
+    if (!this.authState) return null;
+    return {
+      userId: this.authState.userId,
+      userName: this.authState.userName
+    };
+  }
+  // --- Local mode (original implementation) ---
+  async localLogin(credentials) {
+    const { items } = await this.list({ filter: { email: credentials.email } });
+    if (items.length === 0) {
+      throw new NotFoundError("Invalid email or password");
+    }
+    const user = items[0];
+    if (user.password !== credentials.password) {
+      throw new ForbiddenError("Invalid email or password");
+    }
+    this.authState = {
+      userId: user.id,
+      email: user.email,
+      userName: user.name || user.email,
+      role: user.role,
+      token: this.generateToken(user)
+    };
+    this.persistState();
+    return user;
+  }
+  async localRegister(data) {
+    const email = data.email;
+    if (email) {
+      const { items } = await this.list({ filter: { email } });
+      if (items.length > 0) {
+        throw new ConflictError("Email already registered");
+      }
+    }
+    const { data: user } = await this.create(data);
+    const u = user;
+    this.authState = {
+      userId: u.id,
+      email: u.email,
+      userName: u.name || u.email,
+      role: u.role,
+      token: this.generateToken(u)
+    };
+    this.persistState();
+    return user;
+  }
+  // --- HTTP mode ---
+  async httpLogin(credentials) {
+    const preset = this.httpDriver.preset;
+    const baseUrl = this.httpDriver.baseUrl;
+    const url = `${baseUrl}${preset.auth.loginUrl}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(credentials)
+    });
+    if (!response.ok) {
+      const body2 = await response.json().catch(() => ({}));
+      if (response.status === 401 || response.status === 403) {
+        throw new ForbiddenError(body2.message ?? "Invalid email or password");
+      }
+      if (response.status === 404) {
+        throw new NotFoundError(body2.message ?? "Invalid email or password");
+      }
+      throw new ForbiddenError(body2.message ?? "Login failed");
+    }
+    const body = await response.json();
+    const token = body[preset.auth.tokenField];
+    const user = body[preset.auth.userField] ?? body;
+    this.authState = {
+      userId: user.id,
+      email: user.email ?? credentials.email,
+      userName: user.name || user.email || credentials.email,
+      role: user.role,
+      token
+    };
+    this.persistState();
+    return user;
+  }
+  async httpRegister(data) {
+    const preset = this.httpDriver.preset;
+    const baseUrl = this.httpDriver.baseUrl;
+    const url = `${baseUrl}${preset.auth.registerUrl}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      const body2 = await response.json().catch(() => ({}));
+      if (response.status === 409) {
+        throw new ConflictError(body2.message ?? "Email already registered");
+      }
+      throw new ForbiddenError(body2.message ?? "Registration failed");
+    }
+    const body = await response.json();
+    const token = body[preset.auth.tokenField];
+    const user = body[preset.auth.userField] ?? body;
+    this.authState = {
+      userId: user.id,
+      email: user.email ?? data.email,
+      userName: user.name || user.email || data.email,
+      role: user.role,
+      token
+    };
+    this.persistState();
+    return user;
+  }
+  generateToken(user) {
+    return btoa(JSON.stringify({
+      userId: user.id,
+      email: user.email,
+      role: user.role,
+      iat: Date.now(),
+      exp: Date.now() + 24 * 60 * 60 * 1e3
+    }));
+  }
+  persistState() {
+    if (this.saveState) {
+      this.saveState(this.authState);
+    }
+  }
+};
+
 // src/query-engine.ts
 var OPERATORS = [
   "startswith",
@@ -392,11 +618,143 @@ var LocalStorageBackend = class {
     localStorage.setItem(`${LS_META_PREFIX}${key}`, value);
   }
 };
+function idbRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+var IDB_DATA_STORE = "data";
+var IDB_META_STORE = "meta";
+var IndexedDBBackend = class {
+  cache = new MemoryStorage();
+  db = null;
+  _ready;
+  constructor(dbName) {
+    this._ready = this.open(dbName);
+  }
+  get ready() {
+    return this._ready;
+  }
+  open(dbName) {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(dbName, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(IDB_DATA_STORE)) {
+          db.createObjectStore(IDB_DATA_STORE);
+        }
+        if (!db.objectStoreNames.contains(IDB_META_STORE)) {
+          db.createObjectStore(IDB_META_STORE);
+        }
+      };
+      req.onsuccess = async () => {
+        this.db = req.result;
+        await this.loadAll();
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async loadAll() {
+    const db = this.db;
+    const tx = db.transaction([IDB_DATA_STORE, IDB_META_STORE], "readonly");
+    const dataStore = tx.objectStore(IDB_DATA_STORE);
+    const metaStore = tx.objectStore(IDB_META_STORE);
+    const dataKeys = await idbRequest(dataStore.getAllKeys());
+    const dataValues = await idbRequest(dataStore.getAll());
+    for (let i = 0; i < dataKeys.length; i++) {
+      const compositeKey = dataKeys[i];
+      const sepIdx = compositeKey.indexOf(":");
+      const resource = compositeKey.substring(0, sepIdx);
+      const id = compositeKey.substring(sepIdx + 1);
+      this.cache.set(resource, id, dataValues[i]);
+    }
+    const metaKeys = await idbRequest(metaStore.getAllKeys());
+    const metaValues = await idbRequest(metaStore.getAll());
+    for (let i = 0; i < metaKeys.length; i++) {
+      this.cache.setMeta(metaKeys[i], metaValues[i]);
+    }
+  }
+  writeData(resource, id, data) {
+    if (!this.db) return;
+    const tx = this.db.transaction(IDB_DATA_STORE, "readwrite");
+    tx.objectStore(IDB_DATA_STORE).put(data, `${resource}:${id}`);
+  }
+  deleteData(resource, id) {
+    if (!this.db) return;
+    const tx = this.db.transaction(IDB_DATA_STORE, "readwrite");
+    tx.objectStore(IDB_DATA_STORE).delete(`${resource}:${id}`);
+  }
+  writeMeta(key, value) {
+    if (!this.db) return;
+    const tx = this.db.transaction(IDB_META_STORE, "readwrite");
+    tx.objectStore(IDB_META_STORE).put(value, key);
+  }
+  getAll(resource) {
+    return this.cache.getAll(resource);
+  }
+  getById(resource, id) {
+    return this.cache.getById(resource, id);
+  }
+  set(resource, id, data) {
+    this.cache.set(resource, id, data);
+    this.writeData(resource, id, data);
+  }
+  remove(resource, id) {
+    this.cache.remove(resource, id);
+    this.deleteData(resource, id);
+  }
+  clear(resource) {
+    const items = this.cache.getAll(resource);
+    this.cache.clear(resource);
+    if (this.db) {
+      const tx = this.db.transaction(IDB_DATA_STORE, "readwrite");
+      const store = tx.objectStore(IDB_DATA_STORE);
+      for (const item of items) {
+        store.delete(`${resource}:${item.id}`);
+      }
+    }
+  }
+  getMeta(key) {
+    return this.cache.getMeta(key);
+  }
+  setMeta(key, value) {
+    this.cache.setMeta(key, value);
+    this.writeMeta(key, value);
+  }
+};
 var LocalDriver = class {
   storage;
   entityClasses = /* @__PURE__ */ new Map();
+  authProvider = null;
+  _ready;
+  _isReady;
   constructor(config) {
-    this.storage = config.persist === "localStorage" ? new LocalStorageBackend() : new MemoryStorage();
+    if (config.persist === "indexeddb") {
+      const backend = new IndexedDBBackend(config.dbName ?? "fauxbase");
+      this.storage = backend;
+      this._isReady = false;
+      this._ready = backend.ready.then(() => {
+        this._isReady = true;
+      });
+    } else {
+      this.storage = config.persist === "localStorage" ? new LocalStorageBackend() : new MemoryStorage();
+      this._isReady = true;
+      this._ready = Promise.resolve();
+    }
+  }
+  get ready() {
+    return this._ready;
+  }
+  get isReady() {
+    return this._isReady;
+  }
+  setAuthProvider(provider) {
+    this.authProvider = provider;
+  }
+  getStorageBackend() {
+    return this.storage;
   }
   registerEntity(resource, entityClass) {
     this.entityClasses.set(resource, entityClass);
@@ -419,13 +777,20 @@ var LocalDriver = class {
   async create(resource, data) {
     const entityClass = this.entityClasses.get(resource);
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const authContext = this.authProvider?.();
     let record = {
       ...data,
       id: data.id || generateUUID(),
       createdAt: now,
       updatedAt: now,
       deletedAt: null,
-      version: 1
+      version: 1,
+      ...authContext ? {
+        createdById: authContext.userId,
+        createdByName: authContext.userName,
+        updatedById: authContext.userId,
+        updatedByName: authContext.userName
+      } : {}
     };
     if (entityClass) {
       record = applyDefaults(record, entityClass);
@@ -444,13 +809,18 @@ var LocalDriver = class {
     if (entityClass) {
       validateEntity(data, entityClass, false);
     }
+    const authContext = this.authProvider?.();
     const record = {
       ...existing,
       ...data,
       id,
       createdAt: existing.createdAt,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      version: (existing.version || 0) + 1
+      version: (existing.version || 0) + 1,
+      ...authContext ? {
+        updatedById: authContext.userId,
+        updatedByName: authContext.userName
+      } : {}
     };
     this.storage.set(resource, id, record);
     const result = entityClass ? applyComputedFields(record, entityClass) : record;
@@ -462,11 +832,18 @@ var LocalDriver = class {
       throw new NotFoundError(`${resource} with id "${id}" not found`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const authContext = this.authProvider?.();
     const record = {
       ...existing,
       deletedAt: now,
       updatedAt: now,
-      version: (existing.version || 0) + 1
+      version: (existing.version || 0) + 1,
+      ...authContext ? {
+        deletedById: authContext.userId,
+        deletedByName: authContext.userName,
+        updatedById: authContext.userId,
+        updatedByName: authContext.userName
+      } : {}
     };
     this.storage.set(resource, id, record);
     return { data: record };
@@ -529,6 +906,631 @@ var LocalDriver = class {
   }
 };
 
+// src/presets/types.ts
+function definePreset(config) {
+  return config;
+}
+
+// src/presets/default.ts
+var defaultPreset = definePreset({
+  name: "default",
+  response: {
+    single: (raw) => ({ data: raw.data ?? raw }),
+    list: (raw) => ({
+      items: raw.items ?? raw.data ?? [],
+      meta: raw.meta ?? {}
+    }),
+    error: (raw) => ({
+      error: raw.error ?? raw.message ?? "Unknown error",
+      code: raw.code ?? "UNKNOWN",
+      details: raw.details
+    })
+  },
+  meta: { page: "page", size: "size", totalItems: "totalItems", totalPages: "totalPages" },
+  query: {
+    filterStyle: "django",
+    pageParam: "page",
+    sizeParam: "size",
+    sortParam: "sort",
+    sortFormat: "field,direction"
+  },
+  auth: {
+    loginUrl: "/auth/login",
+    registerUrl: "/auth/register",
+    logoutUrl: "/auth/logout",
+    tokenField: "token",
+    userField: "user",
+    headerFormat: "Bearer {token}"
+  }
+});
+
+// src/presets/spring-boot.ts
+var springBootPreset = definePreset({
+  name: "spring-boot",
+  response: {
+    single: (raw) => ({ data: raw }),
+    list: (raw) => ({
+      items: raw.content ?? [],
+      meta: {
+        page: (raw.pageable?.pageNumber ?? 0) + 1,
+        size: raw.pageable?.pageSize ?? raw.size ?? 20,
+        totalItems: raw.totalElements ?? 0,
+        totalPages: raw.totalPages ?? 0
+      }
+    }),
+    error: (raw) => ({
+      error: raw.message ?? raw.error ?? "Unknown error",
+      code: raw.status?.toString() ?? "UNKNOWN",
+      details: raw.errors?.reduce?.((acc, e) => {
+        acc[e.field ?? e.code ?? "unknown"] = e.defaultMessage ?? e.message ?? "";
+        return acc;
+      }, {}) ?? void 0
+    })
+  },
+  meta: { page: "page", size: "size", totalItems: "totalElements", totalPages: "totalPages" },
+  query: {
+    filterStyle: "dot",
+    pageParam: "page",
+    sizeParam: "size",
+    sortParam: "sort",
+    sortFormat: "field,direction",
+    pageOffset: -1
+    // 0-indexed
+  },
+  auth: {
+    loginUrl: "/api/auth/login",
+    registerUrl: "/api/auth/register",
+    tokenField: "token",
+    userField: "user",
+    headerFormat: "Bearer {token}"
+  }
+});
+
+// src/presets/laravel.ts
+var laravelPreset = definePreset({
+  name: "laravel",
+  response: {
+    single: (raw) => ({ data: raw.data ?? raw }),
+    list: (raw) => ({
+      items: raw.data ?? [],
+      meta: {
+        page: raw.meta?.current_page ?? raw.current_page ?? 1,
+        size: raw.meta?.per_page ?? raw.per_page ?? 15,
+        totalItems: raw.meta?.total ?? raw.total ?? 0,
+        totalPages: raw.meta?.last_page ?? raw.last_page ?? 0
+      }
+    }),
+    error: (raw) => ({
+      error: raw.message ?? "Unknown error",
+      code: raw.status?.toString() ?? "UNKNOWN",
+      details: raw.errors ? Object.entries(raw.errors).reduce((acc, [key, val]) => {
+        acc[key] = Array.isArray(val) ? val[0] : val;
+        return acc;
+      }, {}) : void 0
+    })
+  },
+  meta: { page: "current_page", size: "per_page", totalItems: "total", totalPages: "last_page" },
+  query: {
+    filterStyle: "bracket",
+    pageParam: "page",
+    sizeParam: "per_page",
+    sortParam: "sort",
+    sortFormat: "field,direction"
+  },
+  auth: {
+    loginUrl: "/api/login",
+    registerUrl: "/api/register",
+    logoutUrl: "/api/logout",
+    tokenField: "token",
+    userField: "user",
+    headerFormat: "Bearer {token}"
+  }
+});
+
+// src/presets/django.ts
+var djangoPreset = definePreset({
+  name: "django",
+  response: {
+    single: (raw) => ({ data: raw }),
+    list: (raw) => ({
+      items: raw.results ?? [],
+      meta: {
+        page: 1,
+        // Django REST doesn't always include page number
+        size: raw.results?.length ?? 0,
+        totalItems: raw.count ?? 0,
+        totalPages: raw.count && raw.results?.length ? Math.ceil(raw.count / raw.results.length) : 0
+      }
+    }),
+    error: (raw) => ({
+      error: raw.detail ?? raw.message ?? "Unknown error",
+      code: raw.status_code?.toString() ?? "UNKNOWN",
+      details: typeof raw === "object" && !raw.detail ? Object.entries(raw).reduce((acc, [key, val]) => {
+        if (key !== "status_code") {
+          acc[key] = Array.isArray(val) ? val[0] : String(val);
+        }
+        return acc;
+      }, {}) : void 0
+    })
+  },
+  meta: { page: "page", size: "page_size", totalItems: "count", totalPages: "total_pages" },
+  query: {
+    filterStyle: "django",
+    pageParam: "page",
+    sizeParam: "page_size",
+    sortParam: "ordering",
+    sortFormat: "field,direction"
+  },
+  auth: {
+    loginUrl: "/api/auth/login/",
+    registerUrl: "/api/auth/register/",
+    logoutUrl: "/api/auth/logout/",
+    tokenField: "token",
+    userField: "user",
+    headerFormat: "Token {token}"
+  }
+});
+
+// src/presets/nestjs.ts
+var nestjsPreset = definePreset({
+  name: "nestjs",
+  response: {
+    single: (raw) => ({ data: raw.data ?? raw }),
+    list: (raw) => ({
+      items: raw.data ?? raw.items ?? [],
+      meta: raw.meta ?? {}
+    }),
+    error: (raw) => ({
+      error: raw.message ?? "Unknown error",
+      code: raw.error ?? raw.statusCode?.toString() ?? "UNKNOWN",
+      details: raw.message && Array.isArray(raw.message) ? raw.message.reduce((acc, msg, i) => {
+        acc[`field_${i}`] = msg;
+        return acc;
+      }, {}) : void 0
+    })
+  },
+  meta: { page: "page", size: "limit", totalItems: "totalItems", totalPages: "totalPages" },
+  query: {
+    filterStyle: "nestjs",
+    pageParam: "page",
+    sizeParam: "limit",
+    sortParam: "sort",
+    sortFormat: "field:direction"
+  },
+  auth: {
+    loginUrl: "/auth/login",
+    registerUrl: "/auth/register",
+    tokenField: "access_token",
+    userField: "user",
+    headerFormat: "Bearer {token}"
+  }
+});
+
+// src/presets/express.ts
+var expressPreset = definePreset({
+  name: "express",
+  response: {
+    single: (raw) => ({ data: raw.data ?? raw }),
+    list: (raw) => ({
+      items: raw.data ?? raw.items ?? [],
+      meta: raw.meta ?? {}
+    }),
+    error: (raw) => ({
+      error: raw.error ?? raw.message ?? "Unknown error",
+      code: raw.code ?? "UNKNOWN",
+      details: raw.details
+    })
+  },
+  meta: { page: "page", size: "size", totalItems: "totalItems", totalPages: "totalPages" },
+  query: {
+    filterStyle: "django",
+    pageParam: "page",
+    sizeParam: "size",
+    sortParam: "sort",
+    sortFormat: "field,direction"
+  },
+  auth: {
+    loginUrl: "/api/auth/login",
+    registerUrl: "/api/auth/register",
+    logoutUrl: "/api/auth/logout",
+    tokenField: "token",
+    userField: "user",
+    headerFormat: "Bearer {token}"
+  }
+});
+
+// src/presets/index.ts
+var presetRegistry = /* @__PURE__ */ new Map([
+  ["default", defaultPreset],
+  ["spring-boot", springBootPreset],
+  ["laravel", laravelPreset],
+  ["django", djangoPreset],
+  ["nestjs", nestjsPreset],
+  ["express", expressPreset]
+]);
+function getPreset(name) {
+  const preset = presetRegistry.get(name);
+  if (!preset) {
+    throw new Error(`Unknown preset: "${name}". Available: ${Array.from(presetRegistry.keys()).join(", ")}`);
+  }
+  return preset;
+}
+
+// src/drivers/query-serializer.ts
+function serializeQuery(query, config) {
+  const params = new URLSearchParams();
+  if (query.filter) {
+    serializeFilters(params, query.filter, config.filterStyle);
+  }
+  if (query.sort && config.sortParam) {
+    const direction = query.sort.direction;
+    if (config.sortParam === "ordering") {
+      params.set(config.sortParam, direction === "desc" ? `-${query.sort.field}` : query.sort.field);
+    } else if (config.sortFormat === "field:direction") {
+      params.set(config.sortParam, `${query.sort.field}:${direction}`);
+    } else {
+      params.set(config.sortParam, `${query.sort.field},${direction}`);
+    }
+  }
+  if (query.page !== void 0) {
+    const pageOffset = config.pageOffset ?? 0;
+    params.set(config.pageParam, String(query.page + pageOffset));
+  }
+  if (query.size !== void 0) {
+    params.set(config.sizeParam, String(query.size));
+  }
+  return params;
+}
+function serializeFilters(params, filter, style) {
+  for (const [key, value] of Object.entries(filter)) {
+    if (value === void 0) continue;
+    const serialized = typeof value === "object" && !Array.isArray(value) ? JSON.stringify(value) : String(value);
+    switch (style) {
+      case "django":
+        params.set(key, serialized);
+        break;
+      case "dot":
+        params.set(key.replace(/__/g, "."), serialized);
+        break;
+      case "bracket": {
+        const bracketKey = key.replace(/__/g, "_");
+        params.set(`filter[${bracketKey}]`, serialized);
+        break;
+      }
+      case "nestjs": {
+        const parts = key.split("__");
+        if (parts.length === 2) {
+          params.set(`filter.${parts[0]}.$${parts[1]}`, serialized);
+        } else {
+          params.set(`filter.${key}`, serialized);
+        }
+        break;
+      }
+    }
+  }
+}
+
+// src/drivers/http.ts
+var HttpDriver = class {
+  baseUrl;
+  preset;
+  timeout;
+  maxRetries;
+  baseDelay;
+  defaultHeaders;
+  endpoints = /* @__PURE__ */ new Map();
+  authProvider = null;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.preset = typeof config.preset === "string" ? getPreset(config.preset ?? "default") : config.preset ?? getPreset("default");
+    this.timeout = config.timeout ?? 3e4;
+    this.maxRetries = config.retry?.maxRetries ?? 3;
+    this.baseDelay = config.retry?.baseDelay ?? 300;
+    this.defaultHeaders = config.headers ?? {};
+  }
+  setAuthProvider(provider) {
+    this.authProvider = provider;
+  }
+  registerEndpoint(resource, endpoint) {
+    this.endpoints.set(resource, endpoint);
+  }
+  getEndpoint(resource) {
+    return this.endpoints.get(resource) ?? `/${resource}`;
+  }
+  buildUrl(resource, id) {
+    const endpoint = this.getEndpoint(resource);
+    const base = `${this.baseUrl}${endpoint}`;
+    return id ? `${base}/${id}` : base;
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.defaultHeaders
+    };
+    const auth = this.authProvider?.();
+    if (auth?.token) {
+      headers["Authorization"] = this.preset.auth.headerFormat.replace("{token}", auth.token);
+    }
+    return headers;
+  }
+  async request(url, options = {}, retryCount = 0) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: { ...this.buildHeaders(), ...options.headers ?? {} },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!response.ok) {
+        if (response.status >= 500 && retryCount < this.maxRetries) {
+          const delay = this.baseDelay * Math.pow(2, retryCount);
+          await new Promise((r) => setTimeout(r, delay));
+          return this.request(url, options, retryCount + 1);
+        }
+        const body = await response.json().catch(() => ({}));
+        this.throwMappedError(response.status, body);
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return response.json();
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof FauxbaseError) throw err;
+      if (err.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${this.timeout}ms`);
+      }
+      throw new NetworkError(err.message ?? "Network request failed");
+    }
+  }
+  throwMappedError(status, body) {
+    const parsed = this.preset.response.error(body);
+    switch (true) {
+      case (status === 400 || status === 422):
+        throw new ValidationError(parsed.error, parsed.details);
+      case (status === 401 || status === 403):
+        throw new ForbiddenError(parsed.error);
+      case status === 404:
+        throw new NotFoundError(parsed.error);
+      case status === 409:
+        throw new ConflictError(parsed.error);
+      default:
+        throw new HttpError(parsed.error, status, parsed.details);
+    }
+  }
+  async list(resource, query) {
+    const url = this.buildUrl(resource);
+    const params = serializeQuery(query, this.preset.query);
+    const queryString = params.toString();
+    const fullUrl = queryString ? `${url}?${queryString}` : url;
+    const raw = await this.request(fullUrl);
+    const parsed = this.preset.response.list(raw);
+    return {
+      items: parsed.items,
+      meta: {
+        page: parsed.meta[this.preset.meta.page] ?? parsed.meta.page ?? query.page ?? 1,
+        size: parsed.meta[this.preset.meta.size] ?? parsed.meta.size ?? query.size ?? 20,
+        totalItems: parsed.meta[this.preset.meta.totalItems] ?? parsed.meta.totalItems ?? 0,
+        totalPages: parsed.meta[this.preset.meta.totalPages] ?? parsed.meta.totalPages ?? 0
+      }
+    };
+  }
+  async get(resource, id) {
+    const url = this.buildUrl(resource, id);
+    const raw = await this.request(url);
+    return this.preset.response.single(raw);
+  }
+  async create(resource, data) {
+    const url = this.buildUrl(resource);
+    const raw = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return this.preset.response.single(raw);
+  }
+  async update(resource, id, data) {
+    const url = this.buildUrl(resource, id);
+    const raw = await this.request(url, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return this.preset.response.single(raw);
+  }
+  async delete(resource, id) {
+    const url = this.buildUrl(resource, id);
+    const raw = await this.request(url, {
+      method: "DELETE"
+    });
+    return this.preset.response.single(raw);
+  }
+  async count(resource, filter) {
+    const url = `${this.buildUrl(resource)}/count`;
+    const params = filter ? serializeQuery({ filter }, this.preset.query) : new URLSearchParams();
+    const queryString = params.toString();
+    const fullUrl = queryString ? `${url}?${queryString}` : url;
+    const raw = await this.request(fullUrl);
+    return raw.count ?? raw.data?.count ?? 0;
+  }
+  async bulkCreate(resource, data) {
+    const url = `${this.buildUrl(resource)}/bulk`;
+    const raw = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    const parsed = this.preset.response.single(raw);
+    return { data: Array.isArray(parsed.data) ? parsed.data : [parsed.data] };
+  }
+  async bulkUpdate(resource, updates) {
+    const url = `${this.buildUrl(resource)}/bulk`;
+    const raw = await this.request(url, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+    const parsed = this.preset.response.single(raw);
+    return { data: Array.isArray(parsed.data) ? parsed.data : [parsed.data] };
+  }
+  async bulkDelete(resource, ids) {
+    const url = `${this.buildUrl(resource)}/bulk`;
+    const raw = await this.request(url, {
+      method: "DELETE",
+      body: JSON.stringify({ ids })
+    });
+    return { data: { count: raw.count ?? raw.data?.count ?? ids.length } };
+  }
+  // Seed methods are no-ops for HTTP — backend owns data
+  seed() {
+  }
+  getSeedVersion() {
+    return null;
+  }
+  setSeedVersion() {
+  }
+  clear() {
+  }
+};
+
+// src/events/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  anyListeners = /* @__PURE__ */ new Set();
+  on(resource, handler) {
+    if (!this.listeners.has(resource)) {
+      this.listeners.set(resource, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(resource).add(handler);
+    return () => {
+      this.listeners.get(resource)?.delete(handler);
+    };
+  }
+  onAny(handler) {
+    this.anyListeners.add(handler);
+    return () => {
+      this.anyListeners.delete(handler);
+    };
+  }
+  emit(event) {
+    const resourceListeners = this.listeners.get(event.resource);
+    if (resourceListeners) {
+      for (const handler of resourceListeners) {
+        handler(event);
+      }
+    }
+    for (const handler of this.anyListeners) {
+      handler(event);
+    }
+  }
+  destroy() {
+    this.listeners.clear();
+    this.anyListeners.clear();
+  }
+};
+
+// src/events/sse-source.ts
+var SSESource = class {
+  constructor(config, eventBus) {
+    this.config = config;
+    this.eventBus = eventBus;
+  }
+  eventSource = null;
+  connect() {
+    this.eventSource = new EventSource(this.config.url, {
+      withCredentials: this.config.withCredentials
+    });
+    for (const [eventType, resource] of Object.entries(this.config.eventMap)) {
+      this.eventSource.addEventListener(eventType, (e) => {
+        const parsed = this.parseEvent(e, resource);
+        if (parsed) {
+          this.eventBus.emit(parsed);
+        }
+      });
+    }
+  }
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+  parseEvent(e, resource) {
+    try {
+      const raw = JSON.parse(e.data);
+      return {
+        action: raw.action,
+        resource,
+        data: raw.data,
+        id: raw.id,
+        ids: raw.ids,
+        timestamp: raw.timestamp ?? Date.now(),
+        source: "remote"
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/events/stomp-source.ts
+var STOMPSource = class {
+  constructor(config, eventBus) {
+    this.config = config;
+    this.eventBus = eventBus;
+  }
+  client = null;
+  connect() {
+    this.connectAsync();
+  }
+  async connectAsync() {
+    let StompJs;
+    try {
+      const moduleName = "@stomp/stompjs";
+      StompJs = await Function("m", "return import(m)")(moduleName);
+    } catch {
+      throw new Error(
+        "STOMP source requires @stomp/stompjs. Install it: npm install @stomp/stompjs"
+      );
+    }
+    this.client = new StompJs.Client({
+      brokerURL: this.config.brokerUrl,
+      connectHeaders: this.config.connectHeaders,
+      onConnect: () => {
+        for (const [destination, resource] of Object.entries(this.config.subscriptions)) {
+          this.client.subscribe(destination, (message) => {
+            const parsed = this.parseMessage(message, resource);
+            if (parsed) {
+              this.eventBus.emit(parsed);
+            }
+          });
+        }
+      }
+    });
+    this.client.activate();
+  }
+  disconnect() {
+    if (this.client) {
+      this.client.deactivate();
+      this.client = null;
+    }
+  }
+  parseMessage(message, resource) {
+    try {
+      const raw = JSON.parse(message.body);
+      return {
+        action: raw.action,
+        resource,
+        data: raw.data,
+        id: raw.id,
+        ids: raw.ids,
+        timestamp: raw.timestamp ?? Date.now(),
+        source: "remote"
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
 // src/seed.ts
 function seed(entityClass, data) {
   const entityName = entityClass.name.toLowerCase();
@@ -553,19 +1555,130 @@ function simpleHash(str) {
 // src/client.ts
 function createClient(config) {
   const driverConfig = config.driver ?? { type: "local" };
-  const driver = createDriver(driverConfig);
+  const defaultDriver = createDriver(driverConfig);
   const client = {};
+  const overrideDrivers = /* @__PURE__ */ new Map();
+  if (config.overrides) {
+    for (const [name, override] of Object.entries(config.overrides)) {
+      overrideDrivers.set(name, createDriver(override.driver));
+    }
+  }
   for (const [name, ServiceClass] of Object.entries(config.services)) {
     const instance = new ServiceClass();
+    const driver = overrideDrivers.get(name) ?? defaultDriver;
     instance._init(driver, name);
     if (driver instanceof LocalDriver) {
       driver.registerEntity(name, instance.entity);
     }
+    if (driver instanceof HttpDriver) {
+      driver.registerEndpoint(name, instance.endpoint);
+    }
     client[name] = instance;
   }
-  if (config.seeds && driver instanceof LocalDriver) {
-    applySeedsIfNeeded(driver, config.seeds);
+  if (config.auth) {
+    const AuthClass = config.auth;
+    const authInstance = new AuthClass();
+    const resourceName = authInstance.entity.name.toLowerCase();
+    if (defaultDriver instanceof LocalDriver) {
+      authInstance._init(defaultDriver, resourceName);
+      defaultDriver.registerEntity(resourceName, authInstance.entity);
+      const storage = defaultDriver.getStorageBackend();
+      authInstance._initAuth(
+        () => {
+          const raw = storage.getMeta("_authState");
+          return raw ? JSON.parse(raw) : null;
+        },
+        (state) => {
+          if (state) {
+            storage.setMeta("_authState", JSON.stringify(state));
+          } else {
+            storage.setMeta("_authState", "");
+          }
+        }
+      );
+      defaultDriver.setAuthProvider(() => authInstance.getAuthContext());
+    } else if (defaultDriver instanceof HttpDriver) {
+      authInstance._init(defaultDriver, resourceName);
+      defaultDriver.registerEndpoint(resourceName, authInstance.endpoint);
+      let memoryAuthState = null;
+      authInstance._initAuth(
+        () => memoryAuthState,
+        (state) => {
+          memoryAuthState = state;
+        }
+      );
+      authInstance._setHttpMode(defaultDriver);
+      defaultDriver.setAuthProvider(() => {
+        const token = authInstance.token;
+        return token ? { token } : null;
+      });
+    }
+    client.auth = authInstance;
+    for (const driver of overrideDrivers.values()) {
+      if (driver instanceof HttpDriver) {
+        driver.setAuthProvider(() => {
+          const token = client.auth?.token;
+          return token ? { token } : null;
+        });
+      }
+    }
   }
+  for (const key of Object.keys(client)) {
+    const svc = client[key];
+    if (svc && typeof svc._setClient === "function") {
+      svc._setClient(client);
+    }
+  }
+  let eventSource = null;
+  if (config.events) {
+    const eventBus = new EventBus();
+    client._eventBus = eventBus;
+    for (const [name, ServiceClass] of Object.entries(config.services)) {
+      const svc = client[name];
+      svc._eventBus = eventBus;
+    }
+    const eventsConfig = config.events === true ? {} : config.events;
+    if (eventsConfig.handlers) {
+      for (const [resource, handler] of Object.entries(eventsConfig.handlers)) {
+        eventBus.on(resource, handler);
+      }
+    }
+    if (eventsConfig.source) {
+      if (eventsConfig.source.type === "sse") {
+        eventSource = new SSESource(eventsConfig.source, eventBus);
+      } else if (eventsConfig.source.type === "stomp") {
+        eventSource = new STOMPSource(eventsConfig.source, eventBus);
+      }
+      eventSource?.connect();
+    }
+    client.disconnect = () => {
+      eventSource?.disconnect();
+      eventBus.destroy();
+    };
+  }
+  let readyPromise;
+  if (defaultDriver instanceof LocalDriver) {
+    if (defaultDriver.isReady) {
+      if (config.seeds) {
+        applySeedsIfNeeded(defaultDriver, config.seeds);
+      }
+      readyPromise = Promise.resolve();
+    } else {
+      readyPromise = defaultDriver.ready.then(() => {
+        if (config.seeds) {
+          applySeedsIfNeeded(defaultDriver, config.seeds);
+        }
+      });
+    }
+  } else {
+    readyPromise = Promise.resolve();
+  }
+  Object.defineProperty(client, "ready", {
+    value: readyPromise,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
   return client;
 }
 function createDriver(config) {
@@ -573,7 +1686,7 @@ function createDriver(config) {
     case "local":
       return new LocalDriver(config);
     case "http":
-      throw new Error("HttpDriver not implemented yet");
+      return new HttpDriver(config);
     default:
       throw new Error(`Unknown driver type: ${config.type}`);
   }
@@ -588,12 +1701,19 @@ function applySeedsIfNeeded(driver, seeds) {
   driver.setSeedVersion(newVersion);
 }
 
+exports.AuthService = AuthService;
 exports.ConflictError = ConflictError;
 exports.Entity = Entity;
+exports.EventBus = EventBus;
 exports.FauxbaseError = FauxbaseError;
 exports.ForbiddenError = ForbiddenError;
+exports.HttpDriver = HttpDriver;
+exports.HttpError = HttpError;
+exports.LocalDriver = LocalDriver;
+exports.NetworkError = NetworkError;
 exports.NotFoundError = NotFoundError;
 exports.Service = Service;
+exports.TimeoutError = TimeoutError;
 exports.ValidationError = ValidationError;
 exports.afterCreate = afterCreate;
 exports.afterUpdate = afterUpdate;
@@ -601,8 +1721,16 @@ exports.beforeCreate = beforeCreate;
 exports.beforeUpdate = beforeUpdate;
 exports.computed = computed;
 exports.createClient = createClient;
+exports.defaultPreset = defaultPreset;
+exports.definePreset = definePreset;
+exports.djangoPreset = djangoPreset;
+exports.expressPreset = expressPreset;
 exports.field = field;
+exports.getPreset = getPreset;
+exports.laravelPreset = laravelPreset;
+exports.nestjsPreset = nestjsPreset;
 exports.relation = relation;
 exports.seed = seed;
+exports.springBootPreset = springBootPreset;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map