@rebasepro/server-core 0.3.0 → 0.4.0

package/dist/index.es.js

@@ -146,6 +146,9 @@ class Vector {
     this.value = value;
   }
 }
+function isPostgresCollection(collection) {
+  return !collection.driver || collection.driver === "postgres";
+}
 function isSQLAdmin(admin) {
   return !!admin && typeof admin.executeSql === "function";
 }
@@ -2547,30 +2550,6 @@ class CollectionRegistry {
     };
   }
 }
-function mapOperator$1(op) {
-  switch (op) {
-    case "==":
-      return "eq";
-    case "!=":
-      return "neq";
-    case ">":
-      return "gt";
-    case ">=":
-      return "gte";
-    case "<":
-      return "lt";
-    case "<=":
-      return "lte";
-    case "array-contains":
-      return "cs";
-    case "array-contains-any":
-      return "csa";
-    case "not-in":
-      return "nin";
-    default:
-      return op;
-  }
-}
 class QueryBuilder {
   constructor(collection) {
     this.collection = collection;
@@ -2578,23 +2557,30 @@ class QueryBuilder {
   params = {
     where: {}
   };
-  /**
-   * Add a filter condition to your query.
-   * @example
-   * client.collection('users').where('age', '>=', 18).find()
-   */
-  where(column, operator, value) {
+  where(columnOrCondition, operator, value) {
+    if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+      this.params.logical = columnOrCondition;
+      return this;
+    }
     if (!this.params.where) {
       this.params.where = {};
     }
-    const mappedOp = mapOperator$1(operator);
-    let formattedValue = value;
-    if (Array.isArray(value) && ["in", "nin", "cs", "csa"].includes(mappedOp)) {
-      formattedValue = `(${value.join(",")})`;
-    } else if (value === null) {
-      formattedValue = "null";
+    const column = columnOrCondition;
+    const condition = [operator, value];
+    const existing = this.params.where[column];
+    if (existing === void 0) {
+      this.params.where[column] = condition;
+    } else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) {
+      this.params.where[column].push(condition);
+    } else {
+      let firstCondition;
+      if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") {
+        firstCondition = existing;
+      } else {
+        firstCondition = ["==", existing];
+      }
+      this.params.where[column] = [firstCondition, condition];
     }
-    this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
     return this;
   }
   /**
@@ -2917,68 +2903,184 @@ function mapOperator(op) {
       return null;
   }
 }
+function getLastValue(val) {
+  if (Array.isArray(val)) {
+    return val[val.length - 1];
+  }
+  return val;
+}
+function parseLogicalString(str) {
+  str = str.trim();
+  if (str.startsWith("or(") && str.endsWith(")")) {
+    const inner = str.slice(3, -1);
+    return {
+      type: "or",
+      conditions: parseLogicalList(inner)
+    };
+  }
+  if (str.startsWith("and(") && str.endsWith(")")) {
+    const inner = str.slice(4, -1);
+    return {
+      type: "and",
+      conditions: parseLogicalList(inner)
+    };
+  }
+  const firstDot = str.indexOf(".");
+  if (firstDot === -1) {
+    return {
+      column: str,
+      operator: "==",
+      value: true
+    };
+  }
+  const field = str.substring(0, firstDot);
+  const rest = str.substring(firstDot + 1);
+  const secondDot = rest.indexOf(".");
+  let op = "eq";
+  let valStr = rest;
+  if (secondDot !== -1) {
+    op = rest.substring(0, secondDot);
+    valStr = rest.substring(secondDot + 1);
+  } else {
+    op = "eq";
+    valStr = rest;
+  }
+  const rebaseOp = mapOperator(op) || "==";
+  let parsedVal = valStr;
+  if (valStr === "true") parsedVal = true;
+  else if (valStr === "false") parsedVal = false;
+  else if (valStr === "null") parsedVal = null;
+  else if (!isNaN(Number(valStr)) && valStr.trim() !== "") parsedVal = Number(valStr);
+  else if (valStr.startsWith("(")) {
+    const arrayContent = valStr.endsWith(")") ? valStr.slice(1, -1) : valStr.slice(1);
+    parsedVal = arrayContent.split(",").map((v) => {
+      const trimmed = v.trim();
+      if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+      if (trimmed === "true") return true;
+      if (trimmed === "false") return false;
+      if (trimmed === "null") return null;
+      return trimmed;
+    });
+  }
+  return {
+    column: field,
+    operator: rebaseOp,
+    value: parsedVal
+  };
+}
+function parseLogicalList(str) {
+  const list = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "(") depth++;
+    if (char === ")") depth--;
+    if (char === "," && depth === 0) {
+      list.push(parseLogicalString(current));
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    list.push(parseLogicalString(current));
+  }
+  return list;
+}
 function parseQueryOptions(query) {
   const options2 = {};
-  if (query.limit) options2.limit = parseInt(String(query.limit));
-  if (query.offset) options2.offset = parseInt(String(query.offset));
-  if (query.page) {
-    const page = parseInt(String(query.page));
+  const limitVal = getLastValue(query.limit);
+  if (limitVal) options2.limit = parseInt(String(limitVal));
+  const offsetVal = getLastValue(query.offset);
+  if (offsetVal) options2.offset = parseInt(String(offsetVal));
+  const pageVal = getLastValue(query.page);
+  if (pageVal) {
+    const page = parseInt(String(pageVal));
     const limit = options2.limit || 20;
     options2.offset = (page - 1) * limit;
   }
   options2.where = {};
-  const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "include", "fields", "searchString", "vector_search", "vector", "vector_distance", "vector_threshold"];
+  const orVal = getLastValue(query.or);
+  const andVal = getLastValue(query.and);
+  if (orVal) {
+    let orStr = String(orVal).trim();
+    if (orStr.startsWith("(") && orStr.endsWith(")")) {
+      orStr = orStr.slice(1, -1);
+    }
+    options2.logical = {
+      type: "or",
+      conditions: parseLogicalList(orStr)
+    };
+  } else if (andVal) {
+    let andStr = String(andVal).trim();
+    if (andStr.startsWith("(") && andStr.endsWith(")")) {
+      andStr = andStr.slice(1, -1);
+    }
+    options2.logical = {
+      type: "and",
+      conditions: parseLogicalList(andStr)
+    };
+  }
+  const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "include", "fields", "searchString", "vector_search", "vector", "vector_distance", "vector_threshold", "or", "and"];
   for (const [key, rawValue] of Object.entries(query)) {
     if (reservedQueryKeys.includes(key)) continue;
-    const value = Array.isArray(rawValue) ? rawValue[rawValue.length - 1] : rawValue;
-    if (typeof value === "string") {
-      const parts = value.split(".");
-      if (parts.length >= 2) {
-        const op = parts[0];
-        const val = parts.slice(1).join(".");
-        const rebaseOp = mapOperator(op);
-        if (rebaseOp) {
-          let parsedVal = val;
-          if (val === "true") parsedVal = true;
-          else if (val === "false") parsedVal = false;
-          else if (val === "null") parsedVal = null;
-          else if (!isNaN(Number(val)) && val.trim() !== "") parsedVal = Number(val);
-          else if (val.startsWith("(")) {
-            const arrayContent = val.endsWith(")") ? val.slice(1, -1) : val.slice(1);
-            parsedVal = arrayContent.split(",").map((v) => {
-              const trimmed = v.trim();
-              if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
-              if (trimmed === "true") return true;
-              if (trimmed === "false") return false;
-              if (trimmed === "null") return null;
-              return trimmed;
-            });
+    const rawValues = Array.isArray(rawValue) ? rawValue : [rawValue];
+    const conditions = [];
+    for (const value of rawValues) {
+      if (typeof value === "string") {
+        const parts = value.split(".");
+        if (parts.length >= 2) {
+          const op = parts[0];
+          const val = parts.slice(1).join(".");
+          const rebaseOp = mapOperator(op);
+          if (rebaseOp) {
+            let parsedVal = val;
+            if (val === "true") parsedVal = true;
+            else if (val === "false") parsedVal = false;
+            else if (val === "null") parsedVal = null;
+            else if (!isNaN(Number(val)) && val.trim() !== "") parsedVal = Number(val);
+            else if (val.startsWith("(")) {
+              const arrayContent = val.endsWith(")") ? val.slice(1, -1) : val.slice(1);
+              parsedVal = arrayContent.split(",").map((v) => {
+                const trimmed = v.trim();
+                if (!isNaN(Number(trimmed)) && trimmed !== "") return Number(trimmed);
+                if (trimmed === "true") return true;
+                if (trimmed === "false") return false;
+                if (trimmed === "null") return null;
+                return trimmed;
+              });
+            }
+            conditions.push([rebaseOp, parsedVal]);
+          } else {
+            let parsedVal = value;
+            if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+            conditions.push(["==", parsedVal]);
           }
-          options2.where[key] = [rebaseOp, parsedVal];
         } else {
           let parsedVal = value;
-          if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
-          options2.where[key] = ["==", parsedVal];
+          if (value === "true") parsedVal = true;
+          else if (value === "false") parsedVal = false;
+          else if (value === "null") parsedVal = null;
+          else if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+          conditions.push(["==", parsedVal]);
         }
-      } else {
-        let parsedVal = value;
-        if (value === "true") parsedVal = true;
-        else if (value === "false") parsedVal = false;
-        else if (value === "null") parsedVal = null;
-        else if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
-        options2.where[key] = ["==", parsedVal];
       }
     }
+    if (conditions.length > 0) {
+      options2.where[key] = conditions.length === 1 ? conditions[0] : conditions;
+    }
   }
   if (Object.keys(options2.where).length === 0) {
     delete options2.where;
   }
-  if (query.orderBy) {
+  const orderByVal = getLastValue(query.orderBy);
+  if (orderByVal) {
     try {
-      options2.orderBy = typeof query.orderBy === "string" ? JSON.parse(query.orderBy) : query.orderBy;
+      options2.orderBy = typeof orderByVal === "string" ? JSON.parse(orderByVal) : orderByVal;
     } catch {
-      if (typeof query.orderBy === "string") {
-        const [field, direction] = query.orderBy.split(":");
+      if (typeof orderByVal === "string") {
+        const [field, direction] = orderByVal.split(":");
         const dir = direction === "desc" ? "desc" : "asc";
         options2.orderBy = [{
           field,
@@ -2987,20 +3089,24 @@ function parseQueryOptions(query) {
       }
     }
   }
-  if (query.include) {
-    const includeStr = String(query.include).trim();
+  const includeVal = getLastValue(query.include);
+  if (includeVal) {
+    const includeStr = String(includeVal).trim();
     if (includeStr === "*") {
       options2.include = ["*"];
     } else {
       options2.include = includeStr.split(",").map((s2) => s2.trim()).filter(Boolean);
     }
   }
-  if (query.fields) {
-    const fieldsStr = String(query.fields).trim();
+  const fieldsVal = getLastValue(query.fields);
+  if (fieldsVal) {
+    const fieldsStr = String(fieldsVal).trim();
     options2.fields = fieldsStr.split(",").map((s2) => s2.trim()).filter(Boolean);
   }
-  if (query.vector_search && query.vector) {
-    const vectorStr = String(query.vector);
+  const vectorSearchVal = getLastValue(query.vector_search);
+  const vectorVal = getLastValue(query.vector);
+  if (vectorSearchVal && vectorVal) {
+    const vectorStr = String(vectorVal);
     let queryVector;
     try {
       queryVector = JSON.parse(vectorStr);
@@ -3010,17 +3116,19 @@ function parseQueryOptions(query) {
     } catch {
       throw new Error("Invalid vector format. Expected JSON array of numbers, e.g. [0.1,0.2,0.3]");
     }
-    const distanceParam = query.vector_distance ? String(query.vector_distance) : "cosine";
+    const distanceParamVal = getLastValue(query.vector_distance);
+    const distanceParam = distanceParamVal ? String(distanceParamVal) : "cosine";
     if (distanceParam !== "cosine" && distanceParam !== "l2" && distanceParam !== "inner_product") {
       throw new Error(`Invalid vector_distance: ${distanceParam}. Expected: cosine, l2, or inner_product`);
     }
     const vectorSearch = {
-      property: String(query.vector_search),
+      property: String(vectorSearchVal),
       vector: queryVector,
       distance: distanceParam
     };
-    if (query.vector_threshold) {
-      const threshold = parseFloat(String(query.vector_threshold));
+    const thresholdVal = getLastValue(query.vector_threshold);
+    if (thresholdVal) {
+      const threshold = parseFloat(String(thresholdVal));
       if (isNaN(threshold)) {
         throw new Error("Invalid vector_threshold. Expected a number.");
       }
@@ -3115,9 +3223,9 @@ class RestApiGenerator {
     const resolvedCollection = collection;
     this.router.get(`${basePath}/count`, async (c) => {
       this.enforceApiKeyPermission(c, collection.slug);
-      const queryDict = c.req.query();
+      const queryDict = c.req.queries();
       const queryOptions = parseQueryOptions(queryDict);
-      const searchString = queryDict.searchString;
+      const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : void 0;
       const driver = c.get("driver") || this.driver;
       const total = await this.countRawEntities(driver, resolvedCollection, queryOptions, searchString);
       return c.json({
@@ -3126,9 +3234,9 @@ class RestApiGenerator {
     });
     this.router.get(basePath, async (c) => {
       this.enforceApiKeyPermission(c, collection.slug);
-      const queryDict = c.req.query();
+      const queryDict = c.req.queries();
       const queryOptions = parseQueryOptions(queryDict);
-      const searchString = queryDict.searchString;
+      const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : void 0;
       const driver = c.get("driver") || this.driver;
       const fetchService = this.getFetchService(driver);
       const hookCtx = this.buildHookContext(c, "GET");
@@ -3171,7 +3279,7 @@ class RestApiGenerator {
     this.router.get(`${basePath}/:id`, async (c) => {
       this.enforceApiKeyPermission(c, collection.slug);
       const id = c.req.param("id");
-      const queryDict = c.req.query();
+      const queryDict = c.req.queries();
       const queryOptions = parseQueryOptions(queryDict);
       const driver = c.get("driver") || this.driver;
       const fetchService = this.getFetchService(driver);
@@ -3340,12 +3448,13 @@ class RestApiGenerator {
       const driver = c.get("driver") || this.driver;
       this.enforceApiKeyPermission(c, c.req.param("parent"));
       if (parsed.entityId === "count") {
-        const queryDict = c.req.query();
+        const queryDict = c.req.queries();
         const queryOptions = parseQueryOptions(queryDict);
+        const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : void 0;
         const total = driver.countEntities ? await driver.countEntities({
           path: parsed.collectionPath,
           filter: queryOptions.where,
-          searchString: queryDict.searchString
+          searchString
         }) : 0;
         return c.json({
           count: total
@@ -3358,15 +3467,16 @@ class RestApiGenerator {
         if (!entity) throw ApiError.notFound("Entity not found");
         return c.json(this.flattenEntity(entity));
       } else {
-        const queryDict = c.req.query();
+        const queryDict = c.req.queries();
         const queryOptions = parseQueryOptions(queryDict);
+        const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : void 0;
         const entities = await driver.fetchCollection({
           path: parsed.collectionPath,
           filter: queryOptions.where,
           limit: queryOptions.limit,
           orderBy: queryOptions.orderBy?.[0]?.field,
           order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
-          searchString: queryDict.searchString
+          searchString
         });
         return c.json({
           data: entities.map((e) => this.flattenEntity(e)),
@@ -13035,11 +13145,6 @@ function createAdminRoutes(config) {
     const results = await Promise.all(users.map((u) => applyUserAfterRead(u, ctx)));
     return results.filter((u) => u !== null);
   }
-  async function applyRoleAfterReadBatch(roles, ctx) {
-    if (!hooks?.roles?.afterRead) return roles;
-    const results = await Promise.all(roles.map((r) => hooks.roles.afterRead(r, ctx)));
-    return results.filter((r) => r !== null);
-  }
   function toAdminUser(u, roles) {
     return {
       uid: u.id,
@@ -13398,90 +13503,6 @@ function createAdminRoutes(config) {
       success: true
     });
   });
-  router.get("/roles", requireAdmin, async (c) => {
-    const roles = await authRepo.listRoles();
-    const hookCtx = buildHookContext(c, "GET");
-    let adminRoles = roles.map((r) => ({
-      id: r.id,
-      name: r.name,
-      isAdmin: r.isAdmin,
-      defaultPermissions: r.defaultPermissions
-    }));
-    adminRoles = await applyRoleAfterReadBatch(adminRoles, hookCtx);
-    return c.json({
-      roles: adminRoles
-    });
-  });
-  router.get("/roles/:roleId", requireAdmin, async (c) => {
-    const roleId = c.req.param("roleId");
-    const role = await authRepo.getRoleById(roleId);
-    if (!role) {
-      throw ApiError.notFound("Role not found");
-    }
-    return c.json({
-      role
-    });
-  });
-  router.post("/roles", requireAdmin, async (c) => {
-    const body = await c.req.json();
-    const {
-      id,
-      name: name2,
-      isAdmin,
-      defaultPermissions
-    } = body;
-    if (!id || !name2) {
-      throw ApiError.badRequest("Role ID and name are required", "INVALID_INPUT");
-    }
-    const existing = await authRepo.getRoleById(id);
-    if (existing) {
-      throw ApiError.conflict("Role already exists", "ROLE_EXISTS");
-    }
-    const role = await authRepo.createRole({
-      id,
-      name: name2,
-      isAdmin: isAdmin ?? false,
-      defaultPermissions: defaultPermissions ?? null
-    });
-    return c.json({
-      role
-    }, 201);
-  });
-  router.put("/roles/:roleId", requireAdmin, async (c) => {
-    const roleId = c.req.param("roleId");
-    const body = await c.req.json();
-    const {
-      name: name2,
-      isAdmin,
-      defaultPermissions
-    } = body;
-    const existing = await authRepo.getRoleById(roleId);
-    if (!existing) {
-      throw ApiError.notFound("Role not found");
-    }
-    const role = await authRepo.updateRole(roleId, {
-      name: name2,
-      isAdmin,
-      defaultPermissions
-    });
-    return c.json({
-      role
-    });
-  });
-  router.delete("/roles/:roleId", requireAdmin, async (c) => {
-    const roleId = c.req.param("roleId");
-    if (["admin", "editor", "viewer"].includes(roleId)) {
-      throw ApiError.badRequest("Cannot delete built-in roles", "BUILTIN_ROLE");
-    }
-    const existing = await authRepo.getRoleById(roleId);
-    if (!existing) {
-      throw ApiError.notFound("Role not found");
-    }
-    await authRepo.deleteRole(roleId);
-    return c.json({
-      success: true
-    });
-  });
   return router;
 }
 function createBuiltinAuthAdapter(config) {
@@ -13525,8 +13546,7 @@ function createBuiltinAuthAdapter(config) {
       const extendedPayload = payload;
       let roles = payload.roles || [];
       try {
-        const userRoles = await authRepository.getUserRoles(payload.userId);
-        roles = userRoles.map((r) => r.id);
+        roles = await authRepository.getUserRoleIds(payload.userId);
       } catch {
       }
       const isAdmin = roles.some((r) => r === "admin" || r === "schema-admin");
@@ -13556,8 +13576,7 @@ function createBuiltinAuthAdapter(config) {
       const extendedPayload = payload;
       let roles = payload.roles || [];
       try {
-        const userRoles = await authRepository.getUserRoles(payload.userId);
-        roles = userRoles.map((r) => r.id);
+        roles = await authRepository.getUserRoleIds(payload.userId);
       } catch {
       }
       const isAdmin = roles.some((r) => r === "admin" || r === "schema-admin");
@@ -13571,7 +13590,6 @@ function createBuiltinAuthAdapter(config) {
       };
     },
     userManagement: createUserManagementFromRepo(authRepository, resolvedOps, authHooks),
-    roleManagement: createRoleManagementFromRepo(authRepository),
     createAuthRoutes() {
       return createAuthRoutes({
         authRepo: authRepository,
@@ -13687,43 +13705,13 @@ function createUserManagementFromRepo(repo, resolvedOps, authHooks) {
       }
     },
     async getUserRoles(userId) {
-      const roles = await repo.getUserRoles(userId);
-      return roles.map(toAuthRoleData);
+      return repo.getUserRoleIds(userId);
     },
     async setUserRoles(userId, roleIds) {
       await repo.setUserRoles(userId, roleIds);
     }
   };
 }
-function createRoleManagementFromRepo(repo) {
-  return {
-    async listRoles() {
-      const roles = await repo.listRoles();
-      return roles.map(toAuthRoleData);
-    },
-    async getRoleById(id) {
-      const role = await repo.getRoleById(id);
-      return role ? toAuthRoleData(role) : null;
-    },
-    async createRole(data) {
-      const role = await repo.createRole({
-        id: data.id,
-        name: data.name,
-        isAdmin: data.isAdmin,
-        defaultPermissions: data.defaultPermissions,
-        collectionPermissions: data.collectionPermissions
-      });
-      return toAuthRoleData(role);
-    },
-    async updateRole(id, data) {
-      const role = await repo.updateRole(id, data);
-      return role ? toAuthRoleData(role) : null;
-    },
-    async deleteRole(id) {
-      await repo.deleteRole(id);
-    }
-  };
-}
 function toAuthUserData(user) {
   return {
     id: user.id,
@@ -13736,15 +13724,6 @@ function toAuthUserData(user) {
     updatedAt: user.updatedAt
   };
 }
-function toAuthRoleData(role) {
-  return {
-    id: role.id,
-    name: role.name,
-    isAdmin: role.isAdmin,
-    defaultPermissions: role.defaultPermissions,
-    collectionPermissions: role.collectionPermissions
-  };
-}
 function configureLogLevel(logLevel) {
   const LOG_LEVEL = logLevel || process.env.LOG_LEVEL || "info";
   const logLevels = {
@@ -24927,7 +24906,6 @@ function createCustomAuthAdapter(options2) {
     verifyRequest: options2.verifyRequest,
     verifyToken: resolvedVerifyToken,
     userManagement: options2.userManagement,
-    roleManagement: options2.roleManagement,
     getCapabilities() {
       return defaultCapabilities;
     }
@@ -26225,15 +26203,33 @@ function normalizeWhereValue(value) {
   if (value === null) return "eq.null";
   if (typeof value === "boolean") return `eq.${value}`;
   if (typeof value === "number") return String(value);
-  if (Array.isArray(value) && value.length === 2) {
-    const [rawOp, val] = value;
-    const op = OP_MAP[rawOp] ?? rawOp;
-    if (val === null) return `${op}.null`;
-    if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
-    return `${op}.${val}`;
+  if (Array.isArray(value)) {
+    const conditions = Array.isArray(value[0]) ? value : [value];
+    const [rawOp, val] = conditions[0] || [];
+    if (rawOp) {
+      const op = OP_MAP[rawOp] ?? rawOp;
+      if (val === null) return `${op}.null`;
+      if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
+      return `${op}.${val}`;
+    }
   }
   return String(value);
 }
+function serializeLogicalCondition(cond2) {
+  if ("type" in cond2) {
+    const sub = cond2.conditions.map(serializeLogicalCondition).join(",");
+    return `${cond2.type}(${sub})`;
+  } else {
+    const op = OP_MAP[cond2.operator] ?? cond2.operator;
+    let formattedValue = cond2.value;
+    if (Array.isArray(cond2.value)) {
+      formattedValue = `(${cond2.value.join(",")})`;
+    } else if (cond2.value === null) {
+      formattedValue = "null";
+    }
+    return `${cond2.column}.${op}.${formattedValue}`;
+  }
+}
 function buildQueryString(params) {
   if (!params) return "";
   const parts = [];
@@ -26249,10 +26245,22 @@ function buildQueryString(params) {
   if (params.include && params.include.length > 0) {
     parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
   }
+  if (params.logical) {
+    const root = params.logical;
+    const serialized = root.conditions.map(serializeLogicalCondition).join(",");
+    parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
+  }
   if (params.where) {
     for (const [field, value] of Object.entries(params.where)) {
-      const normalized2 = normalizeWhereValue(value);
-      parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized2)}`);
+      if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
+        for (const subVal of value) {
+          const normalized2 = normalizeWhereValue(subVal);
+          parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized2)}`);
+        }
+      } else {
+        const normalized2 = normalizeWhereValue(value);
+        parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized2)}`);
+      }
     }
   }
   return parts.length > 0 ? "?" + parts.join("&") : "";
@@ -26927,33 +26935,6 @@ function createAdmin(transport, options2) {
       method: "DELETE"
     });
   }
-  async function listRoles() {
-    return transport.request(adminPath + "/roles", {
-      method: "GET"
-    });
-  }
-  async function getRole(roleId) {
-    return transport.request(adminPath + "/roles/" + encodeURIComponent(roleId), {
-      method: "GET"
-    });
-  }
-  async function createRole(data) {
-    return transport.request(adminPath + "/roles", {
-      method: "POST",
-      body: JSON.stringify(data)
-    });
-  }
-  async function updateRole(roleId, data) {
-    return transport.request(adminPath + "/roles/" + encodeURIComponent(roleId), {
-      method: "PUT",
-      body: JSON.stringify(data)
-    });
-  }
-  async function deleteRole(roleId) {
-    return transport.request(adminPath + "/roles/" + encodeURIComponent(roleId), {
-      method: "DELETE"
-    });
-  }
   async function bootstrap() {
     return transport.request(adminPath + "/bootstrap", {
       method: "POST"
@@ -26966,11 +26947,6 @@ function createAdmin(transport, options2) {
     createUser,
     updateUser,
     deleteUser,
-    listRoles,
-    getRole,
-    createRole,
-    updateRole,
-    deleteRole,
     bootstrap
   };
 }
@@ -27036,11 +27012,18 @@ function createCollectionClient(transport, slug, ws) {
       };
     },
     async findById(id) {
-      const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
-        method: "GET"
-      });
-      if (!raw) return void 0;
-      return rowToEntity(raw, slug);
+      try {
+        const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+          method: "GET"
+        });
+        if (!raw) return void 0;
+        return rowToEntity(raw, slug);
+      } catch (err) {
+        if (err instanceof RebaseApiError && err.status === 404) {
+          return void 0;
+        }
+        throw err;
+      }
     },
     async create(data, id) {
       const body = {
@@ -27080,8 +27063,12 @@ function createCollectionClient(transport, slug, ws) {
       return raw.count ?? 0;
     },
     // Fluent builder instantiation
-    where(column, operator, value) {
-      return new QueryBuilder(client).where(column, operator, value);
+    where(columnOrCondition, operator, value) {
+      const builder = new QueryBuilder(client);
+      if (typeof columnOrCondition === "object") {
+        return builder.where(columnOrCondition);
+      }
+      return builder.where(columnOrCondition, operator, value);
     },
     orderBy(column, ascending) {
       return new QueryBuilder(client).orderBy(column, ascending);
@@ -38359,13 +38346,35 @@ var createTransport = function(transporter, defaults) {
   mailer2 = new Mailer(transporter, options2, defaults);
   return mailer2;
 };
+function getHostname(urlStr) {
+  try {
+    const url = new URL(urlStr.includes("://") ? urlStr : `https://${urlStr}`);
+    return url.hostname;
+  } catch {
+    return void 0;
+  }
+}
 class SMTPEmailService {
   transporter = null;
   config;
   constructor(config) {
     this.config = config;
     if (config.smtp) {
+      let smtpName = config.smtp.name;
+      if (!smtpName) {
+        const urlsToTry = [process.env.FRONTEND_URL, config.resetPasswordUrl, config.verifyEmailUrl];
+        for (const urlStr of urlsToTry) {
+          if (urlStr) {
+            const hostname = getHostname(urlStr);
+            if (hostname) {
+              smtpName = hostname;
+              break;
+            }
+          }
+        }
+      }
       this.transporter = createTransport({
+        name: smtpName,
         host: config.smtp.host,
         port: config.smtp.port,
         secure: config.smtp.secure ?? config.smtp.port === 465,
@@ -38515,6 +38524,14 @@ async function _initializeRebaseBackend(config) {
       dir: config.collectionsDir
     });
   }
+  if (config.defaultSecurityRules?.length) {
+    for (const collection of activeCollections) {
+      if (isPostgresCollection(collection) && (!collection.securityRules || collection.securityRules.length === 0)) {
+        collection.securityRules = config.defaultSecurityRules;
+      }
+    }
+    logger.info("Default security rules applied to collections without explicit rules");
+  }
   const realtimeServices = {};
   const delegates = {};
   let bootstrappers = config.bootstrappers || [];
@@ -38583,8 +38600,7 @@ async function _initializeRebaseBackend(config) {
         id: authAdapter.id
       });
       authConfigResult = {
-        userService: authAdapter.userManagement ?? {},
-        roleService: authAdapter.roleManagement ?? {}
+        userService: authAdapter.userManagement ?? {}
       };
     } else {
       const safeAuthConfig = config.auth;
@@ -38929,6 +38945,26 @@ async function _initializeRebaseBackend(config) {
     logger.info("Email service attached to singleton", {
       configured: emailService.isConfigured()
     });
+    if (emailService.isConfigured() && typeof emailService.verifyConnection === "function") {
+      emailService.verifyConnection().then((success) => {
+        if (!success) {
+          logger.warn("Warning: SMTP connection verification failed. Email delivery may fail.");
+        } else {
+          logger.info("SMTP connection verified successfully.");
+        }
+      }).catch((err) => {
+        logger.warn("Warning: SMTP connection verification failed. Email delivery may fail.", {
+          error: err
+        });
+      });
+    }
+  }
+  const driverAdmin = defaultBootstrapper.getAdmin?.(defaultDriverResult);
+  if (isSQLAdmin(driverAdmin)) {
+    Object.assign(serverClient, {
+      sql: (query, options2) => driverAdmin.executeSql(query, options2)
+    });
+    logger.info("SQL capability attached to singleton");
   }
   _initRebase(serverClient);
   logger.info("Rebase singleton initialized");