@cloud-cli/d0 1.8.0 → 1.9.0

package/README.md

@@ -15,6 +15,13 @@ console.log(schema.tables, schema.statements);
 
 **GET /api** returns an OpenAPI 3.1 description of the HTTP API.
 
+**POST /clone** creates a copy of the selected database. The target name must contain only letters, numbers, and hyphens. An existing target returns `409` until overwrite is explicitly confirmed.
+
+```js
+await db.clone('test-copy');
+await db.clone('test-copy', true); // overwrite an existing copy
+```
+
 The web console uses an explicit method selector instead of guessing from SQL text. Use `all` or `get` for reads, `run` for one prepared statement, `exec` for DDL or multiple statements, and `transaction` to run the entered SQL atomically.
 
 **POST /query**

package/client.mjs

@@ -30,6 +30,16 @@ export async function schema({ internal = false } = {}) {
   throw new Error(await req.text());
 }
 
+export async function clone(name, overwrite = false) {
+  const req = await fetch(new URL('/clone', baseURL), {
+    method: 'POST',
+    body: JSON.stringify({ name, overwrite }),
+  });
+
+  if (req.ok) return req.json();
+  throw new Error(await req.text());
+}
+
 export async function transaction(statements, pragma = pragmas) {
   return query('transaction', undefined, undefined, pragma, statements);
 }
@@ -45,4 +55,4 @@ export function pragma(p) {
   }
 }
 
-export default { query, get, run, all, exec, transaction, schema, pragma };
+export default { query, get, run, all, exec, transaction, schema, clone, pragma };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createServer } from 'node:http';
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import SQLite from 'better-sqlite3';
 import { join } from 'node:path';
@@ -12,6 +12,7 @@ const maxDatabases = Math.max(1, Number.parseInt(process.env.MAX_DATABASES || '3
 const maxBodyBytes = Math.max(1, Number.parseInt(process.env.MAX_BODY_BYTES || '1048576', 10) || 1048576);
 const slowQueryMs = Math.max(0, Number.parseInt(process.env.SLOW_QUERY_MS || '1000', 10) || 1000);
 const databases = new Map();
+const cloneLocks = new Set();
 mkdirSync(dataPath, { recursive: true });
 export function getDatabase(file) {
     const fullPath = join(dataPath, file);
@@ -89,6 +90,8 @@ export async function handleRequest(request, response, db) {
             return onSchema(response, db, url.searchParams.get('internal') === '1');
         case 'POST /query':
             return onQuery(request, response, db);
+        case 'POST /clone':
+            return onClone(request, response, db);
         default:
             response.writeHead(404).end();
     }
@@ -136,8 +139,21 @@ function onApi(request, response) {
                 },
             },
             '/index.mjs': { get: { summary: 'Get the consumer ES module', responses: { '200': { description: 'JavaScript module.' } } } },
-            '/console.html': { get: { summary: 'Get the web console', responses: { '200': { description: 'HTML console.' } } } },
-            '/logo.svg': { get: { summary: 'Get the d0 logo', responses: { '200': { description: 'SVG image.' } } } },
+            '/clone': {
+                post: {
+                    summary: 'Clone the selected database',
+                    requestBody: {
+                        required: true,
+                        content: { 'application/json': { schema: { $ref: '#/components/schemas/CloneRequest' } } },
+                    },
+                    responses: {
+                        '201': { description: 'Database cloned.' },
+                        '400': { description: 'Invalid database name.' },
+                        '409': { description: 'Target exists and overwrite was not confirmed.' },
+                        '503': { description: 'Another clone is already running for the target.' },
+                    },
+                },
+            },
         },
         components: {
             schemas: {
@@ -161,11 +177,71 @@ function onApi(request, response) {
                         m: { type: 'string', enum: ['all', 'get', 'run', 'exec'], default: 'run' },
                     },
                 },
+                CloneRequest: {
+                    type: 'object',
+                    required: ['name'],
+                    properties: {
+                        name: { type: 'string', pattern: '^[a-zA-Z0-9][a-zA-Z0-9-]*$', description: 'Name of the cloned database.' },
+                        overwrite: { type: 'boolean', default: false, description: 'Replace the target if it already exists.' },
+                    },
+                },
             },
         },
     };
     sendJson(response, 200, document);
 }
+async function onClone(request, response, source) {
+    const body = await readBody(request);
+    if (!body) {
+        sendError(response, 413, new Error('Request body too large.'));
+        return;
+    }
+    try {
+        const { name: requestedName, overwrite = false } = JSON.parse(body.toString('utf-8'));
+        const name = String(requestedName || '').replace(/\.sqlite3$/i, '');
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(name)) {
+            sendError(response, 400, new Error('Invalid database name.'));
+            return;
+        }
+        const target = join(dataPath, `${name}.sqlite3`);
+        const sourcePath = join(dataPath, source);
+        if (target === sourcePath) {
+            sendError(response, 400, new Error('The clone must have a different name.'));
+            return;
+        }
+        if (cloneLocks.has(target)) {
+            sendError(response, 503, new Error('A clone is already running for this database.'));
+            return;
+        }
+        const exists = existsSync(target);
+        if (exists && overwrite !== true) {
+            sendJson(response, 409, { exists: true, name, requiresOverwrite: true });
+            return;
+        }
+        cloneLocks.add(target);
+        try {
+            const targetDatabase = databases.get(target);
+            if (targetDatabase) {
+                targetDatabase.close();
+                databases.delete(target);
+            }
+            if (exists) {
+                rmSync(target, { force: true });
+                rmSync(`${target}-wal`, { force: true });
+                rmSync(`${target}-shm`, { force: true });
+            }
+            await getDatabase(source).backup(target);
+            sendJson(response, 201, { name, overwritten: exists });
+        }
+        finally {
+            cloneLocks.delete(target);
+        }
+    }
+    catch (error) {
+        DEBUG && console.error(error);
+        sendError(response, 400, error);
+    }
+}
 async function onSchema(response, db, includeInternal) {
     try {
         const sqlite = getDatabase(db);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/d0",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "packageManager": "pnpm@12.3.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",