@rebasepro/server-postgresql 0.2.5 → 0.4.0

package/dist/index.umd.js

@@ -2719,166 +2719,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(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;
@@ -2886,23 +2726,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(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;
     }
     /**
@@ -3004,10 +2851,13 @@
         filter[field] = ["==", rawValue];
         continue;
       }
-      if (Array.isArray(rawValue) && rawValue.length === 2) {
-        const [rawOp, val] = rawValue;
-        const mappedOp = operatorMap[rawOp] ?? "==";
-        filter[field] = [mappedOp, val];
+      if (Array.isArray(rawValue)) {
+        const conditions = Array.isArray(rawValue[0]) ? rawValue : [rawValue];
+        const mappedConditions = conditions.map(([rawOp, val]) => {
+          const mappedOp = operatorMap[rawOp] ?? "==";
+          return [mappedOp, val];
+        });
+        filter[field] = Array.isArray(rawValue[0]) ? mappedConditions : mappedConditions[0];
         continue;
       }
       if (typeof rawValue === "string") {
@@ -3145,8 +2995,12 @@
         });
       } : void 0,
       // Fluent Query Builder
-      where(column, operator, value) {
-        return new QueryBuilder(accessor).where(column, operator, value);
+      where(columnOrCondition, operator, value) {
+        const builder = new QueryBuilder(accessor);
+        if (typeof columnOrCondition === "object") {
+          return builder.where(columnOrCondition);
+        }
+        return builder.where(columnOrCondition, operator, value);
       },
       orderBy(column, ascending) {
         return new QueryBuilder(accessor).orderBy(column, ascending);
@@ -3197,7 +3051,6 @@
       const conditions = [];
       for (const [field, filterParam] of Object.entries(filter)) {
         if (!filterParam) continue;
-        const [op, value] = filterParam;
         let fieldColumn = table[field];
         if (!fieldColumn) {
           const relationKey = `${field}_id`;
@@ -3209,13 +3062,39 @@
           console.warn(`Filtering by field '${field}', but it does not exist in table for collection '${collectionPath}'`);
           continue;
         }
-        const condition = this.buildSingleFilterCondition(fieldColumn, op, value);
-        if (condition) {
-          conditions.push(condition);
+        const paramsList = Array.isArray(filterParam) && filterParam.length > 0 && Array.isArray(filterParam[0]) ? filterParam : [filterParam];
+        for (const [op, value] of paramsList) {
+          const condition = this.buildSingleFilterCondition(fieldColumn, op, value);
+          if (condition) {
+            conditions.push(condition);
+          }
         }
       }
       return conditions;
     }
+    /**
+     * Build logical conditions recursively from LogicalCondition or FilterCondition
+     */
+    static buildLogicalConditions(cond, table, collectionPath) {
+      if ("type" in cond) {
+        const subSQLs = cond.conditions.map((c) => this.buildLogicalConditions(c, table, collectionPath)).filter((sql2) => sql2 !== null);
+        if (subSQLs.length === 0) return null;
+        return (cond.type === "or" ? drizzleOrm.or(...subSQLs) : drizzleOrm.and(...subSQLs)) ?? null;
+      } else {
+        let fieldColumn = table[cond.column];
+        if (!fieldColumn) {
+          const relationKey = `${cond.column}_id`;
+          if (relationKey in table) {
+            fieldColumn = table[relationKey];
+          }
+        }
+        if (!fieldColumn) {
+          console.warn(`Filtering by field '${cond.column}', but it does not exist in table for collection '${collectionPath}'`);
+          return null;
+        }
+        return this.buildSingleFilterCondition(fieldColumn, cond.operator, cond.value);
+      }
+    }
     /**
      * Build a single filter condition for a specific operator and value
      */
@@ -5612,6 +5491,10 @@
         const filterConditions = this.buildFilterConditions(options.filter, table, collectionPath);
         if (filterConditions.length > 0) allConditions.push(...filterConditions);
       }
+      if (options.logical) {
+        const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(options.logical, table, collectionPath);
+        if (logicalCondition) allConditions.push(logicalCondition);
+      }
       if (options.startAfter) {
         const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options, collectionPath);
         if (cursorConditions.length > 0) allConditions.push(...cursorConditions);
@@ -5783,6 +5666,10 @@
         const filterConditions = this.buildFilterConditions(options.filter, table, collectionPath);
         if (filterConditions.length > 0) allConditions.push(...filterConditions);
       }
+      if (options.logical) {
+        const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(options.logical, table, collectionPath);
+        if (logicalCondition) allConditions.push(logicalCondition);
+      }
       if (vectorMeta?.filter) {
         allConditions.push(vectorMeta.filter);
       }
@@ -8741,7 +8628,6 @@ ${tableRelations.join(",\n")}
       if (!collections || !Array.isArray(collections)) {
         collections = [];
       }
-      collections = Array.from(new Map([defaultUsersCollection, ...collections].map((c) => [c.slug, c])).values());
       collections.sort((a, b) => a.slug.localeCompare(b.slug));
       const schemaContent = await generateSchema(collections);
       if (outputPath) {
@@ -10349,31 +10235,23 @@ ${tableRelations.join(",\n")}
       return collection.relations.map((r) => r.relationName || r.localKey || "").filter(Boolean);
     }
   }
-  async function ensureAuthTablesExist(db, registry) {
+  async function ensureAuthTablesExist(db, collection) {
     serverCore.logger.info("🔍 Checking auth tables...");
     try {
-      let usersTableName = '"users"';
+      let usersTableName = '"rebase"."users"';
       let userIdType = "TEXT";
-      let usersSchema2 = "public";
-      if (registry) {
-        const usersTable = registry.getTable("users");
-        if (usersTable) {
-          const {
-            getTableName: getTableName2
-          } = await import("drizzle-orm");
-          usersSchema2 = pgCore.getTableConfig(usersTable).schema || "public";
-          usersTableName = usersSchema2 === "public" ? `"${getTableName2(usersTable)}"` : `"${usersSchema2}"."${getTableName2(usersTable)}"`;
-          if (usersTable.id) {
-            const col = usersTable.id;
-            const meta = getColumnMeta(col);
-            const columnType = meta.columnType;
-            if (columnType === "PgUUID") {
-              userIdType = "UUID";
-            } else if (columnType === "PgSerial" || columnType === "PgInteger") {
-              userIdType = "INTEGER";
-            } else if (columnType === "PgBigInt" || columnType === "PgBigSerial") {
-              userIdType = "BIGINT";
-            }
+      let usersSchema2 = "rebase";
+      if (collection) {
+        const rawTable = "table" in collection && typeof collection.table === "string" ? collection.table : collection.slug;
+        usersSchema2 = "schema" in collection && typeof collection.schema === "string" ? collection.schema : "public";
+        usersTableName = usersSchema2 === "public" ? `"${rawTable}"` : `"${usersSchema2}"."${rawTable}"`;
+        const idProp = collection.properties?.id;
+        if (idProp) {
+          const isId = "isId" in idProp ? idProp.isId : void 0;
+          if (isId === "uuid") {
+            userIdType = "UUID";
+          } else if (isId === "autoincrement") {
+            userIdType = "INTEGER";
           }
         }
       }
@@ -11766,19 +11644,21 @@ ${tableRelations.join(",\n")}
         const internals = driverResult.internals;
         const db = internals.db;
         const registry = internals.registry;
-        await ensureAuthTablesExist(db, registry);
+        const authCollection = authConfig.collection;
+        await ensureAuthTablesExist(db, authCollection);
         let emailService;
         if (authConfig.email) {
           emailService = serverCore.createEmailService(authConfig.email);
         }
-        const customUsersTable = registry?.getTable("users");
+        const tableName = authCollection ? "table" in authCollection && typeof authCollection.table === "string" ? authCollection.table : authCollection.slug : void 0;
+        const usersTable = tableName ? registry.getTable(tableName) : void 0;
         let usersSchemaName = "rebase";
-        if (customUsersTable) {
-          usersSchemaName = pgCore.getTableConfig(customUsersTable).schema || "public";
+        if (authCollection && "schema" in authCollection && typeof authCollection.schema === "string") {
+          usersSchemaName = authCollection.schema;
         }
         const authTables = createAuthSchema(usersSchemaName);
-        if (customUsersTable) {
-          authTables.users = customUsersTable;
+        if (usersTable) {
+          authTables.users = usersTable;
         }
         const userService = new UserService(db, authTables);
         const authRepository = new PostgresAuthRepository(db, authTables);