alteração na chamada do migration para fazer a chamada passando a instancia do Database ao inves da transaction.

Author: Fernando

src/providers/database-migration-contract.ts

@@ -1,6 +1,6 @@
 import { Injectable } from "@angular/core";
 import { Version } from "./../model/version-model";
-import { DatabaseTransaction, GetMapper } from "database-builder";
+import { GetMapper, DatabaseObject } from "database-builder";
 import { DatabaseResettableContract } from "./database-resettable-contract";
 import { Observable } from "rxjs";
 
@@ -9,7 +9,7 @@ export abstract class DatabaseMigrationContract {
 
     public abstract to(
         version: Version,
-        transation: DatabaseTransaction,
+        database: DatabaseObject,
         mappers: GetMapper,
         resettable: DatabaseResettableContract
     ): Array<Observable<any>>;

src/providers/database-migration.ts

@@ -2,13 +2,13 @@ import { DatabaseSettingsFactoryContract } from "..";
 import { Version } from "./../model/version-model";
 import { forkJoin, from, Observable, Observer } from "rxjs";
 import { Injectable, Injector, Optional } from "@angular/core";
-import { DatabaseTransaction, Ddl } from "database-builder";
+import { Ddl, DatabaseObject } from "database-builder";
 import { DatabaseMigrationContract } from "./database-migration-contract";
 import { DatabaseMigrationBase } from "../utils/database-migration-base";
 import { DatabaseResettableContract } from "./database-resettable-contract";
 
 @Injectable()
-export class DatabaseMigration extends DatabaseMigrationBase implements DatabaseResettableContract{
+export class DatabaseMigration extends DatabaseMigrationBase implements DatabaseResettableContract {
 
     private _settings: DatabaseSettingsFactoryContract;
 
@@ -20,7 +20,7 @@ export class DatabaseMigration extends DatabaseMigrationBase implements Database
         this._settings = _injector.get(DatabaseSettingsFactoryContract);
     }
 
-    public reset(transation: DatabaseTransaction): Observable<any> {
+    public reset(database: DatabaseObject): Observable<any> {
 
         // tslint:disable-next-line:no-console
         console.info("database reset");
@@ -30,7 +30,7 @@ export class DatabaseMigration extends DatabaseMigrationBase implements Database
         const mappers = this._settings.mapper(this._injector);
 
         // remove dados offline da versão anterior, pois o formato dos dados foi alterado de uma versão para a outra
-        const ddl = new Ddl(transation, mappers, true);
+        const ddl = new Ddl(database, mappers, true);
         mappers.forEachMapper((value, key) => {
             if (!value.readOnly) {
                 observablesWait.push(from(ddl.drop(value.newable).execute()));
@@ -41,14 +41,14 @@ export class DatabaseMigration extends DatabaseMigrationBase implements Database
         return forkJoin(observablesWait);
     }
 
-    protected migrationExecute(transation: DatabaseTransaction, version: Version): Promise<boolean> {
+    protected migrationExecute(database: DatabaseObject, version: Version): Promise<boolean> {
         return new Promise<boolean>((resolve, reject) => {
 
             let observablesNested: Array<Observable<any>> = [];
             if (this._databaseMigrationContract) {
                 const toObservables = this._databaseMigrationContract.to(
-                    version, 
-                    transation, 
+                    version,
+                    database,
                     this._settings.mapper(this._injector),
                     this
                 );
@@ -58,23 +58,24 @@ export class DatabaseMigration extends DatabaseMigrationBase implements Database
             }
 
             if (observablesNested.length === 0 && version.oldVersion < 1) {
-                observablesNested.push(this.reset(transation));
+                observablesNested.push(this.reset(database));
             }
 
-            this.callNested(observablesNested, 0).subscribe(result => {
-                resolve(result);
-            }, error => reject(error));
+            this.callNested(observablesNested, 0)
+                .subscribe((result: boolean | PromiseLike<boolean>) => {
+                    resolve(result);
+                }, (error: any) => reject(error));
         });
     }
 
     private callNested(observablesNested: Array<Observable<any>>, nextIndex: number): Observable<boolean> {
         return Observable.create((observer: Observer<boolean>) => {
             if (observablesNested.length > nextIndex) {
-                observablesNested[nextIndex].subscribe(result => {
-                    this.callNested(observablesNested, ++nextIndex).subscribe(_ => {
+                observablesNested[nextIndex].subscribe((result: any) => {
+                    this.callNested(observablesNested, ++nextIndex).subscribe((_: any) => {
                         observer.next(true);
                         observer.complete();
-                    }, error => {
+                    }, (error: any) => {
                         observer.error(error);
                         observer.complete();
                     });

src/providers/database-resettable-contract.ts

@@ -1,6 +1,6 @@
-import { DatabaseTransaction } from "database-builder";
+import { DatabaseObject } from "database-builder";
 import { Observable } from "rxjs";
 
 export interface DatabaseResettableContract{
-    reset(transation: DatabaseTransaction): Observable<any>;
+    reset(database: DatabaseObject): Observable<any>;
 }

src/test/factory/database-settings-factory.ts

@@ -2,7 +2,7 @@ import { GetMapper } from 'database-builder';
 import { TableMapper } from './../mapper/table-mapper';
 
 import { Injector } from '@angular/core';
-import { DatabaseSettingsFactoryContract } from '../..';
+import { DatabaseSettingsFactoryContract } from '../../utils/database-settings-factory-contract';
 
 export class DatabaseSettingsFactory extends DatabaseSettingsFactoryContract {
 

src/test/mapper.spec.ts

@@ -10,7 +10,6 @@ import { Regiao } from './models/regiao';
 import { DatabaseMigrationService } from './provider/database-migration-service';
 import { DatabaseSettingsFactory } from './factory/database-settings-factory';
 import { TableMapper } from './mapper/table-mapper';
-import { DatabaseCreatorFake } from './factory/database-creator-fake';
 import { DatabaseBrowserProvider } from './factory/database-browser';
 
 describe('Mapper', () => {

src/test/mapper/table-mapper.ts

@@ -1,5 +1,4 @@
 import { Injectable } from "@angular/core";
-import { DatabaseHelperService } from "../..";
 import { TestClazzRef } from "../models/test-clazz-ref";
 import { TestClazz } from "../models/test-clazz";
 import { Cliente } from "../models/cliente";
@@ -10,6 +9,7 @@ import { Regiao } from "../models/regiao";
 import { Classificacao } from "../models/classificacao";
 import { MapperBase } from "database-builder";
 import { PrimaryKeyType } from "database-builder/src/core/enums/primary-key-type";
+import { DatabaseHelperService } from "../../providers/database-helper-service";
 
 @Injectable()
 export class TableMapper extends MapperBase {

src/test/provider/database-migration-service.ts

@@ -1,18 +1,18 @@
-import { GetMapper } from 'database-builder';
+import { GetMapper, DatabaseObject } from 'database-builder';
 import { Injectable } from '@angular/core';
-import { DatabaseTransaction } from 'database-builder';
-import { DatabaseMigrationContract, Version } from '../..';
 import { Observable } from 'rxjs';
 import { DatabaseResettableContract } from '../../providers/database-resettable-contract';
+import { Version } from '../../model/version-model';
+import { DatabaseMigrationContract } from '../../providers/database-migration-contract';
 
 @Injectable()
 export class DatabaseMigrationService extends DatabaseMigrationContract {
 
-    public to(version: Version, transation: DatabaseTransaction, mappers: GetMapper, resettable: DatabaseResettableContract): Observable<any>[] {
+    public to(version: Version, database: DatabaseObject, mappers: GetMapper, resettable: DatabaseResettableContract): Observable<any>[] {
         const observablesNested: Observable<any>[] = [];
 
         if (!(window as any)._resetCalled) {
-            resettable.reset(transation);
+            resettable.reset(database);
             (window as any)._resetCalled = true;
         }
 

src/utils/database-migration-base.ts

@@ -1,6 +1,6 @@
 import * as momentNs from "moment";
 const moment = momentNs;
-import { DatabaseBaseTransaction, DatabaseObject } from "database-builder";
+import { DatabaseObject } from "database-builder";
 import { Observable, Observer } from "rxjs";
 
 export abstract class DatabaseMigrationBase {
@@ -9,11 +9,11 @@ export abstract class DatabaseMigrationBase {
         return new Promise<boolean>((resolve, reject) => {
             this.checkTableVersion(database).then(_ => {
                 this.checkVersion(database, version)
-                    .subscribe(result => {
+                    .subscribe((result: { oldVersion: number; newVersion: number; }) => {
                         this.migration(database, result)
                             .then(r => resolve(r))
                             .catch(er => reject(er));
-                    }, er => reject(er));
+                    }, (er: any) => reject(er));
             })
                 .catch(er => reject(er));
         });
@@ -27,7 +27,8 @@ export abstract class DatabaseMigrationBase {
     }
 
     protected abstract migrationExecute(
-        transation: DatabaseBaseTransaction, control: { oldVersion: number, newVersion: number }): Promise<boolean>;
+        database: DatabaseObject, control: { oldVersion: number, newVersion: number }
+    ): Promise<boolean>;
 
     private checkTableVersion(database: DatabaseObject): Promise<any> {
         return new Promise<any>((resolve, reject) => {
@@ -44,7 +45,7 @@ export abstract class DatabaseMigrationBase {
 
     private checkVersion(database: DatabaseObject, newVersion: number): Observable<{ oldVersion: number, newVersion: number }> {
         return Observable.create((observer: Observer<any>) => {
-            this.getVersion(database).subscribe(oldVersion => {
+            this.getVersion(database).subscribe((oldVersion: number) => {
                 if (oldVersion > 0) {
                     if (newVersion > oldVersion) {
                         // tslint:disable-next-line:no-console
@@ -87,11 +88,14 @@ export abstract class DatabaseMigrationBase {
 
     private migration(database: DatabaseObject, control: { oldVersion: number, newVersion: number }): Promise<boolean> {
         return new Promise<boolean>((resolve, reject) => {
-            database.transaction((transation: DatabaseBaseTransaction) => {
-                this.migrationExecute(transation, control)
-                    .then(r => resolve(r))
-                    .catch(er => reject(er));
-            });
+            this.migrationExecute(database, control)
+                .then(r => resolve(r))
+                .catch(er => reject(er));
+            // database.transaction((transation: DatabaseBaseTransaction) => {
+            //     this.migrationExecute(transation, control)
+            //         .then(r => resolve(r))
+            //         .catch(er => reject(er));
+            // });
         });
     }
 }