@rebasepro/server-core 0.3.0 → 0.4.0

package/dist/index.umd.js

@@ -133,6 +133,9 @@
       this.value = value;
     }
   }
+  function isPostgresCollection(collection) {
+    return !collection.driver || collection.driver === "postgres";
+  }
   function isSQLAdmin(admin) {
     return !!admin && typeof admin.executeSql === "function";
   }
@@ -2534,30 +2537,6 @@
       };
     }
   }
-  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;
@@ -2565,23 +2544,30 @@
     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;
     }
     /**
@@ -2904,68 +2890,184 @@
         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 i2 = 0; i2 < str.length; i2++) {
+      const char = str[i2];
+      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,
@@ -2974,20 +3076,24 @@
         }
       }
     }
-    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);
@@ -2997,17 +3103,19 @@
       } 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.");
         }
@@ -3102,9 +3210,9 @@
       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({
@@ -3113,9 +3221,9 @@
       });
       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");
@@ -3158,7 +3266,7 @@
       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);
@@ -3327,12 +3435,13 @@
         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
@@ -3345,15 +3454,16 @@
           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)),
@@ -13022,11 +13132,6 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
       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,
@@ -13385,90 +13490,6 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
         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) {
@@ -13512,8 +13533,7 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
         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");
@@ -13543,8 +13563,7 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
         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");
@@ -13558,7 +13577,6 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
         };
       },
       userManagement: createUserManagementFromRepo(authRepository, resolvedOps, authHooks),
-      roleManagement: createRoleManagementFromRepo(authRepository),
       createAuthRoutes() {
         return createAuthRoutes({
           authRepo: authRepository,
@@ -13674,43 +13692,13 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
         }
       },
       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,
@@ -13723,15 +13711,6 @@ Si tienes alguna pregunta, no dudes en contactarnos respondiendo a este correo.
       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 = {
@@ -24914,7 +24893,6 @@ ${credentialScope}
       verifyRequest: options2.verifyRequest,
       verifyToken: resolvedVerifyToken,
       userManagement: options2.userManagement,
-      roleManagement: options2.roleManagement,
       getCapabilities() {
         return defaultCapabilities;
       }
@@ -26259,15 +26237,33 @@ ${credentialScope}
     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 = [];
@@ -26283,10 +26279,22 @@ ${credentialScope}
     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("&") : "";
@@ -26961,33 +26969,6 @@ ${credentialScope}
         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"
@@ -27000,11 +26981,6 @@ ${credentialScope}
       createUser,
       updateUser,
       deleteUser,
-      listRoles,
-      getRole,
-      createRole,
-      updateRole,
-      deleteRole,
       bootstrap
     };
   }
@@ -27070,11 +27046,18 @@ ${credentialScope}
         };
       },
       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 = {
@@ -27114,8 +27097,12 @@ ${credentialScope}
         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);
@@ -38393,13 +38380,35 @@ ${credentialScope}
     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,
@@ -38549,6 +38558,14 @@ ${credentialScope}
         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 || [];
@@ -38617,8 +38634,7 @@ ${credentialScope}
           id: authAdapter.id
         });
         authConfigResult = {
-          userService: authAdapter.userManagement ?? {},
-          roleService: authAdapter.roleManagement ?? {}
+          userService: authAdapter.userManagement ?? {}
         };
       } else {
         const safeAuthConfig = config.auth;
@@ -38963,6 +38979,26 @@ ${credentialScope}
       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");