ul-db-utils 2.10.7__py3-none-any.whl

ul_db_utils/commands/cmd_action.py

@@ -0,0 +1,37 @@
+import os
+import subprocess
+import sys
+from argparse import ArgumentParser
+from typing import Any
+
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdAction(Cmd):
+    app_dir: str
+    app_migration_dir_name: str
+    app_file_name: str
+
+    @property
+    def app_rel_dir(self) -> str:
+        return os.path.relpath(self.app_dir, os.getcwd())
+
+    @staticmethod
+    def add_parser_args(parser: ArgumentParser) -> None:
+        parser.add_argument('--app-dir', dest='app_dir', type=str, required=True)
+        parser.add_argument('--app-migration-dir-name', dest='app_migration_dir_name', type=str, default='migrations', required=False)
+        parser.add_argument('--app-flask-file-name', dest='app_file_name', type=str, default='main.py', required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        migration_dir = os.path.join(self.app_dir, self.app_migration_dir_name)
+        flask_app_path = os.path.join(self.app_dir, self.app_file_name)
+        additional_args = ' '.join([f'{key}={value}' for key, value in kwargs.items()])
+
+        result = subprocess.run(
+            [f'FLASK_APP="{flask_app_path}" flask db {self.cmd} {additional_args} --directory "{migration_dir}"'],
+            shell=True,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        if result.returncode == 1:
+            exit(1)

ul_db_utils/commands/cmd_docs.py

@@ -0,0 +1,60 @@
+import argparse
+import os
+import re
+from contextlib import closing
+from typing import Any
+from urllib.parse import urlparse
+
+import psycopg2
+from pydantic import PostgresDsn
+from sqlalchemy import text
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdDocs(Cmd):
+    uri: PostgresDsn
+    dest_path: str
+    schema_db: str
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        def_dir = os.path.join(os.getcwd(), 'docs/db')
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--dest', dest='dest_path', type=str, default=def_dir, required=False)
+        parser.add_argument('--schema_db', dest='schema_db', type=str, default='public', required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        parsed_db_uri = urlparse(self.uri)
+        db_name = parsed_db_uri.path.strip("/")
+        assert len(db_name) > 0
+
+        with open(os.path.join(os.path.dirname(__file__), 'doc_request_sql.sql'), 'rt') as sql_file:
+            doc_request_sql = sql_file.read()
+
+        doc_request_sql = text(doc_request_sql.format(  # type: ignore
+            schema_db=self.schema_db,
+        ))
+
+        with closing(psycopg2.connect(self.uri)) as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(str(doc_request_sql))
+                doc_data = cursor.fetchall()
+
+        for item in doc_data:
+            db_name = item[0]
+            schema_name = item[1]
+            table_name = item[2]
+            table_description = item[3]
+            file_path = os.path.join(self.dest_path, self.clean_slug(db_name), f"{self.clean_slug(schema_name)}__{self.clean_slug(table_name)}.md")
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, "w+") as file:
+                file.write(f"# {db_name} \"{schema_name}.{table_name}\"\n\n"
+                           f"{table_description}\n\n"
+                           f"## Описание колонок\n\n"
+                           f"| Название | Тип | Описание |\n"
+                           f"| -------- | --- | -------- |\n")
+                for table_field_name, table_field_type, table_field_description in zip(item[4], item[5], item[6]):
+                    file.write(f"| {table_field_name} | {table_field_type} | {table_field_description} |\n")
+
+    def clean_slug(self, text: str) -> str:
+        return re.sub(r"[^\w\d]+", "_", text)

ul_db_utils/commands/cmd_dump.py

@@ -0,0 +1,42 @@
+import os
+import subprocess
+import sys
+from argparse import ArgumentParser
+from datetime import datetime
+from typing import Any
+from urllib.parse import urlparse
+
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdDump(Cmd):
+    uri: str
+    dest_path: str
+
+    @staticmethod
+    def add_parser_args(parser: ArgumentParser) -> None:
+        def_file = os.path.join(os.getcwd(), '.tmp', f'dbdump_{datetime.now().isoformat()}.sql')
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--dest', dest='dest_path', type=str, default=def_file, required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        parsed_db_uri = urlparse(self.uri)
+        db_name = parsed_db_uri.path.strip("/")
+        assert len(db_name) > 0
+        os.makedirs(os.path.dirname(self.dest_path), exist_ok=True)
+        result = subprocess.run(
+            [(
+                f'PGPASSWORD={parsed_db_uri.password} pg_dump --schema=public --data-only -Fc '
+                f'-h {parsed_db_uri.hostname} '
+                f'-p {parsed_db_uri.port} '
+                f'-U {parsed_db_uri.username} '
+                f'-d {db_name} '
+                f'-f {self.dest_path} '
+            )],
+            shell=True,
+            check=True,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        if result.returncode == 1:
+            exit(1)

ul_db_utils/commands/cmd_restore.py

@@ -0,0 +1,109 @@
+import argparse
+import os
+import subprocess
+import sys
+from typing import Any
+from urllib.parse import urlparse
+
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdRestore(Cmd):
+    uri: str
+    db_dump_file_path: str
+    flags: str
+    clean_data: int
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        db_dump_path = os.path.join(os.getcwd(), '.tmp', 'dbdump.sql')
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--dump-file', dest='db_dump_file_path', type=str, default=db_dump_path, required=False)
+        parser.add_argument('--clean-data', dest='clean_data', type=int, default=1, required=False)
+        parser.add_argument('--flags', dest='flags', type=str, default='', required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        parsed_db_uri = urlparse(self.uri)
+        db_name = parsed_db_uri.path.strip("/")
+        if not os.path.exists(self.db_dump_file_path):
+            raise ValueError(f'file {self.db_dump_file_path} was not found')
+
+        db_pref = f'-U {parsed_db_uri.username} -d {db_name} -h {parsed_db_uri.hostname} -p {parsed_db_uri.port}'
+        db_pwd = f'PGPASSWORD={parsed_db_uri.password}'
+
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create user replicator; "'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create user postgres;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create user viewer;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create schema audit;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create schema public;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create schema cache;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "drop extension timescaledb;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+
+        if self.clean_data:
+            truncate_all_sql = (
+                f"CREATE OR REPLACE FUNCTION truncate_tables(username IN VARCHAR) RETURNS void AS \\$$ "
+                f"DECLARE statements CURSOR FOR SELECT tablename FROM pg_tables WHERE tableowner = username AND schemaname = 'public'; "
+                f"BEGIN FOR stmt IN statements LOOP EXECUTE 'TRUNCATE TABLE ' || quote_ident(stmt.tablename) || ' CASCADE;'; END LOOP; END; "
+                f"\\$$ LANGUAGE plpgsql; "
+                f"SELECT truncate_tables('{parsed_db_uri.username}');"
+            )
+
+            subprocess.run(
+                [f'{db_pwd} psql {db_pref} -c "{truncate_all_sql}"'],
+                shell=True,
+                check=True,
+                stderr=sys.stderr,
+                stdout=sys.stdout,
+            )
+
+        result = subprocess.run(
+            [f'{db_pwd} pg_restore {db_pref} --data-only --exclude-schema=audit {self.flags} < "{self.db_dump_file_path}"'],
+            shell=True,
+            check=True,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        if result.returncode == 1:
+            exit(1)

ul_db_utils/commands/cmd_waiting.py

@@ -0,0 +1,26 @@
+import argparse
+import logging
+from typing import Any
+
+from ul_py_tool.commands.cmd import Cmd
+
+from ul_db_utils.utils.waiting_for_postgres import waiting_for_postgres
+
+logger = logging.getLogger(__name__)
+
+
+class CmdWaiting(Cmd):
+    uri: str
+    max_times: int
+    delay: int
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--retry-times', dest='max_times', type=int, default=100, required=False)
+        parser.add_argument('--retry-delay-sec', dest='delay', type=int, default=1, required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        if not waiting_for_postgres(self.uri, retry_max_count=self.max_times, retry_delay_s=float(self.delay)):
+            exit(2)
+        exit(0)

ul_db_utils/commands/doc_request_sql.sql

@@ -0,0 +1,16 @@
+SELECT
+    current_database() as "db_name",
+    pgns.nspname as "schema_name",
+    tbl.relname as "table_name",
+    obj_description(tbl.oid, 'pg_class') as "table_description",
+    ARRAY_AGG(pgattr.attname) as "table_field_name",
+    ARRAY_AGG(pgtype.typname) as "table_field_type",
+    ARRAY_AGG(col_description(tbl.oid, pgattr.attnum)) as "table_field_description"
+FROM pg_class tbl
+    LEFT OUTER JOIN pg_catalog.pg_namespace pgns ON pgns.nspname = '{schema_db}'
+    LEFT OUTER JOIN pg_attribute pgattr ON pgattr.attrelid = tbl.oid AND pgattr.attnum > 0 AND pgattr.atttypid != 0
+    LEFT OUTER JOIN pg_type pgtype ON pgtype.oid = pgattr.atttypid
+    WHERE tbl.relnamespace = pgns.oid AND tbl.reltype != 0
+GROUP BY
+    db_name, schema_name, table_name, table_description
+ORDER BY table_name;

ul_db_utils/conf.py

@@ -0,0 +1,6 @@
+import os.path
+from typing import Optional
+
+THIS_LIBRARY_DIR = os.path.dirname(__file__)
+
+APPLICATION__DB_URI: Optional[str] = os.environ.get('APPLICATION__DB_URI', None)  # none only for backward compatibility

ul_db_utils/errors/compare_null_error.py

@@ -0,0 +1,9 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class ComparisonToNullError(DbError):
+    """Raised when a client attempts to use a filter object that compares a
+    resource's attribute to ``NULL`` using the ``==`` operator instead of using
+    ``is_null``.
+    """
+    pass

ul_db_utils/errors/db_error.py

@@ -0,0 +1,2 @@
+class DbError(Exception):
+    pass

ul_db_utils/errors/db_filter_error.py

@@ -0,0 +1,6 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class DBFiltersError(DbError):
+    """Raised when a client attempts to filters with invalid query params"""
+    pass

ul_db_utils/errors/db_sort_error.py

@@ -0,0 +1,6 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class DBSortError(DbError):
+    """Raised when a client attempts to sort with invalid query params"""
+    pass

ul_db_utils/errors/deletion_not_allowed.py

@@ -0,0 +1,7 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class DeletionNotAllowedError(DbError):
+    """Raised when db obj deletion not allowed.
+    """
+    pass

ul_db_utils/errors/multiple_objects_returned.py

@@ -0,0 +1,7 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class MultipleObjectsReturnedError(DbError):
+    """Raised when db returned multiple objects.
+    """
+    pass

ul_db_utils/errors/unknow_field_error.py

@@ -0,0 +1,13 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class UnknownFieldError(DbError):
+    """Raised when the user attempts to reference a field that does not
+    exist on a model in a search.
+
+    """
+
+    def __init__(self, field: str) -> None:
+
+        #: The name of the unknown attribute.
+        self.field = field

ul_db_utils/errors/update_column_not_allowed_error.py

@@ -0,0 +1,7 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class UpdateColumnNotAllowedError(DbError):
+    """Raised when db table column update not allowed.
+    """
+    pass

ul_db_utils/errors/update_not_allowed.py

@@ -0,0 +1,7 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class UpdateNotAllowedError(DbError):
+    """Raised when db table update not allowed.
+    """
+    pass

ul_db_utils/main.py

@@ -0,0 +1,33 @@
+import logging
+
+from ul_py_tool.commands.cmd import Cmd
+
+from ul_db_utils.commands.cmd_action import CmdAction
+from ul_db_utils.commands.cmd_docs import CmdDocs
+from ul_db_utils.commands.cmd_dump import CmdDump
+from ul_db_utils.commands.cmd_restore import CmdRestore
+from ul_db_utils.commands.cmd_waiting import CmdWaiting
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    Cmd.main({
+        'waiting': CmdWaiting,
+        'dump': CmdDump,
+        'restore': CmdRestore,
+        'migrate': CmdAction,
+        'upgrade': CmdAction,
+        'downgrade': CmdAction,
+        'init': CmdAction,
+        'revision': CmdAction,
+        'history': CmdAction,
+        'branches': CmdAction,
+        'current': CmdAction,
+        'merge': CmdAction,
+        'gen_docs': CmdDocs,
+    })
+
+
+if __name__ == '__main__':
+    main()

ul_db_utils/model/api_user.py

@@ -0,0 +1,14 @@
+from sqlalchemy.dialects.postgresql import ARRAY
+
+from ul_db_utils.model.base_model import BaseModel
+from ul_db_utils.modules.db import db
+
+
+class ApiUser(BaseModel):
+    __tablename__ = 'api_user'
+    __table_args__ = {"comment": "Пользователь API"}
+
+    date_expiration = db.Column(db.DateTime(), nullable=False, comment="Срок действия доступа")
+    name = db.Column(db.String(255), unique=True, nullable=False, comment="Имя пользователя")
+    note = db.Column(db.Text(), nullable=False, comment="Примечание")
+    permissions = db.Column(ARRAY(db.Integer()), nullable=False, comment="Список разрешений")

ul_db_utils/model/base_api_user_log_model.py

@@ -0,0 +1,124 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from sqlalchemy import inspect
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlalchemy.engine.base import Connection
+from sqlalchemy.ext.declarative import declared_attr
+
+from ul_db_utils.model.base_model import BaseModel
+from ul_db_utils.model.base_user_log_model import BaseUserLogModel
+from ul_db_utils.modules import transaction_commit
+from ul_db_utils.modules.db import db, DbMapper
+
+
+class BaseApiUserLogModel(BaseModel):
+
+    __abstract__ = True
+
+    @declared_attr
+    def user_created_id(cls):   # type: ignore
+        return db.Column(PG_UUID(as_uuid=True), db.ForeignKey('api_user.id'), nullable=False, comment="Идентификатор пользователя, создавшего запись")
+
+    @declared_attr
+    def user_modified_id(cls):  # type: ignore
+        return db.Column(PG_UUID(as_uuid=True), db.ForeignKey('api_user.id'), nullable=False, comment="Идентификатор пользователя, изменившего запись")
+
+    def mark_as_created(  # type: ignore
+        self,
+        user_created_id: UUID,
+        date_created: Optional[datetime] = None,
+    ) -> None:
+        """Util for set user_created_id and date_created"""
+        assert transaction_commit.transaction_context,\
+            f'database insert must be in {transaction_commit} context manager'
+        assert 'user_created_id' in [column.name for column in self.__table__.columns], \
+            f"model {self.__repr__()} must have user_created_id foreign key"
+        assert isinstance(user_created_id, UUID), f"user_created_id must be type of {UUID}"
+        self.user_created_id = user_created_id
+        self.user_modified_id = user_created_id
+        if date_created:
+            assert isinstance(date_created, datetime), f"date_created must be type of {datetime}"
+            self.date_created = date_created
+            self.date_modified = date_created
+        else:
+            self.date_created = datetime.utcnow()
+            self.date_modified = datetime.utcnow()
+
+    def mark_as_modified(  # type: ignore
+        self,
+        user_modified_id: UUID,
+        date_modified: Optional[datetime] = None,
+    ) -> None:
+        """Util for set user_modified_id and date_modified"""
+        assert transaction_commit.transaction_context,\
+            f'database update must be in {transaction_commit} context manager'
+        assert isinstance(user_modified_id, UUID), f"user_modified_id must be type of {UUID}"
+        self.user_modified_id = user_modified_id
+        if date_modified is not None:
+            assert isinstance(date_modified, datetime), f"date_modified must be type of {datetime}"
+            self.date_modified = date_modified
+        else:
+            self.date_modified = datetime.utcnow()
+
+    def mark_as_deleted(  # type: ignore
+        self,
+        user_modified_id: UUID,
+        date_modified: Optional[datetime] = None,
+    ) -> None:
+        """Util for set user_modified_id and date_modified"""
+        assert transaction_commit.transaction_context,\
+            f'database delete must be in {transaction_commit} context manager'
+
+        assert isinstance(user_modified_id, UUID), \
+            f"user_modified_id must be type of {UUID}, but {type(user_modified_id)} is given"
+
+        self.user_modified_id = user_modified_id
+        if date_modified is not None:
+            assert isinstance(date_modified, datetime), \
+                f"date_modified must be type of {datetime}, but {type(date_modified)} is given"
+
+            self.date_modified = date_modified
+        else:
+            self.date_modified = datetime.utcnow()
+        self.is_alive = False
+
+
+@db.event.listens_for(db.Mapper, 'before_update')
+def receive_before_update(mapper: db.Mapper, connection: Connection, target: BaseUserLogModel) -> None:  # type: ignore
+    if issubclass(target.__class__, BaseUserLogModel):
+        assert transaction_commit.transaction_context,\
+            f'database updates must be in {transaction_commit} context manager'
+
+        unchanged_keys = inspect(target).attrs.get('id').state.unmodified  # type: ignore
+
+        assert 'date_modified' not in unchanged_keys, \
+            "date_modified must be set on model update"
+
+        assert isinstance(target.date_modified, datetime), \
+            f"date_modified must be type of {datetime}, but {type(target.date_modified)} is given"
+
+        assert 'user_modified_id' not in unchanged_keys,\
+            "user_modified_id must be set on model update"
+
+        assert isinstance(target.user_modified_id, UUID), \
+            f"user_modified_id must be type of {UUID}, but {type(target.user_modified_id)} is given"
+
+
+@db.event.listens_for(db.Mapper, 'before_insert')
+def receive_before_create(mapper: DbMapper, connection: Connection, target: BaseUserLogModel) -> None:
+    if issubclass(target.__class__, BaseUserLogModel):
+        assert transaction_commit.transaction_context,\
+            f'database insert must be in {transaction_commit} context manager'
+        assert isinstance(target.date_created, datetime), \
+            f"date_created must be type of {datetime}, but {type(target.date_created)} is given"
+
+        assert isinstance(target.date_modified, datetime), \
+            f"date_modified must be type of {datetime}, but {type(target.date_modified)} is given"
+
+        assert isinstance(target.user_created_id, UUID), \
+            f"user_created_id must be type of {UUID}, but {type(target.user_created_id)} is given"
+
+        assert isinstance(target.user_modified_id, UUID), \
+            f"user_modified_id must be type of {UUID}, but {type(target.user_modified_id)} is given"

ul_db_utils/model/base_immutable_model.py

@@ -0,0 +1,67 @@
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from flask_sqlalchemy import BaseQuery
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
+from sqlalchemy.engine.base import Connection
+from sqlalchemy_serializer import SerializerMixin
+
+from ul_db_utils.errors.deletion_not_allowed import DeletionNotAllowedError
+from ul_db_utils.errors.update_not_allowed import UpdateNotAllowedError
+from ul_db_utils.modules import transaction_commit
+from ul_db_utils.modules.db import db, DbModel, DbMapper
+
+
+class BaseImmutableModel(DbModel, SerializerMixin):
+    __abstract__ = True
+
+    query_class = BaseQuery
+
+    id = db.Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, comment="Идентификатор записи")
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False, comment="Дата и время создания записи")
+    user_created_id = db.Column(PG_UUID(as_uuid=True), nullable=False, comment="Идентификатор пользователя, создавшего запись")
+
+    def mark_as_created(self, user_created_id: uuid.UUID, date_created: Optional[datetime] = None) -> None:
+        """Util for set user_created_id and date_created"""
+        assert transaction_commit.transaction_context, \
+            f'database insert must be in {transaction_commit} context manager'
+        assert 'user_created_id' in [column.name for column in self.__table__.columns], \
+            f"model {self.__repr__()} must have user_created_id foreign key"
+        assert isinstance(user_created_id, uuid.UUID), f"user_created_id must be type of {uuid.UUID}"
+        self.user_created_id = user_created_id
+        if date_created:
+            assert isinstance(date_created, datetime), f"date_created must be type of {datetime}"
+            self.date_created = date_created
+        else:
+            self.date_created = datetime.utcnow()
+
+    def mark_as_modified(self, user_modified_id: uuid.UUID, date_modified: Optional[datetime] = None) -> None:
+        """Util for set user_modified_id and date_modified"""
+        raise UpdateNotAllowedError()
+
+    def __repr__(self) -> str:
+        return self.__class__.__name__
+
+    def mark_as_deleted(
+        self,
+        user_modified_id: uuid.UUID,
+        date_modified: Optional[datetime] = None,
+    ) -> None:
+        raise DeletionNotAllowedError()
+
+
+@db.event.listens_for(DbMapper, 'before_insert')
+def receive_before_create(mapper: DbMapper, connection: Connection, target: BaseImmutableModel) -> None:
+    if issubclass(target.__class__, BaseImmutableModel):
+        assert transaction_commit.transaction_context, \
+            f'database updates must be in {transaction_commit} context manager'
+
+        assert isinstance(target.date_created, datetime), \
+            f"date_created must be type of {datetime}, but {type(target.date_created)} is given"
+
+
+@db.event.listens_for(db.Mapper, 'before_update')
+def receive_before_update(mapper: DbMapper, connection: Connection, target: BaseImmutableModel) -> None:
+    if issubclass(target.__class__, BaseImmutableModel):
+        raise UpdateNotAllowedError()