fix: update app instance deletion logic to mark as terminated instead of deleting

from uuid import UUID

from sqlalchemy import delete, select

from sqlalchemy import select

from sqlalchemy.ext.asyncio import AsyncSession

from open_exposure_gateway.adapters.database.mappers import AppInstanceMapper

        if saved is None:

            raise RuntimeError("Saved app instance could not be reloaded")

        return saved

    async def delete(self, app_instance_id: UUID) -> None:

        stmt = delete(AppInstanceRow).where(AppInstanceRow.app_instance_id == app_instance_id)

        await self._session.execute(stmt)

            raise RuntimeError("AppInstanceRepository is not available")

        app_instance = await self._app_instance_repo.get_by_id(app_instance_id)

        if app_instance is None:

        if app_instance is None or app_instance.state == AppInstanceState.TERMINATED:

            raise NotFoundException(message=f"App instance {app_instance_id} not found")

        operation_id, correlation_id, requested_at = self._new_operation_metadata(x_correlator)

                    )

                    continue

                if is_terminate and instance.status == "completed":

                    # No terminal "terminated" state exists on app_instances.state

                    # (only instantiating/ready/failed/terminating) -- once SRM

                    # confirms teardown, the row's job is done.

                    await self._app_instance_repo.delete(app_instance_id)

                    continue

                    state = AppInstanceState.TERMINATED

                else:

                    state = _APP_INSTANCE_COMPLETION_STATE_MAP[instance.status]

                saved = await self._app_instance_repo.save(

                    app_instance.model_copy(

                        update={"state": _APP_INSTANCE_COMPLETION_STATE_MAP[instance.status]}

                    )

                    app_instance.model_copy(update={"state": state})

                )

                updated_instances.append(saved)

        elif status == OperationStatus.FAILED:

    READY = "ready"

    FAILED = "failed"

    TERMINATING = "terminating"

    TERMINATED = "terminated"

    @abstractmethod

    async def save(self, app_instance: AppInstance) -> AppInstance:

        pass

    @abstractmethod

    async def delete(self, app_instance_id: UUID) -> None:

        pass

        self.rows[stored.app_instance_id] = stored

        return stored.model_copy(deep=True)

    async def delete(self, app_instance_id: UUID) -> None:

        self.rows.pop(app_instance_id, None)

class FakeCallbackRegistrationRepository(CallbackRegistrationRepository):

    def __init__(self) -> None: