@memberjunction/open-app-engine 0.0.1 → 5.2.0

package/dist/install/install-orchestrator.js

@@ -0,0 +1,634 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { ParseAndValidateManifest } from '../manifest/manifest-loader.js';
+import { CheckMJVersionCompatibility, IsValidUpgrade } from '../dependency/version-checker.js';
+import { ResolveDependencies } from '../dependency/dependency-resolver.js';
+import { FetchManifestFromGitHub, DownloadMigrations, GetLatestVersion } from '../github/github-client.js';
+import { CreateAppSchema, DropAppSchema, SchemaExists, EscapeSqlString } from './schema-manager.js';
+import { RunAppMigrations } from './migration-runner.js';
+import { AddAppPackages, RemoveAppPackages, RunNpmInstall } from './package-manager.js';
+import { AddServerDynamicPackages, RemoveServerDynamicPackages, ToggleServerDynamicPackages } from './config-manager.js';
+import { RegenerateClientBootstrap } from './client-bootstrap-gen.js';
+import { Metadata, RunView } from '@memberjunction/core';
+import { RecordAppInstallation, RecordInstallHistoryEntry, RecordAppDependencies, DeleteAppDependencies, SetAppStatus, FindInstalledApp, FindDependentApps, ListInstalledApps, UpdateAppRecord, } from './history-recorder.js';
+export async function InstallApp(options, context) {
+    const startTime = Date.now();
+    const { Callbacks } = context;
+    let createdAppId;
+    let manifest;
+    try {
+        Callbacks?.OnProgress?.('Fetch', `Fetching manifest from ${options.Source}...`);
+        const fetchResult = await FetchManifestFromGitHub(options.Source, options.Version, context.GitHubOptions);
+        if (!fetchResult.Success || !fetchResult.ManifestJSON) {
+            return BuildFailureResult('Install', options.Source, '', 'Schema', startTime, fetchResult.ErrorMessage ?? 'Failed to fetch manifest');
+        }
+        Callbacks?.OnProgress?.('Validate', 'Validating manifest...');
+        const parseResult = ParseAndValidateManifest(fetchResult.ManifestJSON);
+        if (!parseResult.Success || !parseResult.Manifest) {
+            return BuildFailureResult('Install', options.Source, '', 'Schema', startTime, `Invalid manifest: ${parseResult.Errors?.join(', ')}`);
+        }
+        manifest = parseResult.Manifest;
+        Callbacks?.OnProgress?.('Validate', 'Checking MJ version compatibility and resolving dependencies...');
+        const [compatResult, depResult] = await Promise.all([
+            Promise.resolve(CheckMJVersionCompatibility(context.MJVersion, manifest.mjVersionRange)),
+            ResolveDependencyChain(manifest, context),
+        ]);
+        if (!compatResult.Compatible) {
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, compatResult.Message ?? 'Incompatible MJ version');
+        }
+        if (!depResult.Success) {
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, depResult.ErrorMessage ?? 'Dependency resolution failed');
+        }
+        if (depResult.DepsToInstall && depResult.DepsToInstall.length > 0) {
+            const depsResult = await InstallDependencies(depResult.DepsToInstall, context);
+            if (!depsResult.Success) {
+                return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, depsResult.ErrorMessage ?? 'Dependency installation failed');
+            }
+        }
+        const existingApp = await FindInstalledApp(context.ContextUser, manifest.name);
+        const isReinstall = existingApp != null && existingApp.Status === 'Removed';
+        if (existingApp && !isReinstall) {
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, `App '${manifest.name}' is already installed with status '${existingApp.Status}'. Use 'mj app upgrade' to update it.`);
+        }
+        Callbacks?.OnProgress?.('Install', `Installing ${manifest.name} v${manifest.version}...`);
+        let schemaCreated = false;
+        if (manifest.schema) {
+            const schemaResult = await HandleSchemaCreation(manifest, context, isReinstall);
+            if (!schemaResult.Success) {
+                return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, schemaResult.ErrorMessage ?? 'Schema creation failed');
+            }
+            schemaCreated = !isReinstall;
+        }
+        if (manifest.migrations && manifest.schema) {
+            const migrationResult = await HandleMigrations(manifest, context);
+            if (!migrationResult.Success) {
+                await CompensateSchemaOnFailure(manifest, context, schemaCreated, Callbacks);
+                return BuildFailureResult('Install', manifest.name, manifest.version, 'Migration', startTime, migrationResult.ErrorMessage ?? 'Migration failed');
+            }
+        }
+        Callbacks?.OnProgress?.('Record', 'Recording app installation...');
+        const recordResult = await RecordInstallationAtomically(context.ContextUser, manifest, Callbacks);
+        if (!recordResult.Success) {
+            await CompensateSchemaOnFailure(manifest, context, schemaCreated, Callbacks);
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Record', startTime, recordResult.ErrorMessage ?? 'Failed to record installation');
+        }
+        createdAppId = recordResult.AppId;
+        Callbacks?.OnProgress?.('Config', 'Updating configuration files...');
+        const pkgResult = await HandlePackageInstallation(manifest, context);
+        if (!pkgResult.Success) {
+            await SetAppStatus(context.ContextUser, createdAppId, 'Error');
+            await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Packages', pkgResult.ErrorMessage ?? 'Package installation failed', startTime);
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Packages', startTime, pkgResult.ErrorMessage ?? 'Package installation failed');
+        }
+        const configResult = HandleServerConfig(manifest, context);
+        if (!configResult.Success) {
+            await SetAppStatus(context.ContextUser, createdAppId, 'Error');
+            await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Config', configResult.ErrorMessage ?? 'Config update failed', startTime);
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Config', startTime, configResult.ErrorMessage ?? 'Config update failed');
+        }
+        await HandleClientBootstrapRegeneration(context);
+        if (manifest.hooks?.postInstall) {
+            Callbacks?.OnProgress?.('Hooks', 'Running postInstall hook...');
+            await ExecuteHook(manifest.hooks.postInstall, context.RepoRoot);
+        }
+        Callbacks?.OnProgress?.('Record', 'Finalizing installation...');
+        await SetAppStatus(context.ContextUser, createdAppId, 'Active');
+        await RecordInstallHistoryEntry(context.ContextUser, createdAppId, 'Install', manifest, {
+            Success: true,
+            DurationSeconds: GetDurationSeconds(startTime),
+            StartedAt: new Date(startTime),
+            EndedAt: new Date(),
+            Summary: 'Initial installation',
+        });
+        Callbacks?.OnSuccess?.('Install', `Successfully installed ${manifest.name} v${manifest.version}`);
+        return {
+            Success: true,
+            Action: 'Install',
+            AppName: manifest.name,
+            Version: manifest.version,
+            DurationSeconds: GetDurationSeconds(startTime),
+            Summary: 'App installed successfully. Restart MJAPI and rebuild MJExplorer to activate.',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (createdAppId && manifest) {
+            try {
+                await RecordFailureHistory(context.ContextUser, createdAppId, 'Install', manifest, 'Schema', message, startTime);
+                await SetAppStatus(context.ContextUser, createdAppId, 'Error');
+            }
+            catch {
+            }
+        }
+        Callbacks?.OnError?.('Install', message);
+        return BuildFailureResult('Install', options.Source, '', 'Schema', startTime, message);
+    }
+}
+async function RecordInstallationAtomically(contextUser, manifest, callbacks) {
+    const md = new Metadata();
+    const tg = await md.CreateTransactionGroup();
+    try {
+        const appId = await RecordAppInstallation(contextUser, manifest, callbacks, tg, 'Installing');
+        if (manifest.dependencies) {
+            await RecordAppDependencies(contextUser, appId, manifest.dependencies, tg);
+        }
+        callbacks?.OnProgress?.('Record', 'Committing installation records...');
+        const success = await tg.Submit();
+        if (!success) {
+            return { Success: false, ErrorMessage: 'Transaction failed: one or more records could not be saved' };
+        }
+        return { Success: true, AppId: appId };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { Success: false, ErrorMessage: `Transaction failed: ${message}` };
+    }
+}
+async function CompensateSchemaOnFailure(manifest, context, schemaWasCreated, callbacks) {
+    if (!schemaWasCreated || !manifest.schema) {
+        return;
+    }
+    try {
+        callbacks?.OnProgress?.('Rollback', `Rolling back: dropping schema '${manifest.schema.name}'...`);
+        await DropAppSchema(manifest.schema.name, context.DatabaseProvider);
+        callbacks?.OnProgress?.('Rollback', `Schema '${manifest.schema.name}' dropped successfully`);
+    }
+    catch (rollbackError) {
+        const msg = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+        callbacks?.OnError?.('Rollback', `Failed to drop schema '${manifest.schema.name}' during rollback: ${msg}`);
+    }
+}
+export async function UpgradeApp(options, context) {
+    const startTime = Date.now();
+    const { Callbacks } = context;
+    let upgradeAppId;
+    let manifest;
+    let previousVersion = '';
+    try {
+        const existingApp = await FindInstalledApp(context.ContextUser, options.AppName);
+        if (!existingApp) {
+            return BuildFailureResult('Upgrade', options.AppName, '', 'Schema', startTime, `App '${options.AppName}' is not installed`);
+        }
+        upgradeAppId = existingApp.ID;
+        previousVersion = existingApp.Version;
+        const targetVersion = options.Version ?? (await GetLatestVersion(existingApp.RepositoryURL, context.GitHubOptions));
+        if (!targetVersion) {
+            return BuildFailureResult('Upgrade', options.AppName, '', 'Schema', startTime, 'Could not determine target version');
+        }
+        const upgradeCheck = IsValidUpgrade(previousVersion, targetVersion);
+        if (!upgradeCheck.Compatible) {
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, upgradeCheck.Message ?? 'Invalid upgrade version');
+        }
+        Callbacks?.OnProgress?.('Fetch', `Fetching manifest for ${options.AppName} v${targetVersion}...`);
+        const fetchResult = await FetchManifestFromGitHub(existingApp.RepositoryURL, targetVersion, context.GitHubOptions);
+        if (!fetchResult.Success || !fetchResult.ManifestJSON) {
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, fetchResult.ErrorMessage ?? 'Failed to fetch manifest');
+        }
+        const parseResult = ParseAndValidateManifest(fetchResult.ManifestJSON);
+        if (!parseResult.Success || !parseResult.Manifest) {
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, `Invalid manifest: ${parseResult.Errors?.join(', ')}`);
+        }
+        manifest = parseResult.Manifest;
+        const compatResult = CheckMJVersionCompatibility(context.MJVersion, manifest.mjVersionRange);
+        if (!compatResult.Compatible) {
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, compatResult.Message ?? 'Incompatible MJ version');
+        }
+        if (manifest.dependencies && Object.keys(manifest.dependencies).length > 0) {
+            const depResult = await ResolveDependencyChain(manifest, context);
+            if (!depResult.Success) {
+                return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, depResult.ErrorMessage ?? 'Dependency check failed for upgrade');
+            }
+            if (depResult.DepsToInstall && depResult.DepsToInstall.length > 0) {
+                const installResult = await InstallDependencies(depResult.DepsToInstall, context);
+                if (!installResult.Success) {
+                    return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, installResult.ErrorMessage ?? 'Failed to install new dependencies for upgrade');
+                }
+            }
+        }
+        await SetAppStatus(context.ContextUser, existingApp.ID, 'Upgrading');
+        if (manifest.migrations && manifest.schema) {
+            const migrationResult = await HandleMigrations(manifest, context);
+            if (!migrationResult.Success) {
+                await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Migration', migrationResult.ErrorMessage ?? 'Migration failed', startTime, previousVersion);
+                await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
+                return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Migration', startTime, migrationResult.ErrorMessage ?? 'Migration failed');
+            }
+        }
+        const pkgResult = await HandlePackageInstallation(manifest, context);
+        if (!pkgResult.Success) {
+            await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Packages', pkgResult.ErrorMessage ?? 'Package update failed', startTime, previousVersion);
+            await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Packages', startTime, pkgResult.ErrorMessage ?? 'Package update failed');
+        }
+        const configResult = HandleServerConfig(manifest, context);
+        if (!configResult.Success) {
+            await RecordFailureHistory(context.ContextUser, existingApp.ID, 'Upgrade', manifest, 'Config', configResult.ErrorMessage ?? 'Config update failed', startTime, previousVersion);
+            await SetAppStatus(context.ContextUser, existingApp.ID, 'Error');
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Config', startTime, configResult.ErrorMessage ?? 'Config update failed');
+        }
+        await HandleClientBootstrapRegeneration(context);
+        if (manifest.hooks?.postUpgrade) {
+            Callbacks?.OnProgress?.('Hooks', 'Running postUpgrade hook...');
+            await ExecuteHook(manifest.hooks.postUpgrade, context.RepoRoot);
+        }
+        await UpdateAppRecord(context.ContextUser, existingApp.ID, {
+            Version: manifest.version,
+            ManifestJSON: JSON.stringify(manifest),
+            Status: 'Active',
+        });
+        if (manifest.dependencies) {
+            await DeleteAppDependencies(context.ContextUser, existingApp.ID);
+            await RecordAppDependencies(context.ContextUser, existingApp.ID, manifest.dependencies);
+        }
+        await RecordInstallHistoryEntry(context.ContextUser, existingApp.ID, 'Upgrade', manifest, {
+            PreviousVersion: previousVersion,
+            Success: true,
+            DurationSeconds: GetDurationSeconds(startTime),
+            StartedAt: new Date(startTime),
+            EndedAt: new Date(),
+            Summary: `Upgraded from ${previousVersion} to ${manifest.version}`,
+        });
+        Callbacks?.OnSuccess?.('Upgrade', `Successfully upgraded ${options.AppName} to v${manifest.version}`);
+        return {
+            Success: true,
+            Action: 'Upgrade',
+            AppName: options.AppName,
+            Version: manifest.version,
+            DurationSeconds: GetDurationSeconds(startTime),
+            Summary: `Upgraded from ${previousVersion} to ${manifest.version}. Restart MJAPI and rebuild MJExplorer.`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (upgradeAppId) {
+            try {
+                if (manifest) {
+                    await RecordFailureHistory(context.ContextUser, upgradeAppId, 'Upgrade', manifest, 'Schema', message, startTime, previousVersion);
+                }
+                await SetAppStatus(context.ContextUser, upgradeAppId, 'Error');
+            }
+            catch {
+            }
+        }
+        Callbacks?.OnError?.('Upgrade', message);
+        return BuildFailureResult('Upgrade', options.AppName, '', 'Schema', startTime, message);
+    }
+}
+export async function RemoveApp(options, context) {
+    const startTime = Date.now();
+    const { Callbacks } = context;
+    let removeAppId;
+    let removeManifest;
+    try {
+        const existingApp = await FindInstalledApp(context.ContextUser, options.AppName);
+        if (!existingApp) {
+            return BuildFailureResult('Remove', options.AppName, '', 'Schema', startTime, `App '${options.AppName}' is not installed`);
+        }
+        removeAppId = existingApp.ID;
+        if (!options.Force) {
+            const dependents = await FindDependentApps(context.ContextUser, options.AppName);
+            if (dependents.length > 0) {
+                return BuildFailureResult('Remove', options.AppName, existingApp.Version, 'Schema', startTime, `Cannot remove: the following apps depend on ${options.AppName}: ${dependents.join(', ')}. Use --force to override.`);
+            }
+        }
+        await SetAppStatus(context.ContextUser, existingApp.ID, 'Removing');
+        removeManifest = JSON.parse(existingApp.ManifestJSON);
+        const manifest = removeManifest;
+        if (manifest.hooks?.preRemove) {
+            Callbacks?.OnProgress?.('Hooks', 'Running preRemove hook...');
+            await ExecuteHook(manifest.hooks.preRemove, context.RepoRoot);
+        }
+        Callbacks?.OnProgress?.('Config', 'Removing config, client bootstrap, and package references...');
+        await Promise.all([
+            Promise.resolve(RemoveServerDynamicPackages(context.RepoRoot, options.AppName)),
+            HandleClientBootstrapRegeneration(context),
+            Promise.resolve(RemoveAppPackages({
+                RepoRoot: context.RepoRoot,
+                ServerPackages: manifest.packages?.server ?? [],
+                ClientPackages: manifest.packages?.client ?? [],
+                SharedPackages: manifest.packages?.shared ?? [],
+                Version: existingApp.Version,
+            })),
+        ]);
+        Callbacks?.OnProgress?.('Packages', 'Running npm install...');
+        const npmResult = RunNpmInstall(context.RepoRoot, options.Verbose);
+        if (!npmResult.Success) {
+            Callbacks?.OnWarn?.('Packages', `npm install warning during removal: ${npmResult.ErrorMessage}`);
+        }
+        if (existingApp.SchemaName) {
+            Callbacks?.OnProgress?.('Metadata', `Removing entity metadata for schema '${existingApp.SchemaName}'...`);
+            await RemoveAppEntityMetadata(existingApp.SchemaName, context.ContextUser, Callbacks);
+        }
+        if (!options.KeepData && existingApp.SchemaName) {
+            Callbacks?.OnProgress?.('Schema', `Dropping schema '${existingApp.SchemaName}'...`);
+            const dropResult = await DropAppSchema(existingApp.SchemaName, context.DatabaseProvider);
+            if (!dropResult.Success) {
+                Callbacks?.OnWarn?.('Schema', `Failed to drop schema: ${dropResult.ErrorMessage}`);
+            }
+        }
+        await RecordInstallHistoryEntry(context.ContextUser, existingApp.ID, 'Remove', manifest, {
+            Success: true,
+            DurationSeconds: GetDurationSeconds(startTime),
+            StartedAt: new Date(startTime),
+            EndedAt: new Date(),
+            Summary: options.KeepData ? 'Removed (data kept)' : 'Removed (data dropped)',
+        });
+        await UpdateAppRecord(context.ContextUser, existingApp.ID, {
+            Status: 'Removed',
+        });
+        Callbacks?.OnSuccess?.('Remove', `Successfully removed ${options.AppName}`);
+        return {
+            Success: true,
+            Action: 'Remove',
+            AppName: options.AppName,
+            Version: existingApp.Version,
+            DurationSeconds: GetDurationSeconds(startTime),
+            Summary: options.KeepData ? 'App removed (database schema preserved)' : 'App removed',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (removeAppId) {
+            try {
+                if (removeManifest) {
+                    await RecordFailureHistory(context.ContextUser, removeAppId, 'Remove', removeManifest, 'Schema', message, startTime);
+                }
+                await SetAppStatus(context.ContextUser, removeAppId, 'Error');
+            }
+            catch {
+            }
+        }
+        Callbacks?.OnError?.('Remove', message);
+        return BuildFailureResult('Remove', options.AppName, '', 'Schema', startTime, message);
+    }
+}
+export async function DisableApp(appName, context) {
+    const startTime = Date.now();
+    const app = await FindInstalledApp(context.ContextUser, appName);
+    if (!app) {
+        return BuildFailureResult('Install', appName, '', 'Config', startTime, `App '${appName}' is not installed`);
+    }
+    ToggleServerDynamicPackages(context.RepoRoot, appName, false);
+    await HandleClientBootstrapRegeneration(context);
+    await SetAppStatus(context.ContextUser, app.ID, 'Disabled');
+    return {
+        Success: true,
+        Action: 'Install',
+        AppName: appName,
+        Version: app.Version,
+        DurationSeconds: GetDurationSeconds(startTime),
+        Summary: 'App disabled. Restart MJAPI and rebuild MJExplorer.',
+    };
+}
+export async function EnableApp(appName, context) {
+    const startTime = Date.now();
+    const app = await FindInstalledApp(context.ContextUser, appName);
+    if (!app) {
+        return BuildFailureResult('Install', appName, '', 'Config', startTime, `App '${appName}' is not installed`);
+    }
+    ToggleServerDynamicPackages(context.RepoRoot, appName, true);
+    await HandleClientBootstrapRegeneration(context);
+    await SetAppStatus(context.ContextUser, app.ID, 'Active');
+    return {
+        Success: true,
+        Action: 'Install',
+        AppName: appName,
+        Version: app.Version,
+        DurationSeconds: GetDurationSeconds(startTime),
+        Summary: 'App enabled. Restart MJAPI and rebuild MJExplorer.',
+    };
+}
+async function ResolveDependencyChain(manifest, context) {
+    if (!manifest.dependencies || Object.keys(manifest.dependencies).length === 0) {
+        return { Success: true };
+    }
+    context.Callbacks?.OnProgress?.('Dependencies', 'Resolving dependencies...');
+    const installedApps = await ListInstalledApps(context.ContextUser);
+    const installedMap = {};
+    for (const app of installedApps) {
+        installedMap[app.Name] = { Version: app.Version, Repository: app.RepositoryURL };
+    }
+    const rootNode = {
+        AppName: manifest.name,
+        Repository: manifest.repository,
+        Dependencies: manifest.dependencies,
+    };
+    const result = ResolveDependencies(rootNode, installedMap);
+    if (!result.Success) {
+        return { Success: false, ErrorMessage: result.ErrorMessage };
+    }
+    const depsToInstall = (result.InstallOrder ?? [])
+        .filter((d) => !d.AlreadyInstalled)
+        .map((d) => ({ AppName: d.AppName, Repository: d.Repository, VersionRange: d.VersionRange }));
+    return { Success: true, DepsToInstall: depsToInstall };
+}
+async function InstallDependencies(deps, context) {
+    for (const dep of deps) {
+        if (!dep.Repository) {
+            return {
+                Success: false,
+                ErrorMessage: `Dependency '${dep.AppName}' is not installed and no repository URL was provided in the manifest. Use the object form: { "version": "${dep.VersionRange}", "repository": "https://github.com/..." }`,
+            };
+        }
+        context.Callbacks?.OnProgress?.('Dependencies', `Installing dependency from ${dep.Repository}...`);
+        const result = await InstallApp({ Source: dep.Repository }, context);
+        if (!result.Success) {
+            return { Success: false, ErrorMessage: `Failed to install dependency: ${result.ErrorMessage}` };
+        }
+    }
+    return { Success: true };
+}
+async function HandleSchemaCreation(manifest, context, isReinstall = false) {
+    if (!manifest.schema) {
+        return { Success: true };
+    }
+    context.Callbacks?.OnProgress?.('Schema', `Checking schema '${manifest.schema.name}'...`);
+    const exists = await SchemaExists(manifest.schema.name, context.DatabaseProvider);
+    if (exists) {
+        if (isReinstall) {
+            context.Callbacks?.OnProgress?.('Schema', `Reusing existing schema '${manifest.schema.name}'`);
+            return { Success: true };
+        }
+        return { Success: false, ErrorMessage: `Schema '${manifest.schema.name}' already exists` };
+    }
+    if (manifest.schema.createIfNotExists !== false) {
+        context.Callbacks?.OnProgress?.('Schema', `Creating schema '${manifest.schema.name}'...`);
+        const result = await CreateAppSchema(manifest.schema.name, context.DatabaseProvider);
+        return { Success: result.Success, ErrorMessage: result.ErrorMessage };
+    }
+    return { Success: false, ErrorMessage: `Schema '${manifest.schema.name}' does not exist and createIfNotExists is false` };
+}
+async function HandleMigrations(manifest, context) {
+    if (!manifest.schema || !manifest.migrations) {
+        return { Success: true };
+    }
+    context.Callbacks?.OnProgress?.('Migration', 'Downloading migration files...');
+    const tempDir = join(tmpdir(), `mj-app-${manifest.name}-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    const downloadResult = await DownloadMigrations(manifest.repository, manifest.version, manifest.migrations.directory, tempDir, context.GitHubOptions);
+    if (!downloadResult.Success) {
+        return { Success: false, ErrorMessage: downloadResult.ErrorMessage };
+    }
+    context.Callbacks?.OnProgress?.('Migration', `Running ${downloadResult.Files?.length ?? 0} migration(s)...`);
+    const migrationResult = await RunAppMigrations({
+        MigrationsDir: tempDir,
+        SchemaName: manifest.schema.name,
+        DatabaseConfig: context.DatabaseConfig,
+    });
+    return { Success: migrationResult.Success, ErrorMessage: migrationResult.ErrorMessage };
+}
+async function HandlePackageInstallation(manifest, context) {
+    if (!manifest.packages) {
+        return { Success: true };
+    }
+    context.Callbacks?.OnProgress?.('Packages', 'Adding npm packages...');
+    const addResult = AddAppPackages({
+        RepoRoot: context.RepoRoot,
+        ServerPackages: manifest.packages.server ?? [],
+        ClientPackages: manifest.packages.client ?? [],
+        SharedPackages: manifest.packages.shared ?? [],
+        Version: manifest.version,
+    });
+    if (!addResult.Success) {
+        return { Success: false, ErrorMessage: addResult.ErrorMessage };
+    }
+    context.Callbacks?.OnProgress?.('Packages', 'Running npm install...');
+    const installResult = RunNpmInstall(context.RepoRoot, undefined, manifest.packages.registry);
+    return { Success: installResult.Success, ErrorMessage: installResult.ErrorMessage };
+}
+function HandleServerConfig(manifest, context) {
+    context.Callbacks?.OnProgress?.('Config', 'Updating server config...');
+    const result = AddServerDynamicPackages(context.RepoRoot, manifest);
+    return { Success: result.Success, ErrorMessage: result.ErrorMessage };
+}
+async function HandleClientBootstrapRegeneration(context) {
+    context.Callbacks?.OnProgress?.('Config', 'Regenerating client bootstrap...');
+    const apps = await ListInstalledApps(context.ContextUser);
+    const appDeps = new Map();
+    for (const app of apps) {
+        const manifest = JSON.parse(app.ManifestJSON);
+        const depNames = manifest.dependencies ? Object.keys(manifest.dependencies) : [];
+        appDeps.set(app.Name, depNames);
+    }
+    const sortedNames = TopologicalSortApps(appDeps);
+    const entries = [];
+    const appsByName = new Map(apps.map((a) => [a.Name, a]));
+    for (const name of sortedNames) {
+        const app = appsByName.get(name);
+        if (!app)
+            continue;
+        const manifest = JSON.parse(app.ManifestJSON);
+        const clientPkgs = [...(manifest.packages?.client ?? []), ...(manifest.packages?.shared ?? [])];
+        for (const pkg of clientPkgs) {
+            entries.push({
+                AppName: app.Name,
+                Version: app.Version,
+                PackageName: pkg.name,
+                Enabled: app.Status === 'Active',
+            });
+        }
+    }
+    RegenerateClientBootstrap(context.RepoRoot, entries);
+}
+function TopologicalSortApps(appDeps) {
+    const visited = new Set();
+    const result = [];
+    function Visit(name) {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        const deps = appDeps.get(name) ?? [];
+        for (const dep of deps) {
+            if (appDeps.has(dep)) {
+                Visit(dep);
+            }
+        }
+        result.push(name);
+    }
+    for (const name of appDeps.keys()) {
+        Visit(name);
+    }
+    return result;
+}
+async function ExecuteHook(command, cwd) {
+    const { execSync } = await import('node:child_process');
+    execSync(command, { cwd, encoding: 'utf-8', timeout: 120000, stdio: 'inherit' });
+}
+async function RemoveAppEntityMetadata(schemaName, contextUser, callbacks) {
+    try {
+        const rv = new RunView();
+        const escaped = EscapeSqlString(schemaName);
+        const entityResult = await rv.RunView({
+            EntityName: 'MJ: Entities',
+            ExtraFilter: `SchemaName = '${escaped}'`,
+            ResultType: 'entity_object',
+        }, contextUser);
+        if (!entityResult.Success || entityResult.Results.length === 0) {
+            await DeleteEntitiesByFilter(rv, contextUser, 'MJ: Schema Info', `SchemaName = '${escaped}'`);
+            callbacks?.OnSuccess?.('Metadata', `Entity metadata for schema '${schemaName}' removed`);
+            return;
+        }
+        const entityIds = entityResult.Results.map((e) => String(e.Get('ID')));
+        const idList = entityIds.map((id) => `'${EscapeSqlString(id)}'`).join(',');
+        const entityIdFilter = `EntityID IN (${idList})`;
+        await Promise.all([
+            DeleteEntitiesByFilter(rv, contextUser, 'MJ: Entity Permissions', entityIdFilter),
+            DeleteEntitiesByFilter(rv, contextUser, 'MJ: Application Entities', entityIdFilter),
+        ]);
+        await DeleteEntitiesByFilter(rv, contextUser, 'MJ: Entity Relationships', `EntityID IN (${idList}) OR RelatedEntityID IN (${idList})`);
+        await DeleteEntitiesByFilter(rv, contextUser, 'MJ: Entity Fields', `EntityID IN (${idList})`);
+        for (const entity of entityResult.Results) {
+            await entity.Delete();
+        }
+        await DeleteEntitiesByFilter(rv, contextUser, 'MJ: Schema Info', `SchemaName = '${escaped}'`);
+        callbacks?.OnSuccess?.('Metadata', `Entity metadata for schema '${schemaName}' removed`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        callbacks?.OnWarn?.('Metadata', `Failed to remove entity metadata: ${message}`);
+    }
+}
+async function DeleteEntitiesByFilter(rv, contextUser, entityName, filter) {
+    const result = await rv.RunView({
+        EntityName: entityName,
+        ExtraFilter: filter,
+        ResultType: 'entity_object',
+    }, contextUser);
+    if (result.Success) {
+        for (const record of result.Results) {
+            await record.Delete();
+        }
+    }
+}
+function GetDurationSeconds(startTime) {
+    return Math.round((Date.now() - startTime) / 1000);
+}
+function BuildFailureResult(action, appName, version, errorPhase, startTime, errorMessage) {
+    return {
+        Success: false,
+        Action: action,
+        AppName: appName,
+        Version: version,
+        ErrorMessage: errorMessage,
+        ErrorPhase: errorPhase,
+        DurationSeconds: GetDurationSeconds(startTime),
+    };
+}
+async function RecordFailureHistory(contextUser, appId, action, manifest, errorPhase, errorMessage, startTime, previousVersion) {
+    try {
+        await RecordInstallHistoryEntry(contextUser, appId, action, manifest, {
+            PreviousVersion: previousVersion,
+            Success: false,
+            ErrorPhase: errorPhase,
+            ErrorMessage: errorMessage,
+            DurationSeconds: GetDurationSeconds(startTime),
+            StartedAt: new Date(startTime),
+            EndedAt: new Date(),
+            Summary: `Failed during ${errorPhase} phase: ${errorMessage}`,
+        });
+    }
+    catch {
+    }
+}
+//# sourceMappingURL=install-orchestrator.js.map