@rebasepro/server-postgresql 0.2.1 → 0.2.3

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

@@ -0,0 +1,51 @@
+import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator } from "@rebasepro/types";
+export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
+    private collection;
+    private params;
+    constructor(collection: CollectionAccessor<M>);
+    /**
+     * Add a filter condition to your query.
+     * @example
+     * client.collection('users').where('age', '>=', 18).find()
+     */
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    /**
+     * Order the results by a specific column.
+     * @example
+     * client.collection('users').orderBy('createdAt', 'desc').find()
+     */
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
+    /**
+     * Limit the number of results returned.
+     */
+    limit(count: number): this;
+    /**
+     * Skip the first N results.
+     */
+    offset(count: number): this;
+    /**
+     * Set a free-text search string if supported by the backend.
+     */
+    search(searchString: string): this;
+    /**
+     * Include related entities in the response.
+     * Relations will be populated with full entity data instead of just IDs.
+     *
+     * @param relations - Relation names to include, or "*" for all.
+     * @example
+     * // Include specific relations
+     * client.data.posts.include("tags", "author").find()
+     *
+     * // Include all relations
+     * client.data.posts.include("*").find()
+     */
+    include(...relations: string[]): this;
+    /**
+     * Execute the find query and return the results.
+     */
+    find(): Promise<FindResponse<M>>;
+    /**
+     * Listen to realtime updates matching this query.
+     */
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
+}

package/dist/common/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./util";
 export * from "./collections";
 export * from "./data/buildRebaseData";
+export * from "./data/query_builder";

package/dist/index.es.js

@@ -1158,118 +1158,6 @@ function enumToObjectEntries(enumValues) {
     });
   }
 }
-function getSubcollections(collection) {
-  if (collection.childCollections) {
-    return collection.childCollections() ?? [];
-  }
-  if (getDataSourceCapabilities(collection.driver).supportsSubcollections && collection.subcollections) {
-    return collection.subcollections() ?? [];
-  }
-  if (getDataSourceCapabilities(collection.driver).supportsRelations && collection.relations) {
-    const manyRelations = collection.relations.filter((r) => r.cardinality === "many");
-    return manyRelations.map((r) => {
-      const target = r.target();
-      if (!target) return void 0;
-      const relationKey = r.relationName || target.slug;
-      let customName;
-      if (collection.properties) {
-        const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
-        if (prop && prop[1].name) {
-          customName = prop[1].name;
-        }
-      }
-      const baseOverrides = {
-        slug: relationKey
-      };
-      if (customName) {
-        baseOverrides.name = customName;
-        baseOverrides.singularName = customName;
-      }
-      const targetWithOverrides = {
-        ...target,
-        ...baseOverrides
-      };
-      return r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
-    }).filter((c) => Boolean(c));
-  }
-  return [];
-}
-function hasPropertyCallbacks(properties, callbackName) {
-  if (!properties) return false;
-  for (const property of Object.values(properties)) {
-    if (property.callbacks?.[callbackName]) return true;
-    if (property.type === "map" && property.properties) {
-      if (hasPropertyCallbacks(property.properties, callbackName)) return true;
-    } else if (property.type === "array" && property.of) {
-      const ofs = Array.isArray(property.of) ? property.of : [property.of];
-      for (const of of ofs) {
-        if (of.callbacks?.[callbackName]) return true;
-        if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
-      }
-    }
-  }
-  return false;
-}
-async function processProperties(properties, values, previousValues, propsContext, callbackName) {
-  if (!values || typeof values !== "object") return values;
-  const result = {
-    ...values
-  };
-  for (const [key, property] of Object.entries(properties)) {
-    if (result[key] === void 0) continue;
-    let currentValue = result[key];
-    const previousValue = previousValues?.[key];
-    if (property.type === "array" && Array.isArray(currentValue)) {
-      if (property.of && !Array.isArray(property.of)) {
-        currentValue = await Promise.all(currentValue.map(async (item, index) => {
-          const prevItem = Array.isArray(previousValue) ? previousValue[index] : void 0;
-          const singlePropData = {
-            "_tmp": property.of
-          };
-          const res = await processProperties(singlePropData, {
-            "_tmp": item
-          }, {
-            "_tmp": prevItem
-          }, propsContext, callbackName);
-          return res["_tmp"];
-        }));
-      }
-    } else if (property.type === "map" && property.properties && typeof currentValue === "object") {
-      currentValue = await processProperties(property.properties, currentValue, previousValue ?? {}, propsContext, callbackName);
-    }
-    if (property.callbacks?.[callbackName]) {
-      const cbRes = await Promise.resolve(property.callbacks[callbackName]({
-        ...propsContext,
-        value: currentValue,
-        previousValue
-      }));
-      if (cbRes !== void 0) {
-        currentValue = cbRes;
-      }
-    }
-    result[key] = currentValue;
-  }
-  return result;
-}
-const buildPropertyCallbacks = (properties) => {
-  if (!properties) return void 0;
-  const propertyCallbacks = {};
-  if (hasPropertyCallbacks(properties, "afterRead")) {
-    propertyCallbacks.afterRead = async (props) => {
-      const processedValues = await processProperties(properties, props.entity.values, props.entity.values, props, "afterRead");
-      return {
-        ...props.entity,
-        values: processedValues
-      };
-    };
-  }
-  if (hasPropertyCallbacks(properties, "beforeSave")) {
-    propertyCallbacks.beforeSave = async (props) => {
-      return await processProperties(properties, props.values, props.previousValues ?? {}, props, "beforeSave");
-    };
-  }
-  return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
-};
 function sanitizeRelation(relation, sourceCollection, resolveCollection) {
   if (!relation.target) {
     throw new Error("Relation is missing a `target` collection.");
@@ -1301,6 +1189,8 @@ function sanitizeRelation(relation, sourceCollection, resolveCollection) {
     } else {
       targetCollection = evaluated;
     }
+  } else if (rawTarget && typeof rawTarget === "object") {
+    targetCollection = rawTarget;
   }
   if (!targetCollection) {
     throw new Error("Relation is missing a valid `target` collection.");
@@ -1420,11 +1310,14 @@ function resolveCollectionRelations(collection) {
   const registeredRelationNames = /* @__PURE__ */ new Set();
   if (relCollection.relations) {
     relCollection.relations.forEach((relation) => {
-      const normalizedRelation = sanitizeRelation(relation, collection);
-      const relationKey = normalizedRelation.relationName;
-      if (relationKey) {
-        relations2[relationKey] = normalizedRelation;
-        registeredRelationNames.add(relationKey);
+      try {
+        const normalizedRelation = sanitizeRelation(relation, collection);
+        const relationKey = normalizedRelation.relationName;
+        if (relationKey) {
+          relations2[relationKey] = normalizedRelation;
+          registeredRelationNames.add(relationKey);
+        }
+      } catch (e) {
       }
     });
   }
@@ -1472,12 +1365,8 @@ function resolvePropertyRelation({
       overrides: relProp.overrides
     };
   }
-  const relation = (sourceCollection.relations ?? []).find((rel) => rel.relationName === relProp.relationName);
-  if (!relation) {
-    console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
-    return void 0;
-  }
-  return relation;
+  console.warn(`Unrecognized or missing relation target for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
+  return void 0;
 }
 function getTableName(collection) {
   if (getDataSourceCapabilities(collection.driver).supportsRelations) {
@@ -1504,6 +1393,119 @@ function findRelation(resolvedRelations, key) {
   if (snakeKey !== key && resolvedRelations[snakeKey]) return resolvedRelations[snakeKey];
   return void 0;
 }
+function getSubcollections(collection) {
+  if (collection.childCollections) {
+    return collection.childCollections() ?? [];
+  }
+  if (getDataSourceCapabilities(collection.driver).supportsSubcollections && collection.subcollections) {
+    return collection.subcollections() ?? [];
+  }
+  if (getDataSourceCapabilities(collection.driver).supportsRelations) {
+    const resolvedRelations = resolveCollectionRelations(collection);
+    const manyRelations = Object.values(resolvedRelations).filter((r) => r.cardinality === "many");
+    return manyRelations.map((r) => {
+      const target = r.target();
+      if (!target) return void 0;
+      const relationKey = r.relationName || target.slug;
+      let customName;
+      if (collection.properties) {
+        const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
+        if (prop && prop[1].name) {
+          customName = prop[1].name;
+        }
+      }
+      const baseOverrides = {
+        slug: relationKey
+      };
+      if (customName) {
+        baseOverrides.name = customName;
+        baseOverrides.singularName = customName;
+      }
+      const targetWithOverrides = {
+        ...target,
+        ...baseOverrides
+      };
+      return r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
+    }).filter((c) => Boolean(c));
+  }
+  return [];
+}
+function hasPropertyCallbacks(properties, callbackName) {
+  if (!properties) return false;
+  for (const property of Object.values(properties)) {
+    if (property.callbacks?.[callbackName]) return true;
+    if (property.type === "map" && property.properties) {
+      if (hasPropertyCallbacks(property.properties, callbackName)) return true;
+    } else if (property.type === "array" && property.of) {
+      const ofs = Array.isArray(property.of) ? property.of : [property.of];
+      for (const of of ofs) {
+        if (of.callbacks?.[callbackName]) return true;
+        if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
+      }
+    }
+  }
+  return false;
+}
+async function processProperties(properties, values, previousValues, propsContext, callbackName) {
+  if (!values || typeof values !== "object") return values;
+  const result = {
+    ...values
+  };
+  for (const [key, property] of Object.entries(properties)) {
+    if (result[key] === void 0) continue;
+    let currentValue = result[key];
+    const previousValue = previousValues?.[key];
+    if (property.type === "array" && Array.isArray(currentValue)) {
+      if (property.of && !Array.isArray(property.of)) {
+        currentValue = await Promise.all(currentValue.map(async (item, index) => {
+          const prevItem = Array.isArray(previousValue) ? previousValue[index] : void 0;
+          const singlePropData = {
+            "_tmp": property.of
+          };
+          const res = await processProperties(singlePropData, {
+            "_tmp": item
+          }, {
+            "_tmp": prevItem
+          }, propsContext, callbackName);
+          return res["_tmp"];
+        }));
+      }
+    } else if (property.type === "map" && property.properties && typeof currentValue === "object") {
+      currentValue = await processProperties(property.properties, currentValue, previousValue ?? {}, propsContext, callbackName);
+    }
+    if (property.callbacks?.[callbackName]) {
+      const cbRes = await Promise.resolve(property.callbacks[callbackName]({
+        ...propsContext,
+        value: currentValue,
+        previousValue
+      }));
+      if (cbRes !== void 0) {
+        currentValue = cbRes;
+      }
+    }
+    result[key] = currentValue;
+  }
+  return result;
+}
+const buildPropertyCallbacks = (properties) => {
+  if (!properties) return void 0;
+  const propertyCallbacks = {};
+  if (hasPropertyCallbacks(properties, "afterRead")) {
+    propertyCallbacks.afterRead = async (props) => {
+      const processedValues = await processProperties(properties, props.entity.values, props.entity.values, props, "afterRead");
+      return {
+        ...props.entity,
+        values: processedValues
+      };
+    };
+  }
+  if (hasPropertyCallbacks(properties, "beforeSave")) {
+    propertyCallbacks.beforeSave = async (props) => {
+      return await processProperties(properties, props.values, props.previousValues ?? {}, props, "beforeSave");
+    };
+  }
+  return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
+};
 var logic = { exports: {} };
 (function(module, exports) {
   (function(root, factory) {
@@ -2411,8 +2413,18 @@ class CollectionRegistry {
     const mergedRelationsRaw = [...extractedRelations];
     for (const manual of manualRelations) {
       const name = manual.relationName;
-      if (!name || !mergedRelationsRaw.find((r) => r.relationName === name)) {
+      if (!name) {
         mergedRelationsRaw.push(manual);
+      } else {
+        const existingIndex = mergedRelationsRaw.findIndex((r) => r.relationName === name);
+        if (existingIndex === -1) {
+          mergedRelationsRaw.push(manual);
+        } else {
+          mergedRelationsRaw[existingIndex] = {
+            ...manual,
+            ...mergedRelationsRaw[existingIndex]
+          };
+        }
       }
     }
     let mergedRelations = mergedRelationsRaw;
@@ -2632,6 +2644,118 @@ class CollectionRegistry {
     };
   }
 }
+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;
+  }
+  params = {
+    where: {}
+  };
+  /**
+   * Add a filter condition to your query.
+   * @example
+   * client.collection('users').where('age', '>=', 18).find()
+   */
+  where(column, operator, value) {
+    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";
+    }
+    this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
+    return this;
+  }
+  /**
+   * Order the results by a specific column.
+   * @example
+   * client.collection('users').orderBy('createdAt', 'desc').find()
+   */
+  orderBy(column, ascending = "asc") {
+    this.params.orderBy = `${column}:${ascending}`;
+    return this;
+  }
+  /**
+   * Limit the number of results returned.
+   */
+  limit(count2) {
+    this.params.limit = count2;
+    return this;
+  }
+  /**
+   * Skip the first N results.
+   */
+  offset(count2) {
+    this.params.offset = count2;
+    return this;
+  }
+  /**
+   * Set a free-text search string if supported by the backend.
+   */
+  search(searchString) {
+    this.params.searchString = searchString;
+    return this;
+  }
+  /**
+   * Include related entities in the response.
+   * Relations will be populated with full entity data instead of just IDs.
+   *
+   * @param relations - Relation names to include, or "*" for all.
+   * @example
+   * // Include specific relations
+   * client.data.posts.include("tags", "author").find()
+   *
+   * // Include all relations
+   * client.data.posts.include("*").find()
+   */
+  include(...relations2) {
+    this.params.include = relations2;
+    return this;
+  }
+  /**
+   * Execute the find query and return the results.
+   */
+  async find() {
+    return this.collection.find(this.params);
+  }
+  /**
+   * Listen to realtime updates matching this query.
+   */
+  listen(onUpdate, onError) {
+    if (!this.collection.listen) {
+      throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
+    }
+    return this.collection.listen(this.params, onUpdate, onError);
+  }
+}
 function convertWhereToFilter(where) {
   if (!where) return void 0;
   const operatorMap = {
@@ -2711,7 +2835,7 @@ function parseOrderBy(orderBy) {
   return [field, direction];
 }
 function createDriverAccessor(driver, slug) {
-  return {
+  const accessor = {
     async find(params) {
       const orderParsed = parseOrderBy(params?.orderBy);
       const entities = await driver.fetchCollection({
@@ -2805,8 +2929,28 @@ function createDriverAccessor(driver, slug) {
         onUpdate: (entity) => onUpdate(entity ?? void 0),
         onError
       });
-    } : void 0
+    } : void 0,
+    // Fluent Query Builder
+    where(column, operator, value) {
+      return new QueryBuilder(accessor).where(column, operator, value);
+    },
+    orderBy(column, ascending) {
+      return new QueryBuilder(accessor).orderBy(column, ascending);
+    },
+    limit(count2) {
+      return new QueryBuilder(accessor).limit(count2);
+    },
+    offset(count2) {
+      return new QueryBuilder(accessor).offset(count2);
+    },
+    search(searchString) {
+      return new QueryBuilder(accessor).search(searchString);
+    },
+    include(...relations2) {
+      return new QueryBuilder(accessor).include(...relations2);
+    }
   };
+  return accessor;
 }
 function buildRebaseData(driver) {
   const cache = /* @__PURE__ */ new Map();
@@ -6514,7 +6658,7 @@ class PostgresBackendDriver {
       callbacks: void 0,
       propertyCallbacks: void 0
     };
-    const registryCollection = this.registry.getCollectionByPath(path2);
+    const registryCollection = this.registry?.getCollectionByPath(path2);
     const resolvedCollection = registryCollection ? {
       ...collection,
       ...registryCollection
@@ -6562,7 +6706,8 @@ class PostgresBackendDriver {
         user: this.user,
         driver: this,
         data: this.data,
-        client: this.client
+        client: this.client,
+        storageSource: this.client?.storage
       };
       return Promise.all(entities.map(async (entity) => {
         let fetched = entity;
@@ -6657,7 +6802,8 @@ class PostgresBackendDriver {
         user: this.user,
         driver: this,
         data: this.data,
-        client: this.client
+        client: this.client,
+        storageSource: this.client?.storage
       };
       if (callbacks?.afterRead) {
         entity = await callbacks.afterRead({
@@ -6727,7 +6873,8 @@ class PostgresBackendDriver {
       user: this.user,
       driver: this,
       data: this.data,
-      client: this.client
+      client: this.client,
+      storageSource: this.client?.storage
     };
     let previousValuesForHistory;
     if (status === "existing" && entityId) {
@@ -6876,7 +7023,8 @@ class PostgresBackendDriver {
       user: this.user,
       driver: this,
       data: this.data,
-      client: this.client
+      client: this.client,
+      storageSource: this.client?.storage
     };
     if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
       let preventDefault = false;
@@ -8155,6 +8303,7 @@ const defaultUsersCollection = {
   singularName: "User",
   slug: "users",
   table: "users",
+  schema: "rebase",
   icon: "Users",
   group: "Settings",
   properties: {