@rebasepro/server-postgresql 0.2.1 → 0.2.3

package/dist/index.umd.js

@@ -1166,118 +1166,6 @@
       });
     }
   }
-  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.");
@@ -1309,6 +1197,8 @@
       } else {
         targetCollection = evaluated;
       }
+    } else if (rawTarget && typeof rawTarget === "object") {
+      targetCollection = rawTarget;
     }
     if (!targetCollection) {
       throw new Error("Relation is missing a valid `target` collection.");
@@ -1428,11 +1318,14 @@
     const registeredRelationNames = /* @__PURE__ */ new Set();
     if (relCollection.relations) {
       relCollection.relations.forEach((relation) => {
-        const normalizedRelation = sanitizeRelation(relation, collection);
-        const relationKey = normalizedRelation.relationName;
-        if (relationKey) {
-          relations[relationKey] = normalizedRelation;
-          registeredRelationNames.add(relationKey);
+        try {
+          const normalizedRelation = sanitizeRelation(relation, collection);
+          const relationKey = normalizedRelation.relationName;
+          if (relationKey) {
+            relations[relationKey] = normalizedRelation;
+            registeredRelationNames.add(relationKey);
+          }
+        } catch (e) {
         }
       });
     }
@@ -1480,12 +1373,8 @@
         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) {
@@ -1512,6 +1401,119 @@
     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(module2, exports3) {
     (function(root, factory) {
@@ -2419,8 +2421,18 @@
       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;
@@ -2640,6 +2652,118 @@
       };
     }
   }
+  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(count) {
+      this.params.limit = count;
+      return this;
+    }
+    /**
+     * Skip the first N results.
+     */
+    offset(count) {
+      this.params.offset = count;
+      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(...relations) {
+      this.params.include = relations;
+      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 = {
@@ -2719,7 +2843,7 @@
     return [field, direction];
   }
   function createDriverAccessor(driver, slug) {
-    return {
+    const accessor = {
       async find(params) {
         const orderParsed = parseOrderBy(params?.orderBy);
         const entities = await driver.fetchCollection({
@@ -2813,8 +2937,28 @@
           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(count) {
+        return new QueryBuilder(accessor).limit(count);
+      },
+      offset(count) {
+        return new QueryBuilder(accessor).offset(count);
+      },
+      search(searchString) {
+        return new QueryBuilder(accessor).search(searchString);
+      },
+      include(...relations) {
+        return new QueryBuilder(accessor).include(...relations);
+      }
     };
+    return accessor;
   }
   function buildRebaseData(driver) {
     const cache = /* @__PURE__ */ new Map();
@@ -6522,7 +6666,7 @@
         callbacks: void 0,
         propertyCallbacks: void 0
       };
-      const registryCollection = this.registry.getCollectionByPath(path2);
+      const registryCollection = this.registry?.getCollectionByPath(path2);
       const resolvedCollection = registryCollection ? {
         ...collection,
         ...registryCollection
@@ -6570,7 +6714,8 @@
           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;
@@ -6665,7 +6810,8 @@
           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({
@@ -6735,7 +6881,8 @@
         user: this.user,
         driver: this,
         data: this.data,
-        client: this.client
+        client: this.client,
+        storageSource: this.client?.storage
       };
       let previousValuesForHistory;
       if (status === "existing" && entityId) {
@@ -6884,7 +7031,8 @@
         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;
@@ -8163,6 +8311,7 @@ ${tableRelations.join(",\n")}
     singularName: "User",
     slug: "users",
     table: "users",
+    schema: "rebase",
     icon: "Users",
     group: "Settings",
     properties: {