@travetto/model-sql 7.1.4 → 8.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "7.1.4",
+  "version": "8.0.0-alpha.0",
   "type": "module",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -28,14 +28,14 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^7.1.4",
-    "@travetto/context": "^7.1.4",
-    "@travetto/model": "^7.1.4",
-    "@travetto/model-query": "^7.1.4"
+    "@travetto/config": "^8.0.0-alpha.0",
+    "@travetto/context": "^8.0.0-alpha.0",
+    "@travetto/model": "^8.0.0-alpha.0",
+    "@travetto/model-query": "^8.0.0-alpha.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.1.4",
-    "@travetto/test": "^7.1.4"
+    "@travetto/cli": "^8.0.0-alpha.0",
+    "@travetto/test": "^8.0.0-alpha.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/dialect/base.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @stylistic/indent */
-import { DataUtil, type SchemaFieldConfig, Schema, SchemaRegistryIndex, type Point } from '@travetto/schema';
-import { type Class, AppError, TypedObject, TimeUtil, castTo, castKey, toConcrete } from '@travetto/runtime';
+import { DataUtil, type SchemaFieldConfig, SchemaRegistryIndex, type Point } from '@travetto/schema';
+import { type Class, RuntimeError, TypedObject, TimeUtil, castTo, castKey, toConcrete, JSONUtil } from '@travetto/runtime';
 import { type SelectClause, type Query, type SortClause, type WhereClause, type RetainQueryPrimitiveFields, ModelQueryUtil } from '@travetto/model-query';
 import type { BulkResponse, IndexConfig, ModelType } from '@travetto/model';
 
@@ -22,11 +22,6 @@ export type SQLTableDescription = {
   indices: { name: string, columns: { name: string, desc: boolean }[], is_unique: boolean }[];
 };
 
-@Schema()
-class Total {
-  total: number;
-}
-
 function makeField(name: string, type: Class, required: boolean, extra: Partial<SchemaFieldConfig>): SchemaFieldConfig {
   return {
     name,
@@ -212,6 +207,8 @@ export abstract class SQLDialect implements DialectState {
       }
     } else if (config.type === Boolean) {
       return `${value ? 'TRUE' : 'FALSE'}`;
+    } else if (config.type === castTo(BigInt)) {
+      return value.toString();
     } else if (config.type === Number) {
       return `${value}`;
     } else if (config.type === Date) {
@@ -223,9 +220,9 @@ export abstract class SQLDialect implements DialectState {
     } else if (config.type === PointConcrete && Array.isArray(value)) {
       return `point(${value[0]},${value[1]})`;
     } else if (config.type === Object) {
-      return this.quote(JSON.stringify(value).replace(/[']/g, "''"));
+      return this.quote(JSONUtil.toUTF8(value).replaceAll("'", "''"));
     }
-    throw new AppError(`Unknown value type for field ${config.name}, ${value}`, { category: 'data' });
+    throw new RuntimeError(`Unknown value type for field ${config.name}, ${value}`, { category: 'data' });
   }
 
   /**
@@ -234,7 +231,9 @@ export abstract class SQLDialect implements DialectState {
   getColumnType(config: SchemaFieldConfig): string {
     let type: string = '';
 
-    if (config.type === Number) {
+    if (config.type === castTo(BigInt)) {
+      type = this.COLUMN_TYPES.BIGINT;
+    } else if (config.type === Number) {
       type = this.COLUMN_TYPES.INT;
       if (config.precision) {
         const [digits, decimals] = config.precision;
@@ -290,18 +289,21 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Delete query and return count removed
    */
-  async deleteAndGetCount<T>(cls: Class<T>, query: Query<T>): Promise<number> {
+  async deleteAndGetCount<T extends ModelType>(cls: Class<T>, query: Query<T>): Promise<number> {
     const { count } = await this.executeSQL<T>(this.getDeleteSQL(SQLModelUtil.classToStack(cls), query.where));
-    return count;
+    return DataUtil.coerceType(count, Number);
   }
 
   /**
    * Get the count for a given query
    */
-  async getCountForQuery<T>(cls: Class<T>, query: Query<T>): Promise<number> {
-    const { records } = await this.executeSQL<{ total: number }>(this.getQueryCountSQL(cls, query.where));
-    const [record] = records;
-    return Total.from(record).total;
+  async getCountForQuery<T extends ModelType>(cls: Class<T>, query: Query<T>): Promise<number> {
+    const { records } = await this.executeSQL<{ total: number }>(
+      this.getQueryCountSQL(cls,
+        ModelQueryUtil.getWhereClause(cls, query.where)
+      )
+    );
+    return DataUtil.coerceType(records[0].total, Number);
   }
 
   /**
@@ -449,13 +451,13 @@ export abstract class SQLDialect implements DialectState {
 
           switch (subKey) {
             case '$nin': case '$in': {
-              const arr = (Array.isArray(value) ? value : [value]).map(item => resolve(item));
+              const arr = (Array.isArray(value) ? value : [value]).map(resolve);
               items.push(`${sPath} ${SQL_OPS[subKey]} (${arr.join(',')})`);
               break;
             }
             case '$all': {
               const set = new Set();
-              const arr = [value].flat().filter(item => !set.has(item) && !!set.add(item)).map(item => resolve(item));
+              const arr = [value].flat().filter(item => !set.has(item) && !!set.add(item)).map(resolve);
               const valueTable = this.parentTable(sStack);
               const alias = `_all_${sStack.length}`;
               const pPath = this.identifier(this.parentPathField.name);
@@ -660,9 +662,9 @@ ${this.getLimitSQL(cls, query)}`;
       (array ? [castTo<SchemaFieldConfig>(config)] : []);
 
     if (!parent) {
-      let idField = fields.find(field => field.name === this.idField.name);
+      const idField = fields.find(field => field.name === this.idField.name);
       if (!idField) {
-        fields.push(idField = this.idField);
+        fields.push(this.idField);
       }
     }
 

package/src/service.ts

@@ -253,8 +253,7 @@ export class SQLModelService implements
   @Connected()
   async queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
     await QueryVerifier.verify(cls, query);
-    const { records } = await this.#exec<{ total: string | number }>(this.#dialect.getQueryCountSQL(cls, ModelQueryUtil.getWhereClause(cls, query.where)));
-    return +records[0].total;
+    return this.#dialect.getCountForQuery(cls, query);
   }
 
   @Connected()

package/src/table-manager.ts

@@ -130,7 +130,9 @@ export class TableManager {
 
     const sqlCommands = await this.getUpsertTablesSQL(cls);
     for (const key of ['dropIndex', 'table', 'createIndex'] as const) {
-      await Promise.all(sqlCommands[key].map(command => this.#exec(command)));
+      for (const command of sqlCommands[key]) {
+        await this.#exec(command);
+      }
     }
   }
 

package/src/util.ts

@@ -318,15 +318,13 @@ export class SQLModelUtil {
       (wrappers[key] ??= { stack, records: [] }).records.push({ stack, value });
     };
 
-    const all = items.map(item =>
+    items.map(item =>
       this.visitSchemaInstance(cls, item, {
         onRoot: ({ path, value }) => track(path, value),
         onSub: ({ path, value }) => track(path, value),
         onSimple: ({ path, value }) => track(path, value)
       }));
 
-    await Promise.all(all);
-
     const result = [...Object.values(wrappers)].toSorted((a, b) => a.stack.length - b.stack.length);
     return result;
   }