fix

src/plugin/src/models/model.d.ts

@@ -30,7 +30,7 @@ export declare class Model {
     static get(arg: getParams): Promise<any>;
     static getOrCreate(arg: getParams): Promise<any>;
     private static getId;
-    static getModelName(): string;
+    static getModelName(): any;
     static filter(...arg: any[]): {
         filter: (...args: any[]) => void;
         execute: () => Promise<any[]>;

src/plugin/src/models/model.js

@@ -173,7 +173,7 @@ export class Model {
         return hashCode(this.toString());
     }
     static getModelName() {
-        return this.toString().split('(' || /s+/)[0].split(' ' || /s+/)[1];
+        return this['$tableName'] || this.toString().split('(' || /s+/)[0].split(' ' || /s+/)[1];
     }
     static filter(...arg) {
         const queryId = uniqueGenerator();

src/plugin/src/models/model.reader.d.ts

@@ -1,7 +1,7 @@
 import { FieldsMap, AttributesMap } from './field/fields.interface.js';
 export declare class ModelReader {
     static read(modelClassRepresentation: any): {
-        modelName: string;
+        modelName: any;
         fields: {
             [key: string]: any;
         };

src/plugin/src/models/register-model.d.ts

@@ -1,5 +1,5 @@
 import { Model, LocalStorage } from './model.js';
-import { DatabaseSchema, DatabaseSchemaLocalStorage, TableSchema, TableSchemaLocalStorage } from './register-modal.interface.js';
+import { DatabaseSchema, DatabaseSchemaLocalStorage, TableSchemaLocalStorage } from './register-modal.interface.js';
 import { OneToOneField, ForeignKey, ManyToManyField } from './field/allFields.js';
 interface register {
     databaseName: string;
@@ -13,15 +13,6 @@ interface register {
     ignoreFieldsStartWidth?: string[];
 }
 export declare const objModels: {};
-export declare const modelsConfig: {
-    [key: string]: {
-        DatabaseSchema: DatabaseSchema;
-        TableSchema: TableSchema;
-        OneToOneField?: {
-            [key: string]: {};
-        };
-    };
-};
 export declare function migrate(register: register): void;
 export declare class registerModel {
     static ModalName(): void;

src/plugin/src/models/register-model.js

@@ -9,9 +9,7 @@ import { transactionOnCommit } from '../triggers/transaction.js';
 import { DatabaseManagerSchema } from './schema/databae-manager-schema.js';
 const models = {};
 export const objModels = {};
-export const modelsConfig = {};
 const modelsLocalStorage = {};
-const modelsConfigLocalStorage = {};
 export function migrate(register) {
     if (register.type == 'indexedDB') {
         registerModel.register(register);
@@ -30,15 +28,19 @@ export class registerModel {
             type: entries.type,
             stores: []
         };
+        const storeNames = [];
         let index = 0;
         for (const modelClassRepresentations of entries.models) {
-            const ModelName = modelClassRepresentations.getModelName();
+            let ModelName = modelClassRepresentations.getModelName();
+            if (storeNames.includes(ModelName)) {
+                ModelName = uniqueGenerator();
+            }
             models[ModelName] = modelClassRepresentations;
-            const { fields, modelName, attributes, fieldTypes } = ModelReader.read(modelClassRepresentations);
+            const { fields, attributes, fieldTypes } = ModelReader.read(modelClassRepresentations);
             const idFieldName = (_a = attributes === null || attributes === void 0 ? void 0 : attributes.primaryKey) === null || _a === void 0 ? void 0 : _a.shift();
             databaseSchema.stores.push({
                 databaseName: databaseSchema.databaseName,
-                name: modelName,
+                name: ModelName,
                 id: {
                     keyPath: idFieldName || 'id',
                     autoIncrement: fields[idFieldName] ? ((_b = fields[idFieldName]) === null || _b === void 0 ? void 0 : _b.primaryKey) == true : true,
@@ -67,28 +69,24 @@ export class registerModel {
                     });
                 }
                 if (Field instanceof OneToOneField) {
-                    await ModelEditor.addMethodOneToOneField(Field, fieldName, modelName, databaseSchema);
+                    await ModelEditor.addMethodOneToOneField(Field, fieldName, ModelName, databaseSchema);
                 }
                 else if (Field instanceof ForeignKey) {
-                    await ModelEditor.addMethodForeignKey(Field, fieldName, modelName, databaseSchema);
+                    await ModelEditor.addMethodForeignKey(Field, fieldName, ModelName, databaseSchema);
                 }
                 else if (Field instanceof ManyToManyField) {
-                    await ModelEditor.addMethodManyToManyField(Field, fieldName, modelName, databaseSchema);
+                    await ModelEditor.addMethodManyToManyField(Field, fieldName, ModelName, databaseSchema);
                 }
             }
             models[ModelName] = modelClassRepresentations;
             const tableSchema = databaseSchema.stores.find((e) => e.name == ModelName);
-            modelsConfig[ModelName] = {
-                DatabaseSchema: databaseSchema,
-                TableSchema: tableSchema
-            };
             index++;
         }
         DatabaseManagerSchema.prepare(databaseSchema);
         for (const stores of databaseSchema.stores) {
             const model = models[stores.name];
             const DbName = databaseSchema.databaseName;
-            ModelEditor.setTableSchema(model, DbName, stores, databaseSchema, entries);
+            ModelEditor.setTableSchema(model, DbName);
             ModelEditor.getDBSchema(model, DbName);
             // ModelEditor.setModel(model, DbName)
             DatabaseManagerSchema.getDb(DbName).getTable(stores.name).setModel(model);
@@ -213,10 +211,6 @@ export class registerLocalStorage {
         modelClassRepresentations.getModelName = () => {
             return ModelName;
         };
-        modelsConfigLocalStorage[ModelName] = {
-            DatabaseSchema: databaseSchema,
-            TableSchema: tableSchema
-        };
         modelsLocalStorage[ModelName] = modelClassRepresentations;
         if (entries === null || entries === void 0 ? void 0 : entries.restore) {
             modelClassRepresentations.get(null);
@@ -241,28 +235,16 @@ export class ModelEditor {
             return DatabaseSchema;
         };
     }
-    static setTableSchema(ModelToEdit, DbName, store, databaseSchema, entries) {
-        try {
-                    
-            const ModelName = ModelToEdit.getModelName();
-            const DBSchema = DatabaseManagerSchema.getDb(DbName);
-            const TableSchemaClass = DBSchema.getTable(ModelName);
-            ModelToEdit.prototype.getTableSchema = () => {
-                return TableSchemaClass.config;
-            };
-            ModelToEdit.getTableSchema = () => {
-                return TableSchemaClass.config;
-            };
-        } catch (error) {
-            console.log('databaseSchema', databaseSchema)
-            console.log('error', error)
-            console.log('ModelToEdit', ModelToEdit)
-            console.log(DbName, 'DbName')
-            console.log('store', store)
-            console.log('models', models)
-            console.log('entries', entries)
-        }
-        
+    static setTableSchema(ModelToEdit, DbName) {
+        const ModelName = ModelToEdit.getModelName();
+        const DBSchema = DatabaseManagerSchema.getDb(DbName);
+        const TableSchemaClass = DBSchema.getTable(ModelName);
+        ModelToEdit.prototype.getTableSchema = () => {
+            return TableSchemaClass.config;
+        };
+        ModelToEdit.getTableSchema = () => {
+            return TableSchemaClass.config;
+        };
     }
     static getDBSchema(ModelToEdit, DbName) {
         const ModelName = ModelToEdit.getModelName();