jmespath-playground/scripts/build-image.mjs

#!/usr/bin/env node

import { execSync } from 'node:child_process';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
import { parseArgs } from 'node:util';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

function execCommand(command, description) {
    try {
        console.log(`${description}...`);
        execSync(command, { stdio: 'inherit' });
    } catch (error) {
        console.error(`Error: ${description} failed`);
        process.exit(1);
    }
}

function getContainerTool() {
    // Check for Docker first (primary tool)
    try {
        execSync('docker --version', { stdio: 'ignore' });
        return 'docker';
    } catch (error) {
        // Fall back to Apple's container command
        try {
            execSync('container --version', { stdio: 'ignore' });
            return 'container';
        } catch (error) {
            console.error('Error: No container tool found. Please install Docker or Apple Container Tools to build container images.');
            process.exit(1);
        }
    }
}

function isGitRepo() {
    try {
        execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore' });
        return true;
    } catch (error) {
        return false;
    }
}

async function generateVersionFile() {
    const versionModuleUrl = pathToFileURL(path.join(__dirname, 'version.mjs')).href;
    const { generateVersionFile: generate } = await import(versionModuleUrl);
    const versionFilePath = path.join(__dirname, '..', 'src', 'version.js');
    generate(versionFilePath);
    return versionFilePath;
}

function writeVersionFile(version, isRelease) {
    const versionFilePath = path.join(__dirname, '..', 'src', 'version.js');
    const contents = [
        `export const VERSION = '${version}';`,
        `export const IS_RELEASE = ${isRelease};`,
        ''
    ].join('\n');
    fs.writeFileSync(versionFilePath, contents, 'utf8');
    return versionFilePath;
}

function readPackageJsonVersion() {
    const packagePath = path.join(__dirname, '..', 'package.json');
    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
    if (!pkg.version) {
        throw new Error('package.json does not contain a version');
    }
    return pkg.version;
}

function readVersionFile(versionFilePath) {
    const contents = fs.readFileSync(versionFilePath, 'utf8');
    const versionMatch = contents.match(/export const VERSION = '([^']+)';/);
    const releaseMatch = contents.match(/export const IS_RELEASE = (true|false);/);

    if (!versionMatch || !releaseMatch) {
        throw new Error(`Could not parse version file at ${versionFilePath}`);
    }

    return {
        version: versionMatch[1],
        isRelease: releaseMatch[1] === 'true'
    };
}

function getHostArchitecture() {
    // Map Node.js architecture names to container architecture names
    const archMap = {
        'arm64': 'arm64',
        'arm': 'arm64',
        'x64': 'amd64'
    };
    return archMap[process.arch] || 'arm64';
}

function showHelp() {
    const hostArch = getHostArchitecture();
    console.log(`Build multi-architecture container images for JMESPath Playground

Usage:
  build-image.mjs [OPTIONS]

Options:
  --all-arch       Build for both arm64 and amd64 (default: build for host architecture only)
  --arch <arch>    Target architecture (arm64 or amd64). Can be specified multiple times.
  --registry <id>  Image registry (default: docker.io). Can also set JMESPATH_REGISTRY.
  --help, -h       Show this help message and exit

Examples:
  build-image.mjs                            # Builds for ${hostArch} only (host architecture)
  build-image.mjs --all-arch                 # Builds for both arm64 and amd64
  build-image.mjs --arch arm64               # Builds for arm64 only
  build-image.mjs --arch arm64 --arch amd64  # Explicitly specify both
  build-image.mjs --registry docker.io       # Use Docker Hub registry explicitly
  build-image.mjs -h                         # Show help`);
}

async function main() {
    const { values } = parseArgs({
        options: {
            help: {
                type: 'boolean',
                short: 'h',
                description: 'Show help'
            },
            'all-arch': {
                type: 'boolean',
                description: 'Build for both arm64 and amd64'
            },
            arch: {
                type: 'string',
                multiple: true,
                description: 'Target architecture (arm64 or amd64)'
            },
            registry: {
                type: 'string',
                description: 'Image registry (default: docker.io)'
            }
        },
        strict: true,
        allowPositionals: false
    });

    if (values.help) {
        showHelp();
        process.exit(0);
    }

    const containerTool = getContainerTool();
    let version;
    let isRelease;

    if (isGitRepo()) {
        const versionFilePath = await generateVersionFile();
        const versionInfo = readVersionFile(versionFilePath);
        version = versionInfo.version;
        isRelease = versionInfo.isRelease;
    } else {
        version = readPackageJsonVersion();
        isRelease = true;
        writeVersionFile(version, isRelease);
    }

    let architectures;
    if (values['all-arch']) {
        architectures = ['arm64', 'amd64'];
    } else if (values.arch && values.arch.length > 0) {
        architectures = values.arch;
    } else {
        architectures = [getHostArchitecture()];
    }

    console.log(`Building ${isRelease ? 'release' : 'development'} version: ${version}`);
    console.log(`Target architectures: ${architectures.join(', ')}`);

    // Build container image
    const registry = values.registry || process.env.JMESPATH_REGISTRY || 'docker.io';
    const imageName = `${registry.replace(/\/$/, '')}/skoszewski/jmespath-playground`;
    const tags = isRelease
        ? [
            `-t ${imageName}:${version}`,
            `-t ${imageName}:latest`
          ].join(' ')
        : [
            `-t ${imageName}:dev`,
            `-t ${imageName}:latest`
          ].join(' ');

    const archFlags = architectures.map(arch => `--arch ${arch}`).join(' ');

    const buildCommand = `${containerTool} build ${archFlags} --build-arg VERSION="${version}" --build-arg IS_RELEASE="${isRelease}" ${tags} .`;

    execCommand(buildCommand, 'Building container image');

    console.log('Container image build completed successfully!');

    // Show usage instructions
    console.log(`\nUsage examples:`);
    console.log(`  build-image.mjs                            # Builds for host architecture only`);
    console.log(`  build-image.mjs --all-arch                 # Builds for both arm64 and amd64`);
    console.log(`  build-image.mjs --arch arm64               # Builds for arm64 only`);
    console.log(`  build-image.mjs --arch arm64 --arch amd64  # Explicitly specify both`);

    if (isRelease) {
        console.log(`\nTo run the container:`);
        console.log(`  ${containerTool} run --arch arm64 --name jmespathpg -p 3000:3000 ${imageName}:${version}`);
        if (containerTool === 'docker') {
            console.log(`\nTo push to Docker Hub:`);
            console.log(`  docker push ${imageName}:${version}`);
            console.log(`  docker push ${imageName}:latest`);
        }
    } else {
        console.log(`\nTo run the container:`);
        console.log(`  ${containerTool} run --arch arm64 --name jmespathpg -p 3000:3000 ${imageName}:dev`);
    }
}

const isDirectRun = process.argv[1]
    && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);

if (isDirectRun) {
    main().catch((error) => {
        console.error(`Error: ${error.message}`);
        process.exit(1);
    });
}