@open-mova/cli 0.1.13 → 0.1.14

package/README.md

@@ -16,6 +16,7 @@ El CLI descarga la shell, el core y la plantilla de microfrontales desde tags es
 - [`mova start`](#mova-start)
 - [`mova build`](#mova-build)
 - [`mova info`](#mova-info)
+- [`mova update`](#mova-update)
 - [`mova shell versions`](#mova-shell-versions)
 - [`mova cap add`](#mova-cap-add)
 - [`mova cap sync`](#mova-cap-sync)
@@ -121,6 +122,23 @@ Muestra la aplicación detectada, la versión de shell y sus microfrontales. Tam
 mova info
 ```
 
+### `mova update`
+
+Actualiza los archivos técnicos de la shell usando como referencia el tag con
+el que se creó la aplicación. No modifica los microfrontales ni sobrescribe
+archivos personalizados: los muestra como conflictos.
+
+```bash
+mova update --check
+mova update
+mova update --to v0.2.0
+```
+
+`--check` solo muestra el plan. Para aplicar cambios, el proyecto debe estar en
+un repositorio Git limpio. Si cambia `package.json`, el CLI elimina el lockfile
+obsoleto y pide ejecutar `npm install`; después se debe comprobar con
+`mova build`.
+
 ### `mova shell versions`
 
 Lista los tags estables disponibles para crear aplicaciones.

package/dist/application/shell-update.d.ts

@@ -0,0 +1,19 @@
+import type { OpenMovaApplicationConfiguration } from '../types.js';
+import { type ShellVersion } from './shell-repository.js';
+interface FileChange {
+    readonly path: string;
+    readonly content?: Buffer;
+}
+export interface ShellUpdatePlan {
+    readonly currentVersion: string;
+    readonly target: ShellVersion;
+    readonly changes: readonly string[];
+    readonly conflicts: readonly string[];
+    readonly fileChanges: readonly FileChange[];
+    readonly packageContent?: string;
+    readonly capacitorContent?: string;
+    readonly removePackageLock: boolean;
+}
+export declare function createShellUpdatePlan(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, requestedVersion?: string): ShellUpdatePlan;
+export declare function applyShellUpdate(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, plan: ShellUpdatePlan): void;
+export {};

package/dist/application/shell-update.js

@@ -0,0 +1,228 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync, } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { tmpdir } from 'node:os';
+import { synchronizeShellConfiguration } from './shell-configuration.js';
+import { downloadShell, listShellVersions } from './shell-repository.js';
+import { writeApplicationConfiguration } from './configuration.js';
+const GENERATED_PATHS = new Set([
+    'package.json',
+    'package-lock.json',
+    'capacitor.config.ts',
+    'src/app/application.config.ts',
+    'src/assets/federation.manifest.json',
+]);
+export function createShellUpdatePlan(applicationRoot, configuration, requestedVersion) {
+    if (!configuration.shell) {
+        throw new Error('La aplicación no tiene registrada una versión de shell.');
+    }
+    const targetVersion = requestedVersion ?? listShellVersions()[0];
+    if (!targetVersion) {
+        throw new Error('No hay versiones estables disponibles para actualizar.');
+    }
+    if (compareVersions(targetVersion, configuration.shell.version) < 0) {
+        throw new Error(`La versión ${targetVersion} es anterior a ${configuration.shell.version}. ` +
+            'mova update no realiza downgrades.');
+    }
+    const temporaryRoot = mkdtempSync(join(tmpdir(), 'open-mova-update-'));
+    try {
+        const currentDirectory = join(temporaryRoot, 'current');
+        const targetDirectory = join(temporaryRoot, 'target');
+        const current = downloadShell(currentDirectory, configuration.shell.version);
+        const target = downloadShell(targetDirectory, targetVersion);
+        if (current.commit !== configuration.shell.commit) {
+            throw new Error(`El commit registrado para ${configuration.shell.version} no coincide con el tag remoto.`);
+        }
+        const conflicts = [];
+        const fileChanges = compareManagedFiles(applicationRoot, currentDirectory, targetDirectory, conflicts);
+        const packageUpdate = comparePackageConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts);
+        const capacitorUpdate = compareCapacitorConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts);
+        const changes = [
+            ...fileChanges.map((change) => `${change.content ? 'Actualizar' : 'Eliminar'} ${change.path}`),
+            ...(packageUpdate ? ['Actualizar package.json', 'Regenerar package-lock.json'] : []),
+            ...(capacitorUpdate ? ['Actualizar capacitor.config.ts'] : []),
+            ...(target.version === configuration.shell.version
+                ? []
+                : [`Registrar shell ${target.version}`]),
+        ];
+        return {
+            currentVersion: configuration.shell.version,
+            target,
+            changes,
+            conflicts,
+            fileChanges,
+            ...(packageUpdate ? { packageContent: packageUpdate } : {}),
+            ...(capacitorUpdate ? { capacitorContent: capacitorUpdate } : {}),
+            removePackageLock: packageUpdate !== undefined,
+        };
+    }
+    finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+}
+export function applyShellUpdate(applicationRoot, configuration, plan) {
+    if (plan.conflicts.length > 0) {
+        throw new Error('No se puede actualizar mientras existan conflictos.');
+    }
+    requireCleanGitRepository(applicationRoot);
+    for (const change of plan.fileChanges) {
+        const destination = join(applicationRoot, change.path);
+        if (change.content) {
+            mkdirSync(dirname(destination), { recursive: true });
+            writeFileSync(destination, change.content);
+        }
+        else {
+            rmSync(destination, { force: true });
+        }
+    }
+    if (plan.packageContent) {
+        writeFileSync(join(applicationRoot, 'package.json'), plan.packageContent, 'utf8');
+    }
+    if (plan.removePackageLock) {
+        rmSync(join(applicationRoot, 'package-lock.json'), { force: true });
+    }
+    if (plan.capacitorContent) {
+        writeFileSync(join(applicationRoot, 'capacitor.config.ts'), plan.capacitorContent, 'utf8');
+    }
+    const updatedConfiguration = {
+        ...configuration,
+        shell: plan.target,
+    };
+    writeApplicationConfiguration(applicationRoot, updatedConfiguration);
+    synchronizeShellConfiguration(applicationRoot, updatedConfiguration);
+}
+function compareManagedFiles(applicationRoot, currentDirectory, targetDirectory, conflicts) {
+    const paths = new Set([
+        ...listFiles(currentDirectory),
+        ...listFiles(targetDirectory),
+    ]);
+    const changes = [];
+    for (const path of [...paths].sort()) {
+        if (GENERATED_PATHS.has(path))
+            continue;
+        const currentContent = readOptionalFile(join(currentDirectory, path));
+        const targetContent = readOptionalFile(join(targetDirectory, path));
+        const applicationContent = readOptionalFile(join(applicationRoot, path));
+        if (buffersEqual(currentContent, targetContent))
+            continue;
+        if (buffersEqual(applicationContent, currentContent)) {
+            changes.push({ path, ...(targetContent ? { content: targetContent } : {}) });
+            continue;
+        }
+        if (buffersEqual(applicationContent, targetContent))
+            continue;
+        conflicts.push(path);
+    }
+    return changes;
+}
+function comparePackageConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts) {
+    const application = readJson(join(applicationRoot, 'package.json'));
+    const current = readJson(join(currentDirectory, 'package.json'));
+    const target = readJson(join(targetDirectory, 'package.json'));
+    let changed = false;
+    for (const section of ['scripts', 'dependencies', 'devDependencies']) {
+        const applicationSection = readStringMap(application[section]);
+        const currentSection = readStringMap(current[section]);
+        const targetSection = readStringMap(target[section]);
+        const keys = new Set([...Object.keys(currentSection), ...Object.keys(targetSection)]);
+        for (const key of keys) {
+            if (currentSection[key] === targetSection[key])
+                continue;
+            if (applicationSection[key] === currentSection[key]) {
+                if (targetSection[key] === undefined) {
+                    delete applicationSection[key];
+                }
+                else {
+                    applicationSection[key] = targetSection[key];
+                }
+                changed = true;
+            }
+            else if (applicationSection[key] !== targetSection[key]) {
+                conflicts.push(`package.json#${section}.${key}`);
+            }
+        }
+        application[section] = applicationSection;
+    }
+    return changed ? `${JSON.stringify(application, null, 2)}\n` : undefined;
+}
+function compareCapacitorConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts) {
+    const applicationPath = join(applicationRoot, 'capacitor.config.ts');
+    const currentPath = join(currentDirectory, 'capacitor.config.ts');
+    const targetPath = join(targetDirectory, 'capacitor.config.ts');
+    if (!existsSync(applicationPath) || !existsSync(currentPath) || !existsSync(targetPath)) {
+        return undefined;
+    }
+    const application = readFileSync(applicationPath, 'utf8');
+    const identity = readCapacitorIdentity(application);
+    const current = applyCapacitorIdentity(readFileSync(currentPath, 'utf8'), identity);
+    const target = applyCapacitorIdentity(readFileSync(targetPath, 'utf8'), identity);
+    if (current === target || application === target)
+        return undefined;
+    if (application === current)
+        return target;
+    conflicts.push('capacitor.config.ts');
+    return undefined;
+}
+function requireCleanGitRepository(applicationRoot) {
+    const repository = spawnSync('git', ['-C', applicationRoot, 'rev-parse', '--is-inside-work-tree'], { encoding: 'utf8' });
+    if (repository.status !== 0) {
+        throw new Error('Inicializa Git y crea un commit antes de ejecutar mova update.');
+    }
+    const status = spawnSync('git', ['-C', applicationRoot, 'status', '--porcelain', '--untracked-files=all'], { encoding: 'utf8' });
+    if (status.status !== 0 || status.stdout.trim() !== '') {
+        throw new Error('El repositorio debe estar limpio antes de ejecutar mova update.');
+    }
+}
+function listFiles(directory) {
+    const files = [];
+    const visit = (currentDirectory) => {
+        for (const entry of readdirSync(currentDirectory, { withFileTypes: true })) {
+            const absolutePath = join(currentDirectory, entry.name);
+            if (entry.isDirectory()) {
+                visit(absolutePath);
+            }
+            else if (entry.isFile()) {
+                files.push(relative(directory, absolutePath));
+            }
+        }
+    };
+    visit(directory);
+    return files;
+}
+function readOptionalFile(path) {
+    return existsSync(path) ? readFileSync(path) : undefined;
+}
+function buffersEqual(first, second) {
+    return first === undefined ? second === undefined : second !== undefined && first.equals(second);
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function readStringMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return { ...value };
+}
+function readCapacitorIdentity(content) {
+    const appId = content.match(/\bappId:\s*['"]([^'"]+)['"]/)?.[1];
+    const appName = content.match(/\bappName:\s*['"]([^'"]+)['"]/)?.[1];
+    if (!appId || !appName) {
+        throw new Error('No se puede leer appId o appName de capacitor.config.ts.');
+    }
+    return { appId, appName };
+}
+function applyCapacitorIdentity(content, identity) {
+    return content
+        .replace(/(\bappId:\s*)['"][^'"]+['"]/, `$1'${identity.appId}'`)
+        .replace(/(\bappName:\s*)['"][^'"]+['"]/, `$1'${identity.appName}'`);
+}
+function compareVersions(first, second) {
+    const firstParts = first.slice(1).split('.').map(Number);
+    const secondParts = second.slice(1).split('.').map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (firstParts[index] ?? 0) - (secondParts[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}

package/dist/cli.js

@@ -8,6 +8,7 @@ import { registerInfoCommand } from './commands/info.js';
 import { registerMicrofrontendCommands } from './commands/microfrontend.js';
 import { registerStartCommand } from './commands/start.js';
 import { registerShellCommands } from './commands/shell.js';
+import { registerUpdateCommand } from './commands/update.js';
 const program = new Command();
 const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 program
@@ -21,6 +22,7 @@ registerShellCommands(program);
 registerBuildCommand(program);
 registerCapacitorCommands(program);
 registerInfoCommand(program);
+registerUpdateCommand(program);
 try {
     await program.parseAsync();
 }

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerUpdateCommand(program: Command): void;

package/dist/commands/update.js

@@ -0,0 +1,44 @@
+import { readApplicationConfiguration, requireApplicationRoot, } from '../application/configuration.js';
+import { applyShellUpdate, createShellUpdatePlan, } from '../application/shell-update.js';
+export function registerUpdateCommand(program) {
+    program
+        .command('update')
+        .description('Actualiza la infraestructura de Open Mova de una aplicación')
+        .option('--check', 'mostrar los cambios sin modificar archivos')
+        .option('--to <tag>', 'versión de destino, por ejemplo v0.2.0')
+        .action((options) => {
+        const applicationRoot = requireApplicationRoot(process.cwd());
+        const configuration = readApplicationConfiguration(applicationRoot);
+        const plan = createShellUpdatePlan(applicationRoot, configuration, options.to);
+        printPlan(plan);
+        if (options.check)
+            return;
+        if (plan.conflicts.length > 0) {
+            throw new Error('Se han detectado archivos modificados. Resuelve los conflictos antes de actualizar.');
+        }
+        if (plan.changes.length === 0) {
+            console.log('La aplicación ya está actualizada.');
+            return;
+        }
+        applyShellUpdate(applicationRoot, configuration, plan);
+        console.log(`Aplicación actualizada a ${plan.target.version}.`);
+        if (plan.removePackageLock) {
+            console.log('Ejecuta npm install para instalar dependencias y regenerar package-lock.json.');
+        }
+        console.log('Después ejecuta mova build para verificar la aplicación.');
+    });
+}
+function printPlan(plan) {
+    console.log(`Shell actual: ${plan.currentVersion}`);
+    console.log(`Shell destino: ${plan.target.version}`);
+    if (plan.changes.length > 0) {
+        console.log('Cambios:');
+        for (const change of plan.changes)
+            console.log(`- ${change}`);
+    }
+    if (plan.conflicts.length > 0) {
+        console.log('Conflictos que no se sobrescribirán:');
+        for (const conflict of plan.conflicts)
+            console.log(`- ${conflict}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mova/cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "CLI para crear y mantener aplicaciones Open Mova",
   "license": "MIT",
   "author": "Open Mova contributors",