v.0.0.6

Author: fernandocode

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ionic-database-builder",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Extended library from database-builder to assist in creating and maintaining SQL commands with integrate execute commands in SQLite ('@ionic-native/sqlite').",
   "main": "index.js",
   "scripts": {

src/defaults/database-factory-default.ts

@@ -15,12 +15,12 @@ export class DatabaseFactoryDefault extends DatabaseFactoryContract {
         super();
     }
 
-    public database(): Promise<DatabaseObject> {
+    public database(databaseName: string): Promise<DatabaseObject> {
         return new Promise<DatabaseObject>((resolve, reject) => {
             if (this._isAvailable) {
                 resolve(
                     this._databaseCreator.create({
-                        name: name,
+                        name: databaseName,
                         location: "default"
                     })
                 );

src/dependency-injection-definition.ts

@@ -1,7 +1,5 @@
 import { InjectionToken } from "@angular/core";
 import { DatabaseCreatorContract } from "./model/database-creator-contract";
 
-// export const VERSION = new InjectionToken<number>("version");
-// export const DATABASE_NAME = new InjectionToken<string>("database_name");
 export const IS_AVAILABLE_DATABASE = new InjectionToken<boolean>("is_available");
 export const DATABASE_CREATOR = new InjectionToken<DatabaseCreatorContract>("database_creator");

src/index.ts

@@ -9,3 +9,5 @@ export * from "./providers/database-migration";
 export * from "./providers/database-helper-service";
 export * from "./defaults/mappers-table-simple";
 export * from "./model/version-model";
+export * from "./model/database-creator-contract";
+export * from "./model/database-config";

src/providers/database.ts

@@ -12,14 +12,10 @@ export class Database extends BuildableDatabaseManager {
 
     constructor(
         private _injector: Injector,
-        // private _settings: DatabaseSettingsFactoryContract,
-        // platform: Platform,
-        // sqlite: SQLite,
         databaseFactory: DatabaseFactoryContract,
         private _databaseMigration: DatabaseMigration
     ) {
         super(
-            // platform, sqlite,
             databaseFactory,
             _injector.get(DatabaseSettingsFactoryContract).mapper(_injector)
         );
@@ -37,4 +33,8 @@ export class Database extends BuildableDatabaseManager {
     public version(): number {
         return this._settings.version(this._injector);
     }
+
+    public databaseNameFile(databaseName: string = this.databaseName()): string {
+        return this.addDatabaseNameExtension(this.cleanDatabaseName(databaseName));
+    }
 }

src/utils/buildable-database-manager.ts

@@ -8,13 +8,11 @@ import { DatabaseFactoryContract } from "./database-factory-contract";
 export abstract class BuildableDatabaseManager extends DatabaseManager {
 
     constructor(
-        // platform: Platform, sqlite: SQLite,
         databaseFactory: DatabaseFactoryContract,
         private _mapper: MappersTableBase,
         public enableLog: boolean = true
     ) {
         super(databaseFactory);
-        // super(platform, sqlite);
     }
 
     public get mapper(): MappersTableBase {
@@ -75,7 +73,6 @@ export abstract class BuildableDatabaseManager extends DatabaseManager {
                 const executable = new ExecutableBuilder(this.enableLog);
                 executable.execute({
                     query: sql,
-                    // tslint:disable-next-line:object-literal-shorthand
                     params: params
                 } as QueryCompiled, database)
                     .then((cursor: DatabaseResult) => {

src/utils/database-factory-contract.ts

@@ -4,6 +4,6 @@ import { DatabaseObject } from "database-builder";
 
 export abstract class DatabaseFactoryContract {
 
-    public abstract database(): Promise<DatabaseObject>;
+    public abstract database(databaseName: string): Promise<DatabaseObject>;
 
 }

src/utils/database-manager.ts

@@ -6,7 +6,6 @@ export abstract class DatabaseManager {
     private _databases: Map<string, Promise<DatabaseObject>> = new Map<string, Promise<DatabaseObject>>();
 
     constructor(
-        // protected _platform: Platform, private _sqlite: SQLite
         protected databaseFactory: DatabaseFactoryContract
     ) {
 
@@ -25,19 +24,21 @@ export abstract class DatabaseManager {
         return this._databases.has(keyDatabaseName)
             ? this._databases.get(keyDatabaseName)
             : this._databases.set(keyDatabaseName,
-                this.createDatabase(this.addDatabaseNameExtension(this.cleanDatabaseName(name)), version))
+                this.createDatabase(this.databaseNameFile(name), version))
                 .get(keyDatabaseName);
     }
 
     public invalidateInstance() {
         this._databases = new Map<string, Promise<DatabaseObject>>();
     }
 
+    public abstract databaseNameFile(databaseName?: string): string;
+
     protected abstract migrationVersion(database: DatabaseObject, version: number): Promise<boolean>;
 
     private createDatabase(name: string, version: number): Promise<DatabaseObject> {
         return new Promise<DatabaseObject>((resolve, reject) => {
-            this.databaseFactory.database()
+            this.databaseFactory.database(name)
                 .then((database: DatabaseObject) => {
                     this.migrationVersion(database, version)
                         .then(_ => resolve(database))
@@ -48,24 +49,6 @@ export abstract class DatabaseManager {
                 });
 
         });
-        // return new Promise<DatabaseObject>((resolve, reject) => {
-        //     if (this._platform.is('cordova')) {
-        //         const db = this._sqlite.create({
-        //             name: name,
-        //             location: 'default'
-        //         });
-        //         db.then((database: DatabaseObject) => {
-        //             this.migrationVersion(database, version)
-        //                 .then(_ => resolve(db))
-        //                 .catch(er => reject(er));
-        //         }).catch(error => {
-        //             this.catchException(error);
-        //             reject(error);
-        //         });
-        //     } else {
-        //         resolve(void 0);
-        //     }
-        // });
     }
 
     private catchException(e: any) {