@travetto/model-sql 4.1.3 → 5.0.0-rc.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 ArcSine Technologies
+Copyright (c) 2023 ArcSine Technologies
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "4.1.3",
+  "version": "5.0.0-rc.0",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -27,14 +27,14 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^4.1.1",
-    "@travetto/context": "^4.1.1",
-    "@travetto/model": "^4.1.3",
-    "@travetto/model-query": "^4.1.3"
+    "@travetto/config": "^5.0.0-rc.0",
+    "@travetto/context": "^5.0.0-rc.0",
+    "@travetto/model": "^5.0.0-rc.0",
+    "@travetto/model-query": "^5.0.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/command": "^4.1.1",
-    "@travetto/test": "^4.1.1"
+    "@travetto/command": "^5.0.0-rc.0",
+    "@travetto/test": "^5.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/command": {

package/src/connection/base.ts

@@ -16,6 +16,16 @@ export abstract class Connection<C = unknown> {
   isolatedTransactions = true;
   nestedTransactions = true;
 
+  transactionDialect = {
+    begin: 'BEGIN;',
+    beginNested: 'SAVEPOINT %;',
+    isolate: 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED;',
+    rollback: 'ROLLBACK;',
+    rollbackNested: 'ROLLBACK TO %;',
+    commit: 'COMMIT;',
+    commitNested: 'RELEASE SAVEPOINT %;'
+  };
+
   constructor(public readonly context: AsyncContext) {
 
   }
@@ -137,13 +147,13 @@ export abstract class Connection<C = unknown> {
   async startTx(conn: C, transactionId?: string): Promise<void> {
     if (transactionId) {
       if (this.nestedTransactions) {
-        await this.execute(conn, `SAVEPOINT ${transactionId};`);
+        await this.execute(conn, this.transactionDialect.beginNested.replace('%', transactionId));
       }
     } else {
       if (this.isolatedTransactions) {
-        await this.execute(conn, 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED;');
+        await this.execute(conn, this.transactionDialect.isolate);
       }
-      await this.execute(conn, 'BEGIN;');
+      await this.execute(conn, this.transactionDialect.begin);
     }
   }
 
@@ -153,10 +163,10 @@ export abstract class Connection<C = unknown> {
   async commitTx(conn: C, transactionId?: string): Promise<void> {
     if (transactionId) {
       if (this.nestedTransactions) {
-        await this.execute(conn, `RELEASE SAVEPOINT ${transactionId};`);
+        await this.execute(conn, this.transactionDialect.commitNested.replace('%', transactionId));
       }
     } else {
-      await this.execute(conn, 'COMMIT;');
+      await this.execute(conn, this.transactionDialect.commit);
     }
   }
 
@@ -166,10 +176,10 @@ export abstract class Connection<C = unknown> {
   async rollbackTx(conn: C, transactionId?: string): Promise<void> {
     if (transactionId) {
       if (this.isolatedTransactions) {
-        await this.execute(conn, `ROLLBACK TO ${transactionId};`);
+        await this.execute(conn, this.transactionDialect.rollbackNested.replace('%', transactionId));
       }
     } else {
-      await this.execute(conn, 'ROLLBACK;');
+      await this.execute(conn, this.transactionDialect.rollback);
     }
   }
 }

package/src/connection/decorator.ts

@@ -1,4 +1,3 @@
-import type { MethodDescriptor } from '@travetto/base';
 import { Connection, TransactionType } from './base';
 
 /**
@@ -12,7 +11,7 @@ export interface ConnectionAware<C = unknown> {
  * Decorator to ensure a method runs with a valid connection
  */
 export function Connected<T extends ConnectionAware>() {
-  return function (target: T, prop: string | symbol, desc: MethodDescriptor): void {
+  return function (target: T, prop: string | symbol, desc: TypedPropertyDescriptor<(...params: unknown[]) => Promise<unknown>>): void {
     const og = desc.value!;
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     desc.value = async function (this: T, ...args: unknown[]) {
@@ -25,7 +24,7 @@ export function Connected<T extends ConnectionAware>() {
  * Decorator to ensure a method runs with a valid connection
  */
 export function ConnectedIterator<T extends ConnectionAware>() {
-  return function (target: T, prop: string | symbol, desc: MethodDescriptor): void {
+  return function (target: T, prop: string | symbol, desc: TypedPropertyDescriptor<(...params: unknown[]) => AsyncGenerator<unknown>>): void {
     const og = desc.value!;
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     desc.value = async function* (this: T, ...args: unknown[]) {
@@ -38,7 +37,7 @@ export function ConnectedIterator<T extends ConnectionAware>() {
  * Decorator to ensure a method runs with a valid transaction
  */
 export function Transactional<T extends ConnectionAware>(mode: TransactionType = 'required') {
-  return function (target: T, prop: string | symbol, desc: MethodDescriptor): void {
+  return function (target: T, prop: string | symbol, desc: TypedPropertyDescriptor<(...params: unknown[]) => Promise<unknown>>): void {
     const og = desc.value!;
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     desc.value = function (this: T, ...args: unknown[]) {

package/src/dialect/base.ts

@@ -1,6 +1,6 @@
 import { RuntimeIndex } from '@travetto/manifest';
 import { DataUtil, SchemaRegistry, FieldConfig, Schema } from '@travetto/schema';
-import { Class, ObjectUtil, AppError, TypedObject } from '@travetto/base';
+import { Class, AppError, TypedObject } from '@travetto/base';
 import { SelectClause, Query, SortClause, WhereClause, RetainFields } from '@travetto/model-query';
 import { BulkResponse, IndexConfig } from '@travetto/model';
 import { PointImpl } from '@travetto/model-query/src/internal/model/point';
@@ -424,7 +424,7 @@ export abstract class SQLDialect implements DialectState {
       }
       const sPath = this.resolveName(sStack);
 
-      if (ObjectUtil.isPlainObject(top)) {
+      if (DataUtil.isPlainObject(top)) {
         const subKey = Object.keys(top)[0];
         if (!subKey.startsWith('$')) {
           const inner = this.getWhereFieldSQL(sStack, top);
@@ -731,7 +731,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
     const fields: [string, boolean][] = idx.fields.map(x => {
       const key = TypedObject.keys(x)[0];
       const val = x[key];
-      if (ObjectUtil.isPlainObject(val)) {
+      if (DataUtil.isPlainObject(val)) {
         throw new Error('Unable to supported nested fields for indices');
       }
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/src/internal/util.ts

@@ -1,7 +1,7 @@
-import { Class, TypedObject, ObjectUtil } from '@travetto/base';
+import { Class, TypedObject } from '@travetto/base';
 import { SelectClause, SortClause } from '@travetto/model-query';
-import { ModelRegistry, ModelType } from '@travetto/model';
-import { SchemaRegistry, ClassConfig, FieldConfig } from '@travetto/schema';
+import { ModelRegistry, ModelType, OptionalId } from '@travetto/model';
+import { SchemaRegistry, ClassConfig, FieldConfig, DataUtil } from '@travetto/schema';
 import { AllViewⲐ } from '@travetto/schema/src/internal/types';
 
 import { DialectState, InsertWrapper, VisitHandler, VisitState, VisitInstanceNode, OrderBy } from './types';
@@ -45,7 +45,7 @@ export class SQLUtil {
   static cleanResults<T, U = T>(dct: DialectState, o: T | T[]): U | U[] {
     if (Array.isArray(o)) {
       return o.filter(x => x !== null && x !== undefined).map(x => this.cleanResults(dct, x));
-    } else if (!ObjectUtil.isSimple(o)) {
+    } else if (!DataUtil.isSimpleValue(o)) {
       for (const k of TypedObject.keys(o)) {
         if (o[k] === null || o[k] === undefined || k === dct.parentPathField.name || k === dct.pathField.name || k === dct.idxField.name) {
           delete o[k];
@@ -173,7 +173,7 @@ export class SQLUtil {
   /**
    * Process a schema instance by visiting it synchronously.  This is synchronous to prevent concurrent calls from breaking
    */
-  static visitSchemaInstance<T extends ModelType>(cls: Class<T>, instance: T, handler: VisitHandler<unknown, VisitInstanceNode<unknown>>): void {
+  static visitSchemaInstance<T extends ModelType>(cls: Class<T>, instance: T | OptionalId<T>, handler: VisitHandler<unknown, VisitInstanceNode<unknown>>): void {
     const pathObj: unknown[] = [instance];
     this.visitSchemaSync(SchemaRegistry.get(cls), {
       onRoot: (config) => {
@@ -236,7 +236,7 @@ export class SQLUtil {
     for (const [k, v] of TypedObject.entries(select)) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const sk = k as string;
-      if (!ObjectUtil.isPlainObject(select[k]) && localMap[sk]) {
+      if (!DataUtil.isPlainObject(select[k]) && localMap[sk]) {
         if (!v) {
           if (toGet.size === 0) {
             toGet = new Set(SchemaRegistry.get(cls).views[AllViewⲐ].fields);
@@ -262,7 +262,7 @@ export class SQLUtil {
         const key = Object.keys(cl)[0];
         const val = cl[key];
         const field = { ...schema.views[AllViewⲐ].schema[key] };
-        if (ObjectUtil.isPrimitive(val)) {
+        if (DataUtil.isPrimitive(val)) {
           stack.push(field);
           found = { stack, asc: val === 1 };
         } else {
@@ -334,7 +334,7 @@ export class SQLUtil {
   /**
    * Get insert statements for a given class, and its child tables
    */
-  static async getInserts<T extends ModelType>(cls: Class<T>, els: T[]): Promise<InsertWrapper[]> {
+  static async getInserts<T extends ModelType>(cls: Class<T>, els: (T | OptionalId<T>)[]): Promise<InsertWrapper[]> {
     const ins: Record<string, InsertWrapper> = {};
 
     const track = (stack: VisitStack[], value: unknown): void => {

package/src/service.ts

@@ -223,8 +223,9 @@ export class SQLModelService implements
       new Map([...existingUpsertedIds.entries()].map(([k, v]) => [v, k]))
     );
 
-    const get = (k: keyof BulkOp<T>): T[] =>
-      operations.map(x => x[k]).filter((x): x is T => !!x);
+    const get = <K extends keyof BulkOp<T>>(k: K): Required<BulkOp<T>>[K][] =>
+      operations.map(x => x[k]).filter((x): x is Required<BulkOp<T>>[K] => !!x);
+
     const getStatements = async (k: keyof BulkOp<T>): Promise<InsertWrapper[]> =>
       (await SQLUtil.getInserts(cls, get(k))).filter(x => !!x.records.length);