@pol-studios/db 1.0.55 → 1.0.56

package/dist/{chunk-OC6S4XFL.js → chunk-DDL63KLQ.js}

@@ -1,6 +1,6 @@
 import {
   useDbUpsert
-} from "./chunk-AKCNWHXV.js";
+} from "./chunk-VYFAMTHI.js";
 import {
   normalizeFilter
 } from "./chunk-Z456IHCB.js";
@@ -9,13 +9,20 @@ import {
 } from "./chunk-7SCJNYTE.js";
 import {
   useDbQuery
-} from "./chunk-WILXD5X3.js";
+} from "./chunk-6SDH7M7J.js";
 import {
   useDataLayerCoreOptional
-} from "./chunk-WSKBZIEI.js";
+} from "./chunk-GWYTROSD.js";
+import {
+  ResultJoiner
+} from "./chunk-YRIPM2AN.js";
 import {
   getSupabaseUrl
 } from "./chunk-GC3TBUWE.js";
+import {
+  parseSelect,
+  selectHasExplicitFkSyntax
+} from "./chunk-W7PERM66.js";
 import {
   PostgrestParser
 } from "./chunk-JOULSXOI.js";
@@ -5094,6 +5101,343 @@ function createAdapterAutoDetector(powerSyncDb, supabase, options) {
   return new AdapterAutoDetector(powerSyncDb, supabase, options);
 }
 
+// src/query/supabase-utils.ts
+var DEFAULT_SCHEMA = "public";
+function parseTableIdentifier(table) {
+  if (table.includes(".")) {
+    const [schema, ...rest] = table.split(".");
+    return {
+      schema,
+      tableName: rest.join(".")
+    };
+  }
+  return {
+    schema: DEFAULT_SCHEMA,
+    tableName: table
+  };
+}
+function applyWhereClause(query, where) {
+  for (const [field, condition] of Object.entries(where)) {
+    if (condition === null) {
+      query = query.is(field, null);
+    } else if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean") {
+      query = query.eq(field, condition);
+    } else if (typeof condition === "object") {
+      const operators = condition;
+      if (operators.in !== void 0) {
+        query = query.in(field, operators.in);
+      }
+      if (operators.gt !== void 0) {
+        query = query.gt(field, operators.gt);
+      }
+      if (operators.gte !== void 0) {
+        query = query.gte(field, operators.gte);
+      }
+      if (operators.lt !== void 0) {
+        query = query.lt(field, operators.lt);
+      }
+      if (operators.lte !== void 0) {
+        query = query.lte(field, operators.lte);
+      }
+      if (operators.like !== void 0) {
+        query = query.ilike(field, operators.like);
+      }
+      if (operators.is !== void 0) {
+        query = query.is(field, null);
+      }
+      if (operators.neq !== void 0) {
+        if (operators.neq === null) {
+          query = query.not(field, "is", null);
+        } else {
+          query = query.neq(field, operators.neq);
+        }
+      }
+      if (operators.notIn !== void 0) {
+        query = query.not(field, "in", `(${operators.notIn.join(",")})`);
+      }
+    }
+  }
+  return query;
+}
+
+// src/query/supabase-executor.ts
+var SupabaseQueryExecutor = class {
+  constructor(supabase, schema) {
+    this.supabase = supabase;
+    this.schema = schema;
+    this.joiner = new ResultJoiner();
+  }
+  joiner;
+  /**
+   * Execute a query and return results.
+   *
+   * @param table - The table to query (optionally schema-qualified, e.g., "chat.Message")
+   * @param options - Query options including select, where, orderBy, limit, offset
+   * @returns Object with data array and optional count
+   */
+  async execute(table, options = {}) {
+    const parsed = parseSelect(options.select ?? "*");
+    const parentSelect = this.buildParentSelect(parsed.columns, parsed.relations);
+    const {
+      schema: schemaName,
+      tableName
+    } = parseTableIdentifier(table);
+    const parentResult = await this.queryTable(schemaName, tableName, parentSelect, options);
+    const parentRecords = parentResult.data;
+    if (parentRecords.length === 0 || parsed.relations.length === 0) {
+      return {
+        data: parentRecords,
+        count: parentResult.count
+      };
+    }
+    const result = await this.queryAndJoinRelations(table, parentRecords, parsed.relations);
+    return {
+      data: result,
+      count: parentResult.count
+    };
+  }
+  /**
+   * Execute a query for a single record by ID.
+   *
+   * @param table - The table to query (optionally schema-qualified)
+   * @param id - The record ID
+   * @param options - Query options (only select is used)
+   * @returns Single record or null
+   */
+  async executeById(table, id, options = {}) {
+    const result = await this.execute(table, {
+      ...options,
+      where: {
+        id
+      },
+      limit: 1
+    });
+    return result.data[0] ?? null;
+  }
+  /**
+   * Build the select string for the parent query.
+   * For relations with explicit FK, we only need the FK column from the parent.
+   * Standard relations are passed through to Supabase's PostgREST.
+   */
+  buildParentSelect(columns, relations) {
+    const parts = [];
+    if (columns === "*") {
+      parts.push("*");
+    } else {
+      for (const col of columns) {
+        if (col.alias) {
+          parts.push(`${col.alias}:${col.name}`);
+        } else {
+          parts.push(col.name);
+        }
+      }
+    }
+    for (const rel of relations) {
+      if (!rel.explicitFk) {
+        const innerSelect = this.buildNestedSelect(rel);
+        if (rel.alias) {
+          parts.push(`${rel.alias}:${rel.name}(${innerSelect})`);
+        } else {
+          parts.push(`${rel.name}(${innerSelect})`);
+        }
+      }
+    }
+    return parts.join(", ");
+  }
+  /**
+   * Build the select string for a nested relation (recursive).
+   */
+  buildNestedSelect(rel) {
+    const parts = [];
+    if (rel.columns === "*") {
+      parts.push("*");
+    } else {
+      for (const col of rel.columns) {
+        if (col.alias) {
+          parts.push(`${col.alias}:${col.name}`);
+        } else {
+          parts.push(col.name);
+        }
+      }
+    }
+    for (const nested of rel.relations) {
+      if (!nested.explicitFk) {
+        const innerSelect = this.buildNestedSelect(nested);
+        if (nested.alias) {
+          parts.push(`${nested.alias}:${nested.name}(${innerSelect})`);
+        } else {
+          parts.push(`${nested.name}(${innerSelect})`);
+        }
+      }
+    }
+    return parts.join(", ");
+  }
+  /**
+   * Query a table via Supabase.
+   */
+  async queryTable(schemaName, tableName, select, options) {
+    let query = this.supabase.schema(schemaName).from(tableName).select(select, {
+      count: "exact"
+    });
+    if (options.where) {
+      query = applyWhereClause(query, options.where);
+    }
+    if (options.orderBy && options.orderBy.length > 0) {
+      for (const order of options.orderBy) {
+        query = query.order(order.field, {
+          ascending: order.direction === "asc"
+        });
+      }
+    }
+    if (options.limit !== void 0 && options.offset !== void 0) {
+      query = query.range(options.offset, options.offset + options.limit - 1);
+    } else if (options.limit !== void 0) {
+      query = query.limit(options.limit);
+    }
+    const {
+      data,
+      error,
+      count
+    } = await query;
+    if (error) {
+      throw new Error(`Supabase query error on ${schemaName}.${tableName}: ${error.message}`);
+    }
+    return {
+      data: data ?? [],
+      count: count ?? void 0
+    };
+  }
+  /**
+   * Query related records using an IN filter.
+   */
+  async queryRelatedRecords(schemaName, tableName, select, filterColumn, filterValues) {
+    if (filterValues.length === 0) {
+      return [];
+    }
+    const {
+      data,
+      error
+    } = await this.supabase.schema(schemaName).from(tableName).select(select).in(filterColumn, filterValues);
+    if (error) {
+      throw new Error(`Supabase relation query error on ${schemaName}.${tableName}: ${error.message}`);
+    }
+    return data ?? [];
+  }
+  /**
+   * Query and join relations onto parent records.
+   *
+   * @param parentTable - The parent table name
+   * @param parentRecords - Parent records to add relations to
+   * @param relations - Relations to query and join
+   * @returns Parent records with relations attached
+   */
+  async queryAndJoinRelations(parentTable, parentRecords, relations) {
+    const explicitFkRelations = relations.filter((r) => r.explicitFk);
+    if (explicitFkRelations.length === 0) {
+      return parentRecords;
+    }
+    const idCache = /* @__PURE__ */ new Map();
+    const getIdsForColumn = (column) => {
+      if (!idCache.has(column)) {
+        idCache.set(column, this.joiner.extractUniqueValues(parentRecords, column));
+      }
+      return idCache.get(column);
+    };
+    const relationResults = await Promise.all(explicitFkRelations.map(async (relation) => {
+      const resolved = this.buildExplicitFkRelationship(parentTable, relation);
+      const idColumn = resolved.type === "one-to-many" ? resolved.referencedColumn : resolved.foreignKey;
+      const parentIds = getIdsForColumn(idColumn);
+      if (parentIds.length === 0) {
+        return {
+          relation,
+          resolved,
+          records: []
+        };
+      }
+      const filterColumn = resolved.type === "one-to-many" ? resolved.foreignKey : resolved.referencedColumn;
+      const relSelect = this.buildRelatedSelect(relation);
+      const {
+        schema: targetSchema,
+        tableName: targetTable
+      } = parseTableIdentifier(relation.explicitFk.targetTable);
+      let records = await this.queryRelatedRecords(targetSchema, targetTable, relSelect, filterColumn, parentIds);
+      if (relation.relations.length > 0 && records.length > 0) {
+        const nestedExplicitFk = relation.relations.filter((r) => r.explicitFk);
+        if (nestedExplicitFk.length > 0) {
+          records = await this.queryAndJoinRelations(relation.explicitFk.targetTable, records, relation.relations);
+        }
+      }
+      return {
+        relation,
+        resolved,
+        records
+      };
+    }));
+    let result = [...parentRecords];
+    for (const {
+      relation,
+      resolved,
+      records
+    } of relationResults) {
+      const relationName = relation.alias ?? relation.name;
+      if (records.length === 0) {
+        result = result.map((r) => ({
+          ...r,
+          [relationName]: resolved.type === "one-to-many" ? [] : null
+        }));
+        continue;
+      }
+      result = this.joiner.join(result, records, resolved, relationName);
+    }
+    return result;
+  }
+  /**
+   * Build the select string for a related table.
+   */
+  buildRelatedSelect(relation) {
+    const parts = [];
+    if (relation.columns === "*") {
+      parts.push("*");
+    } else {
+      for (const col of relation.columns) {
+        if (col.alias) {
+          parts.push(`${col.alias}:${col.name}`);
+        } else {
+          parts.push(col.name);
+        }
+      }
+    }
+    for (const nested of relation.relations) {
+      if (!nested.explicitFk) {
+        const innerSelect = this.buildNestedSelect(nested);
+        if (nested.alias) {
+          parts.push(`${nested.alias}:${nested.name}(${innerSelect})`);
+        } else {
+          parts.push(`${nested.name}(${innerSelect})`);
+        }
+      }
+    }
+    return parts.join(", ");
+  }
+  /**
+   * Build a ResolvedRelationship from an explicit FK specification.
+   * This bypasses schema lookup and constructs the relationship directly.
+   */
+  buildExplicitFkRelationship(parentTable, relation) {
+    const explicitFk = relation.explicitFk;
+    const {
+      tableName: targetTable
+    } = parseTableIdentifier(explicitFk.targetTable);
+    return {
+      type: "many-to-one",
+      fromTable: parentTable,
+      toTable: targetTable,
+      foreignKey: explicitFk.sourceField,
+      referencedColumn: explicitFk.targetColumn ?? "id"
+    };
+  }
+};
+
 // src/adapters/supabase-adapter.ts
 var SupabaseAdapter = class {
   constructor(supabase, schema) {
@@ -5107,28 +5451,19 @@ var SupabaseAdapter = class {
     supportsCache: false,
     supportsSync: false
   };
-  // ===========================================================================
-  // Private Helper - Table Name Parsing
-  // ===========================================================================
   /**
-   * Parse a table identifier to extract schema and table name.
-   * Handles schema-qualified names like "core.Profile" -> { schema: "core", tableName: "Profile" }
-   *
-   * @param table - The table name, optionally schema-qualified (e.g., "users" or "core.Profile")
-   * @returns Object with schema (defaults to "public") and tableName
+   * Query executor for handling explicit FK syntax.
+   * Lazily initialized when needed.
    */
-  parseTableIdentifier(table) {
-    if (table.includes(".")) {
-      const [schema, ...rest] = table.split(".");
-      return {
-        schema,
-        tableName: rest.join(".")
-      };
+  queryExecutor = null;
+  /**
+   * Get or create the SupabaseQueryExecutor for explicit FK queries.
+   */
+  getQueryExecutor() {
+    if (!this.queryExecutor) {
+      this.queryExecutor = new SupabaseQueryExecutor(this.supabase, this.schema);
     }
-    return {
-      schema: "public",
-      tableName: table
-    };
+    return this.queryExecutor;
   }
   // ===========================================================================
   // Query Operations
@@ -5161,6 +5496,14 @@ var SupabaseAdapter = class {
       limit,
       offset
     } = options;
+    if (select && selectHasExplicitFkSyntax(select)) {
+      const executor = this.getQueryExecutor();
+      const result = await executor.execute(table, options);
+      return {
+        data: result.data,
+        count: result.count
+      };
+    }
     if (this.hasInvalidUuidFilter(where)) {
       console.warn(`[SupabaseAdapter] Query on ${table} has invalid UUID filter (empty string), returning empty results`);
       return {
@@ -5171,12 +5514,12 @@ var SupabaseAdapter = class {
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     let query = this.supabase.schema(schema).from(tableName).select(select, {
       count: "exact"
     });
     if (where) {
-      query = this.applyWhereClause(query, where);
+      query = applyWhereClause(query, where);
     }
     if (orderBy && orderBy.length > 0) {
       for (const order of orderBy) {
@@ -5213,10 +5556,14 @@ var SupabaseAdapter = class {
    */
   async queryById(table, id, options) {
     const select = options?.select ?? "*";
+    if (select && selectHasExplicitFkSyntax(select)) {
+      const executor = this.getQueryExecutor();
+      return executor.executeById(table, id, options);
+    }
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     const {
       data,
       error
@@ -5243,7 +5590,7 @@ var SupabaseAdapter = class {
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     const {
       data: insertedData,
       error
@@ -5265,7 +5612,7 @@ var SupabaseAdapter = class {
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     const {
       data: updatedData,
       error
@@ -5290,7 +5637,7 @@ var SupabaseAdapter = class {
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     const hasId = "id" in data && data.id != null;
     if (hasId) {
       const id = data.id;
@@ -5325,7 +5672,7 @@ var SupabaseAdapter = class {
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     const {
       error
     } = await this.supabase.schema(schema).from(tableName).delete().eq("id", id);
@@ -5348,7 +5695,7 @@ var SupabaseAdapter = class {
     const {
       schema,
       tableName
-    } = this.parseTableIdentifier(table);
+    } = parseTableIdentifier(table);
     const channelName = `v3:${table}:${Date.now()}`;
     const channel = this.supabase.channel(channelName).on("postgres_changes", {
       event: "*",
@@ -5368,71 +5715,6 @@ var SupabaseAdapter = class {
       this.supabase.removeChannel(channel);
     };
   }
-  // ===========================================================================
-  // Private Helper Methods
-  // ===========================================================================
-  /**
-   * Apply where clause filters to a Supabase query
-   *
-   * Converts WhereClause to Supabase filter methods:
-   * - Direct value: .eq(field, value)
-   * - { in: [...] }: .in(field, values)
-   * - { gt: n }: .gt(field, n)
-   * - { gte: n }: .gte(field, n)
-   * - { lt: n }: .lt(field, n)
-   * - { lte: n }: .lte(field, n)
-   * - { like: s }: .ilike(field, s)
-   * - { is: null }: .is(field, null)
-   * - { neq: v }: .neq(field, v) or .not(field, "is", null)
-   * - { notIn: [...] }: .not().in(field, values)
-   *
-   * @param query - The Supabase query builder
-   * @param where - The where clause to apply
-   * @returns The query with filters applied
-   */
-  applyWhereClause(query, where) {
-    for (const [field, condition] of Object.entries(where)) {
-      if (condition === null) {
-        query = query.is(field, null);
-      } else if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean") {
-        query = query.eq(field, condition);
-      } else if (typeof condition === "object") {
-        const operators = condition;
-        if (operators.in !== void 0) {
-          query = query.in(field, operators.in);
-        }
-        if (operators.gt !== void 0) {
-          query = query.gt(field, operators.gt);
-        }
-        if (operators.gte !== void 0) {
-          query = query.gte(field, operators.gte);
-        }
-        if (operators.lt !== void 0) {
-          query = query.lt(field, operators.lt);
-        }
-        if (operators.lte !== void 0) {
-          query = query.lte(field, operators.lte);
-        }
-        if (operators.like !== void 0) {
-          query = query.ilike(field, operators.like);
-        }
-        if (operators.is !== void 0) {
-          query = query.is(field, null);
-        }
-        if (operators.neq !== void 0) {
-          if (operators.neq === null) {
-            query = query.not(field, "is", null);
-          } else {
-            query = query.neq(field, operators.neq);
-          }
-        }
-        if (operators.notIn !== void 0) {
-          query = query.not(field, "in", `(${operators.notIn.join(",")})`);
-        }
-      }
-    }
-    return query;
-  }
 };
 function createSupabaseAdapter(supabase, schema) {
   return new SupabaseAdapter(supabase, schema);
@@ -5652,6 +5934,7 @@ function useLiveChangeTracking(tableName, item, action) {
   let t0;
   if ($[0] !== item || $[1] !== oldItem || $[2] !== supabase || $[3] !== tableName) {
     t0 = () => {
+      let isMounted = true;
       setChangeLog(null);
       if (isUsable(item) === false) {
         return;
@@ -5671,6 +5954,9 @@ function useLiveChangeTracking(tableName, item, action) {
       supabase.schema("core").from("OperationLog").select().filter("tableName", "eq", tableName).filter("recordId", "eq", itemId).order("changeAt", {
         ascending: false
       }).limit(1).single().then((x) => {
+        if (!isMounted) {
+          return;
+        }
         if (isUsable(x.data) === false) {
           return;
         }
@@ -5686,6 +5972,9 @@ function useLiveChangeTracking(tableName, item, action) {
         setChangeLog(changeLog_0);
       });
       setOldItem(item);
+      return () => {
+        isMounted = false;
+      };
     };
     $[0] = item;
     $[1] = oldItem;
@@ -6931,14 +7220,6 @@ function useDbRealtime(key, query, table, primaryKeys, options) {
         if (onChange) {
           onChange(payload);
         }
-      }).on("postgres_changes", {
-        event: "DELETE",
-        schema: schemaValue,
-        table: tableNameValue
-      }, async (payload_0) => {
-        if (payload_0.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
-          await deleteItem(payload_0.old);
-        }
       }).subscribe((status) => {
         setRealtimeState(status);
         if (status === "SUBSCRIBED") {
@@ -7984,4 +8265,4 @@ moment/moment.js:
   (*! license : MIT *)
   (*! momentjs.com *)
 */
-//# sourceMappingURL=chunk-OC6S4XFL.js.map
+//# sourceMappingURL=chunk-DDL63KLQ.js.map