save computed payloads into sqlite db

1 files changed, 79 insertions, 34 deletions

diff --git a/src/hydrilla/proxy/state_impl/concrete_state.py b/src/hydrilla/proxy/state_impl/concrete_state.py
index 1b46ae9..ccb1269 100644
--- a/src/hydrilla/proxy/state_impl/concrete_state.py
+++ b/src/hydrilla/proxy/state_impl/concrete_state.py
@@ -313,19 +313,10 @@ def get_or_make_item_version(
         cursor:            sqlite3.Cursor,
         item_id:           int,
         repo_iteration_id: int,
-        definition:        str,
-        info:              item_infos.AnyInfo
+        version:           versions.VerTuple,
+        definition:        str
 ) -> int:
-    ver_str = versions.version_string(info.version)
-
-    values = (
-        item_id,
-        ver_str,
-        repo_iteration_id,
-        definition,
-        info.allows_eval,
-        info.allows_cors_bypass
-    )
+    ver_str = versions.version_string(version)
 
     cursor.execute(
         '''
@@ -333,13 +324,11 @@ def get_or_make_item_version(
     	        item_id,
                 version,
 	        repo_iteration_id,
-                definition,
-                eval_allowed,
-                cors_bypass_allowed
+                definition
         )
-        VALUES(?, ?, ?, ?, ?, ?);
+        VALUES(?, ?, ?, ?);
         ''',
-        values
+        (item_id, ver_str, repo_iteration_id, definition)
     )
 
     cursor.execute(
@@ -417,12 +406,12 @@ def make_file_use(
         (item_version_id, file_id, name, type, mime_type, idx)
     )
 
-def get_infos_of_type(cursor: sqlite3.Cursor, info_type: t.Type[AnyInfoVar]) \
-    -> t.Iterable[AnyInfoVar]:
+def get_infos_of_type(cursor: sqlite3.Cursor, info_type: t.Type[AnyInfoVar],) \
+    -> t.Mapping[AnyInfoVar, int]:
     cursor.execute(
         '''
         SELECT
-                iv.definition, r.name, ri.iteration
+                i.item_id, iv.definition, r.name, ri.iteration
         FROM
                      item_versions   AS iv
                 JOIN items           AS i  USING (item_id)
@@ -434,11 +423,12 @@ def get_infos_of_type(cursor: sqlite3.Cursor, info_type: t.Type[AnyInfoVar]) \
         (info_type.type_name[0].upper(),)
     )
 
-    result: list[AnyInfoVar] = []
+    result: dict[AnyInfoVar, int] = {}
 
-    for definition, repo_name, repo_iteration in cursor.fetchall():
+    for item_id, definition, repo_name, repo_iteration in cursor.fetchall():
         definition_io = io.StringIO(definition)
-        result.append(info_type.load(definition_io, repo_name, repo_iteration))
+        info = info_type.load(definition_io, repo_name, repo_iteration)
+        result[info] = item_id
 
     return result
 
@@ -449,7 +439,7 @@ class ConcreteHaketiloState(base.HaketiloStateWithFields):
 
         self._populate_database_with_stuff_from_temporary_malcontent_dir()
 
-        with self.cursor() as cursor:
+        with self.cursor(transaction=True) as cursor:
             self.rebuild_structures(cursor)
 
     def _prepare_database(self) -> None:
@@ -459,9 +449,12 @@ class ConcreteHaketiloState(base.HaketiloStateWithFields):
         try:
             cursor.execute(
                 '''
-                SELECT COUNT(name)
-                        FROM sqlite_master
-                        WHERE name = 'general' AND type = 'table';
+                SELECT
+                        COUNT(name)
+                FROM
+                        sqlite_master
+                WHERE
+                        name = 'general' AND type = 'table';
                 '''
             )
 
@@ -473,8 +466,10 @@ class ConcreteHaketiloState(base.HaketiloStateWithFields):
             else:
                 cursor.execute(
                     '''
-                    SELECT haketilo_version
-                            FROM general;
+                    SELECT
+                            haketilo_version
+                    FROM
+                            general;
                     '''
                 )
 
@@ -495,7 +490,7 @@ class ConcreteHaketiloState(base.HaketiloStateWithFields):
         malcontent_dir_path = self.store_dir / 'temporary_malcontent'
         files_by_sha256_path = malcontent_dir_path / 'file' / 'sha256'
 
-        with self.cursor(lock=True, transaction=True) as cursor:
+        with self.cursor(transaction=True) as cursor:
             for info_type in [item_infos.ResourceInfo, item_infos.MappingInfo]:
                 info: item_infos.AnyInfo
                 for info, definition in read_items(
@@ -517,8 +512,8 @@ class ConcreteHaketiloState(base.HaketiloStateWithFields):
                         cursor,
                         item_id,
                         repo_iteration_id,
-                        definition,
-                        info
+                        info.version,
+                        definition
                     )
 
                     if info_type is item_infos.MappingInfo:
@@ -574,16 +569,66 @@ class ConcreteHaketiloState(base.HaketiloStateWithFields):
                         )
 
     def rebuild_structures(self, cursor: sqlite3.Cursor) -> None:
+        assert self.connection.in_transaction
+
         resources = get_infos_of_type(cursor, item_infos.ResourceInfo)
         mappings  = get_infos_of_type(cursor, item_infos.MappingInfo)
 
-        payloads = compute_payloads(resources, mappings)
+        payloads = compute_payloads(resources.keys(), mappings.keys())
 
         payloads_data = {}
 
+        cursor.execute('DELETE FROM payloads;')
+
         for mapping_info, by_pattern in payloads.items():
             for num, (pattern, payload) in enumerate(by_pattern.items()):
-                payload_id = f'{num}@{mapping_info.identifier}'
+                print('adding payload')
+                cursor.execute(
+                    '''
+                    INSERT INTO payloads(
+                            mapping_item_id,
+                            pattern,
+	                    eval_allowed,
+                            cors_bypass_allowed
+                    )
+                    VALUES (?, ?, ?, ?);
+                    ''',
+                    (
+                        mappings[mapping_info],
+                        pattern.orig_url,
+                        payload.allows_eval,
+                        payload.allows_cors_bypass
+                    )
+                )
+
+                cursor.execute(
+                    '''
+                    SELECT
+                            payload_id
+                    FROM
+                            payloads
+                    WHERE
+                            mapping_item_id = ? AND pattern = ?;
+                    ''',
+                    (mappings[mapping_info], pattern.orig_url)
+                )
+
+                (payload_id_int,), = cursor.fetchall()
+
+                for res_num, resource_info in enumerate(payload.resources):
+                    cursor.execute(
+                        '''
+                        INSERT INTO resolved_depended_resources(
+                                payload_id,
+                                resource_item_id,
+                                idx
+                        )
+                        VALUES(?, ?, ?);
+                        ''',
+                        (payload_id_int, resources[resource_info], res_num)
+                    )
+
+                payload_id = str(payload_id_int)
 
                 ref = ConcretePayloadRef(payload_id, payload)