nca-ai-cms-astro-plugin 1.0.17 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nca-ai-cms-astro-plugin",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",

package/src/api/db/upload.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'fs/promises';
+
+const mockClose = vi.fn();
+const mockReconnect = vi.fn();
+
+vi.mock('astro:db', () => ({
+  db: {
+    $client: {
+      close: mockClose,
+      reconnect: mockReconnect,
+    },
+  },
+}));
+
+vi.mock('fs/promises', () => ({
+  writeFile: vi.fn().mockResolvedValue(undefined),
+  copyFile: vi.fn().mockResolvedValue(undefined),
+}));
+
+// SQLite file header
+const SQLITE_HEADER = Buffer.from('SQLite format 3\0');
+
+function createSqliteBuffer(size = 4096): Buffer {
+  const buf = Buffer.alloc(size);
+  SQLITE_HEADER.copy(buf);
+  return buf;
+}
+
+function createFormDataRequest(file: Buffer, fieldName = 'database'): Request {
+  const formData = new FormData();
+  formData.append(fieldName, new Blob([file]), 'test.db');
+  return new Request('http://localhost/api/db/upload', {
+    method: 'POST',
+    body: formData,
+  });
+}
+
+function createOctetStreamRequest(file: Buffer): Request {
+  return new Request('http://localhost/api/db/upload', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: file,
+  });
+}
+
+describe('DB Upload API', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.ASTRO_DATABASE_FILE = '.astro/content.db';
+  });
+
+  it('accepts a valid SQLite file via multipart/form-data', async () => {
+    const { POST } = await import('./upload.js');
+    const request = createFormDataRequest(createSqliteBuffer());
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.success).toBe(true);
+    expect(data.size).toBeGreaterThan(0);
+  });
+
+  it('accepts a valid SQLite file via application/octet-stream', async () => {
+    const { POST } = await import('./upload.js');
+    const request = createOctetStreamRequest(createSqliteBuffer());
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.success).toBe(true);
+  });
+
+  it('rejects non-SQLite files', async () => {
+    const { POST } = await import('./upload.js');
+    const badFile = Buffer.from('not a sqlite file');
+    const request = createFormDataRequest(badFile);
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toContain('not a SQLite database');
+  });
+
+  it('rejects missing database field', async () => {
+    const { POST } = await import('./upload.js');
+    const formData = new FormData();
+    formData.append('wrongfield', new Blob([createSqliteBuffer()]), 'test.db');
+    const request = new Request('http://localhost/api/db/upload', {
+      method: 'POST',
+      body: formData,
+    });
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toContain('No database file');
+  });
+
+  it('rejects invalid content type', async () => {
+    const { POST } = await import('./upload.js');
+    const request = new Request('http://localhost/api/db/upload', {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/plain' },
+      body: 'hello',
+    });
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toContain('Invalid content type');
+  });
+
+  it('creates a backup before writing', async () => {
+    const { POST } = await import('./upload.js');
+    const request = createFormDataRequest(createSqliteBuffer());
+
+    await POST({ request } as any);
+
+    expect(fs.copyFile).toHaveBeenCalled();
+  });
+
+  it('reconnects the DB client after successful upload', async () => {
+    const { POST } = await import('./upload.js');
+    const request = createFormDataRequest(createSqliteBuffer());
+
+    await POST({ request } as any);
+
+    expect(mockClose).toHaveBeenCalledOnce();
+    expect(mockReconnect).toHaveBeenCalledOnce();
+  });
+
+  it('rejects oversized file via multipart/form-data', async () => {
+    const { POST } = await import('./upload.js');
+    const oversized = createSqliteBuffer(50 * 1024 * 1024 + 1);
+    const request = createFormDataRequest(oversized);
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(413);
+    expect(data.error).toContain('too large');
+  });
+
+  it('rejects oversized file via application/octet-stream', async () => {
+    const { POST } = await import('./upload.js');
+    const oversized = createSqliteBuffer(50 * 1024 * 1024 + 1);
+    const request = createOctetStreamRequest(oversized);
+
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(413);
+    expect(data.error).toContain('too large');
+  });
+
+  it('still succeeds if reconnect is not available', async () => {
+    const { POST } = await import('./upload.js');
+    mockClose.mockImplementation(() => { throw new Error('not available'); });
+
+    const request = createFormDataRequest(createSqliteBuffer());
+    const response = await POST({ request } as any);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.success).toBe(true);
+  });
+});

package/src/api/db/upload.ts

@@ -2,6 +2,8 @@ import type { APIRoute } from 'astro';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { jsonResponse, jsonError } from '../_utils';
+// @ts-ignore - resolved by Astro build pipeline
+import { db } from 'astro:db';
 
 const MAX_DB_SIZE = 50 * 1024 * 1024; // 50 MB
 
@@ -64,6 +66,17 @@ export const POST: APIRoute = async ({ request }) => {
 
     await fs.writeFile(dbPath, dbBuffer);
 
+    // Reconnect DB client to pick up the new file
+    try {
+      const client = (db as any).$client;
+      if (client?.close && client?.reconnect) {
+        await client.close();
+        await client.reconnect();
+      }
+    } catch {
+      // Reconnect not available — manual restart needed
+    }
+
     return jsonResponse({
       success: true,
       size: dbBuffer.length,

package/update.md

@@ -1,3 +1,18 @@
+# v1.0.18
+
+## Fix: DB upload reconnects client after file replacement
+- After writing the new SQLite file, the libsql client is closed and reconnected via `db.$client.close()` / `db.$client.reconnect()`
+- Close and reconnect calls are now properly awaited to prevent race conditions with async DB operations
+- Changes from uploaded database are immediately visible without node restart
+- Graceful fallback: if reconnect is not available, upload still succeeds (manual restart needed)
+
+## Tests: DB upload endpoint coverage
+- 10 tests covering upload endpoint — validation, backup, reconnect behavior, size limits
+- Added size limit rejection tests for both `multipart/form-data` and `application/octet-stream` content types
+- Tests verify 50 MB max file size is enforced with proper 413 status response
+
+---
+
 # v1.0.17
 
 ## Feature: Database download/upload via Editor UI