fix issue

src/plugin/src/connection/indexedDb/connector.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseSchema } from '../../models/register-modal.interface.js';
 export declare class IndexedDBConnection {
     constructor();
-    connect(config: DatabaseSchema): Promise<IDBDatabase>;
-    migrate(config: DatabaseSchema): Promise<boolean>;
+    static connect(config: DatabaseSchema): Promise<IDBDatabase>;
+    static migrate(config: DatabaseSchema): Promise<boolean>;
     private runMigrations;
 }

src/plugin/src/connection/indexedDb/connector.js

@@ -13,8 +13,13 @@ export class IndexedDBConnection {
                     reject(e.target.error.name);
                 };
                 request.onupgradeneeded = async (e) => {
-                    throw ('need to migrate first');
+                    console.log('need to migrate first');
+                    await this.migrate(config);
+                    return await this.connect(config);
                 };
+                // request.onblocked = async (e: any) => {
+                //   reject(e.target.error.name);
+                // }
             }
             else {
                 reject("IDBDatabase not supported inside webworker");

src/plugin/src/connection/indexedDb/indexedb.d.ts

@@ -11,7 +11,7 @@ declare class _indexedDB {
         getOneByIndex: (keyPath: string, value: string | number) => Promise<any>;
         getManyByIndex: (keyPath: string, value: string | number) => Promise<any[]>;
         getAll: () => Promise<any[]>;
-        add: (value: Object, key?: any) => Promise<number>;
+        add: (value: Object, key?: any) => Promise<number | Object>;
         update: (value: any, key?: any) => Promise<any>;
         deleteByID: (id: any) => Promise<any>;
         deleteAll: () => Promise<any>;

src/plugin/src/connection/indexedDb/indexedb.js

@@ -77,6 +77,13 @@ class _indexedDB {
                                 var _a, _b;
                                 (_b = (_a = tx) === null || _a === void 0 ? void 0 : _a.commit) === null || _b === void 0 ? void 0 : _b.call(_a);
                                 resolve(e.target.result);
+                                db.transaction;
+                            };
+                            request.onerror = (e) => {
+                                let data = {
+                                    error: e.target['error']
+                                };
+                                resolve(data);
                             };
                         })
                             .catch(reject);
@@ -94,11 +101,6 @@ class _indexedDB {
                                 (_b = (_a = tx) === null || _a === void 0 ? void 0 : _a.commit) === null || _b === void 0 ? void 0 : _b.call(_a);
                                 resolve(e.target.result);
                             };
-
-                            request.onerror = (e) => {
-                                console.log(value, key)
-                                console.log(e)
-                            }
                         })
                             .catch(reject);
                     });
@@ -152,6 +154,7 @@ class _indexedDB {
                             request.onsuccess = e => {
                                 cursorCallback(e);
                                 resolve();
+                                // db.close();
                             };
                         })
                             .catch(reject);
@@ -278,7 +281,6 @@ class _indexedDB {
                 delete: async (methods) => {
                     if (methods[methods.length - 1].methodName == 'delete' &&
                         methods[methods.length - 1].arguments == null) {
-                            
                         const customMethods = Object.create(methods);
                         customMethods[methods.length - 1].methodName = 'execute';
                         const result = await this.requestHandler(TableSchema, config, queryId).select(customMethods);
@@ -293,15 +295,11 @@ class _indexedDB {
                     }
                     else if (methods[methods.length - 1].methodName == 'delete' &&
                         typeof methods[methods.length - 1].arguments == 'object') {
-                        
                         const IdInObject = methods[methods.length - 1].arguments;
                         const idValue = IdInObject[TableSchema.id.keyPath];
-                        
-                        const result = await this.getActions(TableSchema.name, config).deleteByID(idValue)
-                        console.log('delete7', IdInObject,idValue, result.type == 'success', result.type)
                         return {
                             queryId: queryId,
-                            value: result.type == 'success'
+                            value: await this.getActions(TableSchema.name, config).deleteByID(idValue)
                         };
                     }
                     else if (methods[methods.length - 1].methodName == 'delete' &&
@@ -310,8 +308,6 @@ class _indexedDB {
                             queryId: queryId,
                             value: await this.getActions(TableSchema.name, config).deleteAll()
                         };
-                    } else {
-                        console.log('delete else')
                     }
                 },
                 insert: async (methods) => {
@@ -319,19 +315,19 @@ class _indexedDB {
                     const rows = methods[0].arguments;
                     for (let insert of rows) {
                         const id = await this.getActions(TableSchema.name, config).add(insert);
-                        createdObjKeys.push(id);
+                        insert[TableSchema.id.keyPath] = id;
                     }
                     // return first element
                     if (rows.length == 1) {
                         return {
                             queryId: queryId,
-                            value: await this.getActions(TableSchema.name, config).getByID(createdObjKeys[0])
+                            value: rows[0]
                         };
                     }
                     else {
                         return {
                             queryId: queryId,
-                            value: createdObjKeys
+                            value: rows
                         };
                     }
                 }

src/plugin/src/connection/intreface.d.ts

@@ -1,2 +1,2 @@
 export declare type actionParam = 'insert' | 'update' | 'delete' | 'select';
-export declare type dbType = 'indexedDB';
+export declare type dbType = 'indexedDB' | 'localStorage';

src/plugin/src/connection/worker.js

@@ -1,17 +1,26 @@
 import { indexedDB } from './indexedDb/indexedb.js';
 onmessage = async (oEvent) => {
     const { TableSchema, DBconfig, queryId, action, arg } = oEvent.data;
-    const result = await indexedDB.requestHandler(TableSchema, DBconfig, queryId)[action](arg);
+    indexedDB.requestHandler(TableSchema, DBconfig, queryId)[action](arg).then((result) => {
+        try {
+            postMessage(result);
+        }
+        catch (error) {
+            postMessage({
+                queryId: result.queryId,
+                value: undefined
+            });
+        }
+    }).catch((result)=> {
+        try {
+            postMessage(result);
+        }
+        catch (error) {
+            postMessage({
+                queryId: result.queryId,
+                value: undefined
+            });
+        }
+    })
 
-    console.log('return response', result)
-    try {
-        
-        postMessage(result);
-    }
-    catch (error) {
-        postMessage({
-            queryId: result.queryId,
-            value: undefined
-        });
-    }
 };

src/plugin/src/index.d.ts

@@ -1,6 +1,7 @@
 import { Model } from './models/model.js';
+import { LocalStorage } from './models/model.js';
 import { ModelReader } from './models/model.reader.js';
-import { registerModel } from './models/register-model.js';
+import { registerModel, migrate } from './models/register-model.js';
 export declare const models: {
     Value(arg: any): {};
     CharField(data?: import("./models/field/interface.js").CharFieldParams): import("./models/field/allFields.js").CharField;
@@ -21,7 +22,8 @@ export declare const models: {
         };
     };
     Model: typeof Model;
+    LocalStorage: typeof LocalStorage;
     read: typeof ModelReader.read;
+    migrate: typeof migrate;
     register: typeof registerModel.register;
-    migrate: typeof registerModel.register;
 };

src/plugin/src/index.js

@@ -1,8 +1,10 @@
 import { Model } from './models/model.js';
+import { LocalStorage } from './models/model.js';
 import * as Fields from './models/field/fields.js';
 import { ModelReader } from './models/model.reader.js';
-import { registerModel } from './models/register-model.js';
-export const models = Object.assign(Object.assign({ Model, read: ModelReader.read, register: registerModel.register, migrate: registerModel.register }, Fields), { Value(arg) {
+import { registerModel, migrate } from './models/register-model.js';
+export const models = Object.assign(Object.assign({ Model,
+    LocalStorage, read: ModelReader.read, migrate: migrate, register: registerModel.register }, Fields), { Value(arg) {
         if (arg == 'null') {
             return {};
         }

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

@@ -1,5 +1,5 @@
 import { getParams } from './model.interface.js';
-import { DatabaseSchema, TableSchema } from './register-modal.interface.js';
+import { DatabaseSchema, DatabaseSchemaLocalStorage, TableSchema } from './register-modal.interface.js';
 import { ModelManager } from './model-manager.js';
 export declare class Model extends ModelManager {
     constructor(obg?: any);
@@ -47,3 +47,18 @@ export declare class Model extends ModelManager {
         all: () => Promise<any>;
     };
 }
+export declare class LocalStorage {
+    constructor();
+    static save(data?: Object): void;
+    static get(): any;
+    static getModelName(): string;
+    static getDBSchema(): DatabaseSchemaLocalStorage;
+    static getTableSchema(): TableSchema;
+    private static getIgnoreAttributes;
+    static ignoreAttributes(attributesStartWidth?: string[]): void;
+    private static getFields;
+    private static formValidation;
+    static clear(): void;
+    static clearComponent(): void;
+    static clearStorage(): void;
+}

src/plugin/src/models/model.js

@@ -1,7 +1,7 @@
 var _a, _b;
 import { hashCode, uniqueGenerator } from '../utils.js';
 import { ModelManager } from './model-manager.js';
-import { models, modelsConfig } from './register-model.js';
+import { models, modelsConfig, modelsConfigLocalStorage } from './register-model.js';
 import { FieldType } from '../sql/query/interface.js';
 import * as Fields from './field/allFields.js';
 let methods = {} = {};
@@ -134,6 +134,10 @@ export class Model extends (_b = ModelManager) {
                 delete newInstance[fieldName];
             }
         }
+        Object.defineProperty(newInstance, TableSchema.id.keyPath, {
+            configurable: false,
+            writable: false
+        });
         delete newInstance.obj;
         return newInstance;
     }
@@ -211,11 +215,16 @@ export class Model extends (_b = ModelManager) {
         const queryId = uniqueGenerator();
         const createObject = await super.obj(DBconfig, TableSchema).create(_methods, queryId);
         if (createObject) {
-            const ModelName = this.getModelName();
-            let newInstance = new models[ModelName]();
-            Object.assign(newInstance, createObject);
-            delete newInstance.obj;
-            return newInstance;
+            if (typeof createObject[TableSchema.id.keyPath] == 'object') {
+                throw (createObject[TableSchema.id.keyPath].error);
+            }
+            else {
+                const ModelName = this.getModelName();
+                let newInstance = new models[ModelName]();
+                Object.assign(newInstance, createObject);
+                delete newInstance.obj;
+                return newInstance;
+            }
         }
         else {
         }
@@ -303,3 +312,82 @@ Model.object = ({ queryId = uniqueGenerator(), DBconfig, TableSchema, some = nul
         }
     };
 };
+export class LocalStorage {
+    constructor() { }
+    static save(data = {}) {
+        const dataToSave = this.getFields(Object.assign(this, Object.assign({}, data)));
+        const key = this.getTableSchema().id;
+        localStorage.setItem(key.keyPath, JSON.stringify(dataToSave));
+    }
+    static get() {
+        const key = this.getTableSchema().id;
+        const restedData = JSON.parse(localStorage.getItem(key.keyPath));
+        Object.assign(this, Object.assign({}, restedData));
+        return restedData;
+    }
+    static getModelName() {
+        return this.toString().split('(' || /s+/)[0].split(' ' || /s+/)[1];
+    }
+    static getDBSchema() {
+        const modalName = this.getModelName();
+        return modelsConfigLocalStorage[modalName].DatabaseSchema;
+    }
+    static getTableSchema() {
+        const modalName = this.getModelName();
+        return modelsConfigLocalStorage[modalName].TableSchema;
+    }
+    static getIgnoreAttributes() {
+        return false;
+    }
+    static ignoreAttributes(attributesStartWidth = []) {
+        if (!this.getIgnoreAttributes()) {
+            this.getIgnoreAttributes = () => {
+                return attributesStartWidth;
+            };
+        }
+    }
+    static getFields(arg) {
+        const TableSchema = this.getTableSchema();
+        const filteredArgs = {};
+        const fieldsName = TableSchema.fields.map((field) => field.name);
+        const Attributes = this.getIgnoreAttributes();
+        const fieldNameFilter = fieldsName.filter((fieldName) => {
+            if (Attributes) {
+                for (let Attribute of Attributes) {
+                    if (fieldName.startsWith(Attribute)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+        for (let fieldName of fieldNameFilter) {
+            if (arg.hasOwnProperty(fieldName)) {
+                filteredArgs[fieldName] = arg[fieldName];
+            }
+        }
+        return filteredArgs;
+    }
+    static formValidation(data) {
+        const TableSchema = this.getTableSchema();
+        for (let field of TableSchema.fields) {
+            const Field = new Fields[field.className](field.fieldAttributes);
+            const FieldValue = data[field.name];
+            if (!Field.valid(FieldValue)) {
+                throw ('invalid insert into ' + TableSchema.name + ', invalid value for field ' + field.name + ' = ' + JSON.stringify(FieldValue));
+            }
+        }
+        return true;
+    }
+    static clear() {
+        this.clearComponent();
+        this.clearStorage();
+    }
+    static clearComponent() {
+        const key = this.getTableSchema().id;
+    }
+    static clearStorage() {
+        const key = this.getTableSchema().id;
+        localStorage.removeItem(key.keyPath);
+    }
+}

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

@@ -9,3 +9,13 @@ export declare class ModelReader {
         attributes: AttributesMap<"maxLength" | "minLength" | "choices" | "primaryKey" | "unique" | "autoIncrement" | "type" | "model" | "blank" | "default" | "onDelete" | "foreignKey", string[]>;
     };
 }
+export declare class LocalStorageModelReader {
+    static read(modelClassRepresentation: any): {
+        modelName: string;
+        fields: {
+            [key: string]: any;
+        };
+        attributes: AttributesMap<"maxLength" | "minLength" | "choices" | "primaryKey" | "unique" | "autoIncrement" | "type" | "model" | "blank" | "default" | "onDelete" | "foreignKey", string[]>;
+        fieldTypes: FieldsMap<"CharField" | "JsonField" | "AutoField" | "BigIntegerField" | "DateField" | "IntegerField" | "TextField" | "BooleanField" | "OneToOneField" | "ForeignKey" | "ManyToManyField" | "indexedDBJsonField" | "indexedDBArrayField" | "DateTimeField", string[]>;
+    };
+}

src/plugin/src/models/model.reader.js

@@ -32,3 +32,22 @@ export class ModelReader {
         };
     }
 }
+export class LocalStorageModelReader {
+    static read(modelClassRepresentation) {
+        const classInstance = modelClassRepresentation;
+        const fieldTypes = {};
+        const attributes = {};
+        const modelName = classInstance.getModelName();
+        const fields = {};
+        for (const [fieldName, Field] of Object.entries(classInstance)) {
+            // const type = Field?.fieldName
+            fields[fieldName] = Field || null;
+        }
+        return {
+            modelName,
+            fields,
+            attributes,
+            fieldTypes
+        };
+    }
+}

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

@@ -1,11 +1,11 @@
-import { Model } from './model.js';
-import { DatabaseSchema, TableSchema } from './register-modal.interface.js';
+import { Model, LocalStorage } from './model.js';
+import { DatabaseSchema, DatabaseSchemaLocalStorage, TableSchema, TableSchemaLocalStorage } from './register-modal.interface.js';
 import { OneToOneField, ForeignKey, ManyToManyField } from './field/allFields.js';
 interface register {
     databaseName: string;
     version: number;
-    type: 'indexedDB';
-    models: typeof Model[];
+    type: 'indexedDB' | 'localStorage';
+    models: typeof Model[] | typeof LocalStorage[];
 }
 export declare const models: {};
 export declare const modelsConfig: {
@@ -17,10 +17,21 @@ export declare const modelsConfig: {
         };
     };
 };
+export declare const modelsLocalStorage: {};
+export declare const modelsConfigLocalStorage: {
+    [key: string]: {
+        DatabaseSchema: DatabaseSchemaLocalStorage;
+        TableSchema: TableSchemaLocalStorage;
+    };
+};
+export declare function migrate(register: register): void;
 export declare class registerModel {
     static register(entries: register): Promise<void>;
     static manyToManyRelationShip(foreignKeyField: ManyToManyField, FieldName: string, modelName: string, databaseSchema: DatabaseSchema): Model;
 }
+export declare class registerLocalStorage {
+    static register(entries: register): Promise<void>;
+}
 export declare class ModelEditor {
     static addMethodOneToOneField(foreignKeyField: OneToOneField, FieldName: string, modelName: string, databaseSchema: DatabaseSchema): void;
     static addMethodForeignKey(foreignKeyField: ForeignKey, FieldName: string, modelName: string, databaseSchema: DatabaseSchema): void;

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

@@ -1,5 +1,5 @@
 import { Model } from './model.js';
-import { ModelReader } from './model.reader.js';
+import { LocalStorageModelReader, ModelReader } from './model.reader.js';
 import { indexedDB } from './../connection/indexedDb/indexedb.js';
 import { OneToOneField, ForeignKey, ManyToManyField } from './field/allFields.js';
 import { uncapitalize } from '../utils.js';
@@ -7,6 +7,16 @@ import { FieldType } from '../sql/query/interface.js';
 import { ModelMigrations } from './mode-migrations.js';
 export const models = {};
 export const modelsConfig = {};
+export const modelsLocalStorage = {};
+export const modelsConfigLocalStorage = {};
+export function migrate(register) {
+    if (register.type == 'indexedDB') {
+        registerModel.register(register);
+    }
+    else if (register.type == 'localStorage') {
+        registerLocalStorage.register(register);
+    }
+}
 export class registerModel {
     static async register(entries) {
         var _a, _b, _c;
@@ -122,6 +132,65 @@ export class registerModel {
         });
     }
 }
+export class registerLocalStorage {
+    static async register(entries) {
+        const databaseSchema = {
+            databaseName: entries.databaseName,
+            version: entries.version,
+            type: 'localStorage',
+            stores: []
+        };
+        for (const modelClassRepresentations of entries.models) {
+            const ModelName = modelClassRepresentations.getModelName();
+            modelsLocalStorage[ModelName] = modelClassRepresentations;
+        }
+        let index = 0;
+        for (const modelClassRepresentations of entries.models) {
+            const { fields, modelName, attributes, fieldTypes } = LocalStorageModelReader.read(modelClassRepresentations);
+            // const idFieldName = attributes?.primaryKey?.shift()
+            databaseSchema.stores.push({
+                name: modelName,
+                id: {
+                    keyPath: modelName,
+                    type: FieldType.VARCHAR,
+                    autoIncrement: false
+                },
+                attributes: attributes,
+                fields: [],
+                fieldTypes
+            });
+            for (const [fieldName, Field] of Object.entries(fields)) {
+                databaseSchema.stores[index].fields.push({
+                    name: fieldName,
+                    keyPath: fieldName,
+                    options: {
+                        unique: false,
+                        type: null
+                    },
+                    className: Field === null || Field === void 0 ? void 0 : Field.fieldName,
+                    fieldAttributes: Object.assign({}, Field)
+                });
+            }
+            index++;
+        }
+        for (const modelClassRepresentations of entries.models) {
+            const ModelName = modelClassRepresentations.getModelName();
+            const tableSchema = databaseSchema.stores.find((e) => e.name == ModelName);
+            modelClassRepresentations.getDBSchema = () => {
+                return databaseSchema;
+            };
+            modelClassRepresentations.getTableSchema = () => {
+                return tableSchema;
+            };
+            modelsConfigLocalStorage[ModelName] = {
+                DatabaseSchema: databaseSchema,
+                TableSchema: tableSchema
+            };
+            modelsLocalStorage[ModelName] = modelClassRepresentations;
+        }
+        ModelMigrations.migrationsState(true);
+    }
+}
 export class ModelEditor {
     static addMethodOneToOneField(foreignKeyField, FieldName, modelName, databaseSchema) {
         const foreignKeyFieldModel = foreignKeyField.model;