@capawesome/cli 1.13.2 → 1.14.0-dev.3b0fc7e.1755934102

package/dist/commands/apps/bundles/create.js

@@ -1,216 +1,190 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const citty_1 = require("citty");
-const consola_1 = __importDefault(require("consola"));
-const fs_1 = require("fs");
-const config_1 = require("../../../config");
-const app_bundle_files_1 = __importDefault(require("../../../services/app-bundle-files"));
-const app_bundles_1 = __importDefault(require("../../../services/app-bundles"));
-const apps_1 = __importDefault(require("../../../services/apps"));
-const authorization_service_1 = __importDefault(require("../../../services/authorization-service"));
-const buffer_1 = require("../../../utils/buffer");
-const error_1 = require("../../../utils/error");
-const file_1 = require("../../../utils/file");
-const hash_1 = require("../../../utils/hash");
-const manifest_1 = require("../../../utils/manifest");
-const prompt_1 = require("../../../utils/prompt");
-const signature_1 = require("../../../utils/signature");
-const zip_1 = __importDefault(require("../../../utils/zip"));
-exports.default = (0, citty_1.defineCommand)({
-    meta: {
-        description: 'Create a new app bundle.',
-    },
-    args: {
-        androidMax: {
-            type: 'string',
-            description: 'The maximum Android version code (`versionCode`) that the bundle supports.',
-        },
-        androidMin: {
-            type: 'string',
-            description: 'The minimum Android version code (`versionCode`) that the bundle supports.',
-        },
-        appId: {
-            type: 'string',
-            description: 'App ID to deploy to.',
-        },
-        artifactType: {
-            type: 'string',
-            description: 'The type of artifact to deploy. Must be either `manifest` or `zip`. The default is `zip`.',
-        },
-        channel: {
-            type: 'string',
-            description: 'Channel to associate the bundle with.',
-        },
-        commitMessage: {
-            type: 'string',
-            description: 'The commit message related to the bundle.',
-        },
-        commitRef: {
-            type: 'string',
-            description: 'The commit ref related to the bundle.',
-        },
-        commitSha: {
-            type: 'string',
-            description: 'The commit sha related to the bundle.',
-        },
-        customProperty: {
-            type: 'string',
-            description: 'A custom property to assign to the bundle. Must be in the format `key=value`. Can be specified multiple times.',
-        },
-        expiresInDays: {
-            type: 'string',
-            description: 'The number of days until the bundle is automatically deleted.',
-        },
-        iosMax: {
-            type: 'string',
-            description: 'The maximum iOS bundle version (`CFBundleVersion`) that the bundle supports.',
-        },
-        iosMin: {
-            type: 'string',
-            description: 'The minimum iOS bundle version (`CFBundleVersion`) that the bundle supports.',
-        },
-        path: {
-            type: 'string',
-            description: 'Path to the bundle to upload. Must be a folder (e.g. `www` or `dist`) or a zip file.',
-        },
-        privateKey: {
-            type: 'string',
-            description: 'The path to the private key file to sign the bundle with.',
-        },
-        rollout: {
-            type: 'string',
-            description: 'The percentage of devices to deploy the bundle to. Must be a number between 0 and 1 (e.g. 0.5).',
-        },
-        url: {
-            type: 'string',
-            description: 'The url to the self-hosted bundle file.',
-        },
-    },
-    run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!authorization_service_1.default.hasAuthorizationToken()) {
-            consola_1.default.error('You must be logged in to run this command.');
+import { MAX_CONCURRENT_UPLOADS } from '../../../config/index.js';
+import appBundleFilesService from '../../../services/app-bundle-files.js';
+import appBundlesService from '../../../services/app-bundles.js';
+import appsService from '../../../services/apps.js';
+import authorizationService from '../../../services/authorization-service.js';
+import organizationsService from '../../../services/organizations.js';
+import { createBufferFromPath, createBufferFromReadStream, createBufferFromString, isPrivateKeyContent, } from '../../../utils/buffer.js';
+import { formatPrivateKey } from '../../../utils/private-key.js';
+import { fileExistsAtPath, getFilesInDirectoryAndSubdirectories, isDirectory } from '../../../utils/file.js';
+import { createHash } from '../../../utils/hash.js';
+import { generateManifestJson } from '../../../utils/manifest.js';
+import { prompt } from '../../../utils/prompt.js';
+import { createSignature } from '../../../utils/signature.js';
+import zip from '../../../utils/zip.js';
+import { defineCommand, defineOptions } from '@robingenz/zli';
+import consola from 'consola';
+import { createReadStream } from 'fs';
+import { z } from 'zod';
+export default defineCommand({
+    description: 'Create a new app bundle.',
+    options: defineOptions(z.object({
+        androidMax: z.coerce
+            .string()
+            .optional()
+            .describe('The maximum Android version code (`versionCode`) that the bundle supports.'),
+        androidMin: z.coerce
+            .string()
+            .optional()
+            .describe('The minimum Android version code (`versionCode`) that the bundle supports.'),
+        appId: z
+            .string({
+            message: 'App ID must be a UUID.',
+        })
+            .uuid({
+            message: 'App ID must be a UUID.',
+        })
+            .optional()
+            .describe('App ID to deploy to.'),
+        artifactType: z
+            .enum(['manifest', 'zip'], {
+            message: 'Invalid artifact type. Must be either `manifest` or `zip`.',
+        })
+            .optional()
+            .describe('The type of artifact to deploy. Must be either `manifest` or `zip`. The default is `zip`.')
+            .default('zip'),
+        channel: z.string().optional().describe('Channel to associate the bundle with.'),
+        commitMessage: z.string().optional().describe('The commit message related to the bundle.'),
+        commitRef: z.string().optional().describe('The commit ref related to the bundle.'),
+        commitSha: z.string().optional().describe('The commit sha related to the bundle.'),
+        customProperty: z
+            .array(z.string().min(1).max(100))
+            .optional()
+            .describe('A custom property to assign to the bundle. Must be in the format `key=value`. Can be specified multiple times.'),
+        expiresInDays: z.coerce
+            .number({
+            message: 'Expiration days must be an integer.',
+        })
+            .int({
+            message: 'Expiration days must be an integer.',
+        })
+            .optional()
+            .describe('The number of days until the bundle is automatically deleted.'),
+        iosMax: z
+            .string()
+            .optional()
+            .describe('The maximum iOS bundle version (`CFBundleVersion`) that the bundle supports.'),
+        iosMin: z
+            .string()
+            .optional()
+            .describe('The minimum iOS bundle version (`CFBundleVersion`) that the bundle supports.'),
+        path: z
+            .string()
+            .optional()
+            .describe('Path to the bundle to upload. Must be a folder (e.g. `www` or `dist`) or a zip file.'),
+        privateKey: z
+            .string()
+            .optional()
+            .describe('The private key to sign the bundle with. Can be a file path to a .pem file or the private key content as plain text.'),
+        rollout: z.coerce
+            .number()
+            .min(0)
+            .max(1, {
+            message: 'Rollout percentage must be a number between 0 and 1 (e.g. 0.5).',
+        })
+            .optional()
+            .default(1)
+            .describe('The percentage of devices to deploy the bundle to. Must be a number between 0 and 1 (e.g. 0.5).'),
+        url: z.string().optional().describe('The url to the self-hosted bundle file.'),
+    })),
+    action: async (options, args) => {
+        let { androidMax, androidMin, appId, artifactType, channel, commitMessage, commitRef, commitSha, customProperty, expiresInDays, iosMax, iosMin, path, privateKey, rollout, url, } = options;
+        // Check if the user is logged in
+        if (!authorizationService.hasAuthorizationToken()) {
+            consola.error('You must be logged in to run this command.');
             process.exit(1);
         }
-        let androidMax = ctx.args.androidMax === undefined ? undefined : ctx.args.androidMax + ''; // Convert to string
-        let androidMin = ctx.args.androidMin === undefined ? undefined : ctx.args.androidMin + ''; // Convert to string
-        let appId = ctx.args.appId;
-        let artifactType = ctx.args.artifactType === 'manifest' || ctx.args.artifactType === 'zip'
-            ? ctx.args.artifactType
-            : 'zip';
-        let channelName = ctx.args.channel;
-        let customProperty = ctx.args.customProperty;
-        let expiresInDays = ctx.args.expiresInDays === undefined ? undefined : ctx.args.expiresInDays + ''; // Convert to string
-        let iosMax = ctx.args.iosMax === undefined ? undefined : ctx.args.iosMax + ''; // Convert to string
-        let iosMin = ctx.args.iosMin === undefined ? undefined : ctx.args.iosMin + ''; // Convert to string
-        let path = ctx.args.path;
-        let privateKey = ctx.args.privateKey;
-        let rolloutAsString = ctx.args.rollout === undefined ? undefined : ctx.args.rollout + ''; // Convert to string
-        let url = ctx.args.url;
-        let commitMessage = ctx.args.commitMessage;
-        let commitRef = ctx.args.commitRef;
-        let commitSha = ctx.args.commitSha;
         // Validate the expiration days
         let expiresAt;
         if (expiresInDays) {
-            const expiresInDaysAsNumber = parseInt(expiresInDays, 10);
-            if (isNaN(expiresInDaysAsNumber) || expiresInDaysAsNumber < 1) {
-                consola_1.default.error('Expires in days must be a number greater than 0.');
-                process.exit(1);
-            }
             const expiresAtDate = new Date();
-            expiresAtDate.setDate(expiresAtDate.getDate() + expiresInDaysAsNumber);
+            expiresAtDate.setDate(expiresAtDate.getDate() + expiresInDays);
             expiresAt = expiresAtDate.toISOString();
         }
-        // Validate the rollout percentage
-        let rolloutPercentage = 1;
-        if (rolloutAsString) {
-            const rolloutAsNumber = parseFloat(rolloutAsString);
-            if (isNaN(rolloutAsNumber) || rolloutAsNumber < 0 || rolloutAsNumber > 1) {
-                consola_1.default.error('Rollout percentage must be a number between 0 and 1.');
-                process.exit(1);
-            }
-            rolloutPercentage = rolloutAsNumber;
-        }
         // Check that either a path or a url is provided
         if (!path && !url) {
-            path = yield (0, prompt_1.prompt)('Enter the path to the app bundle:', {
+            path = await prompt('Enter the path to the app bundle:', {
                 type: 'text',
             });
             if (!path) {
-                consola_1.default.error('You must provide a path to the app bundle.');
+                consola.error('You must provide a path to the app bundle.');
                 process.exit(1);
             }
         }
         if (path) {
             // Check if the path exists when a path is provided
-            const pathExists = yield (0, file_1.fileExistsAtPath)(path);
+            const pathExists = await fileExistsAtPath(path);
             if (!pathExists) {
-                consola_1.default.error(`The path does not exist.`);
+                consola.error(`The path does not exist.`);
                 process.exit(1);
             }
             // Check if the directory contains an index.html file
-            const pathIsDirectory = yield (0, file_1.isDirectory)(path);
+            const pathIsDirectory = await isDirectory(path);
             if (pathIsDirectory) {
-                const files = yield (0, file_1.getFilesInDirectoryAndSubdirectories)(path);
+                const files = await getFilesInDirectoryAndSubdirectories(path);
                 const indexHtml = files.find((file) => file.href === 'index.html');
                 if (!indexHtml) {
-                    consola_1.default.error('The directory must contain an `index.html` file.');
+                    consola.error('The directory must contain an `index.html` file.');
                     process.exit(1);
                 }
             }
         }
         // Check that the path is a directory when creating a bundle with an artifact type
         if (artifactType === 'manifest' && path) {
-            const pathIsDirectory = yield (0, file_1.isDirectory)(path);
+            const pathIsDirectory = await isDirectory(path);
             if (!pathIsDirectory) {
-                consola_1.default.error('The path must be a folder when creating a bundle with an artifact type of `manifest`.');
+                consola.error('The path must be a folder when creating a bundle with an artifact type of `manifest`.');
                 process.exit(1);
             }
         }
         // Check that a URL is not provided when creating a bundle with an artifact type of manifest
         if (artifactType === 'manifest' && url) {
-            consola_1.default.error('It is not yet possible to provide a URL when creating a bundle with an artifact type of `manifest`.');
+            consola.error('It is not yet possible to provide a URL when creating a bundle with an artifact type of `manifest`.');
             process.exit(1);
         }
         if (!appId) {
-            const apps = yield apps_1.default.findAll();
+            const organizations = await organizationsService.findAll();
+            if (organizations.length === 0) {
+                consola.error('You must create an organization before creating a bundle.');
+                process.exit(1);
+            }
+            // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
+            const organizationId = await prompt('Select the organization of the app for which you want to create a bundle.', {
+                type: 'select',
+                options: organizations.map((organization) => ({ label: organization.name, value: organization.id })),
+            });
+            if (!organizationId) {
+                consola.error('You must select the organization of an app for which you want to create a bundle.');
+                process.exit(1);
+            }
+            const apps = await appsService.findAll({
+                organizationId,
+            });
             if (apps.length === 0) {
-                consola_1.default.error('You must create an app before creating a bundle.');
+                consola.error('You must create an app before creating a bundle.');
                 process.exit(1);
             }
             // @ts-ignore wait till https://github.com/unjs/consola/pull/280 is merged
-            appId = yield (0, prompt_1.prompt)('Which app do you want to deploy to:', {
+            appId = await prompt('Which app do you want to deploy to:', {
                 type: 'select',
                 options: apps.map((app) => ({ label: app.name, value: app.id })),
             });
             if (!appId) {
-                consola_1.default.error('You must select an app to deploy to.');
+                consola.error('You must select an app to deploy to.');
                 process.exit(1);
             }
         }
-        if (!channelName) {
-            const promptChannel = yield (0, prompt_1.prompt)('Do you want to deploy to a specific channel?', {
+        if (!channel) {
+            const promptChannel = await prompt('Do you want to deploy to a specific channel?', {
                 type: 'select',
                 options: ['Yes', 'No'],
             });
             if (promptChannel === 'Yes') {
-                channelName = yield (0, prompt_1.prompt)('Enter the channel name:', {
+                channel = await prompt('Enter the channel name:', {
                     type: 'text',
                 });
-                if (!channelName) {
-                    consola_1.default.error('The channel name must be at least one character long.');
+                if (!channel) {
+                    consola.error('The channel name must be at least one character long.');
                     process.exit(1);
                 }
             }
@@ -218,57 +192,66 @@ exports.default = (0, citty_1.defineCommand)({
         // Create the private key buffer
         let privateKeyBuffer;
         if (privateKey) {
-            if (privateKey.endsWith('.pem')) {
-                const fileExists = yield (0, file_1.fileExistsAtPath)(privateKey);
+            if (isPrivateKeyContent(privateKey)) {
+                // Handle plain text private key content
+                const formattedPrivateKey = formatPrivateKey(privateKey);
+                privateKeyBuffer = createBufferFromString(formattedPrivateKey);
+            }
+            else if (privateKey.endsWith('.pem')) {
+                // Handle file path
+                const fileExists = await fileExistsAtPath(privateKey);
                 if (fileExists) {
-                    privateKeyBuffer = yield (0, buffer_1.createBufferFromPath)(privateKey);
+                    const keyBuffer = await createBufferFromPath(privateKey);
+                    const keyContent = keyBuffer.toString('utf8');
+                    const formattedPrivateKey = formatPrivateKey(keyContent);
+                    privateKeyBuffer = createBufferFromString(formattedPrivateKey);
                 }
                 else {
-                    consola_1.default.error('Private key file not found.');
+                    consola.error('Private key file not found.');
                     process.exit(1);
                 }
             }
             else {
-                consola_1.default.error('Private key must be a path to a .pem file.');
+                consola.error('Private key must be either a path to a .pem file or the private key content as plain text.');
                 process.exit(1);
             }
         }
         let appBundleId;
         try {
             // Create the app bundle
-            consola_1.default.start('Creating bundle...');
+            consola.start('Creating bundle...');
             let checksum;
             let signature;
             if (path && url) {
                 // Create the file buffer
-                if (!zip_1.default.isZipped(path)) {
-                    consola_1.default.error('The path must be a zip file when providing a URL.');
+                if (!zip.isZipped(path)) {
+                    consola.error('The path must be a zip file when providing a URL.');
                     process.exit(1);
                 }
-                const fileBuffer = yield (0, buffer_1.createBufferFromPath)(path);
+                const fileBuffer = await createBufferFromPath(path);
                 // Generate checksum
-                checksum = yield (0, hash_1.createHash)(fileBuffer);
+                checksum = await createHash(fileBuffer);
                 // Sign the bundle
                 if (privateKeyBuffer) {
-                    signature = yield (0, signature_1.createSignature)(privateKeyBuffer, fileBuffer);
+                    signature = await createSignature(privateKeyBuffer, fileBuffer);
                 }
             }
-            const response = yield app_bundles_1.default.create({
+            const response = await appBundlesService.create({
                 appId,
                 artifactType,
-                channelName,
+                channelName: channel,
                 checksum,
                 gitCommitMessage: commitMessage,
                 gitCommitRef: commitRef,
                 gitCommitSha: commitSha,
                 customProperties: parseCustomProperties(customProperty),
-                expiresAt: expiresAt,
+                expiresAt,
                 url,
                 maxAndroidAppVersionCode: androidMax,
                 maxIosAppVersionCode: iosMax,
                 minAndroidAppVersionCode: androidMin,
                 minIosAppVersionCode: iosMin,
-                rolloutPercentage,
+                rolloutPercentage: rollout,
                 signature,
             });
             appBundleId = response.id;
@@ -281,132 +264,133 @@ exports.default = (0, citty_1.defineCommand)({
                     let appBundleFileId;
                     // Upload the app bundle files
                     if (artifactType === 'manifest') {
-                        yield uploadFiles({ appId, appBundleId: response.id, path, privateKeyBuffer });
+                        await uploadFiles({ appId, appBundleId: response.id, path, privateKeyBuffer });
                     }
                     else {
-                        const result = yield uploadZip({ appId, appBundleId: response.id, path, privateKeyBuffer });
+                        const result = await uploadZip({ appId, appBundleId: response.id, path, privateKeyBuffer });
                         appBundleFileId = result.appBundleFileId;
                     }
                     // Update the app bundle
-                    consola_1.default.start('Updating bundle...');
-                    yield app_bundles_1.default.update({ appBundleFileId, appId, artifactStatus: 'ready', appBundleId: response.id });
+                    consola.start('Updating bundle...');
+                    await appBundlesService.update({
+                        appBundleFileId,
+                        appId,
+                        artifactStatus: 'ready',
+                        appBundleId: response.id,
+                    });
                 }
             }
-            consola_1.default.success('Bundle successfully created.');
-            consola_1.default.info(`Bundle ID: ${response.id}`);
+            consola.success('Bundle successfully created.');
+            consola.info(`Bundle ID: ${response.id}`);
         }
         catch (error) {
             if (appBundleId) {
-                yield app_bundles_1.default.delete({ appId, appBundleId }).catch(() => {
+                await appBundlesService.delete({ appId, appBundleId }).catch(() => {
                     // No-op
                 });
             }
-            const message = (0, error_1.getMessageFromUnknownError)(error);
-            consola_1.default.error(message);
-            process.exit(1);
+            throw error;
         }
-    }),
+    },
 });
-const uploadFile = (options) => __awaiter(void 0, void 0, void 0, function* () {
+const uploadFile = async (options) => {
+    let { appId, appBundleId, buffer, href, mimeType, name, privateKeyBuffer, retryOnFailure } = options;
     try {
         // Generate checksum
-        const hash = yield (0, hash_1.createHash)(options.buffer);
+        const hash = await createHash(buffer);
         // Sign the bundle
         let signature;
-        if (options.privateKeyBuffer) {
-            signature = yield (0, signature_1.createSignature)(options.privateKeyBuffer, options.buffer);
+        if (privateKeyBuffer) {
+            signature = await createSignature(privateKeyBuffer, buffer);
         }
         // Create the multipart upload
-        return yield app_bundle_files_1.default.create({
-            appId: options.appId,
-            appBundleId: options.appBundleId,
-            buffer: options.buffer,
+        return await appBundleFilesService.create({
+            appId,
+            appBundleId,
+            buffer,
             checksum: hash,
-            href: options.href,
-            mimeType: options.mimeType,
-            name: options.name,
+            href,
+            mimeType,
+            name,
             signature,
         });
     }
     catch (error) {
-        if (options.retryOnFailure) {
-            return uploadFile(Object.assign(Object.assign({}, options), { retryOnFailure: false }));
+        if (retryOnFailure) {
+            return uploadFile({
+                ...options,
+                retryOnFailure: false,
+            });
         }
         throw error;
     }
-});
-const uploadFiles = (options) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const uploadFiles = async (options) => {
+    let { appId, appBundleId, path, privateKeyBuffer } = options;
     // Generate the manifest file
-    yield (0, manifest_1.generateManifestJson)(options.path);
+    await generateManifestJson(path);
     // Get all files in the directory
-    const files = yield (0, file_1.getFilesInDirectoryAndSubdirectories)(options.path);
+    const files = await getFilesInDirectoryAndSubdirectories(path);
     // Iterate over each file
     let fileIndex = 0;
-    const uploadNextFile = () => __awaiter(void 0, void 0, void 0, function* () {
+    const uploadNextFile = async () => {
         if (fileIndex >= files.length) {
             return;
         }
         const file = files[fileIndex];
         fileIndex++;
-        consola_1.default.start(`Uploading file (${fileIndex}/${files.length})...`);
-        const buffer = yield (0, buffer_1.createBufferFromPath)(file.path);
-        yield uploadFile({
-            appId: options.appId,
-            appBundleId: options.appBundleId,
+        consola.start(`Uploading file (${fileIndex}/${files.length})...`);
+        const buffer = await createBufferFromPath(file.path);
+        await uploadFile({
+            appId,
+            appBundleId: appBundleId,
             buffer,
             href: file.href,
             mimeType: file.mimeType,
             name: file.name,
-            privateKeyBuffer: options.privateKeyBuffer,
+            privateKeyBuffer: privateKeyBuffer,
             retryOnFailure: true,
         });
-        yield uploadNextFile();
-    });
-    const uploadPromises = Array.from({ length: config_1.MAX_CONCURRENT_UPLOADS });
-    for (let i = 0; i < config_1.MAX_CONCURRENT_UPLOADS; i++) {
+        await uploadNextFile();
+    };
+    const uploadPromises = Array.from({ length: MAX_CONCURRENT_UPLOADS });
+    for (let i = 0; i < MAX_CONCURRENT_UPLOADS; i++) {
         uploadPromises[i] = uploadNextFile();
     }
-    yield Promise.all(uploadPromises);
-});
-const uploadZip = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    await Promise.all(uploadPromises);
+};
+const uploadZip = async (options) => {
+    let { appId, appBundleId, path, privateKeyBuffer } = options;
     // Read the zip file
     let fileBuffer;
-    if (zip_1.default.isZipped(options.path)) {
-        const readStream = (0, fs_1.createReadStream)(options.path);
-        fileBuffer = yield (0, buffer_1.createBufferFromReadStream)(readStream);
+    if (zip.isZipped(path)) {
+        const readStream = createReadStream(path);
+        fileBuffer = await createBufferFromReadStream(readStream);
     }
     else {
-        consola_1.default.start('Zipping folder...');
-        fileBuffer = yield zip_1.default.zipFolder(options.path);
+        consola.start('Zipping folder...');
+        fileBuffer = await zip.zipFolder(path);
     }
     // Upload the zip file
-    consola_1.default.start('Uploading file...');
-    const result = yield uploadFile({
-        appId: options.appId,
-        appBundleId: options.appBundleId,
+    consola.start('Uploading file...');
+    const result = await uploadFile({
+        appId,
+        appBundleId: appBundleId,
         buffer: fileBuffer,
         mimeType: 'application/zip',
         name: 'bundle.zip',
-        privateKeyBuffer: options.privateKeyBuffer,
+        privateKeyBuffer: privateKeyBuffer,
     });
     return {
         appBundleFileId: result.id,
     };
-});
+};
 const parseCustomProperties = (customProperty) => {
     let customProperties;
     if (customProperty) {
         customProperties = {};
-        if (Array.isArray(customProperty)) {
-            for (const property of customProperty) {
-                const [key, value] = property.split('=');
-                if (key && value) {
-                    customProperties[key] = value;
-                }
-            }
-        }
-        else {
-            const [key, value] = customProperty.split('=');
+        for (const property of customProperty) {
+            const [key, value] = property.split('=');
             if (key && value) {
                 customProperties[key] = value;
             }