implement type casting methods (#97)

* implement type casting methods * no-unused-vars * update type declaration * no-unused-vars * 2.14.2
themost-framework · Aug 20, 2024 · 898b00d · 898b00d
1 parent d3768c7
commit 898b00d
Show file tree

Hide file tree

Showing 8 changed files with 186 additions and 7 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@themost/query",
-  "version": "2.14.1",
+  "version": "2.14.2",
   "description": "MOST Web Framework Codename ZeroGravity - Query Module",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",

diff --git a/spec/TypeCast.spec.js b/spec/TypeCast.spec.js
@@ -0,0 +1,78 @@
+import { SqlFormatter, QueryEntity, QueryExpression, QueryField } from '../src/index';
+import { MemoryAdapter } from './test/TestMemoryAdapter';
+import { MemoryFormatter } from './test/TestMemoryFormatter';
+
+describe('Type Casting', () => {
+
+    /**
+     * @type {MemoryAdapter}
+     */
+    let db;
+    beforeAll(() => {
+        db = new MemoryAdapter({
+            name: 'local',
+            database: './spec/db/local.db'
+        });
+    });
+    afterAll((done) => {
+        if (db) {
+            db.close();
+            return done();
+        }
+    })
+    it('should use $toString function', async () => {
+        const Product = new QueryEntity('ProductData');
+        const Order = new QueryEntity('OrderData');
+        const id = new QueryField('id').from(Product);
+        let orderedItem = new QueryField('orderedItem').from(Order);
+        let expr = new QueryExpression().where(id).equal(orderedItem);
+        const formatter = new MemoryFormatter();
+        let sql = formatter.formatWhere(expr.$where);
+        expect(sql).toEqual('(`ProductData`.`id`=`OrderData`.`orderedItem`)');
+        orderedItem =new QueryField({
+            '$toString': [
+                new QueryField('orderedItem').from(Order)
+            ]
+        });
+        expr = new QueryExpression().where(id).equal(orderedItem);
+        sql = formatter.formatWhere(expr.$where);
+        expect(sql).toEqual('(`ProductData`.`id`=CAST(`OrderData`.`orderedItem` AS TEXT))');
+    });
+
+    it('should use $toString inside closure', async () => {
+        const Products = new QueryEntity('ProductData');
+        const q = new QueryExpression().select(({id, name, price}) => {
+            return {
+                id,
+                price,
+                priceString: price.toString(),
+                name
+            }
+        }).from(Products);
+        const formatter = new MemoryFormatter();
+        const items = await db.executeAsync(q);
+        items.forEach(({price, priceString}) => {
+            expect(typeof priceString).toEqual('string');
+            const fromString = parseFloat(priceString);
+            expect(price).toEqual(fromString);
+        });
+    });
+
+    it('should use $toInt inside closure', async () => {
+        const Products = new QueryEntity('ProductData');
+        const q = new QueryExpression().select(({id, name, price}) => {
+            return {
+                id,
+                price,
+                priceInt: parseInt(price),
+                name
+            }
+        }).from(Products);
+        const items = await db.executeAsync(q);
+        items.forEach(({price, priceInt}) => {
+            expect(typeof priceInt).toEqual('number');
+            const fromInt = parseInt(price);
+            expect(priceInt).toEqual(fromInt);
+        });
+    });
+});
diff --git a/spec/test/TestMemoryFormatter.js b/spec/test/TestMemoryFormatter.js
@@ -1,6 +1,24 @@
 
 import { SqliteFormatter } from '@themost/sqlite';
 
+Object.assign(SqliteFormatter.prototype, {
+    $toString(arg) {
+        return `CAST(${this.escape(arg)} AS TEXT)`;
+    },
+    $toDouble(arg) {
+        return `CAST(${this.escape(arg)} AS NUMERIC)`;
+    },
+    $toDecimal(arg) {
+        return `CAST(${this.escape(arg)} AS NUMERIC)`;
+    },
+    $toInt(arg) {
+        return `CAST(${this.escape(arg)} AS INTEGER)`;
+    },
+    $toLong(arg) {
+        return `CAST(${this.escape(arg)} AS INTEGER)`;
+    }
+});
+
 // noinspection JSUnusedGlobalSymbols
 /**
  * @augments {SqlFormatter}

diff --git a/src/closures/FallbackMethodParser.js b/src/closures/FallbackMethodParser.js
@@ -74,6 +74,12 @@ class FallbackMethodParser {
     static now() {
         return new SimpleMethodCallExpression('now', []);
     }
+    static parseInt(args) {
+        return new SimpleMethodCallExpression('toInt', args);
+    }
+    static parseFloat(args) {
+        return new SimpleMethodCallExpression('toDouble', args);
+    }
 }
 
 export {

diff --git a/src/closures/PrototypeMethodParser.js b/src/closures/PrototypeMethodParser.js
@@ -1,16 +1,16 @@
-// MOST Web Framework Codename Zero Gravity Copyright (c) 2017-2022, THEMOST LP All rights reserved
+import { SimpleMethodCallExpression } from '../expressions';
 
 class PrototypeMethodParser {
     constructor() {
     }
     test(name) {
-        if (name === 'toString') {
-            return;
-        }
         if (typeof this[name] === 'function') {
             return this[name];
         }
     }
+    toString(args) {
+        return new SimpleMethodCallExpression('toString', args);
+    }
 }
 
 export {

diff --git a/src/formatter.d.ts b/src/formatter.d.ts
@@ -68,6 +68,11 @@ export declare class SqlFormatter {
     $switch(expr: {
         branches: {case: any, then: any}[], defaultValue?: any
     }): string | any;
+    $toString(arg0:any): string | any;
+    $toInt(arg0:any): string | any;
+    $toDouble(arg0:any): string | any;
+    $toLong(arg0:any): string | any;
+    $toDecimal(arg0:any): string | any;
     formatWhere(where: any): any;
     formatCount(query: QueryExpression | any): any;
     formatFixedSelect(query: QueryExpression | any): any;

diff --git a/src/formatter.js b/src/formatter.js
@@ -8,6 +8,12 @@ import './polyfills';
 import { ObjectNameValidator } from './object-name.validator';
 import { isNameReference, trimNameReference } from './name-reference';
 
+class AbstractMethodError extends Error {
+    constructor() {
+        super('Abstract method error')
+    }
+}
+
 const ALIAS_KEYWORD = ' AS ';
 const DEFAULT_COUNT_ALIAS = '__count__';
 /**
@@ -1363,6 +1369,55 @@ class SqlFormatter {
         sql += ')';
         return sql;
     }
+
+    /**
+     * @abstract
+     * @param {*} arg 
+     * @returns {string}
+     */
+    /* eslint-disable-next-line no-unused-vars */
+    $toString(arg) {
+        throw new AbstractMethodError();
+    }
+    /**
+     * @abstract
+     * @param {*} arg 
+     * @returns {string}
+     */
+     /* eslint-disable-next-line no-unused-vars */
+    $toDouble(arg) {
+        throw new AbstractMethodError();
+    }
+
+    /**
+     * @abstract
+     * @param {*} arg 
+     * @returns {string}
+     */
+     /* eslint-disable-next-line no-unused-vars */
+    $toDecimal(arg) {
+        throw new AbstractMethodError();
+    }
+
+    /**
+     * @abstract
+     * @param {*} arg 
+     * @returns {string}
+     */
+     /* eslint-disable-next-line no-unused-vars */
+    $toInt(arg) {
+        throw new AbstractMethodError();
+    }
+
+    /**
+     * @abstract
+     * @param {*} arg 
+     * @returns {string}
+     */
+     /* eslint-disable-next-line no-unused-vars */
+    $toLong(arg) {
+        throw new AbstractMethodError();
+    }
 }
 
 export {