@rebasepro/server-postgresql 0.2.5 → 0.4.0

package/dist/common/src/data/query_builder.d.ts

@@ -1,4 +1,7 @@
-import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator } from "@rebasepro/types";
+import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
+export declare function or(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
+export declare function and(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
+export declare function cond(column: string, operator: FilterOperator, value: unknown): FilterCondition;
 export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
     private collection;
     private params;
@@ -8,7 +11,8 @@ export declare class QueryBuilder<M extends Record<string, unknown> = Record<str
      * @example
      * client.collection('users').where('age', '>=', 18).find()
      */
-    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
+    where(logicalCondition: LogicalCondition): this;
     /**
      * Order the results by a specific column.
      * @example

package/dist/index.es.js

@@ -1,6 +1,6 @@
 import { Pool, Client } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
-import { sql, inArray, eq, and, or, ilike, asc, desc, gt, lt, getTableName as getTableName$1, count, relations, isTable } from "drizzle-orm";
+import { or, and, sql, inArray, eq, ilike, asc, desc, gt, lt, getTableName as getTableName$1, count, relations, isTable } from "drizzle-orm";
 import { PgVarchar, PgText, PgChar, pgSchema, pgTable, timestamp, jsonb, text, boolean, varchar, uuid, unique, getTableConfig } from "drizzle-orm/pg-core";
 import { createHash, randomUUID } from "crypto";
 import * as fs from "fs";
@@ -2711,166 +2711,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(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;
@@ -2878,23 +2718,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(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;
   }
   /**
@@ -2996,10 +2843,13 @@ function convertWhereToFilter(where) {
       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") {
@@ -3137,8 +2987,12 @@ function createDriverAccessor(driver, slug) {
       });
     } : 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);
@@ -3189,7 +3043,6 @@ class DrizzleConditionBuilder {
     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`;
@@ -3201,13 +3054,39 @@ class DrizzleConditionBuilder {
         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" ? or(...subSQLs) : 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
    */
@@ -5604,6 +5483,10 @@ class EntityFetchService {
       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);
@@ -5775,6 +5658,10 @@ class EntityFetchService {
       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);
     }
@@ -8733,7 +8620,6 @@ const runGeneration = async (collectionsFilePath, outputPath) => {
     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) {
@@ -10341,31 +10227,23 @@ class PostgresCollectionRegistry extends CollectionRegistry {
     return collection.relations.map((r) => r.relationName || r.localKey || "").filter(Boolean);
   }
 }
-async function ensureAuthTablesExist(db, registry) {
+async function ensureAuthTablesExist(db, collection) {
   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 = 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";
         }
       }
     }
@@ -11758,19 +11636,21 @@ function createPostgresBootstrapper(pgConfig) {
       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 = 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 = 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);