@capawesome/cli 4.17.3 → 4.18.0-dev.9810ff51.1785743282

package/dist/utils/app-import.js

@@ -0,0 +1,10 @@
+export const generateUniqueAppName = (name, takenNames) => {
+    if (!takenNames.has(name)) {
+        return name;
+    }
+    let counter = 2;
+    while (takenNames.has(`${name} (${counter})`)) {
+        counter++;
+    }
+    return `${name} (${counter})`;
+};

package/dist/utils/appflow-export.js

@@ -0,0 +1,391 @@
+import { getMessageFromUnknownError, UserError } from '../utils/error.js';
+import { parseGitRemoteUrl } from '../utils/git.js';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+const WEBHOOKS_DOCS_URL = 'https://capawesome.io/docs/cloud/webhooks/';
+const LIVE_UPDATES_DOCS_URL = 'https://capawesome.io/docs/cloud/live-updates/';
+const SUPPORTED_BUILD_TYPES = ['ad-hoc', 'app-store', 'debug', 'development', 'enterprise', 'release', 'simulator'];
+const appDetailSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    appType: z.string(),
+});
+const repoAssociationSchema = z.union([
+    z.object({
+        gitProvider: z.string(),
+        cloneUrl: z.string(),
+    }),
+    z.array(z.unknown()),
+]);
+const environmentsSchema = z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    vars: z.record(z.string(), z.string()).nullish(),
+    secrets: z.record(z.string(), z.string()).nullish(),
+}));
+const liveUpdateChannelsSchema = z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+}));
+const nativeConfigsSchema = z.array(z.object({
+    id: z.number(),
+    name: z.string(),
+    configs: z
+        .object({
+        base: z
+            .object({
+            name: z.string().nullish(),
+            bundle_id: z.string().nullish(),
+        })
+            .nullish(),
+        ionic: z.record(z.string(), z.unknown()).nullish(),
+    })
+        .nullish(),
+}));
+const nativeBuildAutomationsSchema = z.array(z.object({
+    name: z.string(),
+    gitBranch: z.string(),
+    platform: z.enum(['android', 'ios']),
+    buildType: z.string().nullish(),
+    environmentId: z.number().nullish(),
+    webhook: z.string().nullish(),
+    automationEnabled: z.boolean(),
+    nativeConfigId: z.number().nullish(),
+    signingCertificateId: z.number().nullish(),
+    destinationId: z.number().nullish(),
+}));
+const webBuildAutomationsSchema = z.array(z.object({
+    name: z.string(),
+    gitBranch: z.string(),
+    environmentId: z.number().nullish(),
+    webhook: z.string().nullish(),
+    automationEnabled: z.boolean(),
+    channelIds: z.array(z.string()).nullish(),
+    webPreviewEnabled: z.boolean().nullish(),
+}));
+const androidSigningCertificateSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    keystoreFile: z.string(),
+    keystorePassword: z.string(),
+    keyAlias: z.string(),
+    keyPassword: z.string(),
+});
+const iosSigningCertificateSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    p12File: z.string(),
+    p12Password: z.string(),
+    provisioningProfiles: z.array(z.string()).nullish(),
+});
+const playStoreDestinationSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    artifactType: z.string().nullish(),
+    packageName: z.string().nullish(),
+    track: z.string().nullish(),
+});
+const appStoreDestinationSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    appleId: z.string().nullish(),
+    appAppleId: z.string().nullish(),
+    appPassword: z.string().nullish(),
+    teamId: z.string().nullish(),
+});
+export const parseAppflowExport = async (directory) => {
+    const appsDirectory = path.join(directory, 'apps');
+    if (!fs.existsSync(appsDirectory) || !fs.statSync(appsDirectory).isDirectory()) {
+        throw new UserError('The provided file does not look like an Ionic Appflow export. It must contain an `apps` directory.');
+    }
+    const apps = [];
+    const skippedApps = [];
+    const appFolders = fs
+        .readdirSync(appsDirectory, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(appsDirectory, entry.name));
+    for (const appFolder of appFolders) {
+        try {
+            const detail = parseJsonFile(path.join(appFolder, 'app-detail.json'), appDetailSchema);
+            const type = mapAppType(detail.appType);
+            if (!type) {
+                skippedApps.push({
+                    sourceId: detail.id,
+                    sourceName: detail.name,
+                    reason: `App type \`${detail.appType}\` is not yet supported.`,
+                    retryLater: detail.appType === 'react_native' || detail.appType === 'flutter',
+                });
+                continue;
+            }
+            apps.push(parseApp(appFolder, detail, type));
+        }
+        catch (error) {
+            skippedApps.push({
+                sourceId: '',
+                sourceName: path.basename(appFolder),
+                reason: getMessageFromUnknownError(error),
+                retryLater: false,
+            });
+        }
+    }
+    return { apps, skippedApps };
+};
+const mapAppType = (appType) => {
+    switch (appType) {
+        case 'android':
+        case 'capacitor':
+        case 'cordova':
+        case 'ios':
+            return appType;
+        case 'ionic':
+            return 'capacitor';
+        default:
+            return undefined;
+    }
+};
+const parseApp = (appFolder, detail, type) => {
+    const notes = [];
+    if (detail.appType === 'ionic') {
+        notes.push('App type `ionic` was mapped to `capacitor`.');
+    }
+    const environments = parseJsonFileIfExists(path.join(appFolder, 'environments.json'), environmentsSchema) ?? [];
+    const channels = parseJsonFileIfExists(path.join(appFolder, 'live-update-channels.json'), liveUpdateChannelsSchema) ?? [];
+    const nativeConfigs = parseJsonFileIfExists(path.join(appFolder, 'native-configs.json'), nativeConfigsSchema) ?? [];
+    const certificates = parseCertificates(appFolder, notes);
+    const destinations = parseDestinations(appFolder);
+    return {
+        sourceId: detail.id,
+        sourceName: detail.name,
+        name: detail.name,
+        type,
+        notes,
+        automations: parseAutomations(appFolder, {
+            certificateNamesById: toNameMap(certificates.map((certificate) => ({ id: certificate.id, name: certificate.certificate.name }))),
+            channelNamesById: new Map(channels.map((channel) => [channel.id, channel.name])),
+            configurationNamesById: toNameMap(nativeConfigs),
+            destinationNamesById: toNameMap(destinations.map((destination) => ({ id: destination.id, name: destination.destination.name }))),
+            environmentNamesById: toNameMap(environments),
+        }, notes),
+        certificates: certificates.map((certificate) => certificate.certificate),
+        channels: channels.map((channel) => channel.name),
+        configurations: parseConfigurations(nativeConfigs, notes),
+        destinations: destinations.map((destination) => destination.destination),
+        environments: environments.map((environment) => ({
+            name: environment.name,
+            variables: Object.entries(environment.vars ?? {}).map(([key, value]) => ({ key, value })),
+            secrets: Object.entries(environment.secrets ?? {}).map(([key, value]) => ({ key, value })),
+        })),
+        repository: parseRepository(appFolder, notes),
+    };
+};
+const parseRepository = (appFolder, notes) => {
+    const repoAssociation = parseJsonFileIfExists(path.join(appFolder, 'repo-association.json'), repoAssociationSchema);
+    if (!repoAssociation || Array.isArray(repoAssociation)) {
+        return null;
+    }
+    try {
+        return parseGitRemoteUrl(repoAssociation.cloneUrl);
+    }
+    catch {
+        notes.push(`The git repository \`${repoAssociation.cloneUrl}\` (provider \`${repoAssociation.gitProvider}\`) is not supported and was not linked. You can link a repository manually in the Capawesome Cloud Console.`);
+        return null;
+    }
+};
+const parseConfigurations = (nativeConfigs, notes) => {
+    const configurationsWithLiveUpdateSettings = nativeConfigs.filter((config) => config.configs?.ionic);
+    if (configurationsWithLiveUpdateSettings.length > 0) {
+        notes.push(`The native configurations ${configurationsWithLiveUpdateSettings.map((config) => `\`${config.name}\``).join(', ')} contain Live Update plugin settings which are not part of configurations in Capawesome Cloud. Configure the Live Update plugin in your app instead (see ${LIVE_UPDATES_DOCS_URL}).`);
+    }
+    return nativeConfigs.map((config) => ({
+        name: config.name,
+        displayName: config.configs?.base?.name ?? undefined,
+        packageName: config.configs?.base?.bundle_id ?? undefined,
+    }));
+};
+const parseCertificates = (appFolder, notes) => {
+    const certificates = [];
+    for (const folder of getSubfolders(path.join(appFolder, 'signing-certificates', 'android'))) {
+        const metadata = parseJsonFile(path.join(folder, 'android-signing-certificate.json'), androidSigningCertificateSchema);
+        const filePath = path.join(folder, metadata.keystoreFile);
+        if (!fs.existsSync(filePath)) {
+            notes.push(`The signing certificate \`${metadata.name}\` was skipped because the file \`${metadata.keystoreFile}\` is missing in the export.`);
+            continue;
+        }
+        certificates.push({
+            id: metadata.id,
+            certificate: {
+                name: metadata.name,
+                platform: 'android',
+                filePath,
+                password: metadata.keystorePassword,
+                keyAlias: metadata.keyAlias,
+                keyPassword: metadata.keyPassword,
+                provisioningProfilePaths: [],
+            },
+        });
+    }
+    for (const folder of getSubfolders(path.join(appFolder, 'signing-certificates', 'ios'))) {
+        const metadata = parseJsonFile(path.join(folder, 'ios-signing-certificate.json'), iosSigningCertificateSchema);
+        const filePath = path.join(folder, metadata.p12File);
+        if (!fs.existsSync(filePath)) {
+            notes.push(`The signing certificate \`${metadata.name}\` was skipped because the file \`${metadata.p12File}\` is missing in the export.`);
+            continue;
+        }
+        const provisioningProfilePaths = [];
+        for (const profileFile of new Set(metadata.provisioningProfiles ?? [])) {
+            const profilePath = path.join(folder, profileFile);
+            if (!fs.existsSync(profilePath)) {
+                notes.push(`The provisioning profile \`${profileFile}\` of the signing certificate \`${metadata.name}\` is missing in the export and was skipped.`);
+                continue;
+            }
+            provisioningProfilePaths.push(profilePath);
+        }
+        certificates.push({
+            id: metadata.id,
+            certificate: {
+                name: metadata.name,
+                platform: 'ios',
+                filePath,
+                password: metadata.p12Password,
+                provisioningProfilePaths,
+            },
+        });
+    }
+    return certificates;
+};
+const parseDestinations = (appFolder) => {
+    const destinations = [];
+    for (const folder of getSubfolders(path.join(appFolder, 'store-destinations', 'android'))) {
+        const metadata = parseJsonFile(path.join(folder, 'play-store-destination.json'), playStoreDestinationSchema);
+        const googleServiceAccountKeyPath = path.join(folder, 'json-key.json');
+        destinations.push({
+            id: metadata.id,
+            destination: {
+                name: metadata.name,
+                platform: 'android',
+                androidPackageName: metadata.packageName ?? undefined,
+                androidBuildArtifactType: metadata.artifactType === 'aab' || metadata.artifactType === 'apk' ? metadata.artifactType : undefined,
+                googlePlayTrack: metadata.track ?? undefined,
+                googleServiceAccountKeyPath: fs.existsSync(googleServiceAccountKeyPath)
+                    ? googleServiceAccountKeyPath
+                    : undefined,
+            },
+        });
+    }
+    for (const folder of getSubfolders(path.join(appFolder, 'store-destinations', 'ios'))) {
+        const metadata = parseJsonFile(path.join(folder, 'app-store-destination.json'), appStoreDestinationSchema);
+        destinations.push({
+            id: metadata.id,
+            destination: {
+                name: metadata.name,
+                platform: 'ios',
+                appleId: metadata.appleId ?? undefined,
+                appleAppId: metadata.appAppleId ?? undefined,
+                appleTeamId: metadata.teamId ?? undefined,
+                appleAppPassword: metadata.appPassword ?? undefined,
+            },
+        });
+    }
+    return destinations;
+};
+const parseAutomations = (appFolder, references, notes) => {
+    const automations = [];
+    const nativeAutomations = parseJsonFileIfExists(path.join(appFolder, 'native-build-automations.json'), nativeBuildAutomationsSchema) ?? [];
+    const webAutomations = parseJsonFileIfExists(path.join(appFolder, 'web-build-automations.json'), webBuildAutomationsSchema) ?? [];
+    const automationsWithWebhook = [...nativeAutomations, ...webAutomations].filter((automation) => automation.webhook);
+    if (automationsWithWebhook.length > 0) {
+        notes.push(`The webhooks of the automations ${automationsWithWebhook.map((automation) => `\`${automation.name}\``).join(', ')} were not imported because Capawesome Cloud supports webhooks at the app level instead. Please add them manually (see ${WEBHOOKS_DOCS_URL}).`);
+    }
+    for (const automation of nativeAutomations) {
+        let buildType = automation.buildType ?? undefined;
+        if (buildType && !SUPPORTED_BUILD_TYPES.includes(buildType)) {
+            notes.push(`The automation \`${automation.name}\` has the unsupported build type \`${buildType}\` which was skipped.`);
+            buildType = undefined;
+        }
+        automations.push({
+            name: automation.name,
+            platform: automation.platform,
+            triggerPattern: automation.gitBranch,
+            buildType,
+            enabled: automation.automationEnabled,
+            appCertificateName: resolveName(references.certificateNamesById, automation.signingCertificateId, automation.name, 'signing certificate', notes),
+            appConfigurationName: resolveName(references.configurationNamesById, automation.nativeConfigId, automation.name, 'native configuration', notes),
+            appDestinationName: resolveName(references.destinationNamesById, automation.destinationId, automation.name, 'destination', notes),
+            appEnvironmentName: resolveName(references.environmentNamesById, automation.environmentId, automation.name, 'environment', notes),
+        });
+    }
+    for (const automation of webAutomations) {
+        if (automation.webPreviewEnabled) {
+            notes.push(`The automation \`${automation.name}\` has web previews enabled which are not supported by Capawesome Cloud.`);
+        }
+        const channelNames = (automation.channelIds ?? [])
+            .map((channelId) => resolveName(references.channelNamesById, channelId, automation.name, 'channel', notes))
+            .filter((name) => !!name);
+        const appEnvironmentName = resolveName(references.environmentNamesById, automation.environmentId, automation.name, 'environment', notes);
+        if (channelNames.length === 0) {
+            automations.push({
+                name: automation.name,
+                platform: 'web',
+                triggerPattern: automation.gitBranch,
+                enabled: automation.automationEnabled,
+                appEnvironmentName,
+            });
+            continue;
+        }
+        for (const channelName of channelNames) {
+            automations.push({
+                name: channelNames.length > 1 ? `${automation.name} (${channelName})` : automation.name,
+                platform: 'web',
+                triggerPattern: automation.gitBranch,
+                enabled: automation.automationEnabled,
+                appChannelName: channelName,
+                appEnvironmentName,
+            });
+        }
+    }
+    return automations;
+};
+const resolveName = (namesById, id, automationName, label, notes) => {
+    if (id === null || id === undefined) {
+        return undefined;
+    }
+    const name = namesById.get(id);
+    if (!name) {
+        notes.push(`The automation \`${automationName}\` references an unknown ${label} which was skipped.`);
+        return undefined;
+    }
+    return name;
+};
+const toNameMap = (entities) => {
+    return new Map(entities.map((entity) => [entity.id, entity.name]));
+};
+const getSubfolders = (directory) => {
+    if (!fs.existsSync(directory)) {
+        return [];
+    }
+    return fs
+        .readdirSync(directory, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(directory, entry.name));
+};
+const parseJsonFile = (filePath, schema) => {
+    let json;
+    try {
+        json = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        throw new UserError(`The export file \`${path.basename(filePath)}\` is missing or contains invalid JSON.`);
+    }
+    const result = schema.safeParse(json);
+    if (!result.success) {
+        throw new UserError(`The export file \`${path.basename(filePath)}\` has an unexpected format.`);
+    }
+    return result.data;
+};
+const parseJsonFileIfExists = (filePath, schema) => {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    return parseJsonFile(filePath, schema);
+};

package/dist/utils/appflow-export.test.js

@@ -0,0 +1,277 @@
+import { parseAppflowExport } from '../utils/appflow-export.js';
+import { UserError } from '../utils/error.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+describe('appflow-export', () => {
+    let exportDirectory;
+    beforeEach(() => {
+        exportDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'appflow-export-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(exportDirectory, { recursive: true, force: true });
+    });
+    const writeAppFiles = (appFolder, files) => {
+        for (const [fileName, content] of Object.entries(files)) {
+            const filePath = path.join(exportDirectory, 'apps', appFolder, fileName);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            if (typeof content === 'string' || Buffer.isBuffer(content)) {
+                fs.writeFileSync(filePath, content);
+            }
+            else {
+                fs.writeFileSync(filePath, JSON.stringify(content));
+            }
+        }
+    };
+    it('should throw a user error if the export does not contain an apps directory', async () => {
+        await expect(parseAppflowExport(exportDirectory)).rejects.toThrow(UserError);
+    });
+    it('should parse a fully configured app', async () => {
+        writeAppFiles('My App-6668c18c', {
+            'app-detail.json': { id: '6668c18c', name: 'My App', appType: 'capacitor' },
+            'repo-association.json': {
+                gitProvider: 'github',
+                gitUsername: 'robingenz',
+                cloneUrl: 'https://github.com/robingenz/appflow-export-test.git',
+            },
+            'environments.json': [
+                { id: 33513, name: 'Development', vars: { DEBUG: 'true' }, secrets: null },
+                { id: 33515, name: 'Production', vars: {}, secrets: { API_KEY: 'secret' } },
+            ],
+            'live-update-channels.json': [
+                { id: 'd33204c6', name: 'Production' },
+                { id: '1e168146', name: 'Staging' },
+            ],
+            'native-configs.json': [
+                {
+                    id: 41087,
+                    name: 'Development',
+                    configs: {
+                        base: { name: 'My App (Dev)', bundle_id: 'dev.robingenz.app.dev' },
+                        ionic: { channel_name: 'Development', update_method: 'background' },
+                    },
+                },
+                { id: 41089, name: 'Barebones', configs: { base: { bundle_id: 'dev.robingenz.app.bare' } } },
+            ],
+            'native-build-automations.json': [
+                {
+                    name: 'Android Release',
+                    gitBranch: 'main',
+                    type: 'package',
+                    platform: 'android',
+                    buildType: 'release',
+                    environmentId: 33515,
+                    webhook: 'https://example.com/webhook',
+                    automationEnabled: true,
+                    nativeConfigId: 41087,
+                    signingCertificateId: 154267,
+                    destinationId: null,
+                },
+                {
+                    name: 'iOS Store',
+                    gitBranch: 'main',
+                    type: 'package',
+                    platform: 'ios',
+                    buildType: 'development',
+                    environmentId: 99999,
+                    webhook: null,
+                    automationEnabled: false,
+                    nativeConfigId: null,
+                    signingCertificateId: null,
+                    destinationId: null,
+                },
+            ],
+            'web-build-automations.json': [
+                {
+                    name: 'Web Prod',
+                    gitBranch: 'main',
+                    type: 'deploy',
+                    platform: 'web-deploy',
+                    environmentId: 33515,
+                    webhook: null,
+                    automationEnabled: true,
+                    channelIds: ['1e168146', 'd33204c6'],
+                    webPreviewEnabled: true,
+                },
+            ],
+            'signing-certificates/android/Debug-154267/android-signing-certificate.json': {
+                id: 154267,
+                name: 'Debug',
+                keystoreFile: 'keystore.jks',
+                keystorePassword: 'test1234',
+                keyAlias: 'key',
+                keyPassword: 'test1234',
+            },
+            'signing-certificates/android/Debug-154267/keystore.jks': Buffer.from('keystore'),
+            'signing-certificates/ios/Dev-154266/ios-signing-certificate.json': {
+                id: 154266,
+                name: 'Dev',
+                p12File: 'ios-certificate.p12',
+                p12Password: '123456',
+                provisioningProfiles: ['Test.mobileprovision'],
+            },
+            'signing-certificates/ios/Dev-154266/ios-certificate.p12': Buffer.from('p12'),
+            'signing-certificates/ios/Dev-154266/Test.mobileprovision': Buffer.from('profile'),
+            'store-destinations/android/Prod-27890/play-store-destination.json': {
+                id: 27890,
+                name: 'Prod',
+                artifactType: 'aab',
+                packageName: 'dev.robingenz.app',
+                track: 'internal',
+            },
+            'store-destinations/android/Prod-27890/json-key.json': { type: 'service_account' },
+        });
+        const { apps, skippedApps } = await parseAppflowExport(exportDirectory);
+        expect(skippedApps).toEqual([]);
+        expect(apps).toHaveLength(1);
+        const app = apps[0];
+        expect(app.sourceId).toBe('6668c18c');
+        expect(app.sourceName).toBe('My App');
+        expect(app.type).toBe('capacitor');
+        expect(app.repository).toEqual({
+            ownerSlug: 'robingenz',
+            provider: 'github',
+            repositorySlug: 'appflow-export-test',
+            projectSlug: undefined,
+        });
+        expect(app.environments).toEqual([
+            { name: 'Development', variables: [{ key: 'DEBUG', value: 'true' }], secrets: [] },
+            { name: 'Production', variables: [], secrets: [{ key: 'API_KEY', value: 'secret' }] },
+        ]);
+        expect(app.channels).toEqual(['Production', 'Staging']);
+        expect(app.configurations).toEqual([
+            { name: 'Development', displayName: 'My App (Dev)', packageName: 'dev.robingenz.app.dev' },
+            { name: 'Barebones', displayName: undefined, packageName: 'dev.robingenz.app.bare' },
+        ]);
+        expect(app.certificates).toHaveLength(2);
+        expect(app.certificates[0]).toMatchObject({
+            name: 'Debug',
+            platform: 'android',
+            password: 'test1234',
+            keyAlias: 'key',
+            keyPassword: 'test1234',
+        });
+        expect(app.certificates[1]).toMatchObject({ name: 'Dev', platform: 'ios', password: '123456' });
+        expect(app.certificates[1].provisioningProfilePaths).toHaveLength(1);
+        expect(app.destinations).toEqual([
+            {
+                name: 'Prod',
+                platform: 'android',
+                androidPackageName: 'dev.robingenz.app',
+                androidBuildArtifactType: 'aab',
+                googlePlayTrack: 'internal',
+                googleServiceAccountKeyPath: expect.stringContaining('json-key.json'),
+            },
+        ]);
+        expect(app.automations).toEqual([
+            {
+                name: 'Android Release',
+                platform: 'android',
+                triggerPattern: 'main',
+                buildType: 'release',
+                enabled: true,
+                appCertificateName: 'Debug',
+                appConfigurationName: 'Development',
+                appDestinationName: undefined,
+                appEnvironmentName: 'Production',
+            },
+            {
+                name: 'iOS Store',
+                platform: 'ios',
+                triggerPattern: 'main',
+                buildType: 'development',
+                enabled: false,
+                appCertificateName: undefined,
+                appConfigurationName: undefined,
+                appDestinationName: undefined,
+                appEnvironmentName: undefined,
+            },
+            {
+                name: 'Web Prod (Staging)',
+                platform: 'web',
+                triggerPattern: 'main',
+                enabled: true,
+                appChannelName: 'Staging',
+                appEnvironmentName: 'Production',
+            },
+            {
+                name: 'Web Prod (Production)',
+                platform: 'web',
+                triggerPattern: 'main',
+                enabled: true,
+                appChannelName: 'Production',
+                appEnvironmentName: 'Production',
+            },
+        ]);
+        expect(app.notes).toHaveLength(4);
+        expect(app.notes).toContainEqual(expect.stringContaining('webhook'));
+        expect(app.notes).toContainEqual(expect.stringContaining('unknown environment'));
+        expect(app.notes).toContainEqual(expect.stringContaining('web previews'));
+        expect(app.notes).toContainEqual(expect.stringContaining('Live Update plugin settings'));
+    });
+    it('should map the app type `ionic` to `capacitor` with a note', async () => {
+        writeAppFiles('Legacy App-11111111', {
+            'app-detail.json': { id: '11111111', name: 'Legacy App', appType: 'ionic' },
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps).toHaveLength(1);
+        expect(apps[0].type).toBe('capacitor');
+        expect(apps[0].notes).toContainEqual(expect.stringContaining('`ionic`'));
+    });
+    it('should skip apps with an unsupported app type', async () => {
+        writeAppFiles('RN App-22222222', {
+            'app-detail.json': { id: '22222222', name: 'RN App', appType: 'react_native' },
+        });
+        writeAppFiles('Other App-33333333', {
+            'app-detail.json': { id: '33333333', name: 'Other App', appType: 'unknown' },
+        });
+        const { apps, skippedApps } = await parseAppflowExport(exportDirectory);
+        expect(apps).toEqual([]);
+        expect(skippedApps).toContainEqual({
+            sourceId: '22222222',
+            sourceName: 'RN App',
+            reason: expect.stringContaining('react_native'),
+            retryLater: true,
+        });
+        expect(skippedApps).toContainEqual({
+            sourceId: '33333333',
+            sourceName: 'Other App',
+            reason: expect.stringContaining('unknown'),
+            retryLater: false,
+        });
+    });
+    it('should handle an empty repo association serialized as an array', async () => {
+        writeAppFiles('No Repo-44444444', {
+            'app-detail.json': { id: '44444444', name: 'No Repo', appType: 'capacitor' },
+            'repo-association.json': [],
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].repository).toBeNull();
+    });
+    it('should skip a signing certificate with a missing file', async () => {
+        writeAppFiles('Broken Cert-55555555', {
+            'app-detail.json': { id: '55555555', name: 'Broken Cert', appType: 'capacitor' },
+            'signing-certificates/android/Debug-1/android-signing-certificate.json': {
+                id: 1,
+                name: 'Debug',
+                keystoreFile: 'keystore.jks',
+                keystorePassword: 'test',
+                keyAlias: 'key',
+                keyPassword: 'test',
+            },
+        });
+        const { apps } = await parseAppflowExport(exportDirectory);
+        expect(apps[0].certificates).toEqual([]);
+        expect(apps[0].notes).toContainEqual(expect.stringContaining('keystore.jks'));
+    });
+    it('should skip an app with an invalid app detail file', async () => {
+        writeAppFiles('Invalid-66666666', {
+            'app-detail.json': 'not json',
+        });
+        const { apps, skippedApps } = await parseAppflowExport(exportDirectory);
+        expect(apps).toEqual([]);
+        expect(skippedApps).toHaveLength(1);
+        expect(skippedApps[0].retryLater).toBe(false);
+    });
+});