@rebasepro/server-core 0.3.0 → 0.4.0

package/dist/types/src/types/user_management_delegate.d.ts

@@ -1,4 +1,4 @@
-import { Role, User } from "../users";
+import type { User } from "../users";
 /**
  * Result of creating a new user via admin flow.
  * Contains the created user plus information about how credentials were delivered.
@@ -15,56 +15,46 @@ export interface UserCreationResult<USER extends User = User> {
     temporaryPassword?: string;
 }
 /**
- * Delegate to manage users, roles, and their permissions.
- * This interface allows the CMS to be completely agnostic of the underlying
- * authentication provider or backend.
+ * Delegate to manage auth-specific user operations.
+ *
+ * This interface allows the CMS to be agnostic of the underlying
+ * authentication provider or backend. User/role CRUD is now handled
+ * by the collection system; this delegate only exposes auth-specific
+ * operations (password hashing, invitations, bootstrap).
  *
  * @group Models
  */
 export interface UserManagementDelegate<USER extends User = User> {
     /**
-     * Are the users and roles currently being fetched?
+     * Are auth-related operations currently loading?
      */
     loading: boolean;
     /**
-     * List of users managed by the CMS.
+     * In-memory list of users (used for client-side filtering fallback).
      */
-    users: USER[];
+    users?: USER[];
     /**
-     * Optional error if users failed to load.
+     * Error from fetching the users list, if any.
      */
     usersError?: Error;
     /**
-     * Function to get a user by its uid. This is used to show
-     * user information when assigning ownership of an entity.
-     * @param uid
+     * Look up a single user by UID from the in-memory cache.
      */
-    getUser: (uid: string) => USER | null;
+    getUser?: (uid: string) => USER | null;
     /**
-     * Search users with server-side pagination.
-     * When provided, the CMS will use this for the users table
-     * instead of loading all users into memory.
+     * Server-side user search with pagination.
      */
-    searchUsers?: (options: {
+    searchUsers?: (params: {
         search?: string;
         limit?: number;
         offset?: number;
-        orderBy?: string;
-        orderDir?: "asc" | "desc";
-        roleId?: string;
     }) => Promise<{
         users: USER[];
         total: number;
     }>;
-    /**
-     * Save a user (create or update)
-     * @param user
-     */
-    saveUser?: (user: USER) => Promise<USER>;
     /**
      * Create a new user with invitation/password generation support.
      * Returns additional info about how the credentials were delivered.
-     * Falls back to saveUser if not provided.
      */
     createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
     /**
@@ -73,42 +63,15 @@ export interface UserManagementDelegate<USER extends User = User> {
      * or a flag indicating an email invitation was sent.
      */
     resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
-    /**
-     * Delete a user
-     * @param user
-     */
-    deleteUser?: (user: USER) => Promise<void>;
-    /**
-     * List of roles defined in the CMS.
-     */
-    roles?: Role[];
-    /**
-     * Optional error if roles failed to load.
-     */
-    rolesError?: Error;
-    /**
-     * Save a role (create or update)
-     * @param role
-     */
-    saveRole?: (role: Role) => Promise<void>;
-    /**
-     * Delete a role
-     * @param role
-     */
-    deleteRole?: (role: Role) => Promise<void>;
     /**
      * Is the currently logged in user an admin?
      */
     isAdmin?: boolean;
-    /**
-     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
-     */
-    allowDefaultRolesCreation?: boolean;
     /**
      * Optionally define roles for a given user. This is useful when the roles
      * are coming from a separate provider than the one issuing the tokens.
      */
-    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    defineRolesFor?: (user: USER) => Promise<string[] | undefined> | string[] | undefined;
     /**
      * Whether any admin users exist. Used by the bootstrap banner to decide
      * whether to prompt.  Populated via a lightweight check (e.g. `limit=1`

package/dist/types/src/users/index.d.ts

@@ -1,2 +1 @@
 export * from "./user";
-export * from "./roles";

package/dist/types/src/users/user.d.ts

@@ -35,7 +35,6 @@ export type User = {
     readonly isAnonymous: boolean;
     /**
      * Role IDs assigned to this user (e.g. ["admin", "editor"]).
-     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
      */
     roles?: string[];
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-core",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Database-Agnostic Backend Core for Rebase",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -54,10 +54,10 @@
     "ts-morph": "27.0.2",
     "ws": "^8.20.1",
     "zod": "^3.25.76",
-    "@rebasepro/common": "0.3.0",
-    "@rebasepro/types": "0.3.0",
-    "@rebasepro/client": "0.3.0",
-    "@rebasepro/utils": "0.3.0"
+    "@rebasepro/client": "0.4.0",
+    "@rebasepro/common": "0.4.0",
+    "@rebasepro/utils": "0.4.0",
+    "@rebasepro/types": "0.4.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/api/rest/api-generator.ts

@@ -87,9 +87,9 @@ export class RestApiGenerator {
         // GET /collection/count - Count entities (with optional filters)
         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 as string | undefined;
+            const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : undefined;
             const driver = c.get("driver") || this.driver;
 
             const total = await this.countRawEntities(driver, resolvedCollection, queryOptions, searchString);
@@ -99,9 +99,9 @@ export class RestApiGenerator {
         // GET /collection - List entities
         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 as string | undefined;
+            const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : undefined;
 
             const driver = c.get("driver") || this.driver;
             const fetchService = this.getFetchService(driver);
@@ -161,7 +161,7 @@ export 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);
@@ -388,13 +388,14 @@ entityId };
 
             if (parsed.entityId === "count") {
                 // GET /parent/:parentId/child/count — count child entities
-                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] : undefined;
                 
                 const total = driver.countEntities ? await driver.countEntities({
                     path: parsed.collectionPath,
                     filter: queryOptions.where as FetchCollectionProps["filter"],
-                    searchString: queryDict.searchString as string | undefined
+                    searchString
                 }) : 0;
                 
                 return c.json({ count: total });
@@ -408,15 +409,16 @@ entityId };
                 return c.json(this.flattenEntity(entity));
             } else {
                 // GET /parent/:parentId/child — list entities
-                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] : undefined;
                 const entities = await driver.fetchCollection({
                     path: parsed.collectionPath,
                     filter: queryOptions.where as FetchCollectionProps["filter"],
                     limit: queryOptions.limit,
                     orderBy: queryOptions.orderBy?.[0]?.field,
                     order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
-                    searchString: queryDict.searchString as string | undefined
+                    searchString
                 });
                 return c.json({
                     data: entities.map(e => this.flattenEntity(e)),

package/src/api/rest/query-parser.ts

@@ -1,4 +1,4 @@
-import type { VectorSearchParams } from "@rebasepro/types";
+import type { VectorSearchParams, LogicalCondition, FilterCondition } from "@rebasepro/types";
 import { QueryOptions } from "../types";
 
 /**
@@ -20,6 +20,86 @@ export function mapOperator(op: string): string | null {
     }
 }
 
+function getLastValue(val: unknown): unknown {
+    if (Array.isArray(val)) {
+        return val[val.length - 1];
+    }
+    return val;
+}
+
+export function parseLogicalString(str: string): FilterCondition | LogicalCondition {
+    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) };
+    }
+    
+    // It's a leaf condition: field.op.val
+    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) || "==") as FilterCondition["operator"];
+    let parsedVal: unknown = 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: string): (FilterCondition | LogicalCondition)[] {
+    const list: (FilterCondition | LogicalCondition)[] = [];
+    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;
+}
+
 /**
  * Parse query parameters into QueryOptions
  */
@@ -27,10 +107,15 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     const options: QueryOptions = {};
 
     // Pagination
-    if (query.limit) options.limit = parseInt(String(query.limit));
-    if (query.offset) options.offset = parseInt(String(query.offset));
-    if (query.page) {
-        const page = parseInt(String(query.page));
+    const limitVal = getLastValue(query.limit);
+    if (limitVal) options.limit = parseInt(String(limitVal));
+    
+    const offsetVal = getLastValue(query.offset);
+    if (offsetVal) options.offset = parseInt(String(offsetVal));
+    
+    const pageVal = getLastValue(query.page);
+    if (pageVal) {
+        const page = parseInt(String(pageVal));
         const limit = options.limit || 20;
         options.offset = (page - 1) * limit;
     }
@@ -38,59 +123,88 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     // Filtering
     options.where = {};
 
+    // Handle logical conditions
+    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);
+        }
+        options.logical = {
+            type: "or",
+            conditions: parseLogicalList(orStr)
+        };
+    } else if (andVal) {
+        let andStr = String(andVal).trim();
+        if (andStr.startsWith("(") && andStr.endsWith(")")) {
+            andStr = andStr.slice(1, -1);
+        }
+        options.logical = {
+            type: "and",
+            conditions: parseLogicalList(andStr)
+        };
+    }
 
     // PostgREST-style filtering: ?field=op.value
-    const reservedQueryKeys = ["limit", "offset", "page", "orderBy", "include", "fields", "searchString", "vector_search", "vector", "vector_distance", "vector_threshold"];
+    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: string | number | boolean | null | (string | number | boolean | null)[] = val;
-                    // Attempt to parse primitive types or arrays
-                    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("(")) {
-                        // Array for 'in' or 'not-in' ops (e.g. (1,2,3) or (a,b,c))
-                        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: [string, unknown][] = [];
+
+        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);
 
-                    options.where[key] = [rebaseOp, parsedVal];
+                    if (rebaseOp) {
+                        let parsedVal: string | number | boolean | null | (string | number | boolean | null)[] = val;
+                        // Attempt to parse primitive types or arrays
+                        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("(")) {
+                            // Array for 'in' or 'not-in' ops (e.g. (1,2,3) or (a,b,c))
+                            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 {
+                        // Fallback: assume implicit eq if the dot wasn't an operator (e.g. email or float)
+                        let parsedVal: string | number | boolean | null = value;
+                        if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
+                        conditions.push(["==", parsedVal]);
+                    }
                 } else {
-                    // Fallback: assume implicit eq if the dot wasn't an operator (e.g. email or float)
+                    // Implicit eq
                     let parsedVal: string | number | boolean | null = value;
-                    if (!isNaN(Number(value)) && value.trim() !== "") parsedVal = Number(value);
-                    options.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 {
-                // Implicit eq
-                let parsedVal: string | number | boolean | null = 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);
-
-                options.where[key] = ["==", parsedVal];
             }
         }
+
+        if (conditions.length > 0) {
+            options.where[key] = conditions.length === 1 ? conditions[0] : conditions;
+        }
     }
 
     if (Object.keys(options.where).length === 0) {
@@ -98,15 +212,16 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     }
 
     // Sorting
-    if (query.orderBy) {
+    const orderByVal = getLastValue(query.orderBy);
+    if (orderByVal) {
         try {
-            options.orderBy = typeof query.orderBy === "string"
-                ? JSON.parse(query.orderBy)
-                : query.orderBy;
+            options.orderBy = typeof orderByVal === "string"
+                ? JSON.parse(orderByVal)
+                : orderByVal;
         } catch {
             // Try simple format: "field:direction"
-            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") as "asc" | "desc";
                 options.orderBy = [
                     {
@@ -119,8 +234,9 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     }
 
     // Relation includes
-    if (query.include) {
-        const includeStr = String(query.include).trim();
+    const includeVal = getLastValue(query.include);
+    if (includeVal) {
+        const includeStr = String(includeVal).trim();
         if (includeStr === "*") {
             options.include = ["*"];
         } else {
@@ -129,14 +245,17 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
     }
 
     // Field selection
-    if (query.fields) {
-        const fieldsStr = String(query.fields).trim();
+    const fieldsVal = getLastValue(query.fields);
+    if (fieldsVal) {
+        const fieldsStr = String(fieldsVal).trim();
         options.fields = fieldsStr.split(",").map(s => s.trim()).filter(Boolean);
     }
 
     // Vector similarity search
-    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: number[];
         try {
             queryVector = JSON.parse(vectorStr) as number[];
@@ -147,19 +266,21 @@ export function parseQueryOptions(query: Record<string, unknown>): QueryOptions
             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: VectorSearchParams = {
-            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.");
             }

package/src/api/types.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, VectorSearchParams } from "@rebasepro/types";
+import { EntityCollection, VectorSearchParams, LogicalCondition } from "@rebasepro/types";
 import { AuthResult } from "../auth/middleware";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { DataDriver } from "@rebasepro/types";
@@ -77,6 +77,7 @@ export interface QueryOptions {
     limit?: number;
     offset?: number;
     where?: Record<string, unknown>;
+    logical?: LogicalCondition;
     orderBy?: Array<{ field: string; direction: "asc" | "desc" }>;
     include?: string[];
     /** Columns to return in the response (field-level selection) */