itw-python-builder 0.1.25__tar.gz → 0.1.27__tar.gz

{itw_python_builder-0.1.25 → itw_python_builder-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itw_python_builder
-Version: 0.1.25
+Version: 0.1.27
 Summary: Standardized Django deployment pipeline with Docker, testing, and SonarQube integration
 Author-email: IT-Works <contact@it-works.io>
 License: MIT

itw_python_builder-0.1.27/itw_python_builder/ssr_tasks.py

@@ -0,0 +1,161 @@
+"""SSR scaffolding tasks. One-time `itw ssr-init` for Angular SSR + ngx-seo-helper.
+
+The build/version tasks (`incrementrc`, `release`, etc.) live in tasks.py and
+take an `ssr=False` kwarg. With --ssr they invoke:
+  - `npm run build:ssr`          on master
+  - `npm run build:ssr:staging`  on any other branch
+
+These two scripts are a contract the project owner defines in package.json.
+ssr-init intentionally does NOT write them, because the right command depends
+on which Angular SSR setup the project ended up with:
+
+  legacy browser builder   →  ng build --configuration=X && ng run <name>:server:X
+  modern application builder (Angular 17+, fresh `ng add @angular/ssr`)
+                           →  ng build --configuration=X
+"""
+import os
+import re
+from pathlib import Path
+
+from invoke import task, Context
+
+from itw_python_builder.utils import detect_project_type, _read_package_name, is_ssr_project
+
+
+TEMPLATES_DIR = Path(__file__).parent / 'templates'
+
+SITEMAP_IMPORT_LINE = "import {sitemapEntries} from './src/sitemap.routes';"
+
+
+def _load_template(name: str) -> str:
+    """Read a template file, stripping the leading `// @ts-nocheck` editor hint."""
+    content = (TEMPLATES_DIR / name).read_text(encoding='utf-8')
+    lines = content.splitlines(keepends=True)
+    if lines and lines[0].lstrip().startswith('// @ts-nocheck'):
+        lines = lines[1:]
+        if lines and lines[0].strip() == '':
+            lines = lines[1:]
+    return ''.join(lines)
+
+
+def _run_ng_add_ssr(ctx: Context) -> None:
+    print('[itw] Running `ng add @angular/ssr` (this may take a minute)...')
+    ctx.run('npx ng add @angular/ssr --skip-confirmation --server-routing=false')
+
+
+def _install_ngx_seo_helper(ctx: Context) -> None:
+    print('[itw] Installing ngx-seo-helper...')
+    ctx.run('npm install ngx-seo-helper')
+
+
+def _write_sitemap_template() -> None:
+    path = os.path.join(os.getcwd(), 'src', 'sitemap.routes.ts')
+    if os.path.exists(path):
+        print(f'[itw] Skipping sitemap template — {path} already exists.')
+        return
+    with open(path, 'w', encoding='utf-8') as fp:
+        fp.write(_load_template('sitemap.routes.ts'))
+    print('[itw] Wrote src/sitemap.routes.ts (empty tree — fill in your routes).')
+
+
+def _patch_server_ts() -> None:
+    """Inject sitemap import + /sitemap.xml handler into server.ts (idempotent)."""
+    path = os.path.join(os.getcwd(), 'server.ts')
+    if not os.path.exists(path):
+        raise RuntimeError('server.ts missing after `ng add @angular/ssr` — cannot patch.')
+
+    with open(path, 'r', encoding='utf-8') as fp:
+        content = fp.read()
+
+    if 'sitemap.routes' in content:
+        print('[itw] server.ts already references sitemap.routes — skipping patch.')
+        return
+
+    lines = content.splitlines(keepends=True)
+    last_import_idx = -1
+    for i, line in enumerate(lines):
+        if line.startswith('import '):
+            last_import_idx = i
+    if last_import_idx == -1:
+        raise RuntimeError('server.ts has no imports — unexpected shape, aborting patch.')
+    lines.insert(last_import_idx + 1, SITEMAP_IMPORT_LINE + '\n')
+    content = ''.join(lines)
+
+    match = re.search(r"(server\.set\('views',\s*distFolder\);\s*\n)", content)
+    if not match:
+        match = re.search(r"(const\s+commonEngine\s*=\s*new\s+CommonEngine\(\);\s*\n)", content)
+    if not match:
+        raise RuntimeError(
+            'Could not find an injection point in server.ts (looked for `server.set(\'views\', ...)` '
+            'or `new CommonEngine()`). Patch sitemap handler manually.'
+        )
+    insert_at = match.end()
+    content = content[:insert_at] + _load_template('server.sitemap.snippet.ts') + content[insert_at:]
+
+    with open(path, 'w', encoding='utf-8') as fp:
+        fp.write(content)
+    print('[itw] Patched server.ts with /sitemap.xml handler.')
+
+
+def _print_next_steps(project_name: str) -> None:
+    print()
+    print('=' * 70)
+    print('[itw] SSR scaffolding complete.')
+    print('=' * 70)
+    print('Next steps you must do manually:')
+    print()
+    print('  1. Add `NgxSeoModule` to your AppModule imports.')
+    print('  2. Fill in src/sitemap.routes.ts with your route tree.')
+    print('  3. Add `staging` (and optionally `development`) configurations to')
+    print('     angular.json under projects.' + project_name + '.architect.build.configurations.')
+    print('     ng add @angular/ssr only creates the `production` configuration.')
+    print()
+    print('  4. Add these two npm scripts to package.json — the deploy pipeline')
+    print('     calls them by name:')
+    print()
+    print('       "build:ssr":          "<build command for production>"')
+    print('       "build:ssr:staging":  "<build command for staging>"')
+    print()
+    print('     The exact command depends on which builder angular.json uses:')
+    print()
+    print('     • Modern application builder (default for fresh ng add @angular/ssr):')
+    print('         "build:ssr":         "ng build --configuration=production"')
+    print('         "build:ssr:staging": "ng build --configuration=staging"')
+    print()
+    print('     • Legacy browser builder (older projects with a separate server target):')
+    print(f'         "build:ssr":         "ng build --configuration=production && ng run {project_name}:server:production"')
+    print(f'         "build:ssr:staging": "ng build --configuration=staging && ng run {project_name}:server:staging"')
+    print()
+    print('  5. Verify locally: npm run build:ssr && npm run serve:ssr')
+    print('  6. Commit the new files.')
+    print('  7. Deploy with: itw incrementrc --ssr  (or incrementpatch/release --ssr)')
+    print('=' * 70)
+
+
+@task(name='ssr-init')
+def ssr_init(ctx: Context, force: bool = False) -> None:
+    """One-time SSR scaffold: ng add @angular/ssr, ngx-seo-helper, sitemap stub, server.ts patch.
+
+    Does NOT write package.json scripts — those depend on which builder Angular
+    chose. The post-run message tells you the two scripts the pipeline expects.
+    """
+    if detect_project_type() != 'frontend':
+        raise RuntimeError('ssr-init only runs on frontend (Angular) projects.')
+
+    if is_ssr_project() and not force:
+        raise RuntimeError(
+            'SSR scaffolding already present (server.ts + tsconfig.server.json exist). '
+            'Re-run with --force to re-apply the sitemap stub and server.ts patch.'
+        )
+
+    name = _read_package_name()
+    print(f'[itw] Scaffolding SSR for project: {name}')
+
+    if not is_ssr_project():
+        _run_ng_add_ssr(ctx)
+
+    _install_ngx_seo_helper(ctx)
+    _write_sitemap_template()
+    _patch_server_ts()
+
+    _print_next_steps(name)

{itw_python_builder-0.1.25 → itw_python_builder-0.1.27}/itw_python_builder/tasks.py

@@ -1,216 +1,87 @@
 from invoke import task, Context
 from itw_python_builder.version import Version
+from itw_python_builder.utils import (
+    detect_project_type,
+    detect_and_activate_venv,
+    load_env,
+    get_current_branch,
+    check_branch,
+    read_version,
+    save_version,
+    generate_image_path,
+    get_gitlab_username,
+    _parse_gitlab_remote,
+    is_ssr_project,
+)
+from itw_python_builder.ssr_tasks import *  # noqa: F401,F403  — exposes ssr-init
+
 import getpass
 import io
 import os
-import re
 from datetime import datetime
 from pathlib import Path
 
 PYLINTRC = Path(__file__).parent / ".pylintrc"
-_venv_activated = False
-
-def detect_project_type() -> str:
-    """Detect whether the current directory is a 'frontend' or 'backend' project."""
-    cwd = os.getcwd()
-    has_package_json = os.path.isfile(os.path.join(cwd, 'package.json'))
-    has_manage_py = os.path.isfile(os.path.join(cwd, 'manage.py'))
-
-    if has_package_json and has_manage_py:
-        raise RuntimeError(
-            'Ambiguous project: both package.json and manage.py found in current directory.'
-        )
-
-    if has_package_json:
-        if not os.path.isdir(os.path.join(cwd, 'node_modules')):
-            raise RuntimeError(
-                'Found package.json but no node_modules/ directory.\n'
-                'Install dependencies with: npm install'
-            )
-        return 'frontend'
-
-    if has_manage_py:
-        has_venv = (
-            os.path.isdir(os.path.join(cwd, '.venv'))
-            or os.path.isdir(os.path.join(cwd, 'venv'))
-        )
-        if not has_venv:
-            raise RuntimeError(
-                'Found manage.py but no virtual environment (venv or .venv) in current directory.\n'
-                'Create one with: python -m venv .venv'
-            )
-        return 'backend'
-
-    raise RuntimeError(
-        'Could not detect project type: no package.json or manage.py in current directory.'
-    )
-
-
-def detect_and_activate_venv():
-    """Detect venv in current directory and prepend to PATH. Runs only once."""
-    global _venv_activated
-    if _venv_activated:
-        return
-
-    cwd = os.getcwd()
-    found = []
-    for venv_name in ['.venv', 'venv']:
-        venv_path = os.path.join(cwd, venv_name)
-        if os.path.isdir(venv_path):
-            bin_dir = os.path.join(venv_path, 'bin')
-            if os.path.isdir(bin_dir):
-                found.append(venv_path)
-
-    if len(found) == 0:
-        raise RuntimeError(
-            'No virtual environment found in current directory.\n'
-            'Create one with: python -m venv .venv'
-        )
-    if len(found) > 1:
-        raise RuntimeError(
-            f'Multiple virtual environments found: {", ".join(found)}\n'
-            'Remove one and keep only .venv or venv.'
-        )
-
-    venv_path = found[0]
-    bin_dir = os.path.join(venv_path, 'bin')
-    os.environ['PATH'] = bin_dir + os.pathsep + os.environ.get('PATH', '')
-    os.environ['VIRTUAL_ENV'] = venv_path
-    print(f"[itw] Using venv: {venv_path}")
-    _venv_activated = True
-
-def _parse_angular_env_file(path: str) -> dict:
-    """Extract string-valued keys from an Angular environment.ts object literal."""
-    with open(path, 'r', encoding='utf-8') as fp:
-        content = fp.read()
-    pattern = re.compile(r"""^\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*['"]([^'"]*)['"]""", re.MULTILINE)
-    return dict(pattern.findall(content))
-
-
-def load_env(ctx: Context = None):
-    """Load env vars. Backend → .env in cwd. Frontend → src/environments/environment[.<branch>].ts."""
-    if detect_project_type() == 'frontend':
-        env_dir = os.path.join(os.getcwd(), 'src', 'environments')
-        candidates = []
-        if ctx is not None:
-            branch = get_current_branch(ctx)
-            candidates.append(os.path.join(env_dir, f'environment.{branch}.ts'))
-        candidates.append(os.path.join(env_dir, 'environment.ts'))
-        env_path = next((p for p in candidates if os.path.exists(p)), None)
-        if not env_path:
-            return
-        for key, value in _parse_angular_env_file(env_path).items():
-            os.environ.setdefault(key, value)
-        return
-    from decouple import Config, RepositoryEnv
-    env_path = os.path.join(os.getcwd(), '.env')
-    if not os.path.exists(env_path):
-        return
-    config = Config(RepositoryEnv(env_path))
-    for key, value in config.repository.data.items():
-        os.environ.setdefault(key, value)
-
-def get_current_branch(ctx: Context) -> str:
-    branch_result = ctx.run('git rev-parse --abbrev-ref HEAD')
-    current_branch = branch_result.stdout.splitlines()[0]
-    return current_branch
-
-
-def is_branch_production(branch: str) -> bool:
-    if branch == 'master':
-        return True
-    else:
-        return False
-
-
-def check_branch(ctx: Context) -> bool:
-    current_branch = get_current_branch(ctx)
-    production = is_branch_production(current_branch)
-    changed_result = ctx.run('git diff --quiet HEAD $REF -- $DIR || echo changed')
-    changed = changed_result.stdout.splitlines()  # empty list if not changed
-    if len(changed) > 0:
-        raise RuntimeError(f'You have uncommitted changes in branch {current_branch}.')
-    if production and current_branch != 'master':
-        raise RuntimeError('You must be in master branch to release in production.')
-    elif not production and current_branch != 'staging':
-        raise RuntimeError(f'Cannot tag in branch {current_branch}.')
-    else:
-        return production
-
-
-def get_latest_tag(ctx: Context) -> Version:
-    result = ctx.run('git describe --tags $(git rev-list --tags --max-count=1)')
-    latest_tag = result.stdout.splitlines()[0]
-    return Version.parse(latest_tag)
-
-
-def _update_package_json_version(version: Version) -> None:
-    """Rewrite only the `"version": "..."` line in package.json, preserving formatting."""
-    pkg_path = os.path.join(os.getcwd(), 'package.json')
-    with open(pkg_path, 'r', encoding='utf-8') as fp:
-        content = fp.read()
-    new_content, n = re.subn(
-        r'(^\s*"version"\s*:\s*")[^"]*(")',
-        lambda m: f'{m.group(1)}{version.bare_semver()}{m.group(2)}',
-        content,
-        count=1,
-        flags=re.MULTILINE,
-    )
-    if n == 0:
-        raise RuntimeError(f'Could not find "version" field in {pkg_path}')
-    with open(pkg_path, 'w', encoding='utf-8') as fp:
-        fp.write(new_content)
-
-
-def read_version(ctx: Context) -> Version:
-    """Read current version. Backend → VERSION file. Frontend → latest git tag."""
-    if detect_project_type() == 'frontend':
-        return get_latest_tag(ctx)
-    return Version.read_from_file()
-
-
-def save_version(version: Version) -> None:
-    """Persist version. Backend → VERSION file. Frontend → package.json (bare semver)."""
-    if detect_project_type() == 'frontend':
-        _update_package_json_version(version)
-        return
-    version.save_to_file()
-
-
-def generate_image_path(ctx: Context, branch: str) -> str:
-    result = ctx.run('git remote get-url origin')
-    result = result.stdout.splitlines()[0]
-    container_registry = result.split(':')[-1].replace('.git', '')
-    container_registry_path = f'gitreg.it-works.io:443/{container_registry}:{branch}-latest'
-    return container_registry_path
-
-
-def get_gitlab_username(ctx: Context) -> str:
-    """Resolve the GitLab username from git config user.email (local part before '@')."""
-    result = ctx.run('git config user.email', hide=True, warn=True)
-    email = result.stdout.strip() if result.ok else ''
-    if not email or '@' not in email:
-        raise RuntimeError(
-            'Could not determine GitLab username from git config user.email. '
-            'Set it with: git config --global user.email "you@email.com" '
-            'or pass --username=... explicitly.'
-        )
-    return email.split('@')[0]
 
 
 @task
 def login(ctx: Context, username=None):
-    """Log in to the GitLab container registry."""
+    """Capture GitLab token. Backend also logs into the container registry."""
     if not username:
         username = get_gitlab_username(ctx)
-    print(f'Logging in to gitreg.it-works.io:443 as {username}')
-    token = getpass.getpass(f'Enter GitLab token (password) for {username}: ')
+    token = getpass.getpass(f'Enter GitLab token for {username}: ')
     if not token:
         raise RuntimeError('No token entered; aborting login.')
+    os.environ['GITLAB_TOKEN'] = token
+    os.environ['GITLAB_USERNAME'] = username
+    if detect_project_type() == 'backend':
+        print(f'Logging in to gitreg.it-works.io:443 as {username}')
+        ctx.run(
+            f'podman login -u {username} --password-stdin gitreg.it-works.io:443 --tls-verify=false',
+            in_stream=io.StringIO(token)
+        )
+    else:
+        print(f'[itw] GitLab token captured for {username} (will be used for package upload).')
+
+
+def build_frontend(ctx: Context, branch: str, ssr: bool = False) -> None:
+    """Build the Angular app. With ssr=True uses the SSR npm scripts."""
+    if ssr:
+        if not is_ssr_project():
+            raise RuntimeError(
+                'Passed --ssr but project is not SSR-scaffolded '
+                '(missing server.ts / tsconfig.server.json). Run `itw ssr-init` first.'
+            )
+        script = 'build:ssr' if branch == 'master' else 'build:ssr:staging'
+        ctx.run(f'npm run {script}')
+        return
+    config = 'production' if branch == 'master' else 'staging'
+    ctx.run(f'npx ng build --configuration={config}')
+
+
+def package_dist(ctx: Context) -> None:
+    """Tar the dist/ output directory into dist.tar.gz."""
+    if not os.path.isdir(os.path.join(os.getcwd(), 'dist')):
+        raise RuntimeError('No dist/ directory found after build — did `ng build` succeed?')
+    ctx.run('tar -czf dist.tar.gz -C dist .')
+
+
+def upload_dist(ctx: Context, version) -> None:
+    """Upload dist.tar.gz to this project's GitLab Generic Package Registry under <version>/."""
+    from urllib.parse import quote
+    if not os.environ.get('GITLAB_TOKEN'):
+        raise RuntimeError('GITLAB_TOKEN not set; run `itw login` first.')
+    host, path = _parse_gitlab_remote(ctx)
+    encoded = quote(path, safe='')
+    url = f'https://{host}/api/v4/projects/{encoded}/packages/generic/frontend/{version}/dist.tar.gz'
+    print(f'[itw] Uploading dist.tar.gz → {url}')
     ctx.run(
-        f'podman login -u {username} --password-stdin gitreg.it-works.io:443 --tls-verify=false',
-        in_stream=io.StringIO(token)
+        'curl --fail --silent --show-error --insecure '
+        '--header "PRIVATE-TOKEN: $GITLAB_TOKEN" '
+        '--upload-file dist.tar.gz '
+        f'"{url}"'
     )
+    print('[itw] Upload complete.')
 
 
 def commit_version(ctx: Context, version: Version) -> None:
@@ -246,7 +117,7 @@ def pushimage(ctx: Context):
     ctx.run(f'podman push {container_registry_path} --tls-verify=false --compress --compression-level=9')
 
 
-def tag_build_push(ctx: Context, version: Version, skip_pipeline: bool = False) -> None:
+def tag_build_push(ctx: Context, version: Version, skip_pipeline: bool = False, ssr: bool = False) -> None:
     project_type = detect_project_type()
     if not skip_pipeline:
         test(ctx)
@@ -255,6 +126,11 @@ def tag_build_push(ctx: Context, version: Version, skip_pipeline: bool = False)
     if project_type == 'backend':
         buildimage(ctx)
         pushimage(ctx)
+    else:
+        branch = get_current_branch(ctx)
+        build_frontend(ctx, branch, ssr=ssr)
+        package_dist(ctx)
+        upload_dist(ctx, version)
     changelog(ctx, version)
     push(ctx)
 
@@ -269,67 +145,65 @@ def taginit(ctx: Context) -> None:
 
 
 @task
-def incrementrc(ctx: Context, skip_pipeline=False, pylintrc=None) -> None:
-    """Increment release candidate version and deploy"""
+def incrementrc(ctx: Context, skip_pipeline=False, pylintrc=None, ssr=False) -> None:
+    """Increment release candidate version and deploy. Use --ssr for Angular SSR builds."""
     check_branch(ctx)
+    login(ctx)
     project_type = detect_project_type()
-    if project_type == 'backend':
-        login(ctx)
     version = read_version(ctx)
     version.increment_release_candidate()
     if project_type == 'backend':
         lint(ctx, pylintrc=pylintrc)
-    tag_build_push(ctx, version, skip_pipeline)
+    tag_build_push(ctx, version, skip_pipeline, ssr=ssr)
     save_version(version)
     commit_version(ctx, version)
     push_version(ctx)
 
 
 @task
-def incrementpatch(ctx: Context, skip_pipeline=False) -> None:
-    """Increment patch version, build, and deploy"""
+def incrementpatch(ctx: Context, skip_pipeline=False, ssr=False) -> None:
+    """Increment patch version, build, and deploy. Use --ssr for Angular SSR builds."""
     production = check_branch(ctx)
     version = read_version(ctx)
     version.increment_patch(release=production)
-    tag_build_push(ctx, version, skip_pipeline)
+    tag_build_push(ctx, version, skip_pipeline, ssr=ssr)
     save_version(version)
     commit_version(ctx, version)
     push_version(ctx)
 
 
 @task
-def incrementminor(ctx: Context, skip_pipeline=False) -> None:
-    """Increment minor version, build, and deploy"""
+def incrementminor(ctx: Context, skip_pipeline=False, ssr=False) -> None:
+    """Increment minor version, build, and deploy. Use --ssr for Angular SSR builds."""
     production = check_branch(ctx)
     version = read_version(ctx)
     version.increment_minor(release=production)
-    tag_build_push(ctx, version, skip_pipeline)
+    tag_build_push(ctx, version, skip_pipeline, ssr=ssr)
     save_version(version)
     commit_version(ctx, version)
     push_version(ctx)
 
 
 @task
-def incrementmajor(ctx: Context, skip_pipeline=False) -> None:
-    """Increment major version, build, and deploy"""
+def incrementmajor(ctx: Context, skip_pipeline=False, ssr=False) -> None:
+    """Increment major version, build, and deploy. Use --ssr for Angular SSR builds."""
     production = check_branch(ctx)
     version = read_version(ctx)
     version.increment_major(release=production)
-    tag_build_push(ctx, version, skip_pipeline)
+    tag_build_push(ctx, version, skip_pipeline, ssr=ssr)
     save_version(version)
     commit_version(ctx, version)
     push_version(ctx)
 
 
 @task
-def release(ctx: Context, skip_pipeline=False) -> None:
-    """Promote release candidate to stable release and deploy"""
+def release(ctx: Context, skip_pipeline=False, ssr=False) -> None:
+    """Promote release candidate to stable release and deploy. Use --ssr for Angular SSR builds."""
     _ = check_branch(ctx)
-    if detect_project_type() == 'backend':
-        login(ctx)
+    login(ctx)
     version = read_version(ctx)
     version.reset_release_candidate(release=True)
-    tag_build_push(ctx, version, skip_pipeline)
+    tag_build_push(ctx, version, skip_pipeline, ssr=ssr)
     save_version(version)
     commit_version(ctx, version)
     push_version(ctx)
@@ -406,10 +280,11 @@ def analyze(ctx: Context):
 
 
 @task
-def buildlocal(ctx: Context):
-    """Build locally (Docker image for backend, npm build for frontend)"""
+def buildlocal(ctx: Context, ssr=False):
+    """Build locally (Docker image for backend, ng build for frontend). Use --ssr for SSR build."""
     if detect_project_type() == 'frontend':
-        ctx.run('npm run build')
+        branch = get_current_branch(ctx)
+        build_frontend(ctx, branch, ssr=ssr)
         print('✓ Built frontend (dist/)')
         return
     current_branch = get_current_branch(ctx)

itw_python_builder-0.1.27/itw_python_builder/templates/server.sitemap.snippet.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck — template fragment, injected into a file where express is imported
+
+  const sitemapHandler = (req: express.Request, res: express.Response) => {
+    const origin = `https://${req.get('host')}`;
+    const now = new Date().toISOString();
+    const urls = sitemapEntries
+      .map(e => `<url><loc>${origin}${e.path}</loc><lastmod>${now}</lastmod><changefreq>${e.changefreq}</changefreq><priority>${e.priority}</priority></url>`)
+      .join('');
+    res.type('application/xml').send(`<?xml version="1.0" encoding="UTF-8"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${urls}</urlset>`);
+  };
+
+  server.get('/sitemap.xml', sitemapHandler);

itw_python_builder-0.1.27/itw_python_builder/templates/sitemap.routes.ts

@@ -0,0 +1,35 @@
+// @ts-nocheck — template file, types resolved in the target project
+import {Routes} from '@angular/router';
+
+// Add your real routes here. Each entry can carry sitemap metadata via
+//   data: { sitemap: { priority: 1, changefreq: 'daily' } }
+// Children are walked recursively. Routes with ':' params are skipped.
+type SitemapMeta = { priority?: number; changefreq?: string };
+type SitemapEntry = { path: string; priority: number; changefreq: string };
+
+const join = (a: string, b: string) => `/${[a,b].filter(Boolean).join('/')}`.replaceAll(/\/+/g,'/');
+
+const flatten = (
+  base: string,
+  routes: Routes,
+  inherited: SitemapMeta = {}
+): SitemapEntry[] =>
+  routes.flatMap(r => {
+    const merged: SitemapMeta = { changefreq: 'daily', priority: 0.8, ...inherited, ...r.data?.['sitemap'] };
+    const full = join(base, r.path || '');
+    if (r.children?.length) return flatten(full, r.children, merged);
+    return [{ path: full || '/', priority: merged.priority!, changefreq: merged.changefreq! }];
+  });
+
+const tree: Routes = [
+  // { path: '', data: { sitemap: { priority: 1 } } },
+];
+
+export const sitemapEntries: SitemapEntry[] = Array.from(
+  new Map(
+    flatten('', tree)
+      .filter(e => !e.path.includes(':'))
+      .sort((a,b) => a.path.localeCompare(b.path))
+      .map(e => [e.path, e])
+  ).values()
+);

itw_python_builder-0.1.27/itw_python_builder/utils.py

@@ -0,0 +1,225 @@
+"""Shared helpers used by tasks.py and ssr_tasks.py.
+
+Only non-@task functions live here. CLI tasks stay in tasks.py / ssr_tasks.py.
+"""
+import getpass
+import io
+import json
+import os
+import re
+from pathlib import Path
+
+from invoke import Context
+
+from itw_python_builder.version import Version
+
+_venv_activated = False
+
+
+def detect_project_type() -> str:
+    """Detect whether the current directory is a 'frontend' or 'backend' project."""
+    cwd = os.getcwd()
+    has_package_json = os.path.isfile(os.path.join(cwd, 'package.json'))
+    has_manage_py = os.path.isfile(os.path.join(cwd, 'manage.py'))
+
+    if has_package_json and has_manage_py:
+        raise RuntimeError(
+            'Ambiguous project: both package.json and manage.py found in current directory.'
+        )
+
+    if has_package_json:
+        if not os.path.isdir(os.path.join(cwd, 'node_modules')):
+            raise RuntimeError(
+                'Found package.json but no node_modules/ directory.\n'
+                'Install dependencies with: npm install'
+            )
+        return 'frontend'
+
+    if has_manage_py:
+        has_venv = (
+            os.path.isdir(os.path.join(cwd, '.venv'))
+            or os.path.isdir(os.path.join(cwd, 'venv'))
+        )
+        if not has_venv:
+            raise RuntimeError(
+                'Found manage.py but no virtual environment (venv or .venv) in current directory.\n'
+                'Create one with: python -m venv .venv'
+            )
+        return 'backend'
+
+    raise RuntimeError(
+        'Could not detect project type: no package.json or manage.py in current directory.'
+    )
+
+
+def detect_and_activate_venv():
+    """Detect venv in current directory and prepend to PATH. Runs only once."""
+    global _venv_activated
+    if _venv_activated:
+        return
+
+    cwd = os.getcwd()
+    found = []
+    for venv_name in ['.venv', 'venv']:
+        venv_path = os.path.join(cwd, venv_name)
+        if os.path.isdir(venv_path):
+            bin_dir = os.path.join(venv_path, 'bin')
+            if os.path.isdir(bin_dir):
+                found.append(venv_path)
+
+    if len(found) == 0:
+        raise RuntimeError(
+            'No virtual environment found in current directory.\n'
+            'Create one with: python -m venv .venv'
+        )
+    if len(found) > 1:
+        raise RuntimeError(
+            f'Multiple virtual environments found: {", ".join(found)}\n'
+            'Remove one and keep only .venv or venv.'
+        )
+
+    venv_path = found[0]
+    bin_dir = os.path.join(venv_path, 'bin')
+    os.environ['PATH'] = bin_dir + os.pathsep + os.environ.get('PATH', '')
+    os.environ['VIRTUAL_ENV'] = venv_path
+    print(f"[itw] Using venv: {venv_path}")
+    _venv_activated = True
+
+
+def _parse_angular_env_file(path: str) -> dict:
+    """Extract string-valued keys from an Angular environment.ts object literal."""
+    with open(path, 'r', encoding='utf-8') as fp:
+        content = fp.read()
+    pattern = re.compile(r"""^\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*['"]([^'"]*)['"]""", re.MULTILINE)
+    return dict(pattern.findall(content))
+
+
+def load_env(ctx: Context = None):
+    if detect_project_type() == 'frontend':
+        env_dir = os.path.join(os.getcwd(), 'src', 'environments')
+        candidates = []
+        if ctx is not None:
+            branch = get_current_branch(ctx)
+            candidates.append(os.path.join(env_dir, f'environment.{branch}.ts'))
+        candidates.append(os.path.join(env_dir, 'environment.ts'))
+        for path in candidates:
+            if os.path.exists(path):
+                for key, value in _parse_angular_env_file(path).items():
+                    os.environ.setdefault(key, value)
+        return
+    from decouple import Config, RepositoryEnv
+    env_path = os.path.join(os.getcwd(), '.env')
+    if not os.path.exists(env_path):
+        return
+    config = Config(RepositoryEnv(env_path))
+    for key, value in config.repository.data.items():
+        os.environ.setdefault(key, value)
+
+
+def get_current_branch(ctx: Context) -> str:
+    branch_result = ctx.run('git rev-parse --abbrev-ref HEAD')
+    current_branch = branch_result.stdout.splitlines()[0]
+    return current_branch
+
+
+def is_branch_production(branch: str) -> bool:
+    return branch == 'master'
+
+
+def check_branch(ctx: Context) -> bool:
+    current_branch = get_current_branch(ctx)
+    production = is_branch_production(current_branch)
+    changed_result = ctx.run('git diff --quiet HEAD $REF -- $DIR || echo changed')
+    changed = changed_result.stdout.splitlines()
+    if len(changed) > 0:
+        raise RuntimeError(f'You have uncommitted changes in branch {current_branch}.')
+    if production and current_branch != 'master':
+        raise RuntimeError('You must be in master branch to release in production.')
+    elif not production and current_branch != 'staging':
+        raise RuntimeError(f'Cannot tag in branch {current_branch}.')
+    else:
+        return production
+
+
+def get_latest_tag(ctx: Context) -> Version:
+    result = ctx.run('git describe --tags $(git rev-list --tags --max-count=1)')
+    latest_tag = result.stdout.splitlines()[0]
+    return Version.parse(latest_tag)
+
+
+def _update_package_json_version(version: Version) -> None:
+    """Update the top-level `version` in package.json (preserves key order)."""
+    pkg_path = os.path.join(os.getcwd(), 'package.json')
+    with open(pkg_path, 'r', encoding='utf-8') as fp:
+        data = json.load(fp)
+    data['version'] = version.bare_semver()
+    with open(pkg_path, 'w', encoding='utf-8') as fp:
+        json.dump(data, fp, indent=2)
+        fp.write('\n')
+
+
+def read_version(ctx: Context) -> Version:
+    """Read current version. Backend → VERSION file. Frontend → latest git tag."""
+    if detect_project_type() == 'frontend':
+        return get_latest_tag(ctx)
+    return Version.read_from_file()
+
+
+def save_version(version: Version) -> None:
+    """Persist version. Backend → VERSION file. Frontend → package.json (bare semver)."""
+    if detect_project_type() == 'frontend':
+        _update_package_json_version(version)
+        return
+    version.save_to_file()
+
+
+def generate_image_path(ctx: Context, branch: str) -> str:
+    result = ctx.run('git remote get-url origin')
+    result = result.stdout.splitlines()[0]
+    container_registry = result.split(':')[-1].replace('.git', '')
+    container_registry_path = f'gitreg.it-works.io:443/{container_registry}:{branch}-latest'
+    return container_registry_path
+
+
+def get_gitlab_username(ctx: Context) -> str:
+    """Resolve the GitLab username from git config user.email (local part before '@')."""
+    result = ctx.run('git config user.email', hide=True, warn=True)
+    email = result.stdout.strip() if result.ok else ''
+    if not email or '@' not in email:
+        raise RuntimeError(
+            'Could not determine GitLab username from git config user.email. '
+            'Set it with: git config --global user.email "you@email.com" '
+            'or pass --username=... explicitly.'
+        )
+    return email.split('@')[0]
+
+
+def _read_package_name() -> str:
+    """Read 'name' field from package.json in cwd."""
+    pkg_path = os.path.join(os.getcwd(), 'package.json')
+    with open(pkg_path, 'r', encoding='utf-8') as fp:
+        return json.load(fp)['name']
+
+
+def _parse_gitlab_remote(ctx: Context) -> tuple:
+    """Return (host, project_path) parsed from `git remote get-url origin`."""
+    result = ctx.run('git remote get-url origin', hide=True)
+    url = result.stdout.strip()
+    if url.endswith('.git'):
+        url = url[:-4]
+    if url.startswith('git@'):
+        host, path = url.split('@', 1)[1].split(':', 1)
+    elif '://' in url:
+        host, path = url.split('://', 1)[1].split('/', 1)
+    else:
+        raise RuntimeError(f'Cannot parse GitLab remote URL: {url}')
+    return host, path
+
+
+def is_ssr_project() -> bool:
+    """Return True if the current frontend project already has SSR scaffolding."""
+    cwd = os.getcwd()
+    return (
+        os.path.isfile(os.path.join(cwd, 'server.ts'))
+        and os.path.isfile(os.path.join(cwd, 'tsconfig.server.json'))
+    )

{itw_python_builder-0.1.25 → itw_python_builder-0.1.27}/itw_python_builder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: itw_python_builder
-Version: 0.1.25
+Version: 0.1.27
 Summary: Standardized Django deployment pipeline with Docker, testing, and SonarQube integration
 Author-email: IT-Works <contact@it-works.io>
 License: MIT

{itw_python_builder-0.1.25 → itw_python_builder-0.1.27}/itw_python_builder.egg-info/SOURCES.txt

@@ -4,11 +4,15 @@ pyproject.toml
 itw_python_builder/.pylintrc
 itw_python_builder/__init__.py
 itw_python_builder/cli.py
+itw_python_builder/ssr_tasks.py
 itw_python_builder/tasks.py
+itw_python_builder/utils.py
 itw_python_builder/version.py
 itw_python_builder.egg-info/PKG-INFO
 itw_python_builder.egg-info/SOURCES.txt
 itw_python_builder.egg-info/dependency_links.txt
 itw_python_builder.egg-info/entry_points.txt
 itw_python_builder.egg-info/requires.txt
-itw_python_builder.egg-info/top_level.txt
+itw_python_builder.egg-info/top_level.txt
+itw_python_builder/templates/server.sitemap.snippet.ts
+itw_python_builder/templates/sitemap.routes.ts

{itw_python_builder-0.1.25 → itw_python_builder-0.1.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "itw_python_builder"
-version = "0.1.25"
+version = "0.1.27"
 description = "Standardized Django deployment pipeline with Docker, testing, and SonarQube integration"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -40,7 +40,7 @@ Issues = "https://git.it-works.io/"
 include-package-data = true
 
 [tool.setuptools.package-data]
-itw_python_builder = [".pylintrc"]
+itw_python_builder = [".pylintrc", "templates/*.ts"]
 
 [project.scripts]
 itw = "itw_python_builder.cli:main"