@rebasepro/server-core 0.2.5 → 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,166 +2550,6 @@ class CollectionRegistry {
     };
   }
 }
-const defaultUsersCollection = {
-  name: "Users",
-  singularName: "User",
-  slug: "users",
-  table: "users",
-  schema: "rebase",
-  icon: "Users",
-  group: "Settings",
-  openEntityMode: "dialog",
-  disableDefaultActions: ["copy"],
-  sort: ["createdAt", "desc"],
-  properties: {
-    id: {
-      name: "ID",
-      type: "string",
-      isId: "uuid",
-      ui: {
-        readOnly: true
-      }
-    },
-    email: {
-      name: "Email",
-      type: "string",
-      validation: {
-        required: true,
-        unique: true
-      }
-    },
-    displayName: {
-      name: "Name",
-      type: "string",
-      columnName: "display_name",
-      validation: {
-        required: true
-      }
-    },
-    photoURL: {
-      name: "Photo URL",
-      type: "string",
-      columnName: "photo_url",
-      url: "image"
-    },
-    roles: {
-      name: "Roles",
-      type: "array",
-      columnType: "text[]",
-      of: {
-        name: "Role",
-        type: "string",
-        enum: {
-          admin: "Admin",
-          editor: "Editor",
-          viewer: "Viewer"
-        }
-      }
-    },
-    passwordHash: {
-      name: "Password Hash",
-      type: "string",
-      columnName: "password_hash",
-      ui: {
-        hideFromCollection: true,
-        disabled: {
-          hidden: true
-        }
-      }
-    },
-    emailVerified: {
-      name: "Email Verified",
-      type: "boolean",
-      columnName: "email_verified",
-      defaultValue: false,
-      ui: {
-        hideFromCollection: true,
-        disabled: {
-          hidden: true
-        }
-      }
-    },
-    emailVerificationToken: {
-      name: "Email Verification Token",
-      type: "string",
-      columnName: "email_verification_token",
-      ui: {
-        hideFromCollection: true,
-        disabled: {
-          hidden: true
-        }
-      }
-    },
-    emailVerificationSentAt: {
-      name: "Email Verification Sent At",
-      type: "date",
-      columnName: "email_verification_sent_at",
-      ui: {
-        hideFromCollection: true,
-        disabled: {
-          hidden: true
-        }
-      }
-    },
-    metadata: {
-      name: "Metadata",
-      type: "map",
-      defaultValue: {},
-      ui: {
-        hideFromCollection: true,
-        disabled: {
-          hidden: true
-        }
-      }
-    },
-    createdAt: {
-      name: "Created At",
-      type: "date",
-      columnName: "created_at",
-      ui: {
-        readOnly: true
-      }
-    },
-    updatedAt: {
-      name: "Updated At",
-      type: "date",
-      columnName: "updated_at",
-      autoValue: "on_update",
-      ui: {
-        hideFromCollection: true,
-        disabled: {
-          hidden: true
-        }
-      }
-    }
-  },
-  listProperties: ["displayName", "email", "roles", "createdAt"],
-  propertiesOrder: ["id", "email", "displayName", "roles", "createdAt"]
-};
-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;
@@ -2714,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;
   }
   /**
@@ -3053,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,
@@ -3123,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);
@@ -3146,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.");
       }
@@ -3251,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({
@@ -3262,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");
@@ -3307,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);
@@ -3476,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
@@ -3494,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)),
@@ -26229,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 = [];
@@ -26253,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("&") : "";
@@ -27008,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 = {
@@ -27052,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);
@@ -38331,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,
@@ -38487,8 +38524,13 @@ async function _initializeRebaseBackend(config) {
       dir: config.collectionsDir
     });
   }
-  if (config.auth) {
-    activeCollections = Array.from(new Map([defaultUsersCollection, ...activeCollections].map((c) => [c.slug, c])).values());
+  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 = {};
@@ -38903,6 +38945,19 @@ 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)) {