caprover-api 0.0.21 → 0.0.23

package/dist/api/ApiManager.js

@@ -78,12 +78,19 @@ class ApiManager {
     }
     saveTheme(oldName, theme) {
         const http = this.http;
-        return Promise.resolve() //
-            .then(http.fetch(http.POST, '/user/system/themes/update', {
+        const payload = {
             oldName,
             name: theme.name,
             content: theme.content,
-        }));
+        };
+        if (theme.extra !== undefined) {
+            payload.extra = theme.extra;
+        }
+        if (theme.headEmbed !== undefined) {
+            payload.headEmbed = theme.headEmbed;
+        }
+        return Promise.resolve() //
+            .then(http.fetch(http.POST, '/user/system/themes/update', payload));
     }
     deleteTheme(themeName) {
         const http = this.http;

package/dist/api/HttpClient.js

@@ -47,7 +47,16 @@ let NAMESPACE = 'x-namespace';
 let CAPTAIN = 'captain';
 class CrossFetchEngine {
     static async post(url, variables, headers, bodyType) {
-        const res = await (0, cross_fetch_1.default)(url, createPostRequestInit(variables, headers, bodyType));
+        const request = createPostRequestInit(variables, headers, bodyType);
+        // node-fetch v2 (used by cross-fetch) stringifies native FormData.
+        // Keep native FormData paired with the runtime's native fetch encoder.
+        const isNativeFormData = bodyType === 'form-data' &&
+            typeof globalThis.FormData !== 'undefined' &&
+            variables instanceof globalThis.FormData &&
+            typeof globalThis.fetch === 'function';
+        const res = isNativeFormData
+            ? await globalThis.fetch(url, request)
+            : await (0, cross_fetch_1.default)(url, request);
         if (!res.ok) {
             const errBody = await res.text();
             throw new Error(`HTTP ${res.status}: ${errBody}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "caprover-api",
-    "version": "0.0.21",
+    "version": "0.0.23",
     "description": "API client for CapRover",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",

package/src/api/ApiManager.ts

@@ -145,15 +145,28 @@ export default class ApiManager {
 
     saveTheme(oldName: string, theme: CapRoverTheme): Promise<{}> {
         const http = this.http
-
-        return Promise.resolve() //
-            .then(
-                http.fetch(http.POST, '/user/system/themes/update', {
-                    oldName,
-                    name: theme.name,
-                    content: theme.content,
-                })
-            )
+        const payload: {
+            oldName: string
+            name: string
+            content: string
+            extra?: string
+            headEmbed?: string
+        } = {
+            oldName,
+            name: theme.name,
+            content: theme.content,
+        }
+
+        if (theme.extra !== undefined) {
+            payload.extra = theme.extra
+        }
+
+        if (theme.headEmbed !== undefined) {
+            payload.headEmbed = theme.headEmbed
+        }
+
+        return Promise.resolve() //
+            .then(http.fetch(http.POST, '/user/system/themes/update', payload))
     }
 
     deleteTheme(themeName: string): Promise<{}> {

package/src/api/HttpClient.ts

@@ -64,10 +64,17 @@ class CrossFetchEngine {
         headers: Record<string, string>,
         bodyType: RequestBodyType
     ): Promise<any> {
-        const res = await fetch(
-            url,
-            createPostRequestInit(variables, headers, bodyType)
-        )
+        const request = createPostRequestInit(variables, headers, bodyType)
+        // node-fetch v2 (used by cross-fetch) stringifies native FormData.
+        // Keep native FormData paired with the runtime's native fetch encoder.
+        const isNativeFormData =
+            bodyType === 'form-data' &&
+            typeof globalThis.FormData !== 'undefined' &&
+            variables instanceof globalThis.FormData &&
+            typeof globalThis.fetch === 'function'
+        const res = isNativeFormData
+            ? await globalThis.fetch(url, request)
+            : await fetch(url, request)
 
         if (!res.ok) {
             const errBody = await res.text()

package/test/ApiManager.test.js

@@ -101,3 +101,48 @@ test('executeGenericApiCommand accepts PATCH', async () => {
 
     assert.equal(requests[0].method, 'PATCH')
 })
+
+test('saveTheme sends supplied writable theme fields', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.saveTheme('old-theme', {
+        name: 'new-theme',
+        content: 'theme-content',
+        extra: '{"siderTheme":"dark"}',
+        headEmbed: '<meta name="theme-marker" content="test">',
+        builtIn: true,
+    })
+
+    assert.deepEqual(requests, [
+        {
+            method: 'POST',
+            endpoint: '/user/system/themes/update',
+            data: {
+                oldName: 'old-theme',
+                name: 'new-theme',
+                content: 'theme-content',
+                extra: '{"siderTheme":"dark"}',
+                headEmbed: '<meta name="theme-marker" content="test">',
+            },
+            bodyType: 'json',
+        },
+    ])
+})
+
+test('saveTheme omits unspecified optional theme fields', async () => {
+    const { api, requests } = createApiWithRequestRecorder()
+
+    await api.saveTheme('old-theme', {
+        name: 'new-theme',
+        content: 'theme-content',
+    })
+
+    assert.deepEqual(requests[0].data, {
+        oldName: 'old-theme',
+        name: 'new-theme',
+        content: 'theme-content',
+    })
+    assert.equal('extra' in requests[0].data, false)
+    assert.equal('headEmbed' in requests[0].data, false)
+    assert.equal(JSON.stringify(requests[0].data).includes('undefined'), false)
+})

package/test/HttpClient.test.js

@@ -74,3 +74,90 @@ test('authentication retry preserves the form-data body type', async () => {
     assert.equal(loginRequests, 1)
     assert.deepEqual(bodyTypes, ['form-data', 'form-data'])
 })
+
+for (const cachedToken of ['', 'stale-token']) {
+    test(`automatic login retries once with cached token ${JSON.stringify(cachedToken)}`, async () => {
+        let token = cachedToken
+        let logins = 0
+        const seen = []
+        const client = new HttpClient(
+            'https://captain.example.com',
+            async () => token,
+            async () => {
+                logins++
+                token = 'fresh-token'
+            }
+        )
+        client.fetchInternal = async () => {
+            const headers = await client.createHeaders()
+            seen.push(headers['x-captain-auth'])
+            return seen.length === 1
+                ? { status: ErrorFactory.STATUS_AUTH_TOKEN_INVALID }
+                : { status: ErrorFactory.OKAY, data: { success: true } }
+        }
+        assert.deepEqual(await client.fetch(client.GET, '/user/apps', {})(), {
+            success: true,
+        })
+        assert.equal(logins, 1)
+        assert.deepEqual(seen, [cachedToken || undefined, 'fresh-token'])
+    })
+}
+
+test('repeated authorization failure is propagated after one retry', async () => {
+    let requests = 0
+    let logins = 0
+    const client = new HttpClient(
+        'https://captain.example.com',
+        async () => '',
+        async () => {
+            logins++
+        }
+    )
+    client.fetchInternal = async () => {
+        requests++
+        return {
+            status: ErrorFactory.STATUS_AUTH_TOKEN_INVALID,
+            description: 'still invalid',
+        }
+    }
+    await assert.rejects(
+        client.fetch(client.GET, '/user/apps', {})(),
+        (error) => {
+            assert.equal(
+                error.captainStatus,
+                ErrorFactory.STATUS_AUTH_TOKEN_INVALID
+            )
+            assert.equal(error.captainMessage, 'still invalid')
+            return true
+        }
+    )
+    assert.equal(requests, 2)
+    assert.equal(logins, 1)
+})
+
+test('ordinary server errors preserve status and message without retrying', async () => {
+    let requests = 0
+    const client = new HttpClient(
+        'https://captain.example.com',
+        async () => 'valid',
+        async () => {
+            assert.fail('unexpected login')
+        }
+    )
+    client.fetchInternal = async () => {
+        requests++
+        return {
+            status: ErrorFactory.ILLEGAL_PARAMETER,
+            description: 'invalid input',
+        }
+    }
+    await assert.rejects(
+        client.fetch(client.POST, '/user/apps', {})(),
+        (error) => {
+            assert.equal(error.captainStatus, ErrorFactory.ILLEGAL_PARAMETER)
+            assert.equal(error.captainMessage, 'invalid input')
+            return true
+        }
+    )
+    assert.equal(requests, 1)
+})

package/test/NativeFormData.test.js

@@ -0,0 +1,58 @@
+const assert = require('node:assert/strict')
+const { createServer } = require('node:http')
+const { once } = require('node:events')
+const test = require('node:test')
+const {
+    default: ApiManager,
+    SimpleAuthenticationProvider,
+} = require('../dist/api/ApiManager')
+
+test('uploadAppData sends a real multipart file through the Node transport', async () => {
+    const requests = []
+    const server = createServer(async (req, res) => {
+        const chunks = []
+        for await (const chunk of req) chunks.push(chunk)
+        requests.push({
+            url: req.url,
+            headers: req.headers,
+            body: Buffer.concat(chunks),
+        })
+        res.setHeader('Content-Type', 'application/json')
+        res.end(JSON.stringify({ status: 100, data: {} }))
+    })
+    server.listen(0, '127.0.0.1')
+    await once(server, 'listening')
+    const provider = new SimpleAuthenticationProvider(async () => ({
+        password: 'unused',
+    }))
+    provider.onAuthTokenUpdated('test-token')
+    const api = new ApiManager(
+        `http://127.0.0.1:${server.address().port}`,
+        provider
+    )
+    try {
+        const payload = new Uint8Array([0, 255, 128, 10, 42])
+        await api.uploadAppData(
+            'fixture',
+            new File([payload], 'fixture.tar', { type: 'application/x-tar' }),
+            false
+        )
+        assert.equal(requests.length, 1)
+        const request = requests[0]
+        assert.equal(request.url, '/api/v2/user/apps/appData/fixture')
+        assert.equal(request.headers['x-captain-auth'], 'test-token')
+        assert.match(
+            request.headers['content-type'],
+            /^multipart\/form-data; boundary=/
+        )
+        assert.match(
+            request.body.toString(),
+            /name="sourceFile"; filename="fixture.tar"/
+        )
+        assert.ok(request.body.includes(Buffer.from(payload)))
+    } finally {
+        api.destroy()
+        server.closeAllConnections()
+        await new Promise((resolve) => server.close(resolve))
+    }
+})