@pol-studios/db 1.0.54 → 1.0.56

package/dist/{chunk-HZIVE5AZ.js → chunk-YRIPM2AN.js}

@@ -1,133 +1,211 @@
-// 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);
+import {
+  parseSelect
+} from "./chunk-W7PERM66.js";
+
+// 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") {
+      const groupedByFK = /* @__PURE__ */ new Map();
+      for (const r of relatedRecords) {
+        const fkValue = r[relationship.foreignKey];
+        if (!groupedByFK.has(fkValue)) groupedByFK.set(fkValue, []);
+        groupedByFK.get(fkValue).push(r);
       }
-      current = "";
+      for (const base of baseRecords) {
+        const baseId = base[relationship.referencedColumn];
+        base[relationName] = groupedByFK.get(baseId) ?? [];
+      }
+      return baseRecords;
     } else {
-      current += char;
+      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);
+        }
+      }
+      for (const base of baseRecords) {
+        const fkValue = base[relationship.foreignKey];
+        base[relationName] = fkValue != null ? relatedMap.get(fkValue) ?? null : null;
+      }
+      return baseRecords;
     }
   }
-  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;
+  /**
+   * 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);
     }
-    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);
+    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;
   }
-  if (Array.isArray(result.columns) && result.columns.length === 0) {
-    result.columns = "*";
+  /**
+   * 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;
   }
-  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);
+  /**
+   * 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);
   }
-  for (const rel of parsed.relations) {
-    const innerStr = stringifySelect({
-      columns: rel.columns,
-      relations: rel.relations
+  /**
+   * 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;
     });
-    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 "*";
+  /**
+   * 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
+      };
+    });
   }
-  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);
+};
+function createResultJoiner() {
+  return new ResultJoiner();
 }
 
 // src/query/relationship-resolver.ts
@@ -655,213 +733,8 @@ 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") {
-      const groupedByFK = /* @__PURE__ */ new Map();
-      for (const r of relatedRecords) {
-        const fkValue = r[relationship.foreignKey];
-        if (!groupedByFK.has(fkValue)) groupedByFK.set(fkValue, []);
-        groupedByFK.get(fkValue).push(r);
-      }
-      for (const base of baseRecords) {
-        const baseId = base[relationship.referencedColumn];
-        base[relationName] = groupedByFK.get(baseId) ?? [];
-      }
-      return baseRecords;
-    } 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);
-        }
-      }
-      for (const base of baseRecords) {
-        const fkValue = base[relationship.foreignKey];
-        base[relationName] = fkValue != null ? relatedMap.get(fkValue) ?? null : null;
-      }
-      return baseRecords;
-    }
-  }
-  /**
-   * 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 MAX_RELATION_CACHE_SIZE = 100;
 var QueryExecutor = class {
   constructor(db, schema) {
     this.db = db;
@@ -1133,7 +1006,7 @@ var QueryExecutor = class {
       return idCache.get(column);
     };
     const relationResults = await Promise.all(relations.map(async (relation) => {
-      const resolved = this.resolveRelationCached(parentTable, relation.name);
+      const resolved = relation.explicitFk ? this.buildExplicitFkRelationship(parentTable, relation) : this.resolveRelationCached(parentTable, relation.name);
       if (!resolved) {
         console.warn(`Could not resolve relationship: ${parentTable} -> ${relation.name}`);
         return {
@@ -1153,8 +1026,9 @@ var QueryExecutor = class {
       }
       const relQuery = this.buildRelatedQuery(relation, resolved, parentIds);
       let records = await this.db.getAll(relQuery.sql, relQuery.params);
+      const nestedParentTable = relation.explicitFk ? this.getTableNameFromQualified(relation.explicitFk.targetTable) : relation.name;
       if (relation.relations.length > 0 && records.length > 0) {
-        records = await this.queryAndJoinRelations(relation.name, records, relation.relations);
+        records = await this.queryAndJoinRelations(nestedParentTable, records, relation.relations);
       }
       return {
         relation,
@@ -1186,6 +1060,43 @@ var QueryExecutor = class {
     }
     return result;
   }
+  /**
+   * Build a ResolvedRelationship from an explicit FK specification.
+   * This bypasses schema lookup and constructs the relationship directly.
+   *
+   * @param parentTable - The parent table name
+   * @param relation - The relation with explicitFk specification
+   * @returns ResolvedRelationship for the explicit FK
+   */
+  buildExplicitFkRelationship(parentTable, relation) {
+    const explicitFk = relation.explicitFk;
+    const targetTable = this.getTableNameFromQualified(explicitFk.targetTable);
+    return {
+      type: "many-to-one",
+      fromTable: parentTable,
+      toTable: targetTable,
+      foreignKey: explicitFk.sourceField,
+      referencedColumn: explicitFk.targetColumn ?? "id"
+    };
+  }
+  /**
+   * Extract the table name from a potentially schema-qualified identifier.
+   * For PowerSync, tables are flattened to a single namespace, so we need
+   * to handle both "core.Profile" -> "CoreProfile" (PowerSync alias) and
+   * simple table names.
+   *
+   * @param qualifiedName - Table name, optionally schema-qualified (e.g., "core.Profile")
+   * @returns The table name to use in queries
+   */
+  getTableNameFromQualified(qualifiedName) {
+    if (!qualifiedName.includes(".")) {
+      return qualifiedName;
+    }
+    const [schema, ...tableParts] = qualifiedName.split(".");
+    const tableName = tableParts.join(".");
+    const pascalSchema = schema.charAt(0).toUpperCase() + schema.slice(1);
+    return `${pascalSchema}${tableName}`;
+  }
   /**
    * Get parent IDs needed for a relation query.
    */
@@ -1204,7 +1115,8 @@ var QueryExecutor = class {
   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);
+    const tableName = relation.explicitFk ? resolved.toTable : relation.name;
+    return this.builder.buildRelationQuery(tableName, filterColumn, uniqueIds, relation.columns);
   }
   /**
    * Get the relationship resolver (for advanced use).
@@ -1226,6 +1138,7 @@ var QueryExecutor = class {
   }
   /**
    * Resolve a relationship with caching.
+   * Uses true LRU eviction: accessed items are moved to the end of the Map.
    *
    * @param fromTable - The source table
    * @param toTable - The target table/relation name
@@ -1233,10 +1146,19 @@ var QueryExecutor = class {
    */
   resolveRelationCached(fromTable, toTable) {
     const key = `${fromTable}:${toTable}`;
-    if (!this.relationCache.has(key)) {
-      this.relationCache.set(key, this.resolver.resolve(fromTable, toTable));
-    }
-    return this.relationCache.get(key);
+    if (this.relationCache.has(key)) {
+      const value = this.relationCache.get(key);
+      this.relationCache.delete(key);
+      this.relationCache.set(key, value);
+      return value;
+    }
+    if (this.relationCache.size >= MAX_RELATION_CACHE_SIZE) {
+      const firstKey = this.relationCache.keys().next().value;
+      if (firstKey) this.relationCache.delete(firstKey);
+    }
+    const resolved = this.resolver.resolve(fromTable, toTable);
+    this.relationCache.set(key, resolved);
+    return resolved;
   }
 };
 function createQueryExecutor(db, schema) {
@@ -1244,20 +1166,13 @@ function createQueryExecutor(db, schema) {
 }
 
 export {
-  tokenizeTopLevel,
-  parseSelect,
-  stringifySelect,
-  extractColumnNames,
-  extractRelationNames,
-  hasRelation,
-  getRelationSelect,
+  ResultJoiner,
+  createResultJoiner,
   RelationshipResolver,
   createRelationshipResolver,
   SQLBuilder,
   createSQLBuilder,
-  ResultJoiner,
-  createResultJoiner,
   QueryExecutor,
   createQueryExecutor
 };
-//# sourceMappingURL=chunk-HZIVE5AZ.js.map
+//# sourceMappingURL=chunk-YRIPM2AN.js.map