@rebasepro/common 0.2.5 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.2.5",
+  "version": "0.4.0",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -41,8 +41,8 @@
   "dependencies": {
     "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/types": "0.2.5",
-    "@rebasepro/utils": "0.2.5"
+    "@rebasepro/types": "0.4.0",
+    "@rebasepro/utils": "0.4.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",

package/src/collections/default-collections.ts

@@ -17,6 +17,10 @@ export const defaultUsersCollection: PostgresCollection = {
     group: "Settings",
     openEntityMode: "dialog",
     disableDefaultActions: ["copy"],
+    securityRules: [
+        { operation: "select", roles: ["admin"] },
+        { operations: ["insert", "update", "delete"], roles: ["admin"] }
+    ],
     sort: ["createdAt", "desc"],
     properties: {
         id: {
@@ -91,6 +95,7 @@ export const defaultUsersCollection: PostgresCollection = {
             name: "Created At",
             type: "date",
             columnName: "created_at",
+            autoValue: "on_create",
             ui: { readOnly: true }
         },
         updatedAt: {

package/src/data/buildRebaseData.ts

@@ -8,7 +8,10 @@ import {
     EntityValues,
     FilterValues,
     WhereFilterOp,
-    WhereFieldValue
+    WhereFieldValue,
+    WhereFilterOpShort,
+    LogicalCondition,
+    WhereValue
 } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
 import { QueryBuilder } from "./query_builder";
@@ -69,11 +72,18 @@ function convertWhereToFilter(where?: Record<string, WhereFieldValue>): FilterVa
             continue;
         }
 
-        // Handle tuple: [operator, value]
-        if (Array.isArray(rawValue) && rawValue.length === 2) {
-            const [rawOp, val] = rawValue;
-            const mappedOp = operatorMap[rawOp] ?? "==";
-            filter[field] = [mappedOp, val];
+        // Handle tuple or array of tuples
+        if (Array.isArray(rawValue)) {
+            const conditions: [WhereFilterOpShort, unknown][] = Array.isArray(rawValue[0])
+                ? (rawValue as [WhereFilterOpShort, unknown][])
+                : [rawValue as [WhereFilterOpShort, unknown]];
+
+            const mappedConditions: [WhereFilterOp, unknown][] = conditions.map(([rawOp, val]) => {
+                const mappedOp = operatorMap[rawOp] ?? "==";
+                return [mappedOp, val];
+            });
+
+            filter[field] = Array.isArray(rawValue[0]) ? mappedConditions : mappedConditions[0];
             continue;
         }
 
@@ -244,8 +254,12 @@ values: {} as Record<string, unknown> }
             } : undefined,
 
         // Fluent Query Builder
-        where(column: keyof M & string, operator: WhereFilterOp, value: unknown) {
-            return new QueryBuilder<M>(accessor).where(column, operator, value);
+        where(columnOrCondition: string | LogicalCondition, operator?: WhereFilterOpShort, value?: unknown) {
+            const builder = new QueryBuilder<M>(accessor);
+            if (typeof columnOrCondition === "object") {
+                return builder.where(columnOrCondition);
+            }
+            return builder.where(columnOrCondition as keyof M & string, operator!, value as WhereValue<M[keyof M & string]>);
         },
         orderBy(column: keyof M & string, ascending?: "asc" | "desc") {
             return new QueryBuilder<M>(accessor).orderBy(column, ascending);

package/src/data/query_builder.ts

@@ -1,21 +1,15 @@
-import { FindParams, Entity, FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator } from "@rebasepro/types";
-
-/**
- * Maps standard operators to Rebase backend's string-based operators
- */
-function mapOperator(op: FilterOperator): string {
-    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;
-    }
+import { FindParams, Entity, FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
+
+export function or(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition {
+    return { type: "or", conditions };
+}
+
+export function and(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition {
+    return { type: "and", conditions };
+}
+
+export function cond(column: string, operator: FilterOperator, value: unknown): FilterCondition {
+    return { column, operator, value };
 }
 
 export class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
@@ -28,22 +22,38 @@ export class QueryBuilder<M extends Record<string, unknown> = Record<string, unk
      * @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;
+    where(columnOrCondition: string | LogicalCondition, operator?: FilterOperator, value?: unknown): this {
+        // Handle LogicalCondition signature
+        if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+            this.params.logical = columnOrCondition as LogicalCondition;
+            return this;
+        }
+
         if (!this.params.where) {
             this.params.where = {};
         }
 
-        const mappedOp = mapOperator(operator);
-        let formattedValue = value;
+        const column = columnOrCondition as string;
+        const condition: [FilterOperator, unknown] = [operator!, value];
+        const existing = this.params.where[column];
 
-        // Handle arrays for in, nin, cs, csa
-        if (Array.isArray(value) && ["in", "nin", "cs", "csa"].includes(mappedOp)) {
-            formattedValue = `(${value.join(",")})`;
-        } else if (value === null) {
-            formattedValue = "null";
+        if (existing === undefined) {
+            this.params.where[column] = condition;
+        } else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) {
+            (this.params.where[column] as [FilterOperator, unknown][]).push(condition);
+        } else {
+            // Convert existing single tuple/value into array of tuples
+            let firstCondition: [FilterOperator, unknown];
+            if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") {
+                firstCondition = existing as [FilterOperator, unknown];
+            } else {
+                firstCondition = ["==", existing];
+            }
+            this.params.where[column] = [firstCondition, condition];
         }
 
-        this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
         return this;
     }