taon-type-sql 21.0.22 → 21.0.24

package/lib-prod/converter/parameterized-converter.js

@@ -0,0 +1,14 @@
+import { createQueryConverter } from "./query-converter";
+import { convertEscapedParam } from './param-converter';
+let pgParamConverter = (index) => '$' + index;
+let mySqlParamConverter = (index) => '?';
+function convertSingleParam(param, params, paramConverter) {
+    params.push(convertEscapedParam(param));
+    return paramConverter(params.length);
+}
+export function convertQueryToParameterizedSQL(query, options, engine) {
+    let params = [];
+    let paramConverter = engine === 'mysql' ? mySqlParamConverter : pgParamConverter;
+    let sql = createQueryConverter((param) => convertSingleParam(param, params, paramConverter), options, engine)(query);
+    return { sql, params };
+}

package/lib-prod/converter/{query-converter.ts → query-converter.js}

@@ -1,104 +1,91 @@
 import { string, number, date, boolean } from './type-converter';
-import { QueryEngine, ConverterOptions } from "./types";
-
-
-export function createQueryConverter(paramConverter: (param: any) => string, options: ConverterOptions, engine: QueryEngine) {
-
+export function createQueryConverter(paramConverter, options, engine) {
     return convertQuery;
-
-    function convertQuery(query: any): string {
-        if (query._action === 'select') return convertSelectQuery(query);
-        if (query._action === 'delete') return convertDeleteQuery(query);
-        if (query._action === 'update') return convertUpdateQuery(query);
-        if (query._action === 'insert') return convertInsertQuery(query);
+    function convertQuery(query) {
+        if (query._action === 'select')
+            return convertSelectQuery(query);
+        if (query._action === 'delete')
+            return convertDeleteQuery(query);
+        if (query._action === 'update')
+            return convertUpdateQuery(query);
+        if (query._action === 'insert')
+            return convertInsertQuery(query);
         throw new Error('Unknown query type:' + query._action);
     }
-
-    function convertDeleteQuery(query: any): string {
+    function convertDeleteQuery(query) {
         let s = 'DELETE FROM ' + convertTable(query._table);
         s += convertConditions(query._conditions);
         return s;
     }
-
-    function convertUpdateQuery(query: any): string {
+    function convertUpdateQuery(query) {
         let s = 'UPDATE ' + convertTable(query._table) + ' SET ';
         s += convertUpdateSetters(query._table, query._entity);
         s += convertConditions(query._conditions);
         return s;
     }
-
-    function convertUpdateSetters(table: any, entity: any): string {
+    function convertUpdateSetters(table, entity) {
         return Object.keys(entity).sort().map(key => {
             let value = entity[key];
             let column = table[key];
             return convertColumnName(column) + ' = ' + convertParam(column, value);
         }).join(', ');
     }
-
-    function convertInsertQuery(query: any): string {
-        let items: any[] = Array.isArray(query._entity) ? query._entity : [query._entity];
-        let keySet: Set<string> = items.reduce((set: Set<string>, item) => {
-            Object.keys(item).forEach(key => set.add(key)); return set;
-        }, new Set<string>());
+    function convertInsertQuery(query) {
+        let items = Array.isArray(query._entity) ? query._entity : [query._entity];
+        let keySet = items.reduce((set, item) => {
+            Object.keys(item).forEach(key => set.add(key));
+            return set;
+        }, new Set());
         let keys = Array.from(keySet).sort();
-
         let s = 'INSERT INTO ' + convertTable(query._table) + ' ';
         s += '(' + keys.map(key => convertColumnName(query._table[key])).join(', ') + ')';
         s += options.lineBreak + 'VALUES ';
         s += items.map(item => convertInsertItem(query._table, item, keys))
-            .map((row: string) => '(' + row + ')').join(', ');
-
+            .map((row) => '(' + row + ')').join(', ');
         s += getPgInsertReturningIfNeeded(query);
         return s;
     }
-
-
-    function getPgInsertReturningIfNeeded(query: any): string {
+    function getPgInsertReturningIfNeeded(query) {
         if (engine === 'pg' && query._action === 'insert' && !Array.isArray(query._entity) &&
             query._table.$id && query._table.$id._table && query._table.$id._name) {
             return ' RETURNING ' + convertColumnName(query._table.$id);
         }
         return '';
     }
-
-    function convertInsertItem(table: any, entity: any, keys: string[]): string {
+    function convertInsertItem(table, entity, keys) {
         return keys.map(key => {
             let value = entity[key];
             let column = table[key];
             return convertParam(column, value);
         }).join(', ');
     }
-
-    function convertSelectQuery(query: any): string {
+    function convertSelectQuery(query) {
         let s = 'SELECT ';
         if (query._distinct) {
             s += 'DISTINCT ';
         }
-
         if (query._columns == null || query._columns.length === 0) {
-            s += '*'
-        } else {
-            s += query._columns.map((column: any) => convertColumn(column)).join(', ');
+            s += '*';
+        }
+        else {
+            s += query._columns.map((column) => convertColumn(column)).join(', ');
         }
-
         s += options.lineBreak + 'FROM ';
         if (query._tables) {
-            s+= query._tables.map((table: any) => table._parent ? convertJoin(table) : convertTable(table)).join(', ');
-        } else {
-            s+= convertTable(query._table);
+            s += query._tables.map((table) => table._parent ? convertJoin(table) : convertTable(table)).join(', ');
+        }
+        else {
+            s += convertTable(query._table);
         }
-
         s += convertConditions(query._conditions);
-
         if (query._groupBy && query._groupBy.length > 0) {
             s += options.lineBreak + 'GROUP BY ';
-            s += query._groupBy.map((column: any) => convertColumn(column)).join(', ');
+            s += query._groupBy.map((column) => convertColumn(column)).join(', ');
         }
         s += convertConditions(query._having, 'HAVING');
-
         if (query._orderings && query._orderings.length > 0) {
             s += options.lineBreak + 'ORDER BY ';
-            s += query._orderings.map((ordering: any) => convertOrdering(ordering)).join(', ');
+            s += query._orderings.map((ordering) => convertOrdering(ordering)).join(', ');
         }
         if (query._limit != null) {
             s += options.lineBreak + 'LIMIT ' + number(query._limit);
@@ -108,8 +95,7 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
         }
         return s;
     }
-
-    function convertConditions(conditions: any[], keyword = 'WHERE'): string {
+    function convertConditions(conditions, keyword = 'WHERE') {
         let s = '';
         if (conditions && conditions.length > 0) {
             s += options.lineBreak + keyword + ' ';
@@ -118,18 +104,15 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
         }
         return s;
     }
-
-    function convertJoin(joinChain: any): string {
-        let items: any[] = [];
+    function convertJoin(joinChain) {
+        let items = [];
         while (joinChain) {
             items.push(joinChain);
             joinChain = joinChain._parent;
         }
-
         let root = items[items.length - 1];
         let s = convertTable(root);
-
-        for (let i = items.length - 2; i >= 0; i-= 2) {
+        for (let i = items.length - 2; i >= 0; i -= 2) {
             let table = items[i]._table;
             let modifier = items[i]._modifier;
             let condition = items[i - 1]._condition;
@@ -137,32 +120,28 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
             s += ' ' + modifier.toUpperCase() + ' JOIN ' + convertTable(table) + ' ON ' +
                 convertColumnCondition(condition, param);
         }
-
         return s;
     }
-
-    function convertOrdering(ordering: any): string {
+    function convertOrdering(ordering) {
         if (ordering._column) {
             let s = convertColumn(ordering._column);
-
             if (ordering._nullsPosition != null) { // "NULLS FIRST" only exists in PG, this is the general solution
                 s += ' IS NULL ' + (ordering._nullsPosition === 'FIRST' ? 'DESC' : 'ASC') + ', ' + s;
             }
-
-            if (ordering._direction === 'ASC') s += ' ASC';
-            if (ordering._direction === 'DESC') s += ' DESC';
-
+            if (ordering._direction === 'ASC')
+                s += ' ASC';
+            if (ordering._direction === 'DESC')
+                s += ' DESC';
             return s;
-        } else {
+        }
+        else {
             return convertColumn(ordering);
         }
     }
-
-    function convertTable(table: any): string {
+    function convertTable(table) {
         return options.nameEscape + table._$name + options.nameEscape;
     }
-
-    function convertColumn(column: any): string {
+    function convertColumn(column) {
         let s = '';
         if (!(column._name === '*' && column._modifiers.length > 0 && column._modifiers[0].name === 'count')) {
             s += convertTable(column._table) + '.';
@@ -170,31 +149,37 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
         s += convertColumnName(column);
         return convertColumnModifiers(s, column);
     }
-
-    function convertColumnModifiers(s: string, column: any): string {
+    function convertColumnModifiers(s, column) {
         if (column._modifiers) {
-            column._modifiers.forEach((modifier: any) => {
+            column._modifiers.forEach((modifier) => {
                 let name = modifier.name;
-                if (name === 'lower') s = 'LOWER(' + s + ')';
-                else if (name === 'upper') s = 'UPPER(' + s + ')';
-                else if (name === 'count') s = 'COUNT(' + s + ')';
-                else if (name === 'sum') s = 'SUM(' + s + ')';
-                else if (name === 'avg') s = 'AVG(' + s + ')';
-                else if (name === 'min') s = 'MIN(' + s + ')';
-                else if (name === 'max') s = 'MAX(' + s + ')';
-                else if (name === 'as') s = s + ' AS ' + options.nameEscape + modifier.params + options.nameEscape;
+                if (name === 'lower')
+                    s = 'LOWER(' + s + ')';
+                else if (name === 'upper')
+                    s = 'UPPER(' + s + ')';
+                else if (name === 'count')
+                    s = 'COUNT(' + s + ')';
+                else if (name === 'sum')
+                    s = 'SUM(' + s + ')';
+                else if (name === 'avg')
+                    s = 'AVG(' + s + ')';
+                else if (name === 'min')
+                    s = 'MIN(' + s + ')';
+                else if (name === 'max')
+                    s = 'MAX(' + s + ')';
+                else if (name === 'as')
+                    s = s + ' AS ' + options.nameEscape + modifier.params + options.nameEscape;
             });
         }
         return s + '';
     }
-
-    function convertColumnName(column: any): string {
-        if (column._name === '*') return column._name;
+    function convertColumnName(column) {
+        if (column._name === '*')
+            return column._name;
         let name = typeof column._name === 'string' ? column._name : column._name.name;
         return options.nameEscape + name + options.nameEscape;
     }
-
-    function preprocessConditions(conditions: any[]): void {
+    function preprocessConditions(conditions) {
         conditions.forEach(condition => {
             if (conditions.length > 1 && condition._sibling) {
                 condition._parenthesis = true;
@@ -202,9 +187,8 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
             preprocessParams(condition);
         });
     }
-
     // this is only needed, so that the $1, $2... numbering is not reversed
-    function preprocessParams(condition: any): void {
+    function preprocessParams(condition) {
         if (condition._sibling) {
             preprocessParams(condition._sibling);
         }
@@ -215,12 +199,10 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
             preprocessParams(condition._child);
         }
     }
-
-    function convertCondition(condition: any, root = false): string {
+    function convertCondition(condition, root = false) {
         if (!condition._sibling && !condition._child) {
             return convertColumnCondition(condition, condition.__param);
         }
-
         let s = '';
         if (condition._child) {
             s += convertCondition(condition._child);
@@ -236,14 +218,12 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
         }
         return s;
     }
-
-    function convertColumnCondition(condition: any, param: string): string {
+    function convertColumnCondition(condition, param) {
         let s = convertColumn(condition._column);
         s += getConditionString(condition, param);
         return s;
     }
-
-    function getConditionString(condition: any, param: string): string {
+    function getConditionString(condition, param) {
         switch (condition._type) {
             case 'eq': return ' = ' + param;
             case 'ne': return ' <> ' + param;
@@ -262,35 +242,39 @@ export function createQueryConverter(paramConverter: (param: any) => string, opt
             default: return '';
         }
     }
-
-    function getConditionParam(condition: any): string {
+    function getConditionParam(condition) {
         let param = '';
         if (condition._otherColumn) {
             param = convertColumn(condition._otherColumn);
-        } else {
-            let _convertParam = (param: any) => convertParam(condition._column, param);
-
+        }
+        else {
+            let _convertParam = (param) => convertParam(condition._column, param);
             if (condition._type === 'in' || condition._type === 'not-in') {
-                param = condition._values.map((value: any) => _convertParam(value)).join(', ');
-            } else if (condition._type === 'between' || condition._type === 'not-between') {
+                param = condition._values.map((value) => _convertParam(value)).join(', ');
+            }
+            else if (condition._type === 'between' || condition._type === 'not-between') {
                 param = _convertParam(condition._values[0]) + ' AND ' + _convertParam(condition._values[1]);
-            } else if (condition._type !== 'is-null' && condition._type !== 'is-not-null') {
+            }
+            else if (condition._type !== 'is-null' && condition._type !== 'is-not-null') {
                 param = _convertParam(condition._values[0]);
             }
         }
         return param;
     }
-
-    function convertParam(column: any, param: any): string {
-        if (param == null) return 'NULL';
+    function convertParam(column, param) {
+        if (param == null)
+            return 'NULL';
         return paramConverter(getTypedParam(column._type, param));
     }
-
-    function getTypedParam(type: string, param: any): any {
-        if (type === 'number') return number(param);
-        else if (type === 'boolean') return boolean(param);
-        else if (type === 'date') return date(param);
-        else if (type === 'string') return string(param);
+    function getTypedParam(type, param) {
+        if (type === 'number')
+            return number(param);
+        else if (type === 'boolean')
+            return boolean(param);
+        else if (type === 'date')
+            return date(param);
+        else if (type === 'string')
+            return string(param);
         return param;
     }
-}
+}

package/lib-prod/converter/result-converter.js

@@ -0,0 +1,85 @@
+export function convertResult(query, result, engine) {
+    let rows = engine === 'pg' ? result.rows : result;
+    let rowCount = engine === 'pg' ? result.rowCount : result.affectedRows || result.changedRows;
+    if (query._action === 'select')
+        return convertSelectResult(query, rows);
+    if (query._action === 'delete')
+        return rowCount;
+    if (query._action === 'update')
+        return rowCount;
+    if (query._action === 'insert')
+        return convertInsertResult(result, engine);
+    throw new Error('Unknown query type:' + query._action);
+}
+function convertInsertResult(result, engine) {
+    if (engine === 'mysql')
+        return result.insertId > 0 ? result.insertId : undefined; // mysql returns 0 for tables that have a non-autoincrement ID
+    if (engine === 'pg' && result.rows && result.rows.length === 1) {
+        let columnName = Object.keys(result.rows[0])[0];
+        return result.rows[0][columnName];
+    }
+}
+function convertSelectResult(query, rows) {
+    if (query._columns && query._columns.length === 1 &&
+        !(query._columns[0]._name === '*' && query._columns[0]._modifiers.length === 0)) {
+        if (rows.length == 0)
+            return [];
+        let columnName = Object.keys(rows[0])[0]; // easier than reverse engineering from the column modifiers
+        let values = rows.map((row) => row[columnName]);
+        if (query._columns[0]._name === '*' && query._columns[0]._modifiers.some((m) => m.name === 'count')) {
+            return values.map((value) => Number(value)); // string to number conversion for PG count values
+        }
+        return values;
+    }
+    else {
+        convertAliasFields(query, rows);
+        return rows;
+    }
+}
+function convertAliasFields(query, rows) {
+    let aliasByName = getColumnAliasesByName(query);
+    if (Object.keys(aliasByName).length === 0)
+        return;
+    rows.forEach((row) => {
+        Object.keys(row).forEach((name) => {
+            if (aliasByName[name]) {
+                row[aliasByName[name]] = row[name];
+                delete row[name];
+            }
+        });
+    });
+}
+function getColumnAliasesByName(query) {
+    let aliasByName = {};
+    if (query._columns && query._columns.length > 0) {
+        query._columns.forEach((column) => {
+            if (column._name && column._name.alias && column._modifiers.length === 0) {
+                aliasByName[column._name.name] = column._name.alias;
+            }
+            else if (column._name === '*' && column._modifiers.length === 0) {
+                getAliasColumnsOfTable(column._table).forEach((column) => {
+                    aliasByName[column._name.name] = column._name.alias;
+                });
+            }
+        });
+    }
+    else {
+        let tables = query._table ? [query._table] : query._tables;
+        tables.forEach((table) => {
+            getAliasColumnsOfTable(table).forEach((column) => {
+                aliasByName[column._name.name] = column._name.alias;
+            });
+            let joinTable = table._parent;
+            while (joinTable) {
+                getAliasColumnsOfTable(joinTable).forEach((column) => {
+                    aliasByName[column._name.name] = column._name.alias;
+                });
+                joinTable = joinTable._parent;
+            }
+        });
+    }
+    return aliasByName;
+}
+function getAliasColumnsOfTable(table) {
+    return Object.keys(table).map(key => table[key]).filter((column) => column && column._name && column._name.alias);
+}

package/lib-prod/converter/sql-converter.js

@@ -0,0 +1,5 @@
+import { createQueryConverter } from "./query-converter";
+import { convertSubstitutionParam } from './param-converter';
+export function convertQueryToSQL(query, options, engine) {
+    return createQueryConverter((param) => convertSubstitutionParam(param), options, engine)(query);
+}

package/lib-prod/converter/type-converter.js

@@ -0,0 +1,36 @@
+export function number(param) {
+    let result = Number(param);
+    if (Number.isNaN(result))
+        throw new Error('Invalid number parameter in SQL query: ' + param);
+    return result;
+}
+export function boolean(param) {
+    if (typeof param === 'boolean')
+        return param;
+    if (param instanceof Boolean)
+        return param.valueOf();
+    if (param === 'true')
+        return true;
+    if (param === 'false')
+        return false;
+    throw new Error('Invalid boolean parameter in SQL query: ' + param);
+}
+export function date(param) {
+    if (param instanceof Date)
+        return param; // @ts-ignore
+    if (typeof param === 'number' || param instanceof Number)
+        return new Date(param);
+    if (typeof param === 'string' || param instanceof String) {
+        if (Number.isNaN(Date.parse(String(param))))
+            throw new Error('Invalid date parameter in SQL query: ' + param); // @ts-ignore
+        return new Date(param);
+    }
+    throw new Error('Invalid date parameter in SQL query: ' + param);
+}
+export function string(param) {
+    if (typeof param === 'string')
+        return param;
+    if (param instanceof String)
+        return param.valueOf();
+    throw new Error('Invalid string parameter in SQL query: ' + param);
+}

package/lib-prod/converter/types.js

@@ -0,0 +1 @@
+export {};

package/lib-prod/env/{env.angular-node-app.ts → env.angular-node-app.js}

@@ -63,4 +63,4 @@ export const ENV_ANGULAR_NODE_APP_IS_CI_PROCESS = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.docs-webapp.ts → env.docs-webapp.js}

@@ -63,4 +63,4 @@ export const ENV_DOCS_WEBAPP_IS_CI_PROCESS = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.electron-app.ts → env.electron-app.js}

@@ -63,4 +63,4 @@ export const ENV_ELECTRON_APP_IS_CI_PROCESS = undefined;
 export const ENV_ELECTRON_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_ELECTRON_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_ELECTRON_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.mobile-app.ts → env.mobile-app.js}

@@ -63,4 +63,4 @@ export const ENV_MOBILE_APP_IS_CI_PROCESS = undefined;
 export const ENV_MOBILE_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_MOBILE_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_MOBILE_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.npm-lib-and-cli-tool.ts → env.npm-lib-and-cli-tool.js}

@@ -63,4 +63,4 @@ export const ENV_NPM_LIB_AND_CLI_TOOL_IS_CI_PROCESS = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.vscode-plugin.ts → env.vscode-plugin.js}

@@ -63,4 +63,4 @@ export const ENV_VSCODE_PLUGIN_IS_CI_PROCESS = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/{index._auto-generated_.ts → index._auto-generated_.js}

@@ -2,4 +2,4 @@
 // This file is auto-generated during init process. Do not modify.
 // This is only placeholder.
 // Use property "shouldGenerateAutogenIndexFile: true" 
-// in taon.jsonc to enable ts exports auto generation. 
+// in taon.jsonc to enable ts exports auto generation.

package/lib-prod/{index.ts → index.js}

@@ -1,5 +1,4 @@
 // Builder:
-
 export { default as BasicColumn } from './builder/column/basic-column';
 export { default as BooleanColumn } from './builder/column/boolean-column';
 export { default as ComparableColumn } from './builder/column/comparable-column';
@@ -8,30 +7,19 @@ export { default as NumberColumn } from './builder/column/number-column';
 export { default as QueryColumn } from './builder/column/query-column';
 export { default as StringColumn } from './builder/column/string-column';
 export { default as ValueColumn } from './builder/column/value-column';
-
 export { default as QueryColumnCondition } from './builder/condition/query-column-condition';
 export { default as QueryCondition } from './builder/condition/query-condition';
 export { default as QueryConditionChain } from './builder/condition/query-condition-chain';
 export { default as QueryJoinCondition } from './builder/condition/query-join-condition';
-
 export { default as JoinedTables } from './builder/join/joined-tables';
 export { default as JoinedTablesChain } from './builder/join/joined-tables-chain';
-
 export { default as QueryOrdering } from './builder/other/query-ordering';
-
 export { default as SelectQuery } from './builder/query/select-query';
 export { default as TableQuery } from './builder/query/table-query';
 export { default as TableConditionQuery } from './builder/query/table-condition-query';
-
 export { default as QuerySource } from './builder/query-source';
 export { default as QueryTable } from './builder/query-table';
-
 // Client:
-
 export { default as MySqlQuerySource } from './client/mysql';
 // export { default as PgQuerySource } from './client/pg';
-
 export { QueryProcessorOptions } from './client/query-processor';
-
-
-export type PropsEntitySQL<IEntityType> = { [prop in keyof Required<IEntityType>]: any; }

package/lib-prod/migrations/index.js

@@ -0,0 +1,2 @@
+//@ts-nocheck
+export * from './migrations_index._auto-generated_';

package/lib-prod/migrations/{migrations_index._auto-generated_.ts → migrations_index._auto-generated_.js}

@@ -1,5 +1,3 @@
 // THIS FILE IS GENERATED - DO NOT MODIFY
-
 // THIS FILE IS GENERATED - DO NOT MODIFY
-
 // THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/package.json

@@ -1,4 +1,4 @@
 {
   "name": "taon-type-sql/lib-prod",
-  "version": "21.0.22"
+  "version": "21.0.24"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql",
-  "version": "21.0.22",
+  "version": "21.0.24",
   "scripts": {
     "taon init": "taon init",
     "taon start": "taon start",

package/websql/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql/websql",
-  "version": "21.0.22",
+  "version": "21.0.24",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/websql-prod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql/websql-prod",
-  "version": "21.0.22",
+  "version": "21.0.24",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"