@memberjunction/open-app-engine 6.2.0-edge.6 → 6.2.0-edge.8

package/dist/install/install-orchestrator.js

@@ -12,7 +12,7 @@ import { OfferTemplateUser } from './template-user.js';
 import { ExtractApplicationIds } from './migration-application-ids.js';
 import { CreateAppTempDir } from './temp-dir.js';
 import { RunAppMigrations } from './migration-runner.js';
-import { AddAppPackages, RemoveAppPackages, RunPackageInstallAsync, BumpPrefixedDependencies } from './package-manager.js';
+import { AddAppPackages, RemoveAppPackages, RunPackageInstallAsync, BumpPrefixedDependencies, PreflightAppPackages } from './package-manager.js';
 import { BuildHookResolutionBases, ResolveHookModule } from './hook-module-resolver.js';
 import { AddServerDynamicPackages, AddClientDynamicPackages, RemoveServerDynamicPackages, PruneDynamicPackagesNotInManifest, ToggleServerDynamicPackages, AddEntityPackageMapping, RemoveEntityPackageMapping, AddExcludeSchema, RemoveExcludeSchema } from './config-manager.js';
 import { AngularConfigManager } from './angular-config-manager.js';
@@ -56,6 +56,7 @@ export async function InstallApp(options, context) {
     const { Callbacks } = context;
     let createdAppId;
     let manifest;
+    let teardownScripts;
     const subpath = options.Subpath ?? ParseGitHubUrl(options.Source)?.Subpath;
     try {
         const explicitVersion = options.Version;
@@ -84,6 +85,10 @@ export async function InstallApp(options, context) {
         if (!compatResult.Compatible) {
             return BuildFailureResult('Install', manifest.name, manifest.version, 'Schema', startTime, compatResult.Message ?? 'Incompatible MJ version');
         }
+        const preflight = await PreflightManifestPackages(manifest, context, effectivePackageVersion, effectiveVersionStrategy);
+        if (!preflight.Success) {
+            return BuildFailureResult('Install', manifest.name, manifest.version, 'Packages', startTime, preflight.ErrorMessage ?? 'Package preflight failed');
+        }
         if (!options._skipDependencyResolution) {
             const depResult = await ResolveDependencyChain(manifest, context);
             if (!depResult.Success) {
@@ -138,16 +143,19 @@ export async function InstallApp(options, context) {
                 await PersistCanonicalSchemaName(manifest, context);
             }
             if (manifest.migrations && manifest.schema) {
+                if (schemaCreated) {
+                    teardownScripts = await PrefetchTeardownScripts(manifest, context, subpath);
+                }
                 const migrationResult = await HandleMigrations(manifest, context, subpath);
                 if (!migrationResult.Success) {
-                    await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks, subpath);
+                    await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks, subpath, teardownScripts);
                     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, undefined, subpath);
             if (!recordResult.Success) {
-                await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks, subpath);
+                await CompensateSchemaOnFailure(manifest, context, schemaCreated, options.AllowDoubleUnderscoreSchema === true, Callbacks, subpath, teardownScripts);
                 return BuildFailureResult('Install', manifest.name, manifest.version, 'Record', startTime, recordResult.ErrorMessage ?? 'Failed to record installation');
             }
             createdAppId = recordResult.AppId;
@@ -267,6 +275,9 @@ export async function InstallApp(options, context) {
         Callbacks?.OnError?.('Install', message);
         return BuildFailureResult('Install', options.Source, '', phase, startTime, message);
     }
+    finally {
+        ReleaseTeardownScripts(teardownScripts, context);
+    }
 }
 async function RecordInstallationAtomically(contextUser, manifest, callbacks, provider, subpath) {
     const md = (provider ?? new Metadata());
@@ -289,7 +300,7 @@ async function RecordInstallationAtomically(contextUser, manifest, callbacks, pr
         return { Success: false, ErrorMessage: `Transaction failed: ${message}` };
     }
 }
-async function CompensateSchemaOnFailure(manifest, context, schemaWasCreated, allowDoubleUnderscore, callbacks, subpath) {
+async function CompensateSchemaOnFailure(manifest, context, schemaWasCreated, allowDoubleUnderscore, callbacks, subpath, teardownScripts) {
     if (!schemaWasCreated || !manifest.schema) {
         return;
     }
@@ -310,37 +321,65 @@ async function CompensateSchemaOnFailure(manifest, context, schemaWasCreated, al
         const msg = error instanceof Error ? error.message : String(error);
         callbacks?.OnError?.('Rollback', `Failed to remove entity metadata for '${schemaName}' during rollback: ${msg}`);
     }
-    if (manifest.migrations?.teardownDirectory) {
-        try {
-            const teardownResult = await HandleTeardown(manifest, context, subpath);
-            if (!teardownResult.Success) {
-                callbacks?.OnError?.('Rollback', `Teardown failed during rollback: ${teardownResult.ErrorMessage ?? 'unknown error'}`);
-            }
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            callbacks?.OnError?.('Rollback', `Teardown failed during rollback: ${msg}`);
+    const dropOptions = { allowDoubleUnderscore, CoreSchema: context.MJCoreSchema };
+    if (!manifest.migrations?.teardownDirectory) {
+        if (manifest.migrations) {
+            callbacks?.OnWarn?.('Rollback', `'${manifest.name}' declares migrations but no teardownDirectory — rows its migrations wrote to the shared core schema WILL remain after this rollback. ` +
+                `If those rows were seeded with fixed IDs, reinstalling this app may fail with a primary-key violation until they are removed manually.`);
         }
+        await DropSchemaAndReport(schemaName, manifest.name, 'Rollback', dropOptions, context);
+        return;
     }
-    else if (manifest.migrations) {
-        callbacks?.OnWarn?.('Rollback', `'${manifest.name}' declares migrations but no teardownDirectory — rows its migrations wrote to the shared core schema WILL remain after this rollback. ` +
-            `If those rows were seeded with fixed IDs, reinstalling this app may fail with a primary-key violation until they are removed manually.`);
+    const firstAttempt = await RunRollbackTeardown(manifest, context, teardownScripts, subpath);
+    const dropResult = await DropSchemaAndReport(schemaName, manifest.name, 'Rollback', dropOptions, context);
+    if (firstAttempt.Success) {
+        return;
     }
+    if (!dropResult.Success) {
+        callbacks?.OnError?.('Rollback', `Teardown failed during rollback: ${firstAttempt.ErrorMessage ?? 'unknown error'}`);
+        return;
+    }
+    callbacks?.OnProgress?.('Rollback', `Teardown failed with schema '${schemaName}' in place; running it again now that the schema is dropped...`);
+    const secondAttempt = await RunRollbackTeardown(manifest, context, teardownScripts, subpath);
+    if (!secondAttempt.Success) {
+        callbacks?.OnError?.('Rollback', `Teardown failed during rollback, before and after dropping schema '${schemaName}'. ` +
+            `With the schema: ${firstAttempt.ErrorMessage ?? 'unknown error'}. Without it: ${secondAttempt.ErrorMessage ?? 'unknown error'}`);
+    }
+}
+async function RunRollbackTeardown(manifest, context, teardownScripts, subpath) {
     try {
-        callbacks?.OnProgress?.('Rollback', `Dropping schema '${schemaName}'...`);
-        const dropResult = await DropAppSchema(schemaName, context.DatabaseProvider, { allowDoubleUnderscore });
-        if (!dropResult.Success) {
-            callbacks?.OnError?.('Rollback', `Failed to drop schema '${schemaName}' during rollback: ${dropResult.ErrorMessage ?? 'unknown error'}`);
-        }
-        else {
-            callbacks?.OnProgress?.('Rollback', `Schema '${schemaName}' dropped successfully`);
-        }
+        return teardownScripts
+            ? await RunTeardownScripts(manifest, context, teardownScripts)
+            : await HandleTeardown(manifest, context, subpath);
     }
-    catch (rollbackError) {
-        const msg = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
-        callbacks?.OnError?.('Rollback', `Failed to drop schema '${schemaName}' during rollback: ${msg}`);
+    catch (error) {
+        return { Success: false, ErrorMessage: error instanceof Error ? error.message : String(error) };
     }
 }
+export async function DropSchemaAndReport(schemaName, appName, phase, options, context) {
+    const callbacks = context.Callbacks;
+    const nameCheck = ValidateSchemaName(schemaName, options);
+    if (!nameCheck.Success) {
+        const refusal = BuildSchemaDropRefusalMessage(nameCheck, appName, schemaName);
+        callbacks?.OnError?.(phase, refusal);
+        return { Success: false, ErrorMessage: refusal };
+    }
+    callbacks?.OnProgress?.(phase, `Dropping schema '${schemaName}'...`);
+    let result;
+    try {
+        result = await DropAppSchema(schemaName, context.DatabaseProvider, options);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result = { Success: false, ErrorMessage: `Failed to drop schema '${schemaName}': ${message}` };
+    }
+    if (!result.Success) {
+        callbacks?.OnError?.(phase, `Schema '${schemaName}' was not dropped: ${result.ErrorMessage ?? 'unknown error'}`);
+        return result;
+    }
+    callbacks?.OnProgress?.(phase, `Schema '${schemaName}' dropped successfully`);
+    return result;
+}
 export async function UpgradeApp(options, context) {
     const startTime = Date.now();
     const { Callbacks } = context;
@@ -401,6 +440,7 @@ export async function UpgradeApp(options, context) {
         if (manifest.schema) {
             const schemaValidation = ValidateSchemaName(manifest.schema.name, {
                 allowDoubleUnderscore: options.AllowDoubleUnderscoreSchema === true,
+                CoreSchema: context.MJCoreSchema,
             });
             if (!schemaValidation.Success) {
                 return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, schemaValidation.ErrorMessage ?? 'Invalid schema name');
@@ -412,6 +452,12 @@ export async function UpgradeApp(options, context) {
                 return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Schema', startTime, migratable.ErrorMessage ?? 'Cannot run migrations in the app schema');
             }
         }
+        const effectiveUpgradeVersion = explicitUpgradeVersion ? targetVersion.replace(/^v/, '') : manifest.version;
+        const effectiveUpgradeStrategy = explicitUpgradeVersion ? 'exact' : context.VersionStrategy;
+        const preflight = await PreflightManifestPackages(manifest, context, effectiveUpgradeVersion, effectiveUpgradeStrategy);
+        if (!preflight.Success) {
+            return BuildFailureResult('Upgrade', options.AppName, targetVersion, 'Packages', startTime, preflight.ErrorMessage ?? 'Package preflight failed');
+        }
         if (manifest.dependencies && Object.keys(manifest.dependencies).length > 0) {
             const depResult = await ResolveDependencyChain(manifest, context);
             if (!depResult.Success) {
@@ -455,8 +501,6 @@ export async function UpgradeApp(options, context) {
         }
         let npmInstallWarning;
         if (!IsStepDone(UPGRADE_STEP_ORDER, resumeCheckpoint, 'PackagesInstalled')) {
-            const effectiveUpgradeVersion = explicitUpgradeVersion ? targetVersion.replace(/^v/, '') : manifest.version;
-            const effectiveUpgradeStrategy = explicitUpgradeVersion ? 'exact' : context.VersionStrategy;
             const pkgResult = await HandlePackageInstallation(manifest, context, effectiveUpgradeVersion, effectiveUpgradeStrategy, options.Verbose);
             if (!pkgResult.Success) {
                 if (pkgResult.PackageJsonUpdated) {
@@ -668,23 +712,11 @@ export async function RemoveApp(options, context) {
             }
             let schemaDropError;
             if (!options.KeepData && existingApp.SchemaName && !schemaShared) {
-                const nameCheck = ValidateSchemaName(existingApp.SchemaName, {
+                const dropResult = await DropSchemaAndReport(existingApp.SchemaName, existingApp.Name, 'Schema', {
                     allowDoubleUnderscore: options.AllowDoubleUnderscoreSchema === true,
-                });
-                if (!nameCheck.Success) {
-                    schemaDropError = BuildSchemaDropRefusalMessage(nameCheck, existingApp.Name, existingApp.SchemaName);
-                    Callbacks?.OnError?.('Schema', schemaDropError);
-                }
-                else {
-                    Callbacks?.OnProgress?.('Schema', `Dropping schema '${existingApp.SchemaName}'...`);
-                    const dropResult = await DropAppSchema(existingApp.SchemaName, context.DatabaseProvider, {
-                        allowDoubleUnderscore: options.AllowDoubleUnderscoreSchema === true,
-                    });
-                    if (!dropResult.Success) {
-                        schemaDropError = dropResult.ErrorMessage;
-                        Callbacks?.OnError?.('Schema', `Failed to drop schema: ${dropResult.ErrorMessage}`);
-                    }
-                }
+                    CoreSchema: context.MJCoreSchema,
+                }, context);
+                schemaDropError = dropResult.Success ? undefined : dropResult.ErrorMessage;
             }
             const removalErrors = [
                 shareCheckError,
@@ -859,18 +891,18 @@ async function ResolveDependencyChain(manifest, context) {
         Repository: manifest.repository,
         Dependencies: dependencies,
     };
-    const result = await ResolveDependencyGraph(root, installedMap, BuildManifestFetcher(context));
+    const result = await ResolveDependencyGraph(root, installedMap, BuildManifestFetcher(context), (repoUrl, versionRange) => ResolveDependencyVersion(repoUrl, versionRange, context.GitHubOptions));
     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, Subpath: d.Subpath }));
+        .map((d) => ({ AppName: d.AppName, Repository: d.Repository, VersionRange: d.VersionRange, Subpath: d.Subpath, Version: d.ResolvedVersion }));
     return { Success: true, DepsToInstall: depsToInstall };
 }
 function BuildManifestFetcher(context) {
-    return async (repoUrl, subpath) => {
-        const fetched = await FetchManifestFromGitHub(repoUrl, undefined, context.GitHubOptions, subpath);
+    return async (repoUrl, subpath, version) => {
+        const fetched = await FetchManifestFromGitHub(repoUrl, version, context.GitHubOptions, subpath);
         if (!fetched.Success || !fetched.ManifestJSON) {
             return { Success: false, ErrorMessage: fetched.ErrorMessage ?? 'Failed to fetch manifest' };
         }
@@ -883,6 +915,7 @@ function BuildManifestFetcher(context) {
             Manifest: {
                 name: parsed.Manifest.name,
                 repository: parsed.Manifest.repository,
+                version: parsed.Manifest.version,
                 dependencies: (parsed.Manifest.dependencies ?? {}),
             },
         };
@@ -897,14 +930,10 @@ async function InstallDependencies(deps, context, inherited) {
             };
         }
         context.Callbacks?.OnProgress?.('Dependencies', `Installing dependency from ${dep.Repository}...`);
-        const resolved = await ResolveDependencyVersion(dep.Repository, dep.VersionRange, context.GitHubOptions);
-        if (resolved.ErrorMessage) {
-            return { Success: false, ErrorMessage: `Cannot install dependency '${dep.AppName}': ${resolved.ErrorMessage}` };
-        }
         const result = await InstallApp({
             Source: dep.Repository,
             Subpath: dep.Subpath,
-            Version: resolved.Version,
+            Version: dep.Version,
             _skipDependencyResolution: true,
             AllowDoubleUnderscoreSchema: inherited.AllowDoubleUnderscoreSchema,
             Verbose: inherited.Verbose,
@@ -961,7 +990,10 @@ async function HandleSchemaCreation(manifest, context, options) {
     if (!manifest.schema) {
         return { Success: true };
     }
-    const validation = ValidateSchemaName(manifest.schema.name, { allowDoubleUnderscore: options.AllowDoubleUnderscore });
+    const validation = ValidateSchemaName(manifest.schema.name, {
+        allowDoubleUnderscore: options.AllowDoubleUnderscore,
+        CoreSchema: context.MJCoreSchema,
+    });
     if (!validation.Success) {
         return { Success: false, ErrorMessage: validation.ErrorMessage };
     }
@@ -1058,6 +1090,18 @@ function CleanupTempDir(tempDir, phase, context) {
     }
 }
 async function HandleTeardown(manifest, context, subpath) {
+    const download = await DownloadTeardownScripts(manifest, context, subpath);
+    if (!download.Success || !download.Scripts) {
+        return download;
+    }
+    try {
+        return await RunTeardownScripts(manifest, context, download.Scripts);
+    }
+    finally {
+        ReleaseTeardownScripts(download.Scripts, context);
+    }
+}
+async function DownloadTeardownScripts(manifest, context, subpath) {
     const teardownDir = manifest.migrations?.teardownDirectory;
     if (!teardownDir) {
         return { Success: true };
@@ -1069,36 +1113,61 @@ async function HandleTeardown(manifest, context, subpath) {
         context.Callbacks?.OnProgress?.('Metadata', 'Downloading teardown scripts...');
         const download = await DownloadMigrations(manifest.repository, manifest.version, dir, tempDir, context.GitHubOptions, subpath, manifest.name);
         if (!download.Success) {
+            CleanupTempDir(tempDir, 'Metadata', context);
             return { Success: false, ErrorMessage: `Failed to download teardown scripts: ${download.ErrorMessage}` };
         }
         const files = (download.Files ?? []).filter((f) => f.endsWith('.sql')).sort();
-        if (files.length === 0) {
-            context.Callbacks?.OnWarn?.('Metadata', `No teardown scripts in '${dir}' — this app's rows in the shared core schema will NOT be retired on remove.`);
-            return { Success: true };
+        return { Success: true, Scripts: { TempDir: tempDir, SourceDir: dir, Files: files } };
+    }
+    catch (error) {
+        CleanupTempDir(tempDir, 'Metadata', context);
+        throw error;
+    }
+}
+async function PrefetchTeardownScripts(manifest, context, subpath) {
+    try {
+        const download = await DownloadTeardownScripts(manifest, context, subpath);
+        if (!download.Success) {
+            context.Callbacks?.OnWarn?.('Migration', `${download.ErrorMessage ?? 'Failed to download teardown scripts'}. A rollback will try to download them again.`);
         }
-        const mjSchema = context.MJCoreSchema ?? '__mj';
-        context.Callbacks?.OnProgress?.('Metadata', `Running ${files.length} teardown script(s) against '${mjSchema}'...`);
-        await context.DatabaseProvider.BeginTransaction();
-        try {
-            for (const file of files) {
-                const sql = readFileSync(join(tempDir, file), 'utf-8').split('${mjSchema}').join(mjSchema);
-                if (sql.trim()) {
-                    await context.DatabaseProvider.ExecuteSQL(sql);
-                }
+        return download.Scripts;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        context.Callbacks?.OnWarn?.('Migration', `Failed to download teardown scripts: ${message}. A rollback will try to download them again.`);
+        return undefined;
+    }
+}
+function ReleaseTeardownScripts(scripts, context) {
+    if (scripts) {
+        CleanupTempDir(scripts.TempDir, 'Metadata', context);
+    }
+}
+async function RunTeardownScripts(manifest, context, scripts) {
+    const files = scripts.Files;
+    if (files.length === 0) {
+        context.Callbacks?.OnWarn?.('Metadata', `No teardown scripts in '${scripts.SourceDir}' — this app's rows in the shared core schema will NOT be retired on remove.`);
+        return { Success: true };
+    }
+    const mjSchema = context.MJCoreSchema ?? '__mj';
+    context.Callbacks?.OnProgress?.('Metadata', `Running ${files.length} teardown script(s) against '${mjSchema}'...`);
+    await context.DatabaseProvider.BeginTransaction();
+    try {
+        for (const file of files) {
+            const sql = readFileSync(join(scripts.TempDir, file), 'utf-8').split('${mjSchema}').join(mjSchema);
+            if (sql.trim()) {
+                await context.DatabaseProvider.ExecuteSQL(sql);
             }
-            await context.DatabaseProvider.CommitTransaction();
         }
-        catch (error) {
-            await context.DatabaseProvider.RollbackTransaction();
-            const message = error instanceof Error ? error.message : String(error);
-            return { Success: false, ErrorMessage: `Teardown failed for '${manifest.name}' (rolled back): ${message}` };
-        }
-        context.Callbacks?.OnSuccess?.('Metadata', `Retired this app's rows from '${mjSchema}' (${files.length} teardown script(s)).`);
-        return { Success: true };
+        await context.DatabaseProvider.CommitTransaction();
     }
-    finally {
-        CleanupTempDir(tempDir, 'Metadata', context);
+    catch (error) {
+        await context.DatabaseProvider.RollbackTransaction();
+        const message = error instanceof Error ? error.message : String(error);
+        return { Success: false, ErrorMessage: `Teardown failed for '${manifest.name}' (rolled back): ${message}` };
     }
+    context.Callbacks?.OnSuccess?.('Metadata', `Retired this app's rows from '${mjSchema}' (${files.length} teardown script(s)).`);
+    return { Success: true };
 }
 async function DownloadAppMigrations(manifest, context, tempDir, subpath) {
     const baseDir = manifest.migrations.directory;
@@ -1116,6 +1185,29 @@ async function DownloadAppMigrations(manifest, context, tempDir, subpath) {
     }
     return DownloadMigrations(manifest.repository, manifest.version, baseDir, tempDir, context.GitHubOptions, subpath, manifest.name);
 }
+async function PreflightManifestPackages(manifest, context, packageVersion, versionStrategy) {
+    if (!manifest.packages) {
+        return { Success: true };
+    }
+    context.Callbacks?.OnProgress?.('Packages', 'Checking app packages against the npm registry...');
+    const result = await PreflightAppPackages({
+        RepoRoot: context.RepoRoot,
+        ServerPackages: manifest.packages.server ?? [],
+        ClientPackages: manifest.packages.client ?? [],
+        SharedPackages: manifest.packages.shared ?? [],
+        Version: packageVersion,
+        PackageManager: context.PackageManager,
+        VersionStrategy: versionStrategy,
+        RegistryUrl: manifest.packages.registry,
+    });
+    if (result.SkippedReason) {
+        context.Callbacks?.OnProgress?.('Packages', `Skipped the registry check: ${result.SkippedReason}.`);
+    }
+    for (const warning of result.Warnings) {
+        context.Callbacks?.OnWarn?.('Packages', warning);
+    }
+    return result.Success ? { Success: true } : { Success: false, ErrorMessage: result.ErrorMessage };
+}
 async function HandlePackageInstallation(manifest, context, packageVersion, versionStrategy, verbose) {
     if (!manifest.packages) {
         return { Success: true };