caprover-api 0.0.19 → 0.0.21

package/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish npm package
+
+on:
+    push:
+        branches:
+            - release
+
+permissions:
+    contents: read
+    id-token: write
+
+jobs:
+    publish:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Check out repository
+              uses: actions/checkout@v4
+
+            - name: Set up Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 24
+                  registry-url: https://registry.npmjs.org
+
+            - name: Install dependencies
+              run: npm ci
+
+            - name: Run tests
+              run: npm test
+
+            - name: Publish package
+              run: npm publish --access public

package/dist/api/ApiManager.d.ts

@@ -1,4 +1,4 @@
-import { IAppDef } from '../models/AppDefinition';
+import { IAppDef, IAppDefinitionPatch } from '../models/AppDefinition';
 import AppDefinitionsResponse from '../models/AppDefinitionsResponse';
 import AppDeleteResponse from '../models/AppDeleteResponse';
 import { IAutomatedCleanupConfigs } from '../models/AutomatedCleanupConfigs';
@@ -75,11 +75,13 @@ export default class ApiManager {
     getAllProjects(): Promise<ProjectsResponse>;
     fetchBuildLogs(appName: string): Promise<BuildLogsResponse>;
     fetchAppLogsInHex(appName: string): Promise<LogsResponse>;
-    uploadAppData(appName: string, file: File): Promise<void>;
+    fetchAppLogs(appName: string, encoding?: string): Promise<LogsResponse>;
+    uploadAppData(appName: string, file: File, detached?: boolean): Promise<void>;
     registerProject(selectedProject: ProjectDefinition): Promise<ProjectDefinition>;
     updateProject(project: ProjectDefinition): Promise<void>;
     uploadCaptainDefinitionContent(appName: string, captainDefinition: ICaptainDefinition, gitHash: string, detached: boolean): Promise<void>;
     updateConfigAndSave(appName: string, appDefinition: IAppDef): Promise<void>;
+    patchAppDefinition(appName: string, patch: IAppDefinitionPatch): Promise<void>;
     renameApp(oldAppName: string, newAppName: string): Promise<void>;
     registerNewApp(appName: string, projectId: string, hasPersistentData: boolean, detached: boolean): Promise<void>;
     deleteApp(appName: string | undefined, volumes: string[], appNames: string[] | undefined): Promise<AppDeleteResponse>;
@@ -128,5 +130,5 @@ export default class ApiManager {
         jobId: string;
     }>;
     getOneClickAppDeployProgress(jobId: string): Promise<OneClickAppDeploymentState>;
-    executeGenericApiCommand(verb: 'GET' | 'POST', endpoint: string, data: any): Promise<any>;
+    executeGenericApiCommand(verb: 'GET' | 'POST' | 'PATCH', endpoint: string, data: any): Promise<any>;
 }

package/dist/api/ApiManager.js

@@ -163,16 +163,21 @@ class ApiManager {
             .then(http.fetch(http.GET, `/user/apps/appData/${appName}`, {}));
     }
     fetchAppLogsInHex(appName) {
+        return this.fetchAppLogs(appName, 'hex');
+    }
+    fetchAppLogs(appName, encoding = 'ascii') {
         const http = this.http;
         return Promise.resolve() //
-            .then(http.fetch(http.GET, `/user/apps/appData/${appName}/logs?encoding=hex`, {}));
+            .then(http.fetch(http.GET, `/user/apps/appData/${appName}/logs`, {
+            encoding,
+        }));
     }
-    uploadAppData(appName, file) {
+    uploadAppData(appName, file, detached = true) {
         const http = this.http;
         let formData = new FormData();
         formData.append('sourceFile', file);
         return Promise.resolve() //
-            .then(http.fetch(http.POST, `/user/apps/appData/${appName}?detached=1`, formData));
+            .then(http.fetch(http.POST, `/user/apps/appData/${appName}${detached ? '?detached=1' : ''}`, formData, http.FORM_DATA));
     }
     registerProject(selectedProject) {
         const http = this.http;
@@ -243,6 +248,14 @@ class ApiManager {
             projectId: projectId,
         }));
     }
+    patchAppDefinition(appName, patch) {
+        const http = this.http;
+        return Promise.resolve() //
+            .then(http.fetch(http.PATCH, '/user/apps/appDefinitions/update', {
+            ...patch,
+            appName,
+        }));
+    }
     renameApp(oldAppName, newAppName) {
         const http = this.http;
         return Promise.resolve() //

package/dist/api/HttpClient.d.ts

@@ -1,15 +1,22 @@
+export type RequestBodyType = 'json' | 'form-data';
+export type HttpMethod = 'GET' | 'POST' | 'PATCH';
+export declare function createPostRequestInit(variables: any, headers: Record<string, string>, bodyType: RequestBodyType): RequestInit;
+export declare function createPatchRequestInit(variables: any, headers: Record<string, string>): RequestInit;
 export default class HttpClient {
     private baseUrl;
     private authTokenProvider;
     private onLoginRequested;
     readonly GET = "GET";
     readonly POST = "POST";
+    readonly PATCH = "PATCH";
+    readonly FORM_DATA = "form-data";
     isDestroyed: boolean;
     constructor(baseUrl: string, authTokenProvider: () => Promise<string>, onLoginRequested: () => Promise<void>);
     createHeaders(): Promise<any>;
     destroy(): void;
-    fetch(method: 'GET' | 'POST', endpoint: string, variables: any): () => Promise<any>;
-    fetchInternal(method: 'GET' | 'POST', endpoint: string, variables: any): Promise<any>;
+    fetch(method: HttpMethod, endpoint: string, variables: any, bodyType?: RequestBodyType): () => Promise<any>;
+    fetchInternal(method: HttpMethod, endpoint: string, variables: any, bodyType?: RequestBodyType): Promise<any>;
     getReq(endpoint: string, variables: any): Promise<any>;
-    postReq(endpoint: string, variables: any): Promise<any>;
+    postReq(endpoint: string, variables: any, bodyType?: RequestBodyType): Promise<any>;
+    patchReq(endpoint: string, variables: any): Promise<any>;
 }

package/dist/api/HttpClient.js

@@ -3,8 +3,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostRequestInit = createPostRequestInit;
+exports.createPatchRequestInit = createPatchRequestInit;
 const ErrorFactory_1 = __importDefault(require("./ErrorFactory"));
 const cross_fetch_1 = __importDefault(require("cross-fetch"));
+function createPostRequestInit(variables, headers, bodyType) {
+    if (bodyType === 'form-data') {
+        return {
+            method: 'POST',
+            headers,
+            body: variables,
+        };
+    }
+    return {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(variables),
+    };
+}
+function createPatchRequestInit(variables, headers) {
+    return {
+        method: 'PATCH',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(variables),
+    };
+}
 function buildQueryParams(params) {
     if (!params || Object.keys(params).length === 0)
         return '';
@@ -17,15 +46,8 @@ let TOKEN_HEADER = 'x-captain-auth';
 let NAMESPACE = 'x-namespace';
 let CAPTAIN = 'captain';
 class CrossFetchEngine {
-    static async post(url, variables, headers) {
-        const res = await (0, cross_fetch_1.default)(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-            },
-            body: JSON.stringify(variables),
-        });
+    static async post(url, variables, headers, bodyType) {
+        const res = await (0, cross_fetch_1.default)(url, createPostRequestInit(variables, headers, bodyType));
         if (!res.ok) {
             const errBody = await res.text();
             throw new Error(`HTTP ${res.status}: ${errBody}`);
@@ -50,6 +72,14 @@ class CrossFetchEngine {
         }
         return res.json();
     }
+    static async patch(url, variables, headers) {
+        const res = await (0, cross_fetch_1.default)(url, createPatchRequestInit(variables, headers));
+        if (!res.ok) {
+            const errBody = await res.text();
+            throw new Error(`HTTP ${res.status}: ${errBody}`);
+        }
+        return res.json();
+    }
 }
 class HttpClient {
     constructor(baseUrl, authTokenProvider, onLoginRequested) {
@@ -58,6 +88,8 @@ class HttpClient {
         this.onLoginRequested = onLoginRequested;
         this.GET = 'GET';
         this.POST = 'POST';
+        this.PATCH = 'PATCH';
+        this.FORM_DATA = 'form-data';
         this.isDestroyed = false;
         //
     }
@@ -78,12 +110,12 @@ class HttpClient {
     destroy() {
         this.isDestroyed = true;
     }
-    fetch(method, endpoint, variables) {
+    fetch(method, endpoint, variables, bodyType = 'json') {
         const self = this;
         return function () {
             return Promise.resolve() //
                 .then(function () {
-                return self.fetchInternal(method, endpoint, variables); //
+                return self.fetchInternal(method, endpoint, variables, bodyType); //
             })
                 .then(function (fetchResponse) {
                 if (
@@ -94,7 +126,7 @@ class HttpClient {
                         .onLoginRequested() //
                         .then(function () {
                         return self
-                            .fetchInternal(method, endpoint, variables)
+                            .fetchInternal(method, endpoint, variables, bodyType)
                             .then(function (httpResponse) {
                             return httpResponse;
                         });
@@ -134,11 +166,13 @@ class HttpClient {
             });
         };
     }
-    fetchInternal(method, endpoint, variables) {
+    fetchInternal(method, endpoint, variables, bodyType = 'json') {
         if (method === this.GET)
             return this.getReq(endpoint, variables);
         if (method === this.POST)
-            return this.postReq(endpoint, variables);
+            return this.postReq(endpoint, variables, bodyType);
+        if (method === this.PATCH)
+            return this.patchReq(endpoint, variables);
         throw new Error(`Unknown method: ${method}`);
     }
     getReq(endpoint, variables) {
@@ -155,19 +189,32 @@ class HttpClient {
             return data;
         });
     }
-    postReq(endpoint, variables) {
+    postReq(endpoint, variables, bodyType = 'json') {
         const self = this;
         return Promise.resolve() //
             .then(function () {
             return self.createHeaders();
         })
             .then(function (headers) {
-            return CrossFetchEngine.post(self.baseUrl + endpoint, variables, headers);
+            return CrossFetchEngine.post(self.baseUrl + endpoint, variables, headers, bodyType);
         })
             .then(function (data) {
             // console.log(data);
             return data;
         });
     }
+    patchReq(endpoint, variables) {
+        const self = this;
+        return Promise.resolve() //
+            .then(function () {
+            return self.createHeaders();
+        })
+            .then(function (headers) {
+            return CrossFetchEngine.patch(self.baseUrl + endpoint, variables, headers);
+        })
+            .then(function (data) {
+            return data;
+        });
+    }
 }
 exports.default = HttpClient;

package/dist/models/AppDefinition.d.ts

@@ -72,6 +72,7 @@ export interface IAppDefinitionBase {
     envVars: IAppEnvVar[];
     versions: IAppVersion[];
     appDeployTokenConfig?: AppDeployTokenConfig;
+    isLegacyAppName?: boolean;
 }
 export interface IHttpAuth {
     user: string;
@@ -82,6 +83,12 @@ export interface AppDeployTokenConfig {
     enabled: boolean;
     appDeployToken?: string;
 }
+export type IAppDefinitionPatch = Partial<Pick<IAppDefinitionBase, 'projectId' | 'description' | 'instanceCount' | 'captainDefinitionRelativeFilePath' | 'envVars' | 'volumes' | 'tags' | 'nodeId' | 'notExposeAsWebApp' | 'containerHttpPort' | 'forceSsl' | 'ports' | 'customNginxConfig' | 'redirectDomain' | 'preDeployFunction' | 'serviceUpdateOverride' | 'websocketSupport' | 'appDeployTokenConfig'>> & {
+    httpAuth?: IHttpAuth;
+    appPushWebhook?: {
+        repoInfo?: RepoInfo;
+    };
+};
 export interface IAppDef extends IAppDefinitionBase {
     appPushWebhook?: {
         tokenVersion: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "caprover-api",
-    "version": "0.0.19",
+    "version": "0.0.21",
     "description": "API client for CapRover",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",
@@ -9,7 +9,7 @@
         "formatter-write": "prettier --write './src/**/*.ts*'",
         "tslint": "tslint -c tslint.json -p tsconfig.json",
         "tslint-fix": "tslint --fix -c tslint.json -p tsconfig.json",
-        "test": "echo \"Error: no test specified\" && exit 1",
+        "test": "npm run build && node --test test/*.test.js",
         "build": "rm -rf ./dist && npm run tslint && npx tsc && chmod +x ./dist -R",
         "dev": "rm -rf ./dist && npx tsc && node ./dist/example.js",
         "generate-barrels": "rm ./src/models/index.ts && barrelsby --directory src/models"

package/src/api/ApiManager.ts

@@ -1,4 +1,4 @@
-import { IAppDef } from '../models/AppDefinition'
+import { IAppDef, IAppDefinitionPatch } from '../models/AppDefinition'
 import AppDefinitionsResponse from '../models/AppDefinitionsResponse'
 import AppDeleteResponse from '../models/AppDeleteResponse'
 import { IAutomatedCleanupConfigs } from '../models/AutomatedCleanupConfigs'
@@ -270,19 +270,28 @@ export default class ApiManager {
     }
 
     fetchAppLogsInHex(appName: string): Promise<LogsResponse> {
+        return this.fetchAppLogs(appName, 'hex')
+    }
+
+    fetchAppLogs(
+        appName: string,
+        encoding: string = 'ascii'
+    ): Promise<LogsResponse> {
         const http = this.http
 
         return Promise.resolve() //
             .then(
-                http.fetch(
-                    http.GET,
-                    `/user/apps/appData/${appName}/logs?encoding=hex`,
-                    {}
-                )
+                http.fetch(http.GET, `/user/apps/appData/${appName}/logs`, {
+                    encoding,
+                })
             )
     }
 
-    uploadAppData(appName: string, file: File): Promise<void> {
+    uploadAppData(
+        appName: string,
+        file: File,
+        detached: boolean = true
+    ): Promise<void> {
         const http = this.http
         let formData = new FormData()
         formData.append('sourceFile', file)
@@ -290,8 +299,11 @@ export default class ApiManager {
             .then(
                 http.fetch(
                     http.POST,
-                    `/user/apps/appData/${appName}?detached=1`,
-                    formData
+                    `/user/apps/appData/${appName}${
+                        detached ? '?detached=1' : ''
+                    }`,
+                    formData,
+                    http.FORM_DATA
                 )
             )
     }
@@ -398,6 +410,21 @@ export default class ApiManager {
             )
     }
 
+    patchAppDefinition(
+        appName: string,
+        patch: IAppDefinitionPatch
+    ): Promise<void> {
+        const http = this.http
+
+        return Promise.resolve() //
+            .then(
+                http.fetch(http.PATCH, '/user/apps/appDefinitions/update', {
+                    ...patch,
+                    appName,
+                })
+            )
+    }
+
     renameApp(oldAppName: string, newAppName: string): Promise<void> {
         const http = this.http
 
@@ -894,7 +921,7 @@ export default class ApiManager {
     }
 
     executeGenericApiCommand(
-        verb: 'GET' | 'POST',
+        verb: 'GET' | 'POST' | 'PATCH',
         endpoint: string,
         data: any
     ): Promise<any> {

package/src/api/HttpClient.ts

@@ -1,6 +1,46 @@
 import ErrorFactory from './ErrorFactory'
 import fetch from 'cross-fetch'
 
+export type RequestBodyType = 'json' | 'form-data'
+export type HttpMethod = 'GET' | 'POST' | 'PATCH'
+
+export function createPostRequestInit(
+    variables: any,
+    headers: Record<string, string>,
+    bodyType: RequestBodyType
+): RequestInit {
+    if (bodyType === 'form-data') {
+        return {
+            method: 'POST',
+            headers,
+            body: variables,
+        }
+    }
+
+    return {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(variables),
+    }
+}
+
+export function createPatchRequestInit(
+    variables: any,
+    headers: Record<string, string>
+): RequestInit {
+    return {
+        method: 'PATCH',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(variables),
+    }
+}
+
 function buildQueryParams(params: Record<string, any>): string {
     if (!params || Object.keys(params).length === 0) return ''
     return (
@@ -20,17 +60,14 @@ let CAPTAIN = 'captain'
 class CrossFetchEngine {
     public static async post(
         url: string,
-        variables: Record<string, any>,
-        headers: Record<string, string>
+        variables: any,
+        headers: Record<string, string>,
+        bodyType: RequestBodyType
     ): Promise<any> {
-        const res = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...headers,
-            },
-            body: JSON.stringify(variables),
-        })
+        const res = await fetch(
+            url,
+            createPostRequestInit(variables, headers, bodyType)
+        )
 
         if (!res.ok) {
             const errBody = await res.text()
@@ -64,11 +101,27 @@ class CrossFetchEngine {
         }
         return res.json()
     }
+
+    public static async patch(
+        url: string,
+        variables: any,
+        headers: Record<string, string>
+    ): Promise<any> {
+        const res = await fetch(url, createPatchRequestInit(variables, headers))
+
+        if (!res.ok) {
+            const errBody = await res.text()
+            throw new Error(`HTTP ${res.status}: ${errBody}`)
+        }
+        return res.json()
+    }
 }
 
 export default class HttpClient {
     public readonly GET = 'GET'
     public readonly POST = 'POST'
+    public readonly PATCH = 'PATCH'
+    public readonly FORM_DATA = 'form-data'
     public isDestroyed = false
 
     constructor(
@@ -99,12 +152,22 @@ export default class HttpClient {
         this.isDestroyed = true
     }
 
-    fetch(method: 'GET' | 'POST', endpoint: string, variables: any) {
+    fetch(
+        method: HttpMethod,
+        endpoint: string,
+        variables: any,
+        bodyType: RequestBodyType = 'json'
+    ) {
         const self = this
         return function (): Promise<any> {
             return Promise.resolve() //
                 .then(function () {
-                    return self.fetchInternal(method, endpoint, variables) //
+                    return self.fetchInternal(
+                        method,
+                        endpoint,
+                        variables,
+                        bodyType
+                    ) //
                 })
                 .then(function (fetchResponse) {
                     if (
@@ -116,7 +179,12 @@ export default class HttpClient {
                             .onLoginRequested() //
                             .then(function () {
                                 return self
-                                    .fetchInternal(method, endpoint, variables)
+                                    .fetchInternal(
+                                        method,
+                                        endpoint,
+                                        variables,
+                                        bodyType
+                                    )
                                     .then(function (httpResponse) {
                                         return httpResponse
                                     })
@@ -159,10 +227,18 @@ export default class HttpClient {
         }
     }
 
-    fetchInternal(method: 'GET' | 'POST', endpoint: string, variables: any) {
+    fetchInternal(
+        method: HttpMethod,
+        endpoint: string,
+        variables: any,
+        bodyType: RequestBodyType = 'json'
+    ) {
         if (method === this.GET) return this.getReq(endpoint, variables)
 
-        if (method === this.POST) return this.postReq(endpoint, variables)
+        if (method === this.POST)
+            return this.postReq(endpoint, variables, bodyType)
+
+        if (method === this.PATCH) return this.patchReq(endpoint, variables)
 
         throw new Error(`Unknown method: ${method}`)
     }
@@ -186,7 +262,11 @@ export default class HttpClient {
             })
     }
 
-    postReq(endpoint: string, variables: any) {
+    postReq(
+        endpoint: string,
+        variables: any,
+        bodyType: RequestBodyType = 'json'
+    ) {
         const self = this
         return Promise.resolve() //
             .then(function () {
@@ -196,7 +276,8 @@ export default class HttpClient {
                 return CrossFetchEngine.post(
                     self.baseUrl + endpoint,
                     variables,
-                    headers
+                    headers,
+                    bodyType
                 )
             })
             .then(function (data) {
@@ -204,4 +285,22 @@ export default class HttpClient {
                 return data
             })
     }
+
+    patchReq(endpoint: string, variables: any) {
+        const self = this
+        return Promise.resolve() //
+            .then(function () {
+                return self.createHeaders()
+            })
+            .then(function (headers) {
+                return CrossFetchEngine.patch(
+                    self.baseUrl + endpoint,
+                    variables,
+                    headers
+                )
+            })
+            .then(function (data) {
+                return data
+            })
+    }
 }

package/src/models/AppDefinition.ts

@@ -84,6 +84,10 @@ export interface IAppDefinitionBase {
     envVars: IAppEnvVar[]
     versions: IAppVersion[]
     appDeployTokenConfig?: AppDeployTokenConfig
+
+    // True for apps created before v1.15.0
+    // non-existent for apps created on or after v1.15.0
+    isLegacyAppName?: boolean
 }
 
 export interface IHttpAuth {
@@ -97,6 +101,33 @@ export interface AppDeployTokenConfig {
     appDeployToken?: string
 }
 
+export type IAppDefinitionPatch = Partial<
+    Pick<
+        IAppDefinitionBase,
+        | 'projectId'
+        | 'description'
+        | 'instanceCount'
+        | 'captainDefinitionRelativeFilePath'
+        | 'envVars'
+        | 'volumes'
+        | 'tags'
+        | 'nodeId'
+        | 'notExposeAsWebApp'
+        | 'containerHttpPort'
+        | 'forceSsl'
+        | 'ports'
+        | 'customNginxConfig'
+        | 'redirectDomain'
+        | 'preDeployFunction'
+        | 'serviceUpdateOverride'
+        | 'websocketSupport'
+        | 'appDeployTokenConfig'
+    >
+> & {
+    httpAuth?: IHttpAuth
+    appPushWebhook?: { repoInfo?: RepoInfo }
+}
+
 export interface IAppDef extends IAppDefinitionBase {
     appPushWebhook?: {
         tokenVersion: string

package/test/ApiManager.test.js

@@ -0,0 +1,103 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const ApiManagerModule = require('../dist/api/ApiManager')
+const ApiManager = ApiManagerModule.default
+const { SimpleAuthenticationProvider } = ApiManagerModule
+
+function createApiWithRequestRecorder() {
+    const api = new ApiManager(
+        'https://captain.example.com',
+        new SimpleAuthenticationProvider(() =>
+            Promise.resolve({ password: 'password' })
+        )
+    )
+    const requests = []
+
+    api.http = {
+        GET: 'GET',
+        POST: 'POST',
+        PATCH: 'PATCH',
+        FORM_DATA: 'form-data',
+        fetch(method, endpoint, data, bodyType = 'json') {
+            requests.push({ method, endpoint, data, bodyType })
+            return () => Promise.resolve({})
+        },
+    }
+
+    return { api, requests }
+}
+
+test('patchAppDefinition uses the partial update endpoint', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.patchAppDefinition('test-app', {
+        instanceCount: 2,
+        description: 'scaled app',
+    })
+
+    assert.deepEqual(requests, [
+        {
+            method: 'PATCH',
+            endpoint: '/user/apps/appDefinitions/update',
+            data: {
+                instanceCount: 2,
+                description: 'scaled app',
+                appName: 'test-app',
+            },
+            bodyType: 'json',
+        },
+    ])
+})
+
+test('fetchAppLogs exposes the backend encoding argument', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.fetchAppLogs('test-app', 'utf8')
+
+    assert.deepEqual(requests[0], {
+        method: 'GET',
+        endpoint: '/user/apps/appData/test-app/logs',
+        data: { encoding: 'utf8' },
+        bodyType: 'json',
+    })
+})
+
+test('fetchAppLogsInHex remains backward compatible', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.fetchAppLogsInHex('test-app')
+
+    assert.deepEqual(requests[0].data, { encoding: 'hex' })
+})
+
+test('uploadAppData keeps detached deployment as the default', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.uploadAppData('test-app', 'tar contents')
+
+    assert.equal(
+        requests[0].endpoint,
+        '/user/apps/appData/test-app?detached=1'
+    )
+    assert.equal(requests[0].bodyType, 'form-data')
+})
+
+test('uploadAppData can wait for an attached deployment', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.uploadAppData('test-app', 'tar contents', false)
+
+    assert.equal(requests[0].endpoint, '/user/apps/appData/test-app')
+    assert.equal(requests[0].bodyType, 'form-data')
+})
+
+test('executeGenericApiCommand accepts PATCH', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.executeGenericApiCommand('PATCH', '/user/example', {
+        value: true,
+    })
+
+    assert.equal(requests[0].method, 'PATCH')
+})

package/test/HttpClient.test.js

@@ -0,0 +1,76 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const ErrorFactory = require('../dist/api/ErrorFactory').default
+const HttpClientModule = require('../dist/api/HttpClient')
+const HttpClient = HttpClientModule.default
+const { createPostRequestInit } = HttpClientModule
+const { createPatchRequestInit } = HttpClientModule
+
+test('JSON requests preserve the existing serialization and content type', () => {
+    const payload = { appName: 'test-app' }
+    const request = createPostRequestInit(
+        payload,
+        { 'x-captain-auth': 'token' },
+        'json'
+    )
+
+    assert.deepEqual(request.headers, {
+        'Content-Type': 'application/json',
+        'x-captain-auth': 'token',
+    })
+    assert.equal(request.body, JSON.stringify(payload))
+})
+
+test('form data is passed through without setting a content type', () => {
+    const formData = { sourceFile: 'tar contents' }
+    const headers = { 'x-captain-auth': 'token' }
+    const request = createPostRequestInit(formData, headers, 'form-data')
+
+    assert.strictEqual(request.body, formData)
+    assert.deepEqual(request.headers, headers)
+    assert.equal(Object.hasOwn(request.headers, 'Content-Type'), false)
+})
+
+test('PATCH requests use JSON serialization and content type', () => {
+    const payload = { appName: 'test-app', instanceCount: 2 }
+    const request = createPatchRequestInit(payload, {
+        'x-captain-auth': 'token',
+    })
+
+    assert.equal(request.method, 'PATCH')
+    assert.deepEqual(request.headers, {
+        'Content-Type': 'application/json',
+        'x-captain-auth': 'token',
+    })
+    assert.equal(request.body, JSON.stringify(payload))
+})
+
+test('authentication retry preserves the form-data body type', async () => {
+    let loginRequests = 0
+    const bodyTypes = []
+    const client = new HttpClient(
+        'https://captain.example.com',
+        () => Promise.resolve('token'),
+        () => {
+            loginRequests++
+            return Promise.resolve()
+        }
+    )
+
+    client.fetchInternal = (_method, _endpoint, _variables, bodyType) => {
+        bodyTypes.push(bodyType)
+        if (bodyTypes.length === 1) {
+            return Promise.resolve({
+                status: ErrorFactory.STATUS_AUTH_TOKEN_INVALID,
+            })
+        }
+
+        return Promise.resolve({ status: ErrorFactory.OKAY, data: {} })
+    }
+
+    await client.fetch(client.POST, '/upload', {}, client.FORM_DATA)()
+
+    assert.equal(loginRequests, 1)
+    assert.deepEqual(bodyTypes, ['form-data', 'form-data'])
+})