@pol-studios/db 1.0.9 → 1.0.11

package/dist/chunk-X3HZLNBV.js

@@ -0,0 +1,2129 @@
+import {
+  getSupabaseUrl
+} from "./chunk-GC3TBUWE.js";
+import {
+  PostgrestParser
+} from "./chunk-TKWR5AAY.js";
+import {
+  isNullOrWhitespace,
+  isUsable,
+  omit
+} from "./chunk-OQ7U6EQ3.js";
+import {
+  encode,
+  useQuery
+} from "./chunk-H6365JPC.js";
+import {
+  generateUUID,
+  useSupabase
+} from "./chunk-5EFDS7SR.js";
+
+// src/query/select-parser.ts
+function tokenizeTopLevel(input) {
+  const tokens = [];
+  let current = "";
+  let depth = 0;
+  for (const char of input) {
+    if (char === "(") {
+      depth++;
+      current += char;
+    } else if (char === ")") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      const trimmed2 = current.trim();
+      if (trimmed2) {
+        tokens.push(trimmed2);
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed) {
+    tokens.push(trimmed);
+  }
+  return tokens;
+}
+function parseColumnToken(token) {
+  const aliasMatch = token.match(/^(\w+):(\w+)$/);
+  if (aliasMatch) {
+    return {
+      name: aliasMatch[2],
+      alias: aliasMatch[1]
+    };
+  }
+  return {
+    name: token
+  };
+}
+function parseSelect(select) {
+  const trimmed = select.trim();
+  if (trimmed === "*") {
+    return {
+      columns: "*",
+      relations: []
+    };
+  }
+  if (!trimmed) {
+    return {
+      columns: "*",
+      relations: []
+    };
+  }
+  const result = {
+    columns: [],
+    relations: []
+  };
+  const tokens = tokenizeTopLevel(trimmed);
+  for (const token of tokens) {
+    const trimmedToken = token.trim();
+    if (!trimmedToken) {
+      continue;
+    }
+    const relationMatch = trimmedToken.match(/^(?:(\w+):)?(\w+)\((.+)\)$/);
+    if (relationMatch) {
+      const alias = relationMatch[1];
+      const name = relationMatch[2];
+      const innerSelect = relationMatch[3];
+      const innerParsed = parseSelect(innerSelect);
+      result.relations.push({
+        name,
+        alias,
+        columns: innerParsed.columns,
+        relations: innerParsed.relations
+      });
+    } else if (trimmedToken === "*") {
+      result.columns = "*";
+    } else {
+      const column = parseColumnToken(trimmedToken);
+      if (result.columns !== "*") {
+        result.columns.push(column);
+      }
+    }
+  }
+  if (Array.isArray(result.columns) && result.columns.length === 0) {
+    result.columns = "*";
+  }
+  return result;
+}
+function stringifySelect(parsed) {
+  const parts = [];
+  if (parsed.columns === "*") {
+    parts.push("*");
+  } else {
+    for (const col of parsed.columns) {
+      if (col.alias) {
+        parts.push(`${col.alias}:${col.name}`);
+      } else {
+        parts.push(col.name);
+      }
+    }
+  }
+  for (const rel of parsed.relations) {
+    const innerStr = stringifySelect({
+      columns: rel.columns,
+      relations: rel.relations
+    });
+    if (rel.alias) {
+      parts.push(`${rel.alias}:${rel.name}(${innerStr})`);
+    } else {
+      parts.push(`${rel.name}(${innerStr})`);
+    }
+  }
+  return parts.join(", ");
+}
+function extractColumnNames(parsed) {
+  if (parsed.columns === "*") {
+    return "*";
+  }
+  return parsed.columns.map((col) => col.name);
+}
+function extractRelationNames(parsed) {
+  return parsed.relations.map((rel) => rel.alias ?? rel.name);
+}
+function hasRelation(parsed, relationName) {
+  return parsed.relations.some((rel) => rel.name === relationName || rel.alias === relationName);
+}
+function getRelationSelect(parsed, relationName) {
+  return parsed.relations.find((rel) => rel.name === relationName || rel.alias === relationName);
+}
+
+// src/query/relationship-resolver.ts
+var RelationshipResolver = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  /**
+   * Resolve a relationship from one table to another.
+   *
+   * This handles both:
+   * - Forward relationships: This table has a FK to the related table (many-to-one)
+   * - Reverse relationships: Related table has a FK to this table (one-to-many)
+   *
+   * @param fromTable - The table we're querying from
+   * @param relationName - The name of the related table
+   * @returns The resolved relationship or null if not found
+   *
+   * @example
+   * // Forward relationship (many-to-one)
+   * // EquipmentUnit.projectDatabaseId -> ProjectDatabase.id
+   * resolver.resolve("EquipmentUnit", "ProjectDatabase")
+   * // Returns: {
+   * //   type: "many-to-one",
+   * //   fromTable: "EquipmentUnit",
+   * //   toTable: "ProjectDatabase",
+   * //   foreignKey: "projectDatabaseId",
+   * //   referencedColumn: "id"
+   * // }
+   *
+   * @example
+   * // Reverse relationship (one-to-many)
+   * // EquipmentUnit <- EquipmentFixture.equipmentUnitId
+   * resolver.resolve("EquipmentUnit", "EquipmentFixture")
+   * // Returns: {
+   * //   type: "one-to-many",
+   * //   fromTable: "EquipmentUnit",
+   * //   toTable: "EquipmentFixture",
+   * //   foreignKey: "equipmentUnitId",
+   * //   referencedColumn: "id"
+   * // }
+   */
+  resolve(fromTable, relationName) {
+    const tableSchema = this.getTableSchema(fromTable);
+    if (!tableSchema) {
+      return null;
+    }
+    for (const rel of tableSchema.relationships) {
+      if (rel.referencedTable === relationName) {
+        return {
+          type: "many-to-one",
+          fromTable,
+          toTable: relationName,
+          foreignKey: rel.foreignKey,
+          referencedColumn: rel.referencedColumn
+        };
+      }
+    }
+    const relatedTableSchema = this.getTableSchema(relationName);
+    if (relatedTableSchema) {
+      for (const rel of relatedTableSchema.relationships) {
+        if (rel.referencedTable === fromTable) {
+          return {
+            type: "one-to-many",
+            fromTable,
+            toTable: relationName,
+            foreignKey: rel.foreignKey,
+            referencedColumn: rel.referencedColumn
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all forward relationships for a table (many-to-one).
+   * These are relationships where this table has a foreign key.
+   */
+  getForwardRelationships(tableName) {
+    const tableSchema = this.getTableSchema(tableName);
+    if (!tableSchema) {
+      return [];
+    }
+    return tableSchema.relationships.map((rel) => ({
+      type: "many-to-one",
+      fromTable: tableName,
+      toTable: rel.referencedTable,
+      foreignKey: rel.foreignKey,
+      referencedColumn: rel.referencedColumn
+    }));
+  }
+  /**
+   * Get all reverse relationships for a table (one-to-many).
+   * These are relationships where other tables have FKs pointing to this table.
+   */
+  getReverseRelationships(tableName) {
+    const results = [];
+    for (const schemaName of Object.keys(this.schema.schemas)) {
+      const schemaDefinition = this.schema.schemas[schemaName];
+      if (!schemaDefinition) continue;
+      for (const [otherTableName, otherTableSchema] of Object.entries(schemaDefinition.tables)) {
+        if (otherTableName === tableName) continue;
+        for (const rel of otherTableSchema.relationships) {
+          if (rel.referencedTable === tableName) {
+            results.push({
+              type: "one-to-many",
+              fromTable: tableName,
+              toTable: otherTableName,
+              foreignKey: rel.foreignKey,
+              referencedColumn: rel.referencedColumn
+            });
+          }
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Get all relationships for a table (both directions).
+   */
+  getAllRelationships(tableName) {
+    return [...this.getForwardRelationships(tableName), ...this.getReverseRelationships(tableName)];
+  }
+  /**
+   * Check if a relationship exists between two tables.
+   */
+  hasRelationship(fromTable, toTable) {
+    return this.resolve(fromTable, toTable) !== null;
+  }
+  /**
+   * Get the table schema from the database schema.
+   * Searches across all schema namespaces (public, core, etc.).
+   */
+  getTableSchema(tableName) {
+    for (const schemaName of Object.keys(this.schema.schemas)) {
+      const schemaDefinition = this.schema.schemas[schemaName];
+      if (!schemaDefinition) continue;
+      if (schemaDefinition.tables[tableName]) {
+        return schemaDefinition.tables[tableName];
+      }
+      if (schemaDefinition.views && schemaDefinition.views[tableName]) {
+        return schemaDefinition.views[tableName];
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the primary key column for a table.
+   * Defaults to "id" if not explicitly found.
+   */
+  getPrimaryKey(tableName) {
+    const tableSchema = this.getTableSchema(tableName);
+    if (!tableSchema) {
+      return "id";
+    }
+    const idColumn = tableSchema.columns.find((col) => col.name === "id");
+    if (idColumn) {
+      return "id";
+    }
+    if (tableSchema.columns.length > 0) {
+      return tableSchema.columns[0].name;
+    }
+    return "id";
+  }
+  /**
+   * Get all column names for a table.
+   */
+  getColumnNames(tableName) {
+    const tableSchema = this.getTableSchema(tableName);
+    if (!tableSchema) {
+      return [];
+    }
+    return tableSchema.columns.map((col) => col.name);
+  }
+  /**
+   * Check if a table exists in the schema.
+   */
+  hasTable(tableName) {
+    return this.getTableSchema(tableName) !== null;
+  }
+  /**
+   * Get all table names in the schema.
+   */
+  getAllTableNames() {
+    const tables = [];
+    for (const schemaName of Object.keys(this.schema.schemas)) {
+      const schemaDefinition = this.schema.schemas[schemaName];
+      if (!schemaDefinition) continue;
+      tables.push(...Object.keys(schemaDefinition.tables));
+    }
+    return tables;
+  }
+};
+function createRelationshipResolver(schema) {
+  return new RelationshipResolver(schema);
+}
+
+// src/query/sql-builder.ts
+function isWhereOperator(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const obj = value;
+  return "in" in obj || "gt" in obj || "gte" in obj || "lt" in obj || "lte" in obj || "like" in obj || "is" in obj || "neq" in obj || "notIn" in obj;
+}
+var SQLBuilder = class {
+  /**
+   * Build a SELECT query for a single table.
+   *
+   * @param table - Table name
+   * @param columns - Columns to select ("*" or array of column definitions)
+   * @param options - Query options (where, orderBy, limit, offset)
+   * @returns Built query with SQL and parameters
+   *
+   * @example
+   * const builder = new SQLBuilder();
+   * const query = builder.build("EquipmentUnit", "*", {
+   *   where: { status: "active", projectDatabaseId: 123 },
+   *   orderBy: [{ field: "name", direction: "asc" }],
+   *   limit: 10
+   * });
+   * // query.sql: SELECT * FROM "EquipmentUnit" WHERE "status" = ? AND "projectDatabaseId" = ? ORDER BY "name" ASC LIMIT ?
+   * // query.params: ["active", 123, 10]
+   */
+  build(table, columns, options = {}) {
+    const params = [];
+    let columnList;
+    if (columns === "*") {
+      columnList = "*";
+    } else if (columns.length === 0) {
+      columnList = "*";
+    } else {
+      columnList = columns.map((c) => {
+        if (c.alias) {
+          return `"${c.name}" AS "${c.alias}"`;
+        }
+        return `"${c.name}"`;
+      }).join(", ");
+    }
+    let sql = `SELECT ${columnList} FROM "${table}"`;
+    if (options.where && Object.keys(options.where).length > 0) {
+      const whereClauses = [];
+      for (const [field, value] of Object.entries(options.where)) {
+        if (value === null) {
+          whereClauses.push(`"${field}" IS NULL`);
+        } else if (isWhereOperator(value)) {
+          const operatorClauses = this.buildOperatorClauses(field, value, params);
+          whereClauses.push(...operatorClauses);
+        } else {
+          whereClauses.push(`"${field}" = ?`);
+          params.push(value);
+        }
+      }
+      if (whereClauses.length > 0) {
+        sql += ` WHERE ${whereClauses.join(" AND ")}`;
+      }
+    }
+    if (options.orderBy && options.orderBy.length > 0) {
+      const orderClauses = options.orderBy.map((o) => `"${o.field}" ${o.direction.toUpperCase()}`);
+      sql += ` ORDER BY ${orderClauses.join(", ")}`;
+    }
+    if (options.limit !== void 0) {
+      sql += ` LIMIT ?`;
+      params.push(options.limit);
+    }
+    if (options.offset !== void 0) {
+      sql += ` OFFSET ?`;
+      params.push(options.offset);
+    }
+    return {
+      sql,
+      params
+    };
+  }
+  /**
+   * Build WHERE clauses from operator objects.
+   */
+  buildOperatorClauses(field, operators, params) {
+    const clauses = [];
+    if ("in" in operators && operators.in !== void 0) {
+      if (operators.in.length === 0) {
+        clauses.push("1 = 0");
+      } else {
+        const placeholders = operators.in.map(() => "?").join(", ");
+        clauses.push(`"${field}" IN (${placeholders})`);
+        params.push(...operators.in);
+      }
+    }
+    if ("notIn" in operators && operators.notIn !== void 0) {
+      if (operators.notIn.length === 0) {
+      } else {
+        const placeholders = operators.notIn.map(() => "?").join(", ");
+        clauses.push(`"${field}" NOT IN (${placeholders})`);
+        params.push(...operators.notIn);
+      }
+    }
+    if ("gt" in operators && operators.gt !== void 0) {
+      clauses.push(`"${field}" > ?`);
+      params.push(operators.gt);
+    }
+    if ("gte" in operators && operators.gte !== void 0) {
+      clauses.push(`"${field}" >= ?`);
+      params.push(operators.gte);
+    }
+    if ("lt" in operators && operators.lt !== void 0) {
+      clauses.push(`"${field}" < ?`);
+      params.push(operators.lt);
+    }
+    if ("lte" in operators && operators.lte !== void 0) {
+      clauses.push(`"${field}" <= ?`);
+      params.push(operators.lte);
+    }
+    if ("like" in operators && operators.like !== void 0) {
+      clauses.push(`"${field}" LIKE ?`);
+      const pattern = operators.like.includes("%") ? operators.like : `%${operators.like}%`;
+      params.push(pattern);
+    }
+    if ("is" in operators && operators.is === null) {
+      clauses.push(`"${field}" IS NULL`);
+    }
+    if ("neq" in operators && operators.neq !== void 0) {
+      if (operators.neq === null) {
+        clauses.push(`"${field}" IS NOT NULL`);
+      } else {
+        clauses.push(`"${field}" != ?`);
+        params.push(operators.neq);
+      }
+    }
+    return clauses;
+  }
+  /**
+   * Build a query to fetch related records by foreign key.
+   *
+   * @param table - The related table name
+   * @param foreignKey - The FK column to match against
+   * @param parentIds - Array of parent IDs to fetch related records for
+   * @param columns - Columns to select
+   * @returns Built query
+   *
+   * @example
+   * // Fetch all EquipmentFixtures for given EquipmentUnit IDs
+   * const query = builder.buildRelationQuery(
+   *   "EquipmentFixture",
+   *   "equipmentUnitId",
+   *   ["uuid-1", "uuid-2"],
+   *   "*"
+   * );
+   * // query.sql: SELECT * FROM "EquipmentFixture" WHERE "equipmentUnitId" IN (?, ?)
+   * // query.params: ["uuid-1", "uuid-2"]
+   */
+  buildRelationQuery(table, foreignKey, parentIds, columns) {
+    if (parentIds.length === 0) {
+      return {
+        sql: `SELECT ${columns === "*" ? "*" : this.buildColumnList(columns, foreignKey)} FROM "${table}" WHERE 1 = 0`,
+        params: []
+      };
+    }
+    let columnList;
+    if (columns === "*") {
+      columnList = "*";
+    } else {
+      columnList = this.buildColumnList(columns, foreignKey);
+    }
+    const placeholders = parentIds.map(() => "?").join(", ");
+    const sql = `SELECT ${columnList} FROM "${table}" WHERE "${foreignKey}" IN (${placeholders})`;
+    return {
+      sql,
+      params: [...parentIds]
+    };
+  }
+  /**
+   * Build column list ensuring the foreign key is included.
+   */
+  buildColumnList(columns, foreignKey) {
+    const colNames = columns.map((c) => c.name);
+    const columnList = columns.map((c) => {
+      if (c.alias) {
+        return `"${c.name}" AS "${c.alias}"`;
+      }
+      return `"${c.name}"`;
+    });
+    if (!colNames.includes(foreignKey)) {
+      columnList.unshift(`"${foreignKey}"`);
+    }
+    return columnList.join(", ");
+  }
+  /**
+   * Build a SELECT query for a single record by ID.
+   *
+   * @param table - Table name
+   * @param id - Record ID
+   * @param columns - Columns to select
+   * @param idColumn - Name of the ID column (defaults to "id")
+   * @returns Built query
+   */
+  buildByIdQuery(table, id, columns = "*", idColumn = "id") {
+    let columnList;
+    if (columns === "*") {
+      columnList = "*";
+    } else if (columns.length === 0) {
+      columnList = "*";
+    } else {
+      columnList = columns.map((c) => c.alias ? `"${c.name}" AS "${c.alias}"` : `"${c.name}"`).join(", ");
+    }
+    const sql = `SELECT ${columnList} FROM "${table}" WHERE "${idColumn}" = ? LIMIT 1`;
+    return {
+      sql,
+      params: [id]
+    };
+  }
+  /**
+   * Build an INSERT query.
+   *
+   * @param table - Table name
+   * @param data - Record data to insert
+   * @returns Built query
+   */
+  buildInsertQuery(table, data) {
+    const columns = Object.keys(data).filter((k) => data[k] !== void 0);
+    const values = columns.map((k) => data[k]);
+    if (columns.length === 0) {
+      throw new Error("Cannot insert empty record");
+    }
+    const columnList = columns.map((c) => `"${c}"`).join(", ");
+    const placeholders = columns.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${table}" (${columnList}) VALUES (${placeholders})`;
+    return {
+      sql,
+      params: values
+    };
+  }
+  /**
+   * Build an UPDATE query.
+   *
+   * @param table - Table name
+   * @param id - Record ID
+   * @param data - Fields to update
+   * @param idColumn - Name of the ID column (defaults to "id")
+   * @returns Built query
+   */
+  buildUpdateQuery(table, id, data, idColumn = "id") {
+    const columns = Object.keys(data).filter((k) => k !== idColumn && data[k] !== void 0);
+    if (columns.length === 0) {
+      throw new Error("No fields to update");
+    }
+    const setClauses = columns.map((c) => `"${c}" = ?`).join(", ");
+    const values = columns.map((k) => data[k]);
+    const sql = `UPDATE "${table}" SET ${setClauses} WHERE "${idColumn}" = ?`;
+    return {
+      sql,
+      params: [...values, id]
+    };
+  }
+  /**
+   * Build a DELETE query.
+   *
+   * @param table - Table name
+   * @param id - Record ID
+   * @param idColumn - Name of the ID column (defaults to "id")
+   * @returns Built query
+   */
+  buildDeleteQuery(table, id, idColumn = "id") {
+    const sql = `DELETE FROM "${table}" WHERE "${idColumn}" = ?`;
+    return {
+      sql,
+      params: [id]
+    };
+  }
+  /**
+   * Build a COUNT query.
+   *
+   * @param table - Table name
+   * @param where - Optional where clause
+   * @returns Built query
+   */
+  buildCountQuery(table, where) {
+    const params = [];
+    let sql = `SELECT COUNT(*) as count FROM "${table}"`;
+    if (where && Object.keys(where).length > 0) {
+      const whereClauses = [];
+      for (const [field, value] of Object.entries(where)) {
+        if (value === null) {
+          whereClauses.push(`"${field}" IS NULL`);
+        } else if (isWhereOperator(value)) {
+          const operatorClauses = this.buildOperatorClauses(field, value, params);
+          whereClauses.push(...operatorClauses);
+        } else {
+          whereClauses.push(`"${field}" = ?`);
+          params.push(value);
+        }
+      }
+      if (whereClauses.length > 0) {
+        sql += ` WHERE ${whereClauses.join(" AND ")}`;
+      }
+    }
+    return {
+      sql,
+      params
+    };
+  }
+};
+function createSQLBuilder() {
+  return new SQLBuilder();
+}
+
+// src/query/result-joiner.ts
+var ResultJoiner = class {
+  /**
+   * Join related data onto base records.
+   *
+   * @param baseRecords - The base table records
+   * @param relatedRecords - Records from the related table
+   * @param relationship - The relationship definition
+   * @param relationName - The property name to use for the relation
+   * @returns Base records with related data attached
+   *
+   * @example
+   * // One-to-many: EquipmentUnit -> EquipmentFixture[]
+   * const joiner = new ResultJoiner();
+   * const result = joiner.join(
+   *   equipmentUnits,
+   *   equipmentFixtures,
+   *   { type: "one-to-many", foreignKey: "equipmentUnitId", referencedColumn: "id", ... },
+   *   "EquipmentFixture"
+   * );
+   * // Each equipmentUnit now has EquipmentFixture: [...]
+   *
+   * @example
+   * // Many-to-one: EquipmentUnit -> ProjectDatabase
+   * const result = joiner.join(
+   *   equipmentUnits,
+   *   projectDatabases,
+   *   { type: "many-to-one", foreignKey: "projectDatabaseId", referencedColumn: "id", ... },
+   *   "ProjectDatabase"
+   * );
+   * // Each equipmentUnit now has ProjectDatabase: {...} or null
+   */
+  join(baseRecords, relatedRecords, relationship, relationName) {
+    if (baseRecords.length === 0) {
+      return baseRecords;
+    }
+    if (relationship.type === "one-to-many") {
+      return baseRecords.map((base) => {
+        const baseId = base[relationship.referencedColumn];
+        const related = relatedRecords.filter((r) => r[relationship.foreignKey] === baseId);
+        return {
+          ...base,
+          [relationName]: related
+        };
+      });
+    } else {
+      const relatedMap = /* @__PURE__ */ new Map();
+      for (const r of relatedRecords) {
+        const refValue = r[relationship.referencedColumn];
+        if (refValue !== null && refValue !== void 0) {
+          relatedMap.set(refValue, r);
+        }
+      }
+      return baseRecords.map((base) => {
+        const fkValue = base[relationship.foreignKey];
+        const related = fkValue != null ? relatedMap.get(fkValue) ?? null : null;
+        return {
+          ...base,
+          [relationName]: related
+        };
+      });
+    }
+  }
+  /**
+   * Recursively join nested relations onto records.
+   *
+   * @param baseRecords - The base records
+   * @param relationData - Map of relation names to join data
+   * @returns Base records with all nested relations attached
+   *
+   * @example
+   * // Join EquipmentFixture and ProjectDatabase onto EquipmentUnit
+   * // where EquipmentFixture has its own nested Organization relation
+   * const result = joiner.joinNested(equipmentUnits, new Map([
+   *   ["EquipmentFixture", {
+   *     records: fixtures,
+   *     relationship: { type: "one-to-many", ... },
+   *     nestedRelations: new Map()
+   *   }],
+   *   ["ProjectDatabase", {
+   *     records: projects,
+   *     relationship: { type: "many-to-one", ... },
+   *     nestedRelations: new Map([
+   *       ["Organization", { records: orgs, relationship: ..., nestedRelations: new Map() }]
+   *     ])
+   *   }]
+   * ]));
+   */
+  joinNested(baseRecords, relationData) {
+    let result = [...baseRecords];
+    const entries = Array.from(relationData.entries());
+    for (const [relationName, data] of entries) {
+      let relatedRecords = data.records;
+      if (data.nestedRelations.size > 0) {
+        relatedRecords = this.joinNested(relatedRecords, data.nestedRelations);
+      }
+      result = this.join(result, relatedRecords, data.relationship, relationName);
+    }
+    return result;
+  }
+  /**
+   * Group records by a key field.
+   * Useful for preparing data before joining.
+   *
+   * @param records - Records to group
+   * @param keyField - Field to group by
+   * @returns Map of key values to arrays of records
+   */
+  groupBy(records, keyField) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const key = record[keyField];
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key).push(record);
+    }
+    return groups;
+  }
+  /**
+   * Index records by a unique key field.
+   * Useful for many-to-one lookups.
+   *
+   * @param records - Records to index
+   * @param keyField - Field to index by (should be unique)
+   * @returns Map of key values to single records
+   */
+  indexBy(records, keyField) {
+    const index = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const key = record[keyField];
+      if (key !== null && key !== void 0) {
+        index.set(key, record);
+      }
+    }
+    return index;
+  }
+  /**
+   * Extract unique values for a field from records.
+   * Useful for building IN clauses for related queries.
+   *
+   * @param records - Records to extract from
+   * @param field - Field to extract
+   * @returns Array of unique non-null values
+   */
+  extractUniqueValues(records, field) {
+    const values = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      const value = record[field];
+      if (value !== null && value !== void 0) {
+        values.add(value);
+      }
+    }
+    return Array.from(values);
+  }
+  /**
+   * Remove a relation property from records (for cleanup).
+   *
+   * @param records - Records to process
+   * @param relationName - Relation property to remove
+   * @returns Records without the specified property
+   */
+  removeRelation(records, relationName) {
+    return records.map((record) => {
+      const {
+        [relationName]: _removed,
+        ...rest
+      } = record;
+      return rest;
+    });
+  }
+  /**
+   * Flatten a nested relation into the parent record.
+   * Useful for flattening many-to-one relations.
+   *
+   * @param records - Records with nested relation
+   * @param relationName - Name of the relation to flatten
+   * @param prefix - Prefix for flattened field names
+   * @returns Records with flattened relation fields
+   */
+  flattenRelation(records, relationName, prefix = "") {
+    return records.map((record) => {
+      const relation = record[relationName];
+      const {
+        [relationName]: _removed,
+        ...rest
+      } = record;
+      if (!relation) {
+        return rest;
+      }
+      const flattenedRelation = {};
+      for (const [key, value] of Object.entries(relation)) {
+        const fieldName = prefix ? `${prefix}_${key}` : `${relationName}_${key}`;
+        flattenedRelation[fieldName] = value;
+      }
+      return {
+        ...rest,
+        ...flattenedRelation
+      };
+    });
+  }
+};
+function createResultJoiner() {
+  return new ResultJoiner();
+}
+
+// src/query/executor.ts
+var QueryExecutor = class {
+  constructor(db, schema) {
+    this.db = db;
+    this.schema = schema;
+    this.resolver = new RelationshipResolver(schema);
+    this.builder = new SQLBuilder();
+    this.joiner = new ResultJoiner();
+  }
+  resolver;
+  builder;
+  joiner;
+  /**
+   * Execute a query and return results.
+   *
+   * @param table - The table to query
+   * @param options - Query options including select, where, orderBy, limit, offset
+   * @returns Array of records with relations attached
+   */
+  async execute(table, options = {}) {
+    const parsed = parseSelect(options.select ?? "*");
+    const baseQuery = this.builder.build(table, parsed.columns, {
+      where: options.where,
+      orderBy: options.orderBy,
+      limit: options.limit,
+      offset: options.offset
+    });
+    const baseRecords = await this.db.getAll(baseQuery.sql, baseQuery.params);
+    if (baseRecords.length === 0 || parsed.relations.length === 0) {
+      return baseRecords;
+    }
+    const result = await this.queryAndJoinRelations(table, baseRecords, parsed.relations);
+    return result;
+  }
+  /**
+   * Execute a query for a single record by ID.
+   *
+   * @param table - The table to query
+   * @param id - The record ID
+   * @param options - Query options (only select is used)
+   * @returns Single record or null
+   */
+  async executeById(table, id, options = {}) {
+    const parsed = parseSelect(options.select ?? "*");
+    const idColumn = this.resolver.getPrimaryKey(table);
+    const baseQuery = this.builder.buildByIdQuery(table, id, parsed.columns, idColumn);
+    const records = await this.db.getAll(baseQuery.sql, baseQuery.params);
+    if (records.length === 0) {
+      return null;
+    }
+    if (parsed.relations.length === 0) {
+      return records[0];
+    }
+    const result = await this.queryAndJoinRelations(table, records, parsed.relations);
+    return result[0];
+  }
+  /**
+   * Execute a count query.
+   *
+   * @param table - The table to count
+   * @param options - Query options (only where is used)
+   * @returns Count of matching records
+   */
+  async count(table, options = {}) {
+    const query = this.builder.buildCountQuery(table, options.where);
+    const result = await this.db.getAll(query.sql, query.params);
+    return result[0]?.count ?? 0;
+  }
+  /**
+   * Insert a record.
+   *
+   * @param table - The table to insert into
+   * @param data - The record data
+   * @returns The inserted record (re-fetched to get defaults)
+   */
+  async insert(table, data) {
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert called:`, {
+        table,
+        dataKeys: Object.keys(data),
+        hasId: "id" in data
+      });
+    }
+    const idColumn = this.resolver.getPrimaryKey(table);
+    if (!data[idColumn]) {
+      const [{
+        id
+      }] = await this.db.getAll("SELECT uuid() as id");
+      data = {
+        ...data,
+        [idColumn]: id
+      };
+      if (__DEV__) {
+        console.log(`[QueryExecutor] insert generated UUID:`, {
+          table,
+          id
+        });
+      }
+    }
+    const query = this.builder.buildInsertQuery(table, data);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert executing SQL:`, {
+        table,
+        sql: query.sql,
+        paramCount: query.params.length
+      });
+    }
+    await this.db.execute(query.sql, query.params);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert SQL executed successfully:`, {
+        table,
+        id: data[idColumn]
+      });
+    }
+    const result = await this.executeById(table, data[idColumn]);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] insert completed:`, {
+        table,
+        operation: "insert",
+        resultId: result?.[idColumn] ?? data[idColumn],
+        refetchSucceeded: result !== null
+      });
+    }
+    return result ?? data;
+  }
+  /**
+   * Update a record.
+   *
+   * @param table - The table to update
+   * @param id - The record ID
+   * @param data - The fields to update
+   * @returns The updated record
+   */
+  async update(table, id, data) {
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update called:`, {
+        table,
+        id,
+        dataKeys: Object.keys(data)
+      });
+    }
+    const idColumn = this.resolver.getPrimaryKey(table);
+    const query = this.builder.buildUpdateQuery(table, id, data, idColumn);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update executing SQL:`, {
+        table,
+        id,
+        sql: query.sql,
+        paramCount: query.params.length
+      });
+    }
+    await this.db.execute(query.sql, query.params);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update SQL executed successfully:`, {
+        table,
+        id
+      });
+    }
+    const result = await this.executeById(table, id);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] update completed:`, {
+        table,
+        operation: "update",
+        id,
+        refetchSucceeded: result !== null
+      });
+    }
+    if (result) {
+      return result;
+    }
+    return {
+      ...data,
+      [idColumn]: id
+    };
+  }
+  /**
+   * Upsert a record (insert or update).
+   *
+   * @param table - The table to upsert into
+   * @param data - The record data (must include ID for update)
+   * @returns The upserted record
+   */
+  async upsert(table, data) {
+    if (__DEV__) {
+      console.log(`[QueryExecutor] upsert called:`, {
+        table,
+        dataKeys: Object.keys(data),
+        hasId: "id" in data,
+        idValue: data.id ?? "none"
+      });
+    }
+    const idColumn = this.resolver.getPrimaryKey(table);
+    let id = data[idColumn];
+    if (!id) {
+      const [{
+        id: generatedId
+      }] = await this.db.getAll("SELECT uuid() as id");
+      id = generatedId;
+      data = {
+        ...data,
+        [idColumn]: id
+      };
+      if (__DEV__) {
+        console.log(`[QueryExecutor] upsert generated UUID:`, {
+          table,
+          id
+        });
+      }
+    }
+    const existing = await this.executeById(table, id);
+    if (__DEV__) {
+      console.log(`[QueryExecutor] upsert existence check:`, {
+        table,
+        id,
+        exists: existing !== null,
+        willPerform: existing ? "update" : "insert"
+      });
+    }
+    if (existing) {
+      return this.update(table, id, data);
+    }
+    return this.insert(table, data);
+  }
+  /**
+   * Delete a record.
+   *
+   * @param table - The table to delete from
+   * @param id - The record ID
+   */
+  async delete(table, id) {
+    const idColumn = this.resolver.getPrimaryKey(table);
+    const query = this.builder.buildDeleteQuery(table, id, idColumn);
+    await this.db.execute(query.sql, query.params);
+  }
+  /**
+   * 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) {
+    let result = [...parentRecords];
+    for (const relation of relations) {
+      const resolved = this.resolver.resolve(parentTable, relation.name);
+      if (!resolved) {
+        console.warn(`Could not resolve relationship: ${parentTable} -> ${relation.name}`);
+        continue;
+      }
+      const parentIds = this.getParentIdsForRelation(parentRecords, resolved);
+      if (parentIds.length === 0) {
+        result = result.map((r) => ({
+          ...r,
+          [relation.alias ?? relation.name]: resolved.type === "one-to-many" ? [] : null
+        }));
+        continue;
+      }
+      const relQuery = this.buildRelatedQuery(relation, resolved, parentIds);
+      let relatedRecords = await this.db.getAll(relQuery.sql, relQuery.params);
+      if (relation.relations.length > 0 && relatedRecords.length > 0) {
+        relatedRecords = await this.queryAndJoinRelations(relation.name, relatedRecords, relation.relations);
+      }
+      result = this.joiner.join(result, relatedRecords, resolved, relation.alias ?? relation.name);
+    }
+    return result;
+  }
+  /**
+   * Get parent IDs needed for a relation query.
+   */
+  getParentIdsForRelation(parentRecords, resolved) {
+    let parentIds;
+    if (resolved.type === "one-to-many") {
+      parentIds = this.joiner.extractUniqueValues(parentRecords, resolved.referencedColumn);
+    } else {
+      parentIds = this.joiner.extractUniqueValues(parentRecords, resolved.foreignKey);
+    }
+    return parentIds;
+  }
+  /**
+   * Build a query for related records.
+   */
+  buildRelatedQuery(relation, resolved, parentIds) {
+    const filterColumn = resolved.type === "one-to-many" ? resolved.foreignKey : resolved.referencedColumn;
+    const uniqueIds = Array.from(new Set(parentIds));
+    return this.builder.buildRelationQuery(relation.name, filterColumn, uniqueIds, relation.columns);
+  }
+  /**
+   * Get the relationship resolver (for advanced use).
+   */
+  getResolver() {
+    return this.resolver;
+  }
+  /**
+   * Get the SQL builder (for advanced use).
+   */
+  getBuilder() {
+    return this.builder;
+  }
+  /**
+   * Get the result joiner (for advanced use).
+   */
+  getJoiner() {
+    return this.joiner;
+  }
+};
+function createQueryExecutor(db, schema) {
+  return new QueryExecutor(db, schema);
+}
+
+// src/query/useQuery.ts
+import { c as _c } from "react/compiler-runtime";
+import { useDelayedValue } from "@pol-studios/hooks/state";
+function useQuery2(query, config) {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== query) {
+    const queryKey = encode(query, false);
+    t0 = queryKey.join("-");
+    $[0] = query;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const queryKeyString = t0;
+  const debouncedKeyString = useDelayedValue(queryKeyString, 50);
+  const isKeyStable = queryKeyString === debouncedKeyString;
+  const effectiveEnabled = config?.enabled !== false && isKeyStable;
+  let t1;
+  if ($[2] !== config || $[3] !== effectiveEnabled) {
+    t1 = omit({
+      retry: 1,
+      ...config,
+      enabled: effectiveEnabled
+    }, ["queryKey"]);
+    $[2] = config;
+    $[3] = effectiveEnabled;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const request = useQuery(query, t1);
+  return request;
+}
+
+// src/query/usePartialQuery.ts
+import { c as _c2 } from "react/compiler-runtime";
+import { useSessionStorageState } from "@pol-studios/hooks/storage";
+function usePartialQuery(query, itemCountPerPage, config) {
+  const $ = _c2(28);
+  let t0;
+  if ($[0] !== query) {
+    t0 = encode(query, false);
+    $[0] = query;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const initialQuery = t0;
+  let t1;
+  if ($[2] !== initialQuery[7] || $[3] !== initialQuery[8]) {
+    t1 = [initialQuery[7], initialQuery[8]];
+    $[2] = initialQuery[7];
+    $[3] = initialQuery[8];
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  const id = t1.join("-");
+  const [currentPage, setCurrentPage] = useSessionStorageState(id, 1);
+  const page = currentPage ?? 1;
+  const t2 = query;
+  let t3;
+  if ($[5] !== itemCountPerPage || $[6] !== page || $[7] !== t2) {
+    t3 = t2.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
+    $[5] = itemCountPerPage;
+    $[6] = page;
+    $[7] = t2;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  const rangedQuery = t3;
+  const baseQuery = useQuery2(rangedQuery, config);
+  let t4;
+  if ($[9] !== setCurrentPage) {
+    t4 = () => {
+      setCurrentPage(_temp);
+    };
+    $[9] = setCurrentPage;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  const safeFetchNextPage = t4;
+  let t5;
+  if ($[11] !== setCurrentPage) {
+    t5 = () => {
+      setCurrentPage(_temp2);
+    };
+    $[11] = setCurrentPage;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  const fetchPreviousPage = t5;
+  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
+  let t6;
+  if ($[13] !== baseQuery.count || $[14] !== baseQuery.data || $[15] !== currentPage || $[16] !== itemCountPerPage) {
+    t6 = baseQuery.data ? toPagedResponse(baseQuery.data, currentPage, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
+    $[13] = baseQuery.count;
+    $[14] = baseQuery.data;
+    $[15] = currentPage;
+    $[16] = itemCountPerPage;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  const t7 = currentPage < pageCount;
+  const t8 = currentPage > 1;
+  let t9;
+  if ($[18] !== baseQuery || $[19] !== currentPage || $[20] !== fetchPreviousPage || $[21] !== pageCount || $[22] !== safeFetchNextPage || $[23] !== setCurrentPage || $[24] !== t6 || $[25] !== t7 || $[26] !== t8) {
+    t9 = {
+      ...baseQuery,
+      fetchPreviousPage,
+      fetchNextPage: safeFetchNextPage,
+      currentPage,
+      setCurrentPage,
+      data: t6,
+      pageCount,
+      hasNextPage: t7,
+      hasPreviousPage: t8
+    };
+    $[18] = baseQuery;
+    $[19] = currentPage;
+    $[20] = fetchPreviousPage;
+    $[21] = pageCount;
+    $[22] = safeFetchNextPage;
+    $[23] = setCurrentPage;
+    $[24] = t6;
+    $[25] = t7;
+    $[26] = t8;
+    $[27] = t9;
+  } else {
+    t9 = $[27];
+  }
+  return t9;
+}
+function _temp2(currentPage_1) {
+  return currentPage_1 - 1;
+}
+function _temp(currentPage_0) {
+  return currentPage_0 + 1;
+}
+function toPagedResponse(results, currentPage, totalCount, itemPerPage) {
+  const newPage = {
+    Items: results,
+    CurrentPage: currentPage,
+    ItemCount: totalCount,
+    MaxCountPerPage: itemPerPage,
+    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
+  };
+  return newPage;
+}
+
+// src/query/useAdvancedQuery.ts
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import { useSessionStorageState as useSessionStorageState2 } from "@pol-studios/hooks/storage";
+var normalizeFilter = (filter) => {
+  const groupOp = filter.op || filter.operator;
+  if (groupOp && (groupOp === "AND" || groupOp === "OR") && filter.filters) {
+    return {
+      id: filter.id || generateUUID(),
+      op: groupOp,
+      not: filter.not || filter.inverted,
+      // Support both 'not' and legacy 'inverted' for groups
+      filters: filter.filters.map(normalizeFilter).filter(Boolean)
+    };
+  }
+  let operator = filter.op || filter.condition;
+  let shouldNegate = filter.not || filter.inverted || false;
+  if (operator === "\u220B") operator = "in";
+  if (operator === "\u2260" || operator === "!=") {
+    operator = "=";
+    shouldNegate = true;
+  }
+  if (operator === "like") operator = "contains";
+  if (operator === "regex" || operator === "regex_i" || operator === "similar_to") {
+    operator = "contains";
+  }
+  if (!operator) {
+    console.error("Filter has undefined operator:", JSON.stringify(filter, null, 2));
+    return null;
+  }
+  if (filter.propertyName) {
+    return {
+      id: filter.id || generateUUID(),
+      field: filter.propertyName,
+      op: operator,
+      value: filter.value,
+      not: shouldNegate,
+      display: filter.display || filter.propertyName
+    };
+  }
+  return {
+    id: filter.id || generateUUID(),
+    field: filter.field || "",
+    op: operator,
+    value: filter.value,
+    not: shouldNegate,
+    similarity: filter.similarity,
+    where: filter.where,
+    display: filter.display || filter.field || ""
+  };
+};
+function useAdvancedFilterQuery(query, config) {
+  const filterKey = useMemo(() => config?.filterKey ?? window.location?.pathname, [config?.filterKey]);
+  const [filterLayer, setFilterLayer] = useSessionStorageState2(filterKey, {
+    id: "root",
+    op: "AND",
+    filters: [],
+    pagination: void 0,
+    sort: [],
+    isReady: isUsable(config?.searchByDefault) ? config.searchByDefault ? false : true : true
+  });
+  const parser = useMemo(() => new PostgrestParser(query), [query, config?.key]);
+  useEffect(() => {
+    const searchParam = parser.searchParams.get("order");
+    if (searchParam) {
+      const orderColumns = searchParam.split(",");
+      const orders = [];
+      orderColumns.forEach((x) => {
+        const values = x.split(".");
+        orders.push({
+          field: values[0],
+          direction: values[1] === "asc" ? "asc" : "desc"
+        });
+      });
+      setFilterLayer((pre) => {
+        if (!pre) {
+          return {
+            id: "root",
+            op: "AND",
+            filters: [],
+            isReady: true,
+            sort: orders
+          };
+        }
+        return {
+          ...pre,
+          id: pre.id || "root",
+          op: pre.op || "AND",
+          filters: pre.filters || [],
+          isReady: pre.isReady ?? true,
+          sort: [...(pre.sort || []).filter((old) => orders.some((o) => o.field === old.field) === false), ...orders]
+        };
+      });
+    }
+  }, [JSON.stringify(parser.searchParams), config?.key]);
+  const encodedQueryKeyRef = useRef([]);
+  const encodedQueryKey = useMemo(() => {
+    const newEncoded = encode(query, false);
+    const newEncodedString = JSON.stringify(newEncoded);
+    const oldEncodedString = JSON.stringify(encodedQueryKeyRef.current);
+    if (newEncodedString !== oldEncodedString) {
+      encodedQueryKeyRef.current = newEncoded;
+    }
+    return encodedQueryKeyRef.current;
+  }, [query, parser.offset, parser.limit]);
+  const filterLayerStringRef = useRef("");
+  const currentFilterString = JSON.stringify(filterLayer, (key, value) => key === "id" ? "redacted" : value);
+  if (filterLayerStringRef.current !== currentFilterString) {
+    filterLayerStringRef.current = currentFilterString;
+  }
+  const queryKeyRef = useRef([]);
+  const newKey = [encodedQueryKey[0], encodedQueryKey[1], encodedQueryKey[2], encodedQueryKey[3], encodedQueryKey[4], encodedQueryKey[5], "count=" + (config?.count ?? ""), encodedQueryKey[7], encodedQueryKey[8], filterLayerStringRef.current];
+  const newKeyString = JSON.stringify(newKey);
+  const oldKeyString = JSON.stringify(queryKeyRef.current);
+  if (oldKeyString !== newKeyString) {
+    queryKeyRef.current = newKey;
+  }
+  const queryKey = queryKeyRef.current;
+  const [previousKey, setPreviousKey] = useState(queryKey);
+  useEffect(() => {
+    if (filterLayer?.isReady) {
+      setPreviousKey(queryKey);
+    }
+  }, [...queryKey]);
+  const loadingKey = filterLayer?.isReady ? queryKey : previousKey ?? queryKey;
+  const supabase = useSupabase();
+  const isEnabled = config?.enabled == null || config?.enabled === void 0 ? true : config.enabled;
+  const [extraData, setExtraData] = useState({});
+  const queryResponse = useQuery3({
+    ...omit({
+      retry: 0,
+      // Changed from 1 to 0 to prevent retries
+      ...config ?? {},
+      // Override any config settings to prevent multiple executions
+      refetchOnMount: false,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      structuralSharing: false,
+      enabled: filterLayer?.isReady && isEnabled
+    }, ["queryKey", "persister", "initialData"]),
+    queryKey: loadingKey,
+    queryFn: async (props) => {
+      if (!filterLayer) {
+        throw new Error("Filter layer is not initialized");
+      }
+      try {
+        const searchParams = Array.from(parser.searchParams.entries());
+        const body = {
+          ...filterLayer,
+          filters: [...filterLayer.filters],
+          pagination: {
+            ...filterLayer.pagination
+          },
+          sort: [...filterLayer.sort || []]
+        };
+        const currentKey = `${parser.schema}${parser.table}${parser.select}${JSON.stringify(omit(body, "pagination"))}`;
+        const requiresEdgeForOrdering = false;
+        const hasNaturalLanguageQuery = !!filterLayer.naturalLanguageQuery;
+        if (filterLayer.filters.length == 0 && requiresEdgeForOrdering === false && !hasNaturalLanguageQuery) {
+          const result = await executeSupabaseQuery(supabase, body, parser, extraData, props.signal, config?.count);
+          setExtraData((pre_0) => ({
+            ...omit(result, "data"),
+            count: result.count ? result.count : pre_0.count,
+            key: currentKey
+          }));
+          return result;
+        }
+        searchParams.forEach(([k, v]) => {
+          if (k.includes("offset")) {
+            body.pagination.offset = Number(v);
+            return;
+          }
+          if (k.includes("limit")) {
+            body.pagination.limit = Number(v);
+            return;
+          }
+          if (k.includes("order")) {
+            return;
+          }
+          if (k === "or") {
+            return;
+          }
+          if (v.includes(".") === false) return;
+          const values_0 = v.split(".");
+          const column = k;
+          let rawCondition = values_0[0];
+          let condition = "";
+          let value_0 = values_0[1];
+          const inverted = values_0[0] === "not";
+          if (column == "select") return;
+          if (rawCondition === "not") {
+            rawCondition = values_0[1];
+            value_0 = values_0[2];
+          }
+          switch (rawCondition) {
+            case "eq":
+              condition = "=";
+              break;
+            case "in":
+              condition = "in";
+              value_0 = value_0.slice(1, value_0.length - 1).split(",").filter((x_0) => isNullOrWhitespace(x_0) === false);
+              break;
+            case "lt":
+              condition = "<";
+              break;
+            case "gt":
+              condition = ">";
+              break;
+            case "lte":
+              condition = "<=";
+              break;
+            case "gte":
+              condition = ">=";
+              break;
+            case "is":
+              condition = "is";
+              if (value_0 == "null") {
+                value_0 = null;
+              }
+              break;
+          }
+          body.filters = [{
+            id: `filter_${column}_${Date.now()}`,
+            field: column,
+            op: condition,
+            value: value_0,
+            not: inverted,
+            display: column
+          }, {
+            filters: [...body.filters],
+            op: body.op ?? "AND",
+            id: "filterstate"
+          }];
+          body.op = "AND";
+          const bodyCopy = JSON.parse(JSON.stringify(body));
+          bodyCopy.pagination = {
+            page: 0,
+            pageSize: 50
+          };
+          bodyCopy.isReady = true;
+        });
+        const {
+          data: {
+            session
+          }
+        } = await supabase.auth.getSession();
+        if (!session?.access_token) {
+          throw new Error("No active session");
+        }
+        const controller = new AbortController();
+        props.signal.addEventListener("abort", () => {
+          controller.abort();
+        });
+        const timeout = setTimeout(() => controller.abort(), config?.timeout ?? 15e3);
+        let result_0 = null;
+        let response = {
+          error: null,
+          data: null
+        };
+        try {
+          const UI_ONLY_KEYS = /* @__PURE__ */ new Set(["info", "options", "display"]);
+          const filteredBody = JSON.parse(JSON.stringify(body, (key_0, value_1) => {
+            if (UI_ONLY_KEYS.has(key_0)) {
+              return void 0;
+            }
+            return value_1;
+          }));
+          filteredBody.filters = filteredBody.filters.map(normalizeFilter).filter(Boolean);
+          const orParam = parser.searchParams.get("or");
+          if (orParam) {
+            const cleanedOrParam = orParam.replace(/^\(|\)$/g, "");
+            const orConditions = cleanedOrParam.split(",");
+            const orFilters = orConditions.map((condition_0, idx) => {
+              const match = condition_0.match(/^(.+?)\.([^.]+)\.(.+)$/);
+              if (match) {
+                const [_, field, rawOp, value_2] = match;
+                let op = rawOp.trim();
+                switch (op) {
+                  case "eq":
+                    op = "=";
+                    break;
+                  case "neq":
+                    op = "!=";
+                    break;
+                  case "gt":
+                    op = ">";
+                    break;
+                  case "gte":
+                    op = ">=";
+                    break;
+                  case "lt":
+                    op = "<";
+                    break;
+                  case "lte":
+                    op = "<=";
+                    break;
+                  case "like":
+                    op = "contains";
+                    break;
+                  case "ilike":
+                    op = "contains";
+                    break;
+                  case "in":
+                    op = "in";
+                    break;
+                }
+                return {
+                  id: `or-${idx}`,
+                  field: field.trim(),
+                  op,
+                  value: value_2.trim()
+                };
+              }
+              return null;
+            }).filter(Boolean);
+            if (orFilters.length > 0) {
+              filteredBody.filters = [...filteredBody.filters, {
+                id: "base-or-group",
+                op: "OR",
+                filters: orFilters,
+                pagination: void 0,
+                sort: void 0,
+                isReady: true
+              }];
+            }
+          }
+          const res = await fetch(`${getSupabaseUrl()}/functions/v1/query?forceDenoVersion=2`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${session.access_token}`
+            },
+            body: JSON.stringify({
+              table: parser.table,
+              schema: parser.schema,
+              select: parser.select,
+              filters: {
+                id: filteredBody.id || "root",
+                op: filteredBody.op || filteredBody.operator || "AND",
+                not: filteredBody.not || filteredBody.inverted,
+                // Support both 'not' and legacy 'inverted'
+                filters: filteredBody.filters || []
+              },
+              pagination: filteredBody.pagination,
+              sort: filteredBody.sort,
+              distinctOn: filteredBody.distinctOn,
+              naturalLanguageQuery: filteredBody.naturalLanguageQuery,
+              count: currentKey === extraData.key ? "" : config?.count ?? "",
+              debug: true
+            }),
+            signal: controller.signal
+          });
+          if (!res.ok) {
+            const errorData = await res.json();
+            const errorMessage_0 = typeof errorData?.error === "string" ? errorData.error : errorData?.error?.message || errorData?.message || "An error occurred while processing your request";
+            throw new Error(errorMessage_0);
+          }
+          const data = await res.json();
+          if (data.clarification) {
+            return {
+              data: [],
+              // Empty data array
+              count: 0,
+              clarification: data.clarification,
+              error: void 0
+            };
+          }
+          result_0 = data;
+          response = {
+            error: null,
+            data
+          };
+        } catch (err) {
+          if (err.name === "AbortError") {
+            console.error("Fetch aborted/time-out");
+            response = {
+              error: new Error("This query timed out"),
+              data: null
+            };
+          } else if (err instanceof Error) {
+            response = {
+              error: err,
+              data: null
+            };
+          } else {
+            const errorMessage = err?.error || err?.message || String(err);
+            response = {
+              error: new Error(errorMessage),
+              data: null
+            };
+          }
+        } finally {
+          clearTimeout(timeout);
+        }
+        if (response.error) {
+          throw response.error;
+        } else if (response.data?.error) {
+          throw new Error(response.data.error);
+        }
+        if (result_0.clarification) {
+          return {
+            data: [],
+            count: 0,
+            clarification: result_0.clarification,
+            error: void 0
+          };
+        }
+        setExtraData((pre_1) => ({
+          ...omit(result_0, "data"),
+          count: pre_1.key === currentKey ? pre_1.count : result_0.count,
+          key: currentKey
+        }));
+        return {
+          ...result_0,
+          statusText: "",
+          status: result_0.data?.length > result_0.count ? 206 : 200,
+          error: response.data?.error ?? null,
+          hasMore: result_0.data?.length < result_0.count ? true : false
+        };
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          console.log("Fetch aborted");
+        } else {
+          console.error("Error fetching data:", error);
+        }
+        if (error instanceof Error && error.message === "Failed to send a request to the Edge Function") {
+          throw new Error("Could not contact query server");
+        }
+        throw error;
+      }
+    }
+  });
+  const response_0 = {
+    ...queryResponse,
+    data: queryResponse.data?.data,
+    count: extraData.count,
+    clarification: queryResponse.data?.clarification
+  };
+  useEffect(() => {
+    if (queryResponse.isFetched && response_0.count == null) {
+      queryResponse.refetch();
+    }
+  }, [response_0.count]);
+  useEffect(() => {
+    if (queryResponse.data?.error == null) return;
+    if (queryResponse.data?.error?.message?.includes(" does not exist")) {
+      setFilterLayer({
+        id: "root",
+        op: "AND",
+        filters: [],
+        pagination: void 0,
+        sort: [],
+        isReady: isUsable(config?.searchByDefault) ? config.searchByDefault ? false : true : true
+      });
+    }
+  }, [queryResponse.data?.error]);
+  return [response_0, filterLayer, setFilterLayer];
+}
+function isSearchableColumn(columnName) {
+  return true;
+}
+async function executeSupabaseQuery(supabase, body, parser, extraData, signal, count) {
+  const searchParams = Array.from(parser.searchParams.entries());
+  const currentKey = `${parser.schema}${parser.table}${parser.select}${JSON.stringify(omit(body, "pagination"))}`;
+  const query = supabase.schema(parser.schema).from(parser.table).select(parser.select, {
+    count: currentKey === extraData.key ? void 0 : count || void 0
+  });
+  if (body.sort && Array.isArray(body.sort)) {
+    body.sort.forEach((s) => {
+      query.order(s.field, {
+        ascending: s.direction === "asc"
+      });
+    });
+  }
+  const from = searchParams.find((x) => x[0].includes("offset"))?.[1];
+  const to = searchParams.find((x) => x[0].includes("limit"))?.[1];
+  searchParams.forEach(([k, v]) => {
+    if (k.includes("offset") && isUsable(v)) {
+      body.pagination.from = Number(v);
+      return;
+    }
+    if (k.includes("limit") && isUsable(v)) {
+      body.pagination.to = Number(from) + Number(v) - 1;
+      return;
+    }
+    if (k === "or") {
+      query.or(v.slice(1, v.length - 1));
+      return;
+    }
+    const values = v.split(".");
+    const column = k;
+    let rawCondition = values[0];
+    let value = values[1];
+    if (column == "select") return;
+    if (column == "order") return;
+    if (v.includes(".") === false) return;
+    if (rawCondition === "ilike" && !isSearchableColumn(column)) {
+      return;
+    }
+    if (rawCondition === "not") {
+      rawCondition = values[1];
+      value = values[2];
+      query.not(column, rawCondition, value);
+    } else {
+      query.filter(column, rawCondition, value);
+    }
+  });
+  if (body.pagination.from !== null && body.pagination.from !== void 0 && body.pagination.to !== null && body.pagination.to !== void 0 && isNaN(body.pagination.from) === false && isNaN(body.pagination.to) === false) {
+    query.range(body.pagination.from, body.pagination.to);
+  }
+  const result = await query.abortSignal(signal);
+  const dataLength = result.data?.length ?? 0;
+  const totalCount = result.count ?? 0;
+  return {
+    ...result,
+    statusText: "",
+    status: dataLength > totalCount ? 206 : 200,
+    error: result.error,
+    hasMore: dataLength < totalCount
+  };
+}
+var useAdvancedQuery = useAdvancedFilterQuery;
+
+// src/query/useInfiniteQuery.ts
+import { useInfiniteQuery as useTanstackInfiniteQuery } from "@tanstack/react-query";
+import { useMemo as useMemo2, useRef as useRef2 } from "react";
+function useInfiniteQuery(query, countPerLoad, config) {
+  const initialQueryKey = encode(query, false).join("-");
+  const lastKnownQuery = useRef2(initialQueryKey);
+  const currentPageNumber = useRef2(1);
+  if (lastKnownQuery.current != initialQueryKey) {
+    lastKnownQuery.current = initialQueryKey;
+    currentPageNumber.current = 1;
+  }
+  const isFetching = useRef2(false);
+  const queryKey = useMemo2(() => encode(query, false), [initialQueryKey, config?.crossOrganization]);
+  const getQuery = useTanstackInfiniteQuery({
+    ...config,
+    queryKey,
+    queryFn: async ({
+      pageParam,
+      signal
+    }) => {
+      let adjustableQuery = query;
+      const pageNumber = pageParam;
+      if (config?.onQuery && config?.enableOnQuery) {
+        config?.onQuery({
+          query: adjustableQuery,
+          pageParam: pageNumber
+        });
+      } else {
+        adjustableQuery = adjustableQuery.range((pageNumber - 1) * countPerLoad, pageNumber * countPerLoad - 1);
+      }
+      adjustableQuery = adjustableQuery.abortSignal(signal);
+      updatedCache.current = false;
+      const response = await adjustableQuery;
+      currentPageNumber.current = pageNumber;
+      if (response.error) {
+        throw response.error;
+      } else {
+        return response;
+      }
+    },
+    initialPageParam: 1,
+    getNextPageParam: (response_0, allResponses, lastParam) => {
+      const pageParam_0 = lastParam;
+      const resp = response_0;
+      if (allResponses.length * countPerLoad >= (resp?.count ?? 0)) {
+        return void 0;
+      }
+      return pageParam_0 + 1;
+    }
+  });
+  const updatedCache = useRef2(true);
+  return useMemo2(() => {
+    const pages = getQuery.data?.pages;
+    return {
+      ...getQuery,
+      count: pages?.[pages.length - 1]?.count,
+      data: pages?.flatMap((x) => x.data ?? [])
+    };
+  }, [getQuery.data, currentPageNumber.current]);
+}
+
+// src/query/usePartialAdvancedQuery.ts
+import { c as _c3 } from "react/compiler-runtime";
+import { useLayoutEffect, useState as useState2 } from "react";
+import { useSessionStorageState as useSessionStorageState3 } from "@pol-studios/hooks/storage";
+function usePartialAdvancedQuery(query, itemCountPerPage, config) {
+  const $ = _c3(54);
+  const initialQuery = encode(query, false);
+  const [id, setId] = useState2(window.location.pathname);
+  const [currentPage, setCurrentPage] = useSessionStorageState3(`${id}-currentPage`, 1);
+  const page = currentPage ?? 1;
+  const t0 = query;
+  let t1;
+  if ($[0] !== itemCountPerPage || $[1] !== page || $[2] !== t0) {
+    t1 = t0.range((page - 1) * itemCountPerPage, page * itemCountPerPage - 1);
+    $[0] = itemCountPerPage;
+    $[1] = page;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const rangedQuery = t1;
+  const t2 = config?.filterKey;
+  const t3 = currentPage ?? 1;
+  let t4;
+  if ($[4] !== t3) {
+    t4 = t3.toString();
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== config || $[7] !== t2 || $[8] !== t4) {
+    t5 = {
+      ...config,
+      filterKey: t2,
+      count: "exact",
+      key: t4
+    };
+    $[6] = config;
+    $[7] = t2;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  const [baseQuery, filter, setFilters] = useAdvancedFilterQuery(rangedQuery, t5);
+  let t6;
+  if ($[10] !== filter) {
+    t6 = JSON.stringify(omit(filter, ["pagination"]));
+    $[10] = filter;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  const filterKey = t6;
+  const select = initialQuery[4].split("&").find(_temp4);
+  let t7;
+  if ($[12] !== filterKey || $[13] !== id || $[14] !== initialQuery[3] || $[15] !== initialQuery[5] || $[16] !== initialQuery[6] || $[17] !== initialQuery[7] || $[18] !== initialQuery[8] || $[19] !== select || $[20] !== setId) {
+    t7 = () => {
+      const newId = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey].join("-");
+      console.log({
+        newId,
+        id
+      });
+      setId(newId);
+    };
+    $[12] = filterKey;
+    $[13] = id;
+    $[14] = initialQuery[3];
+    $[15] = initialQuery[5];
+    $[16] = initialQuery[6];
+    $[17] = initialQuery[7];
+    $[18] = initialQuery[8];
+    $[19] = select;
+    $[20] = setId;
+    $[21] = t7;
+  } else {
+    t7 = $[21];
+  }
+  let t8;
+  if ($[22] !== filterKey || $[23] !== initialQuery[3] || $[24] !== initialQuery[5] || $[25] !== initialQuery[6] || $[26] !== initialQuery[7] || $[27] !== initialQuery[8] || $[28] !== select) {
+    t8 = [initialQuery[3], select, initialQuery[5], initialQuery[6], initialQuery[7], initialQuery[8], filterKey];
+    $[22] = filterKey;
+    $[23] = initialQuery[3];
+    $[24] = initialQuery[5];
+    $[25] = initialQuery[6];
+    $[26] = initialQuery[7];
+    $[27] = initialQuery[8];
+    $[28] = select;
+    $[29] = t8;
+  } else {
+    t8 = $[29];
+  }
+  useLayoutEffect(t7, t8);
+  let t9;
+  if ($[30] !== setCurrentPage) {
+    t9 = () => {
+      setCurrentPage(_temp22);
+    };
+    $[30] = setCurrentPage;
+    $[31] = t9;
+  } else {
+    t9 = $[31];
+  }
+  const safeFetchNextPage = t9;
+  let t10;
+  if ($[32] !== setCurrentPage) {
+    t10 = () => {
+      setCurrentPage(_temp3);
+    };
+    $[32] = setCurrentPage;
+    $[33] = t10;
+  } else {
+    t10 = $[33];
+  }
+  const fetchPreviousPage = t10;
+  const pageCount = Math.max(Math.ceil((baseQuery.count ?? 0) / itemCountPerPage), 1);
+  let t11;
+  if ($[34] !== baseQuery.count || $[35] !== baseQuery.data || $[36] !== currentPage || $[37] !== itemCountPerPage) {
+    t11 = baseQuery.data ? toPagedResponse2(baseQuery.data, currentPage ?? 1, baseQuery.count ?? baseQuery.data.length, itemCountPerPage) : null;
+    $[34] = baseQuery.count;
+    $[35] = baseQuery.data;
+    $[36] = currentPage;
+    $[37] = itemCountPerPage;
+    $[38] = t11;
+  } else {
+    t11 = $[38];
+  }
+  const t12 = (currentPage ?? 1) < pageCount;
+  const t13 = (currentPage ?? 1) > 1;
+  const t14 = baseQuery.count ?? baseQuery.data?.length;
+  let t15;
+  if ($[39] !== baseQuery || $[40] !== currentPage || $[41] !== fetchPreviousPage || $[42] !== pageCount || $[43] !== safeFetchNextPage || $[44] !== setCurrentPage || $[45] !== t11 || $[46] !== t12 || $[47] !== t13 || $[48] !== t14) {
+    t15 = {
+      ...baseQuery,
+      clarification: baseQuery.clarification,
+      fetchPreviousPage,
+      fetchNextPage: safeFetchNextPage,
+      currentPage,
+      setCurrentPage,
+      data: t11,
+      pageCount,
+      hasNextPage: t12,
+      hasPreviousPage: t13,
+      count: t14
+    };
+    $[39] = baseQuery;
+    $[40] = currentPage;
+    $[41] = fetchPreviousPage;
+    $[42] = pageCount;
+    $[43] = safeFetchNextPage;
+    $[44] = setCurrentPage;
+    $[45] = t11;
+    $[46] = t12;
+    $[47] = t13;
+    $[48] = t14;
+    $[49] = t15;
+  } else {
+    t15 = $[49];
+  }
+  const request = t15;
+  let t16;
+  if ($[50] !== filter || $[51] !== request || $[52] !== setFilters) {
+    t16 = [request, filter, setFilters];
+    $[50] = filter;
+    $[51] = request;
+    $[52] = setFilters;
+    $[53] = t16;
+  } else {
+    t16 = $[53];
+  }
+  return t16;
+}
+function _temp3(currentPage_1) {
+  return (currentPage_1 ?? 1) - 1;
+}
+function _temp22(currentPage_0) {
+  return (currentPage_0 ?? 1) + 1;
+}
+function _temp4(x) {
+  return x.startsWith("select=");
+}
+function toPagedResponse2(results, currentPage, totalCount, itemPerPage) {
+  const newPage = {
+    Items: results,
+    CurrentPage: currentPage,
+    ItemCount: totalCount,
+    MaxCountPerPage: itemPerPage,
+    PageCount: Math.max(Math.ceil(totalCount / itemPerPage), 1)
+  };
+  return newPage;
+}
+
+export {
+  tokenizeTopLevel,
+  parseSelect,
+  stringifySelect,
+  extractColumnNames,
+  extractRelationNames,
+  hasRelation,
+  getRelationSelect,
+  RelationshipResolver,
+  createRelationshipResolver,
+  SQLBuilder,
+  createSQLBuilder,
+  ResultJoiner,
+  createResultJoiner,
+  QueryExecutor,
+  createQueryExecutor,
+  useQuery2 as useQuery,
+  usePartialQuery,
+  useAdvancedFilterQuery,
+  useAdvancedQuery,
+  useInfiniteQuery,
+  usePartialAdvancedQuery
+};
+//# sourceMappingURL=chunk-X3HZLNBV.js.map