@carbonorm/carbonnode 3.9.3 → 3.9.5

package/src/__tests__/sqlBuilders.complex.test.ts

@@ -19,11 +19,6 @@ const Parcel_Sales = {
   SALE_DATE: 'parcel_sales.sale_date',
 } as const;
 
-const Parcel_Building_Details = {
-  TABLE_NAME: 'parcel_building_details',
-  PARCEL_ID: 'parcel_building_details.parcel_id',
-} as const;
-
 /**
  * Complex SELECT coverage focused on WHERE operators, JOIN chains, ORDER, and pagination.
  */
@@ -56,6 +51,7 @@ describe('SQL Builders - Complex SELECTs', () => {
     const { sql, params } = qb.build('actor');
 
     // SQL fragments
+    // noinspection SqlResolve
     expect(sql).toContain('SELECT actor.actor_id, actor.first_name FROM `actor`');
     expect(sql).toContain('WHERE');
     expect(sql).toMatch(/\(actor\.first_name\) LIKE \?/);
@@ -131,6 +127,7 @@ describe('SQL Builders - Complex SELECTs', () => {
 
     const { sql, params } = qb.build('actor');
 
+    // noinspection SqlResolve
     expect(sql).toContain('SELECT DISTINCT actor.first_name, COUNT(actor.actor_id) AS cnt FROM `actor`');
     expect(sql).toContain('GROUP BY actor.first_name');
     expect(sql).toContain('HAVING');
@@ -238,6 +235,7 @@ describe('SQL Builders - Complex SELECTs', () => {
 
     const { sql, params } = qb.build(Property_Units.TABLE_NAME);
 
+    // noinspection SqlResolve
     expect(sql).toContain('SELECT property_units.unit_id, property_units.location, pu_target.location FROM `property_units`');
     expect(sql).toContain('INNER JOIN `parcel_sales` AS `ps`');
     expect(sql).toContain('INNER JOIN `parcel_building_details` AS `pbd`');
@@ -404,6 +402,29 @@ describe('SQL Builders - Complex SELECTs', () => {
     expect(params.slice(-1)[0]).toBe('POINT(-104.8967729 39.3976764)');
   });
 
+  it('orders by distance to ST_GeomFromText(WKT, 4326) using literal WKT', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [Property_Units.UNIT_ID],
+      [C6C.PAGINATION]: {
+        [C6C.LIMIT]: 10,
+        [C6C.ORDER]: {
+          [C6C.ST_DISTANCE_SPHERE]: [
+            Property_Units.LOCATION,
+            [C6C.ST_GEOMFROMTEXT, ['POINT(-104.8967729 39.3976764)', 4326]],
+          ],
+        },
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build(Property_Units.TABLE_NAME);
+    expect(sql).toContain(
+      "ORDER BY ST_Distance_Sphere(property_units.location, ST_GEOMFROMTEXT('POINT(-104.8967729 39.3976764)', 4326))",
+    );
+    expect(params).not.toContain('POINT(-104.8967729 39.3976764)');
+  });
+
   it('leaves normal table joins unaffected', () => {
     const config = buildTestConfig();
 

package/src/api/orm/builders/AggregateBuilder.ts

@@ -43,6 +43,11 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
         }
 
         const F = String(fn).toUpperCase();
+        const isGeomFromText = F === C6C.ST_GEOMFROMTEXT.toUpperCase();
+
+        if (args.length === 1 && Array.isArray(args[0])) {
+            args = args[0];
+        }
 
         // Parameter placeholder helper: [C6C.PARAM, value]
         if (F === C6C.PARAM) {
@@ -79,7 +84,7 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
         const identifierPathRegex = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
 
         const argList = args
-            .map(arg => {
+            .map((arg, index) => {
                 if (Array.isArray(arg)) return this.buildAggregateField(arg, params);
                 if (typeof arg === 'string') {
                     if (identifierPathRegex.test(arg)) {
@@ -88,6 +93,17 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
                     }
                     // Treat numeric-looking strings as literals, not identifier paths
                     if (isNumericString(arg)) return arg;
+
+                    if (isGeomFromText && index === 0) {
+                        const trimmed = arg.trim();
+                        const alreadyQuoted = trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2;
+                        if (alreadyQuoted) {
+                            return trimmed;
+                        }
+                        const escaped = arg.replace(/'/g, "''");
+                        return `'${escaped}'`;
+                    }
+
                     return arg;
                 }
                 return String(arg);

package/src/api/orm/builders/ConditionBuilder.ts

@@ -187,10 +187,30 @@ export abstract class ConditionBuilder<
                 this.OPERATORS.has(column) &&
                 Array.isArray(op)
             ) {
+                // Helper to serialize operand which may be a qualified identifier or a nested function array
+                const serializeOperand = (arg: any): string => {
+                    const identifierPathRegex = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
+                    if (Array.isArray(arg)) {
+                        // Delegate to aggregate builder to handle nested functions/params
+                        // @ts-ignore - buildAggregateField is defined upstream in AggregateBuilder
+                        return this.buildAggregateField(arg, params);
+                    }
+                    if (typeof arg === 'string') {
+                        if (identifierPathRegex.test(arg)) {
+                            this.assertValidIdentifier(arg, 'WHERE argument');
+                            return arg;
+                        }
+                        return arg;
+                    }
+                    return String(arg);
+                };
+
                 if (column === C6C.ST_DISTANCE_SPHERE) {
                     const [col1, col2] = op;
                     const threshold = Array.isArray(value) ? value[0] : value;
-                    return `ST_Distance_Sphere(${col1}, ${col2}) < ${this.addParam(params, '', threshold)}`;
+                    const left = serializeOperand(col1);
+                    const right = serializeOperand(col2);
+                    return `ST_Distance_Sphere(${left}, ${right}) < ${this.addParam(params, '', threshold)}`;
                 }
                 if ([
                     C6C.ST_CONTAINS,
@@ -203,7 +223,9 @@ export abstract class ConditionBuilder<
                     C6C.ST_TOUCHES
                 ].includes(column)) {
                     const [geom1, geom2] = op;
-                    return `${column}(${geom1}, ${geom2})`;
+                    const left = serializeOperand(geom1);
+                    const right = serializeOperand(geom2);
+                    return `${column}(${left}, ${right})`;
                 }
             }
 
@@ -308,6 +330,24 @@ export abstract class ConditionBuilder<
             const numeric = entries.filter(([k]) => !isNaN(Number(k)));
 
             const processEntry = (k: string, v: any) => {
+                // Operator-as-key handling, e.g., { [C6C.ST_DISTANCE_SPHERE]: [arg1, arg2, threshold] }
+                if (typeof k === 'string' && this.OPERATORS.has(k) && Array.isArray(v)) {
+                    if (k === C6C.ST_DISTANCE_SPHERE) {
+                        // Accept either [arg1, arg2, threshold] or [[arg1, arg2], threshold]
+                        let args: any[];
+                        let threshold: any;
+                        if (Array.isArray(v[0]) && v.length >= 2) {
+                            args = v[0];
+                            threshold = v[1];
+                        } else {
+                            args = v.slice(0, 2);
+                            threshold = v[2];
+                        }
+                        subParts.push(addCondition(k, args as any, threshold));
+                        return;
+                    }
+                }
+
                 if (typeof v === 'object' && v !== null && Object.keys(v).length === 1) {
                     const [op, val] = Object.entries(v)[0];
                     subParts.push(addCondition(k, op, val));