@rebasepro/server-core 0.2.5 → 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,166 +2537,6 @@
       };
     }
   }
-  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;
@@ -2701,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;
     }
     /**
@@ -3040,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,
@@ -3110,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);
@@ -3133,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.");
         }
@@ -3238,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({
@@ -3249,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");
@@ -3294,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);
@@ -3463,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
@@ -3481,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)),
@@ -26263,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 = [];
@@ -26287,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("&") : "";
@@ -27042,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 = {
@@ -27086,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);
@@ -38365,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,
@@ -38521,8 +38558,13 @@ ${credentialScope}
         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 = {};
@@ -38937,6 +38979,19 @@ ${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)) {