quickscale-cli 0.87.0__tar.gz → 0.88.0__tar.gz

{quickscale_cli-0.87.0 → quickscale_cli-0.88.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickscale-cli
-Version: 0.87.0
+Version: 0.88.0
 Summary: Command-line interface for QuickScale Django project generator
 License-Expression: Apache-2.0
 Keywords: django,cli,project-generator,saas
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 6.0
 Requires-Dist: click (>=8.4.2,<9.0.0)
-Requires-Dist: quickscale-core (>=0.87.0,<0.88.0)
+Requires-Dist: quickscale-core (>=0.88.0,<0.89.0)
 Project-URL: Documentation, https://github.com/Experto-AI/quickscale/tree/main/docs
 Project-URL: Homepage, https://github.com/Experto-AI/quickscale
 Project-URL: Repository, https://github.com/Experto-AI/quickscale

{quickscale_cli-0.87.0 → quickscale_cli-0.88.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quickscale-cli"
-version = "0.87.0"
+version = "0.88.0"
 description = "Command-line interface for QuickScale Django project generator"
 requires-python = ">=3.14,<3.15"
 readme = "README.md"
@@ -31,7 +31,7 @@ packages = [{include = "quickscale_cli", from = "src"}]
 [tool.poetry.dependencies]
 python = ">=3.14,<3.15"
 click = "^8.4.2"
-quickscale-core = "^0.87.0"
+quickscale-core = "^0.88.0"
 
 [tool.poetry.group.dev.dependencies]
 # Dev dependencies centralized in root pyproject.toml

{quickscale_cli-0.87.0 → quickscale_cli-0.88.0}/src/quickscale_cli/_version.py

@@ -1,2 +1,2 @@
 # Auto-generated by scripts/version_tool.sh
-__version__ = "0.87.0"
+__version__ = "0.88.0"

{quickscale_cli-0.87.0 → quickscale_cli-0.88.0}/src/quickscale_cli/commands/apply_command.py

@@ -68,9 +68,12 @@ from quickscale_cli.commands.apply_support import (
     _report_theme_preflight_error,
 )
 from quickscale_cli.commands.apply_support import _resolve_apply_raw_root  # noqa: F401
-from quickscale_cli.commands.module_commands import embed_module, ModuleEmbedProvenance
-from quickscale_cli.commands.module_config import (
+from quickscale_cli.commands.module_commands import (
     APPLY_MODULE_EXECUTION_MODE,
+    embed_module,
+    ModuleEmbedProvenance,
+)
+from quickscale_cli.commands.module_config import (
     get_default_backups_config,
     validate_backups_module_options,
 )
@@ -139,6 +142,7 @@ from quickscale_core.utils.git_utils import (
     GitError,
     is_working_directory_clean,
     resolve_remote_ref,
+    resolve_split_branch,
     validate_module_name,
     validate_tag_name,
 )
@@ -513,6 +517,30 @@ def _parse_split_ref_overrides(split_refs: tuple[str, ...]) -> dict[str, str]:
     return parsed
 
 
+def _expand_split_refs_from_branches(ctx: ApplyContext) -> dict[str, str]:
+    """
+    Map every module being embedded to its canonical ``splits/<name>-module`` branch.
+
+    This is the bulk form of ``--split-ref``.  Every override in the pre-seal
+    verification flow is mechanically the module's own split branch, so deriving
+    them removes a dozen hand-typed arguments -- and with them the chance of
+    typing one wrong or omitting one, which the exact-coverage rule would reject
+    only after the operator had already retyped the whole line.
+
+    The result covers exactly the embed set by construction, so
+    :func:`_validate_split_ref_override_coverage` cannot fail on it.  It is
+    recomputed against the refreshed context after the advisory lock is taken,
+    because the embed set itself can change there.
+    """
+    try:
+        return {
+            module_name: resolve_split_branch(module_name)
+            for module_name in sorted(_module_names_to_embed(ctx))
+        }
+    except GitError as error:
+        raise click.UsageError(f"--split-refs-from-branches: {error}") from error
+
+
 def _module_names_to_embed(ctx: ApplyContext) -> set[str]:
     """Return the exact module target set for this apply pass."""
     if ctx.existing_state is None:
@@ -882,12 +910,7 @@ def _load_module_manifests(
     """Load manifests for all installed modules"""
     manifests: dict[str, ModuleManifest] = {}
     for module_name in module_names:
-        try:
-            manifest = get_manifest_for_module(project_path, module_name, strict=strict)
-        except ManifestError as error:
-            if strict and "Manifest file not found:" not in str(error):
-                raise
-            manifest = None
+        manifest = get_manifest_for_module(project_path, module_name, strict=strict)
         if manifest:
             manifests[module_name] = manifest
     return manifests
@@ -1898,16 +1921,18 @@ def _attempt_provenance_repair_if_needed(ctx: ApplyContext) -> None:
 
         try:
             resolved_sha = resolve_remote_ref(remote, branch)
-            module_state.commit_sha = resolved_sha
-            # Backfill the full provenance triple: also refresh embedded_at
-            # to the repair timestamp and ensure version is populated from
-            # the embedded manifest when available.
-            module_state.embedded_at = repair_timestamp
             manifest = get_manifest_for_module(ctx.output_path, module_name)
+            repaired_version = module_state.version
             if manifest is not None:
                 normalized_version = normalize_installed_version(manifest.version)
                 if normalized_version is not None:
-                    module_state.version = normalized_version
+                    repaired_version = normalized_version
+            # Commit the complete repair only after every lookup succeeds.
+            # An incomplete embedded module must not leave partially repaired
+            # state that can later be persisted.
+            module_state.commit_sha = resolved_sha
+            module_state.embedded_at = repair_timestamp
+            module_state.version = repaired_version
             repaired_any = True
             click.secho(f"✅ Repaired {module_name}: {resolved_sha[:8]}", fg="green")
         except Exception as e:
@@ -2980,15 +3005,12 @@ def _regenerate_managed_wiring_for_apply(
         delta: Any | None,
     ) -> tuple[bool, str]:
         try:
-            desired_module_names = sorted(qs_config.modules.keys())
-            if existing_state is None:
-                selected = module_names
-            else:
-                unchanged = getattr(delta, "modules_unchanged", []) if delta else []
-                selected = sorted(set(unchanged) | set(module_names))
-            if not desired_module_names:
-                selected = []
-            options = {m: c.options for m, c in qs_config.modules.items()}
+            del module_names, existing_state, delta
+            selected = sorted(qs_config.modules.keys())
+            options = {
+                module_name: dict(module_config.options or {})
+                for module_name, module_config in qs_config.modules.items()
+            }
             return regenerate_managed_wiring(
                 output_path,
                 module_names=selected,
@@ -3183,8 +3205,8 @@ def _refresh_context_after_lock(ctx: ApplyContext) -> None:
                 list(merged_state.modules.keys()),
                 strict=True,
             )
-        except ManifestError:
-            manifests = {}
+        except ManifestError as error:
+            _abort_for_manifest_error(error, command_name="apply")
 
         # SA7.4: re-validate required-module version constraints with
         # fresh manifests so a concurrent module update is not missed.
@@ -3373,6 +3395,8 @@ def _execute_apply_steps(
     no_modules: bool,
     verbose_docker: bool = False,
     split_ref_overrides: Mapping[str, str] | None = None,
+    *,
+    split_refs_from_branches: bool = False,
 ) -> None:
     """Execute the apply steps after confirmation."""
     click.echo("\n" + "=" * 50)
@@ -3412,6 +3436,11 @@ def _execute_apply_steps(
         # the lock so that planning uses fresh state, not a stale snapshot
         # taken before the lock was held.
         _refresh_context_after_lock(ctx)
+        # The embed set can change under the lock, so a set derived before it
+        # would no longer cover exactly the modules being embedded.  Re-derive
+        # rather than re-validating a stale map.
+        if split_refs_from_branches:
+            split_ref_overrides = _expand_split_refs_from_branches(ctx)
         _validate_split_ref_override_coverage(
             ctx,
             split_ref_overrides,
@@ -3589,11 +3618,14 @@ def _execute_apply_steps_locked(
     # the full post-embed module set before continuing to wiring, dependency
     # sync, or migration steps.
     if embedded_modules:
-        post_embed_manifests = _load_module_manifests(
-            ctx.output_path,
-            list(ctx.qs_config.modules.keys()),
-            strict=True,
-        )
+        try:
+            post_embed_manifests = _load_module_manifests(
+                ctx.output_path,
+                list(ctx.qs_config.modules.keys()),
+                strict=True,
+            )
+        except ManifestError as error:
+            _abort_for_manifest_error(error, command_name="apply")
         try:
             check_required_module_versions(post_embed_manifests)
         except ManifestError as error:
@@ -3973,6 +4005,14 @@ def _resolve_apply_preflight(config_path: Path) -> Path:
     multiple=True,
     help="Use an explicit split ref for each module being embedded (repeatable).",
 )
+@click.option(
+    "--split-refs-from-branches",
+    is_flag=True,
+    help=(
+        "Embed every module from its own splits/<module>-module branch. "
+        "Bulk form of --split-ref for pre-seal release verification."
+    ),
+)
 @click.option(
     "--verbose-docker",
     is_flag=True,
@@ -3984,6 +4024,7 @@ def apply(
     no_docker: bool,
     no_modules: bool,
     split_refs: tuple[str, ...],
+    split_refs_from_branches: bool,
     verbose_docker: bool,
 ) -> None:
     """
@@ -4026,12 +4067,18 @@ def apply(
       15. Finalize authoritative state
       16. Display next steps
     """
+    if split_refs and split_refs_from_branches:
+        raise click.UsageError(
+            "--split-refs-from-branches cannot be combined with --split-ref"
+        )
     split_ref_overrides = _parse_split_ref_overrides(split_refs)
     config_path = Path(config)
     _resolve_apply_preflight(config_path)
 
     # Prepare context
     ctx = _prepare_apply_context(config_path)
+    if split_refs_from_branches:
+        split_ref_overrides = _expand_split_refs_from_branches(ctx)
     _validate_split_ref_override_coverage(
         ctx,
         split_ref_overrides,
@@ -4071,4 +4118,5 @@ def apply(
         no_modules,
         show_docker_output,
         split_ref_overrides,
+        split_refs_from_branches=split_refs_from_branches,
     )

{quickscale_cli-0.87.0 → quickscale_cli-0.88.0}/src/quickscale_cli/commands/deployment_commands.py

@@ -1,5 +1,7 @@
 """Deployment commands for production platforms."""
 
+import json
+import secrets
 import sys
 from pathlib import Path
 
@@ -32,6 +34,23 @@ from quickscale_cli.utils.railway_utils import (
 )
 
 
+RUNTIME_DB_ROLE = "quickscale_runtime"
+
+
+def runtime_database_url(postgres_service: str, password: str) -> str:
+    """Build RUNTIME_DATABASE_URL for the restricted runtime role.
+
+    Host, port and database are Railway reference variables on the PostgreSQL
+    service, resolved by Railway at deploy time. The generated start.sh creates
+    the role from RUNTIME_DB_ROLE and RUNTIME_DB_PASSWORD before migrating.
+    """
+    ref = postgres_service
+    return (
+        f"postgresql://{RUNTIME_DB_ROLE}:{password}"
+        f"@${{{{{ref}.PGHOST}}}}:${{{{{ref}.PGPORT}}}}/${{{{{ref}.PGDATABASE}}}}"
+    )
+
+
 @click.group()
 def deploy() -> None:
     """Deployment commands for production platforms."""
@@ -225,13 +244,30 @@ def _init_railway_project_step() -> None:
         click.echo("✅ Railway project already initialized")
 
 
-def _setup_postgres_step() -> None:
-    """Set up PostgreSQL database service."""
+def _list_railway_service_names() -> list[str]:
+    """Return the service names in the linked Railway environment.
+
+    Uses ``railway service list --json``.  A bare ``railway service`` is the
+    deprecated interactive link prompt: once a project has services it waits
+    for a selection and only ends at the command timeout.
+    """
+    result = run_railway_command(["service", "list", "--json"], timeout=30)
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"railway service list failed: {(result.stderr or result.stdout).strip()}"
+        )
+    return [str(service.get("name", "")) for service in json.loads(result.stdout)]
+
+
+def _setup_postgres_step() -> str:
+    """Set up PostgreSQL database service and return its service name."""
     try:
-        result = run_railway_command(["service"], timeout=10)
+        names = _list_railway_service_names()
 
-        if "postgres" in result.stdout.lower():
+        existing = [name for name in names if "postgres" in name.lower()]
+        if existing:
             click.echo("✅ PostgreSQL service already exists")
+            return existing[0]
         else:
             click.echo("Adding PostgreSQL service...")
             result = run_railway_command(["add", "--database", "postgres"], timeout=30)
@@ -243,24 +279,31 @@ def _setup_postgres_step() -> None:
                 click.secho("✅ PostgreSQL service added", fg="green")
     except Exception as e:
         click.secho(f"⚠️  Warning: Could not check database service: {e}", fg="yellow")
+    return "Postgres"
 
 
 def _create_app_service_step(app_service: str) -> None:
     """Create application service."""
     try:
-        result = run_railway_command(["service"], timeout=10)
+        names = _list_railway_service_names()
 
-        if app_service.lower() in result.stdout.lower():
+        if app_service.lower() in (name.lower() for name in names):
             click.echo(f"✅ Service '{app_service}' already exists")
         else:
+            # Railway CLI 5.x prompts ("What do you need?", "Enter a variable")
+            # whenever it sees a TTY, even with --service, and its TUI leaves the
+            # terminal in raw mode on timeout. Run without a TTY so it never prompts.
             result = run_railway_command(
-                ["add", "--service", app_service], timeout=30, interactive=True
+                ["add", "--service", app_service], timeout=60, input_data=""
             )
 
             if result.returncode != 0:
                 click.secho(
                     f"⚠️  Warning: Could not create service '{app_service}'", fg="yellow"
                 )
+                detail = (result.stderr or result.stdout or "").strip()
+                if detail:
+                    click.echo(f"   {detail}", err=True)
                 click.echo("💡 Create manually: railway add --service", err=True)
             else:
                 click.secho(f"✅ Service '{app_service}' created", fg="green")
@@ -283,11 +326,11 @@ def _link_database_step(app_service: str) -> bool:
         click.secho(f"⚠️  Warning: {link_message}", fg="yellow")
         click.echo("💡 You may need to link DATABASE_URL manually:")
         click.echo(
-            f"   railway variables --set 'DATABASE_URL=${{{{Postgres.DATABASE_URL}}}}' "
+            f"   railway variable set 'DATABASE_URL=${{{{Postgres.DATABASE_URL}}}}' "
             f"--service {app_service}"
         )
         click.echo(
-            f"   railway variables --set 'DATABASE_URL=${{{{PostgreSQL.DATABASE_URL}}}}' "
+            f"   railway variable set 'DATABASE_URL=${{{{PostgreSQL.DATABASE_URL}}}}' "
             f"--service {app_service}"
         )
         click.echo("   Use single quotes to prevent shell expansion errors")
@@ -311,12 +354,46 @@ def _generate_domain_step(app_service: str) -> str | None:
     else:
         click.secho("⚠️  Warning: Could not auto-generate domain", fg="yellow")
         click.echo("💡 Generate manually: railway domain")
-        click.echo("💡 Then set: railway variables --set ALLOWED_HOSTS=<your-domain>")
+        click.echo("💡 Then set: railway variable set ALLOWED_HOSTS=<your-domain>")
         return None
 
 
-def _configure_env_vars_step(app_service: str, domain_name: str | None) -> None:
-    """Configure environment variables in batch."""
+def _existing_service_variables(app_service: str) -> dict[str, str]:
+    """Return the app service's current Railway variables, or {} if unreadable."""
+    try:
+        return get_railway_variables(app_service) or {}
+    except Exception:
+        return {}
+
+
+def _runtime_role_variables(
+    postgres_service: str, existing: dict[str, str]
+) -> dict[str, str]:
+    """Return the runtime-role variables to set, honouring what already exists.
+
+    - ``RUNTIME_DATABASE_URL`` set without ``RUNTIME_DB_PASSWORD``: the role is
+      operator-managed, so nothing is written.
+    - ``RUNTIME_DB_PASSWORD`` already set: it is reused, so a re-deploy never
+      rotates the password underneath the container still serving traffic.
+    - Otherwise a new URL-safe (hex) password is generated.
+    """
+    if existing.get("RUNTIME_DATABASE_URL") and not existing.get("RUNTIME_DB_PASSWORD"):
+        return {}
+    password = existing.get("RUNTIME_DB_PASSWORD") or secrets.token_hex(24)
+    return {
+        "RUNTIME_DB_ROLE": RUNTIME_DB_ROLE,
+        "RUNTIME_DB_PASSWORD": password,
+        "RUNTIME_DATABASE_URL": runtime_database_url(postgres_service, password),
+    }
+
+
+def _configure_env_vars_step(
+    app_service: str,
+    domain_name: str | None,
+    postgres_service: str = "Postgres",
+    existing_vars: dict[str, str] | None = None,
+) -> None:
+    """Configure environment variables in batch, including the runtime DB role."""
     click.echo(f"Setting variables for service: {app_service}")
     click.echo("💡 Setting all variables at once to minimize deployments")
 
@@ -329,6 +406,9 @@ def _configure_env_vars_step(app_service: str, domain_name: str | None) -> None:
         "DJANGO_SETTINGS_MODULE": f"{django_package}.settings.production",
     }
 
+    runtime_vars = _runtime_role_variables(postgres_service, existing_vars or {})
+    env_vars.update(runtime_vars)
+
     if domain_name:
         env_vars["ALLOWED_HOSTS"] = domain_name
 
@@ -337,10 +417,16 @@ def _configure_env_vars_step(app_service: str, domain_name: str | None) -> None:
     if success:
         click.secho("✅ All environment variables configured successfully", fg="green")
         for key in env_vars:
-            if key == "SECRET_KEY":
+            if key in ("SECRET_KEY", "RUNTIME_DB_PASSWORD"):
                 click.echo(f"   • {key}=<generated>")
+            elif key == "RUNTIME_DATABASE_URL":
+                click.echo(f"   • {key}=<{RUNTIME_DB_ROLE} @ {postgres_service}>")
             else:
                 click.echo(f"   • {key}={env_vars[key]}")
+        if not runtime_vars:
+            click.echo(
+                "   • RUNTIME_DATABASE_URL: operator-managed (RUNTIME_DB_PASSWORD unset), left unchanged"
+            )
         click.echo(
             "💡 Variables are set without triggering a deployment. The deploy step below will start one."
         )
@@ -487,7 +573,7 @@ def _display_summary(
         "dashboard — start.sh will create it on next deploy"
     )
     click.echo(
-        f"      Or manually: railway run --service {app_service} "
+        f"      Or manually: railway ssh --service {app_service} "
         f"python manage.py createsuperuser"
     )
     click.echo("   5. Configure custom domain (optional): railway domain")
@@ -497,11 +583,15 @@ def _display_summary(
     click.echo("   • Verify DATABASE_URL in Railway dashboard > Variables")
     if not database_linked:
         click.echo(
-            "   • Link DB manually: railway variables --set "
+            "   • Link DB manually: railway variable set "
             f"'DATABASE_URL=${{{{Postgres.DATABASE_URL}}}}' --service {app_service}"
         )
     click.echo("   • Check healthcheck status in Railway dashboard")
     click.echo("   • Migrations run automatically on first deploy")
+    click.echo(
+        f"   • start.sh creates the restricted '{RUNTIME_DB_ROLE}' database role "
+        "before migrating"
+    )
 
     click.echo("\n📖 Documentation:")
     click.echo("   • Railway: https://docs.railway.app")
@@ -552,7 +642,7 @@ def railway(project_name: str | None) -> None:
 
     # Step 4: Check for PostgreSQL service
     click.echo("\n🗄️  Setting up PostgreSQL database...")
-    _setup_postgres_step()
+    postgres_service = _setup_postgres_step()
 
     # Step 5: Create app service
     click.echo(f"\n📦 Creating application service: {app_service}...")
@@ -569,7 +659,12 @@ def railway(project_name: str | None) -> None:
 
     # Step 8: Configure environment variables in batch
     click.echo("\n⚙️  Configuring environment variables...")
-    _configure_env_vars_step(app_service, domain_name)
+    _configure_env_vars_step(
+        app_service,
+        domain_name,
+        postgres_service,
+        _existing_service_variables(app_service),
+    )
 
     # Step 9: Deploy to app service
     click.echo("\n🚢 Deploying application...")