@carbonorm/carbonnode 3.9.0 → 3.9.2

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

@@ -301,6 +301,88 @@ describe('SQL Builders - Complex SELECTs', () => {
     expect(() => qb.build(Property_Units.TABLE_NAME)).toThrowError(/Unknown table or alias 'missing_alias'/);
   });
 
+  it('orders by distance to a literal ST_Point with numeric string coords', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [Property_Units.UNIT_ID],
+      [C6C.PAGINATION]: {
+        [C6C.LIMIT]: 200,
+        [C6C.ORDER]: {
+          [C6C.ST_DISTANCE_SPHERE]: [
+            Property_Units.LOCATION,
+            [C6C.ST_POINT, ['-104.8967729', '39.3976764']],
+          ],
+        },
+      },
+    } as any, false);
+
+    const { sql } = qb.build(Property_Units.TABLE_NAME);
+    expect(sql).toContain('ORDER BY ST_Distance_Sphere(property_units.location, ST_POINT(-104.8967729, 39.3976764))');
+  });
+
+  it('orders by distance to ST_SRID(ST_Point(lng, lat), 4326)', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [Property_Units.UNIT_ID],
+      [C6C.PAGINATION]: {
+        [C6C.LIMIT]: 50,
+        [C6C.ORDER]: {
+          [C6C.ST_DISTANCE_SPHERE]: [
+            Property_Units.LOCATION,
+            [C6C.ST_SRID, [C6C.ST_POINT, [10, 20]], 4326],
+          ],
+        },
+      },
+    } as any, false);
+
+    const { sql } = qb.build(Property_Units.TABLE_NAME);
+    expect(sql).toContain('ORDER BY ST_Distance_Sphere(property_units.location, ST_SRID(ST_POINT(10, 20), 4326))');
+  });
+
+  it('orders by distance using placeholders via PARAM inside nested ST_Point', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [Property_Units.UNIT_ID],
+      [C6C.PAGINATION]: {
+        [C6C.LIMIT]: 25,
+        [C6C.ORDER]: {
+          [C6C.ST_DISTANCE_SPHERE]: [
+            Property_Units.LOCATION,
+            [C6C.ST_SRID, [C6C.ST_POINT, [[C6C.PARAM, 10], [C6C.PARAM, 20]]], 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_SRID(ST_POINT(?, ?), 4326))');
+    expect(params.slice(-2)).toEqual([10, 20]);
+  });
+
+  it('orders by distance using named params via PARAM inside nested ST_Point', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [Property_Units.UNIT_ID],
+      [C6C.PAGINATION]: {
+        [C6C.LIMIT]: 25,
+        [C6C.ORDER]: {
+          [C6C.ST_DISTANCE_SPHERE]: [
+            Property_Units.LOCATION,
+            [C6C.ST_SRID, [C6C.ST_POINT, [[C6C.PARAM, 10], [C6C.PARAM, 20]]], 4326],
+          ],
+        },
+      },
+    } as any, true);
+
+    const { sql, params } = qb.build(Property_Units.TABLE_NAME);
+    expect(sql).toMatch(/ST_SRID\(ST_POINT\(:param0, :param1\), 4326\)/);
+    expect(params).toEqual({ param0: 10, param1: 20 });
+  });
+
   it('leaves normal table joins unaffected', () => {
     const config = buildTestConfig();
 

package/src/api/C6Constants.ts

@@ -101,6 +101,7 @@ export const C6Constants = {
     SECOND_MICROSECOND: 'SECOND_MICROSECOND',
     SELECT: 'SELECT',
     SUBSELECT: 'SUBSELECT',
+    PARAM: 'PARAM',
 
     // MySQL Spatial Functions
     ST_AREA: 'ST_Area',
@@ -188,4 +189,4 @@ export const C6Constants = {
 };
 
 
-export const C6C = C6Constants;
+export const C6C = C6Constants;

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

@@ -21,6 +21,19 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
             throw new Error('Invalid SELECT field entry');
         }
 
+        // If the array represents a tuple/literal list (e.g., [lng, lat]) rather than a
+        // function call like [FN, ...args], serialize the list as a comma-separated
+        // literal sequence so parent calls (like ORDER BY FN(<here>)) can embed it.
+        const isNumericString = (s: string) => /^-?\d+(?:\.\d+)?$/.test(String(s).trim());
+        if (typeof field[0] !== 'string' || isNumericString(field[0])) {
+            return field
+                .map((arg) => {
+                    if (Array.isArray(arg)) return this.buildAggregateField(arg, params);
+                    return String(arg);
+                })
+                .join(', ');
+        }
+
         let [fn, ...args] = field;
         let alias: string | undefined;
 
@@ -31,6 +44,17 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
 
         const F = String(fn).toUpperCase();
 
+        // Parameter placeholder helper: [C6C.PARAM, value]
+        if (F === C6C.PARAM) {
+            if (!params) {
+                throw new Error('PARAM requires parameter tracking.');
+            }
+            const value = args[0];
+            // Use empty column context; ORDER/SELECT literals have no column typing.
+            // @ts-ignore addParam is provided by ConditionBuilder in our hierarchy.
+            return this.addParam(params, '', value);
+        }
+
         if (F === C6C.SUBSELECT) {
             if (!params) {
                 throw new Error('Scalar subselects in SELECT require parameter tracking.');
@@ -52,11 +76,18 @@ export abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G
             return expr;
         }
 
+        const identifierPathRegex = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
+
         const argList = args
             .map(arg => {
                 if (Array.isArray(arg)) return this.buildAggregateField(arg, params);
                 if (typeof arg === 'string') {
-                    this.assertValidIdentifier(arg, 'SELECT expression');
+                    if (identifierPathRegex.test(arg)) {
+                        this.assertValidIdentifier(arg, 'SELECT expression');
+                        return arg;
+                    }
+                    // Treat numeric-looking strings as literals, not identifier paths
+                    if (isNumericString(arg)) return arg;
                     return arg;
                 }
                 return String(arg);

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

@@ -30,11 +30,18 @@ export abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuild
                 }
                 // FUNCTION CALL: val is an array of args
                 if (Array.isArray(val)) {
+                    const identifierPathRegex = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
+                    const isNumericString = (s: string) => /^-?\d+(?:\.\d+)?$/.test(s.trim());
                     const args = val
                         .map((arg) => {
                             if (Array.isArray(arg)) return this.buildAggregateField(arg, params);
-                            if (typeof arg === 'string' && arg.includes('.')) {
-                                this.assertValidIdentifier(arg, 'ORDER BY argument');
+                            if (typeof arg === 'string') {
+                                if (identifierPathRegex.test(arg)) {
+                                    this.assertValidIdentifier(arg, 'ORDER BY argument');
+                                    return arg;
+                                }
+                                // numeric-looking strings should be treated as literals
+                                if (isNumericString(arg)) return arg;
                                 return arg;
                             }
                             return String(arg);