@undefineds.co/drizzle-solid 0.3.0 → 0.3.2

package/dist/core/query-builders/select-query-builder.js

@@ -10,6 +10,7 @@ const helpers_1 = require("./helpers");
 const uri_1 = require("../uri");
 const order_by_1 = require("../order-by");
 const expressions_1 = require("../expressions");
+const query_where_policy_1 = require("../query-where-policy");
 class SelectQueryBuilder {
     constructor(session, fields) {
         this.session = session;
@@ -40,23 +41,19 @@ class SelectQueryBuilder {
     /**
      * Add WHERE conditions to the query
      *
-     * Note: Using '@id' directly in conditions is deprecated.
-     * Use db.findByIri(table, iri) for IRI-based lookups instead.
+     * Public where() is collection-oriented.
+     * Exact-target reads must use findByLocator()/findByIri().
      */
     where(conditions) {
         if (conditions instanceof drizzle_orm_1.SQL) {
             this.sql = conditions;
         }
         else if (this.isQueryCondition(conditions)) {
+            (0, query_where_policy_1.assertPublicWhereCondition)('select', conditions);
             this.processQueryCondition(conditions);
         }
         else {
-            // Check for @id usage and warn/reject
-            if (conditions && typeof conditions === 'object' && '@id' in conditions) {
-                throw new Error(`Using '@id' in where() is not supported. ` +
-                    `Use db.findByIri(table, iri) for IRI-based lookups, ` +
-                    `or use { id: 'value' } for id-based lookups.`);
-            }
+            (0, query_where_policy_1.assertPublicWhereObject)('select', conditions);
             this.processWhereObject(conditions);
         }
         return this;
@@ -304,6 +301,10 @@ class SelectQueryBuilder {
             this.whereConditions = simpleConditions;
         }
     }
+    applyInternalQueryCondition(condition) {
+        this.processQueryCondition(condition);
+        return this;
+    }
     normalizeWhereConditions() {
         if (this.conditionTree) {
             return this.conditionTree;
@@ -457,9 +458,12 @@ class SelectQueryBuilder {
                     limit: undefined,
                     offset: undefined,
                     orderBy: undefined,
+                    ...(hasJoins ? { joins: undefined, joinFilters: undefined } : {}),
                     ...(useAggregateFallback ? { groupBy: undefined, having: undefined } : {}),
                 }
-                : plan;
+                : (hasJoins
+                    ? { ...plan, joins: undefined, joinFilters: undefined }
+                    : plan);
             const operation = {
                 type: 'select',
                 table: this.selectedTable,
@@ -497,6 +501,7 @@ class SelectQueryBuilder {
                 }
                 if (hasJoins) {
                     intermediateRows = this.normalizeBaseRows(intermediateRows);
+                    intermediateRows = this.mergeRowsBySubject(intermediateRows);
                     intermediateRows = await this.applyJoinFallback(intermediateRows);
                     intermediateRows = this.applyJoinFilters(intermediateRows);
                 }
@@ -913,10 +918,19 @@ class SelectQueryBuilder {
     applySubjectMetadata(rows) {
         return rows.map((row) => this.attachSubjectMetadata(row));
     }
+    extractSubjectValue(row) {
+        const candidate = row.subject ?? row['@id'] ?? row.uri;
+        if (typeof candidate === 'object' && candidate && 'value' in candidate) {
+            const value = candidate.value;
+            return typeof value === 'string' && value.length > 0 ? value : undefined;
+        }
+        if (typeof candidate === 'string' && candidate.length > 0) {
+            return candidate;
+        }
+        return undefined;
+    }
     attachSubjectMetadata(row) {
-        const subjectValue = typeof row.subject === 'object' && row.subject && 'value' in row.subject
-            ? row.subject.value
-            : row.subject;
+        const subjectValue = this.extractSubjectValue(row);
         if (typeof subjectValue === 'string' && subjectValue.length > 0) {
             if (row['@id'] === undefined) {
                 row['@id'] = subjectValue;
@@ -946,7 +960,7 @@ class SelectQueryBuilder {
                 }
                 result[`${alias}.${key}`] = value;
             }
-            const subjectValue = row.subject;
+            const subjectValue = this.extractSubjectValue(row);
             if (subjectValue) {
                 result.subject = subjectValue;
                 result['@id'] = subjectValue;
@@ -1234,7 +1248,17 @@ class SelectQueryBuilder {
                 return;
             }
             if (!merged.has(key)) {
-                merged.set(key, { ...row });
+                const normalizedRow = { ...row };
+                Object.entries(normalizedRow).forEach(([col, value]) => {
+                    if (value === undefined)
+                        return;
+                    const colDef = this.getColumnDefinitionForRowKey(col);
+                    const isArrayType = colDef?.options?.isArray || colDef?.dataType === 'array';
+                    if (isArrayType && !Array.isArray(value)) {
+                        normalizedRow[col] = [value];
+                    }
+                });
+                merged.set(key, normalizedRow);
                 order.push(key);
                 return;
             }
@@ -1274,7 +1298,7 @@ class SelectQueryBuilder {
                         combined.push(entry);
                     }
                 });
-                const colDef = this.selectedTable?.columns[col];
+                const colDef = this.getColumnDefinitionForRowKey(col);
                 const isArrayType = colDef?.options?.isArray || colDef?.dataType === 'array';
                 if (!isArrayType && combined.length > 1) {
                     console.warn(`[Data Integrity] Multiple values found for single-value column '${col}' on subject '${key}'. Using first value.`);
@@ -1294,6 +1318,22 @@ class SelectQueryBuilder {
         const result = order.map((key) => merged.get(key));
         return result;
     }
+    getColumnDefinitionForRowKey(key) {
+        if (!key) {
+            return undefined;
+        }
+        if (!key.includes('.')) {
+            return this.selectedTable?.columns[key];
+        }
+        const [alias, columnName] = key.split('.', 2);
+        if (!alias || !columnName) {
+            return undefined;
+        }
+        if (alias === this.primaryAlias) {
+            return this.selectedTable?.columns[columnName];
+        }
+        return this.aliasToTable.get(alias)?.columns?.[columnName];
+    }
     inferSourceFromChild(childIri, table) {
         if (!childIri) {
             return this.session.getDialect().getPodUrl();
@@ -1357,21 +1397,154 @@ class SelectQueryBuilder {
             return [];
         }
         const valuesArray = Array.from(uniqueValues.values());
+        const buildJoinQuery = () => this.session.select().from(join.table);
         const joinColumnInstance = join.table.getColumn(joinRef.column);
-        let joinQuery = this.session.select().from(join.table);
-        if (joinColumnInstance && joinRef.column !== 'id') {
-            joinQuery = joinQuery.where((0, query_conditions_1.inArray)(joinColumnInstance, valuesArray));
+        const exactJoinConditions = this.buildExactJoinLookupConditions(join, baseRows);
+        if (exactJoinConditions && exactJoinConditions.length > 0) {
+            const exactJoinRows = [];
+            for (const joinCondition of exactJoinConditions) {
+                const joinQuery = buildJoinQuery();
+                const conditionedJoinQuery = (0, query_where_policy_1.conditionTargetsReservedIdentifier)(joinCondition)
+                    ? joinQuery.applyInternalQueryCondition(joinCondition)
+                    : joinQuery.where(joinCondition);
+                const joinRows = await conditionedJoinQuery;
+                exactJoinRows.push(...joinRows);
+            }
+            return this.mergeRowsBySubject(this.normalizeJoinRows(join, exactJoinRows));
+        }
+        const joinLookupCondition = this.buildJoinLookupCondition(joinColumnInstance, valuesArray);
+        if (joinLookupCondition) {
+            const joinQuery = buildJoinQuery();
+            const filteredJoinQuery = (0, query_where_policy_1.conditionTargetsReservedIdentifier)(joinLookupCondition)
+                ? joinQuery.applyInternalQueryCondition(joinLookupCondition)
+                : joinQuery.where(joinLookupCondition);
+            const joinRows = await filteredJoinQuery;
+            return this.normalizeJoinRows(join, joinRows);
         }
-        const joinRows = await joinQuery;
+        const joinRows = await buildJoinQuery();
         return this.normalizeJoinRows(join, joinRows);
     }
+    buildExactJoinLookupConditions(join, baseRows) {
+        const conditions = join.resolvedConditions ?? [];
+        if (conditions.length === 0) {
+            return undefined;
+        }
+        const [primaryCondition] = conditions;
+        const primaryJoinRef = primaryCondition.left.alias === join.alias ? primaryCondition.left : primaryCondition.right;
+        const primaryBaseRef = primaryJoinRef === primaryCondition.left ? primaryCondition.right : primaryCondition.left;
+        const requiredLocatorVars = this.getRequiredSubjectTemplateVariables(join.table);
+        const joinUsesTemplateScopedId = primaryJoinRef.column === 'id' && requiredLocatorVars.length > 0;
+        if (!joinUsesTemplateScopedId && conditions.length === 1) {
+            return undefined;
+        }
+        const locatorConditionMap = new Map();
+        for (const condition of conditions) {
+            const joinRef = condition.left.alias === join.alias ? condition.left : condition.right;
+            locatorConditionMap.set(joinRef.column, condition);
+        }
+        const exactConditions = [];
+        const seen = new Set();
+        for (const baseRow of baseRows) {
+            const primaryValue = this.getRowValueForColumn(baseRow, primaryBaseRef);
+            if (primaryValue === undefined || primaryValue === null) {
+                continue;
+            }
+            const primaryIsAbsoluteIri = typeof primaryValue === 'string' && this.isAbsoluteIri(primaryValue);
+            const clauses = [];
+            const dedupeParts = [];
+            let skipRow = false;
+            for (const condition of conditions) {
+                const joinRef = condition.left.alias === join.alias ? condition.left : condition.right;
+                const baseRef = joinRef === condition.left ? condition.right : condition.left;
+                const baseValue = this.getRowValueForColumn(baseRow, baseRef);
+                if (baseValue === undefined || baseValue === null) {
+                    if (joinUsesTemplateScopedId && !primaryIsAbsoluteIri && requiredLocatorVars.includes(joinRef.column)) {
+                        throw new Error(this.buildMissingJoinLocatorError(join, requiredLocatorVars.filter((variable) => {
+                            const variableCondition = locatorConditionMap.get(variable);
+                            if (!variableCondition) {
+                                return true;
+                            }
+                            const variableJoinRef = variableCondition.left.alias === join.alias ? variableCondition.left : variableCondition.right;
+                            const variableBaseRef = variableJoinRef === variableCondition.left ? variableCondition.right : variableCondition.left;
+                            const variableValue = this.getRowValueForColumn(baseRow, variableBaseRef);
+                            return variableValue === undefined || variableValue === null;
+                        })));
+                    }
+                    skipRow = true;
+                    break;
+                }
+                const joinColumn = join.table.getColumn(joinRef.column);
+                if (!joinColumn) {
+                    skipRow = true;
+                    break;
+                }
+                clauses.push((0, query_conditions_1.eq)(joinColumn, baseValue));
+                dedupeParts.push(`${joinRef.column}:${this.serializeValueForKey(baseValue)}`);
+            }
+            if (skipRow) {
+                continue;
+            }
+            if (joinUsesTemplateScopedId && !primaryIsAbsoluteIri) {
+                const missingLocatorVars = requiredLocatorVars.filter((variable) => {
+                    const variableCondition = locatorConditionMap.get(variable);
+                    if (!variableCondition) {
+                        return true;
+                    }
+                    const variableJoinRef = variableCondition.left.alias === join.alias ? variableCondition.left : variableCondition.right;
+                    const variableBaseRef = variableJoinRef === variableCondition.left ? variableCondition.right : variableCondition.left;
+                    const variableValue = this.getRowValueForColumn(baseRow, variableBaseRef);
+                    return variableValue === undefined || variableValue === null;
+                });
+                if (missingLocatorVars.length > 0) {
+                    throw new Error(this.buildMissingJoinLocatorError(join, missingLocatorVars));
+                }
+            }
+            if (clauses.length === 0) {
+                continue;
+            }
+            const dedupeKey = dedupeParts.join('|');
+            if (seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
+            exactConditions.push(clauses.length === 1 ? clauses[0] : (0, query_conditions_1.and)(...clauses));
+        }
+        return exactConditions.length > 0 ? exactConditions : undefined;
+    }
+    buildJoinLookupCondition(joinColumnInstance, valuesArray) {
+        if (!joinColumnInstance || valuesArray.length === 0) {
+            return undefined;
+        }
+        if (valuesArray.length === 1) {
+            return (0, query_conditions_1.eq)(joinColumnInstance, valuesArray[0]);
+        }
+        return (0, query_conditions_1.inArray)(joinColumnInstance, valuesArray);
+    }
+    getRequiredSubjectTemplateVariables(table) {
+        const template = table.getSubjectTemplate?.() ?? table.config?.subjectTemplate ?? '';
+        return Array.from(template.matchAll(/\{([^}]+)\}/g))
+            .map((match) => match[1])
+            .filter((variable) => variable !== 'id' && variable !== 'index');
+    }
+    isAbsoluteIri(value) {
+        return /^[a-zA-Z][\w+.-]*:\/\//.test(value);
+    }
+    buildMissingJoinLocatorError(join, missingVariables) {
+        const template = join.table.getSubjectTemplate?.() ?? join.table.config?.subjectTemplate ?? '{id}';
+        const uniqueMissingVariables = Array.from(new Set(missingVariables));
+        const exampleVariable = uniqueMissingVariables[0] ?? '...';
+        return (`Cannot join table "${join.table.config.name ?? 'unknown'}" by id with subjectTemplate "${template}" ` +
+            `because locator variable(s) [${uniqueMissingVariables.join(', ')}] are missing. ` +
+            `Add join conditions for all required template variables (for example eq(base.${exampleVariable}, join.${exampleVariable})) ` +
+            `or join via full IRI values.`);
+    }
     normalizeJoinRows(join, rows) {
         return rows.map((row) => {
             const normalized = {};
             for (const [key, value] of Object.entries(row)) {
                 normalized[`${join.alias}.${key}`] = value;
             }
-            const subjectValue = row.subject;
+            const subjectValue = this.extractSubjectValue(row);
             if (subjectValue) {
                 normalized.subject = subjectValue;
                 normalized['@id'] = subjectValue;
@@ -1423,7 +1596,8 @@ class SelectQueryBuilder {
         for (const baseRow of baseRows) {
             const baseValue = this.getRowValueForColumn(baseRow, baseRef);
             const key = this.serializeValueForKey(baseValue);
-            const matches = baseValue !== undefined && baseValue !== null ? joinValueMap.get(key) ?? [] : [];
+            const primaryMatches = baseValue !== undefined && baseValue !== null ? joinValueMap.get(key) ?? [] : [];
+            const matches = primaryMatches.filter((joinRow) => this.joinRowMatchesAllConditions(baseRow, joinRow, join.alias, conditions));
             if (matches.length === 0) {
                 if (join.type === 'innerJoin') {
                     continue;
@@ -1437,6 +1611,18 @@ class SelectQueryBuilder {
         }
         return merged;
     }
+    joinRowMatchesAllConditions(baseRow, joinRow, joinAlias, conditions) {
+        return conditions.every((condition) => {
+            const joinRef = condition.left.alias === joinAlias ? condition.left : condition.right;
+            const baseRef = joinRef === condition.left ? condition.right : condition.left;
+            const baseValue = this.getRowValueForColumn(baseRow, baseRef);
+            const joinValue = this.getRowValueForColumn(joinRow, joinRef);
+            if (baseValue === undefined || baseValue === null || joinValue === undefined || joinValue === null) {
+                return false;
+            }
+            return this.serializeValueForKey(baseValue) === this.serializeValueForKey(joinValue);
+        });
+    }
     createEmptyJoinRow(join) {
         const empty = {};
         for (const columnName of Object.keys(join.table.columns)) {