d1s 0.2.1

package/scripts/studio.js

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import open from 'open';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createHash } from 'crypto';
+import { homedir } from 'os';
+import os from 'os';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import express from 'express';
+import { createServer } from 'http';
+import next from 'next';
+import { findWranglerConfig } from '../src/lib/find-wrangler-config.js';
+
+// Compute the absolute path of this file and its directory.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// console.log(chalk.blue('Resolved __filename:'), __filename);
+// console.log(chalk.blue('Resolved __dirname:'), __dirname);
+
+// License validation utilities
+class LicenseError extends Error {
+  constructor(message, type = 'VALIDATION_ERROR') {
+    super(message);
+    this.name = 'LicenseError';
+    this.type = type;
+  }
+}
+
+async function generateHardwareId() {
+  const osInfo = {
+    platform: process.platform,
+    arch: process.arch,
+    cpus: os.cpus().length,
+    hostname: os.hostname(),
+    username: os.userInfo().username,
+  };
+  const systemString = JSON.stringify(osInfo);
+  return createHash('sha256').update(systemString).digest('hex');
+}
+
+async function validateLicenseRemote(licenseKey, email, hardwareId) {
+  const baseUrl =
+    process.env.NODE_ENV === 'development'
+      ? 'http://localhost:4000'
+      : 'https://d1-studio.com';
+
+  try {
+    const response = await fetch(`${baseUrl}/api/validate-license`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        licenseKey,
+        email,
+        hardwareId,
+      }),
+    });
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      throw new LicenseError(
+        result.message || 'License validation failed',
+        result.type || 'VALIDATION_ERROR'
+      );
+    }
+
+    return result;
+  } catch (error) {
+    if (error instanceof LicenseError) {
+      throw error;
+    }
+
+    if (error.name === 'TypeError' && error.message.includes('fetch')) {
+      throw new LicenseError(
+        process.env.NODE_ENV === 'development'
+          ? 'Unable to connect to local license validation service. Make sure the development server is running.'
+          : 'Unable to connect to license server. Please check your internet connection.',
+        'CONNECTION_ERROR'
+      );
+    }
+
+    throw new LicenseError(
+      'An unexpected error occurred during license validation',
+      'VALIDATION_ERROR'
+    );
+  }
+}
+
+async function checkLicenseFile() {
+  const licenseDir = join(homedir(), '.d1studio');
+  const licensePath = join(licenseDir, 'license.json');
+
+  try {
+    const licenseData = JSON.parse(await readFile(licensePath, 'utf8'));
+    const hardwareId = await generateHardwareId();
+
+    if (licenseData.hardwareId !== hardwareId) {
+      return null;
+    }
+
+    return licenseData;
+  } catch (error) {
+    return null;
+  }
+}
+
+async function saveLicenseFile(licenseData) {
+  const licenseDir = join(homedir(), '.d1studio');
+  const licensePath = join(licenseDir, 'license.json');
+
+  try {
+    await mkdir(licenseDir, { recursive: true });
+    await writeFile(licensePath, JSON.stringify(licenseData, null, 2));
+  } catch (error) {
+    throw new LicenseError('Failed to save license information', 'SAVE_ERROR');
+  }
+}
+
+async function startServer(port, projectDirectory) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const dev = process.env.NODE_ENV === 'development';
+    // Point to the parent directory that contains both app and .next
+    const dir = join(__dirname, '..');
+    const app = next({ 
+      dev,
+      dir,
+      conf: {
+        distDir: '.next',
+        // Ensure app directory is correctly set for routing
+        experimental: {
+          appDir: true
+        }
+      }
+    });
+    const handle = app.getRequestHandler();
+
+    app.prepare()
+      .then(() => {
+        const server = express();
+        
+        // Set environment variables
+        process.env.PORT = port.toString();
+        process.env.D1_PROJECT_DIR = projectDirectory;
+
+        // Create HTTP server
+        const httpServer = createServer((req, res) => {
+          handle(req, res);
+        });
+
+        // Handle all requests through Next.js
+        server.all('*', (req, res) => {
+          return handle(req, res);
+        });
+
+        // Start listening
+        httpServer.listen(port, (err) => {
+          if (err) {
+            console.error(chalk.red('Failed to start server:'), err);
+            rejectPromise(err);
+            return;
+          }
+
+          console.log(chalk.green(`Server started on port ${port}`));
+          resolvePromise(httpServer);
+        });
+
+        // Handle server errors
+        httpServer.on('error', (err) => {
+          console.error(chalk.red('Server error:'), err);
+          rejectPromise(err);
+        });
+      })
+      .catch((err) => {
+        console.error(chalk.red('Failed to prepare Next.js app:'), err);
+        rejectPromise(err);
+      });
+  });
+}
+
+async function startStudio() {
+  try {
+    console.log(chalk.green('Initializing D1 Studio...'));
+
+    // Validate license
+    let licenseData = await checkLicenseFile();
+    console.log(chalk.blue('License data found:'), licenseData);
+
+    if (!licenseData) {
+      const { default: inquirer } = await import('inquirer');
+      console.log(chalk.blue('\nPlease enter your D1 Studio license information:'));
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'licenseKey',
+          message: 'License Key:',
+          validate: (input) => input.length > 0 || 'License key is required',
+        },
+        {
+          type: 'input',
+          name: 'email',
+          message: 'Email:',
+          validate: (input) => {
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            return emailRegex.test(input) || 'Please enter a valid email';
+          },
+        },
+      ]);
+
+      console.log(chalk.blue('Entered license information:'), answers);
+
+      const hardwareId = await generateHardwareId();
+      // console.log(chalk.blue('Generated hardware ID:'), hardwareId);
+
+      try {
+        const validation = await validateLicenseRemote(
+          answers.licenseKey,
+          answers.email,
+          hardwareId
+        );
+
+        licenseData = {
+          licenseKey: answers.licenseKey,
+          email: answers.email,
+          hardwareId,
+          licenseType: validation.licenseType,
+          activatedAt: new Date().toISOString(),
+        };
+
+        await saveLicenseFile(licenseData);
+        console.log(chalk.green('\nLicense activated successfully!'));
+      } catch (error) {
+        console.error(chalk.red('\nLicense validation failed:'), error.message);
+        process.exit(1);
+      }
+    }
+
+    // Get wrangler configuration
+    try {
+      const userProjectPath = process.cwd();
+      // console.log(chalk.blue('Current working directory:'), userProjectPath);
+    
+      if (!userProjectPath) {
+        console.error(chalk.red('Error: Could not determine project directory'));
+        process.exit(1);
+      }
+    
+      const wranglerResult = await findWranglerConfig(userProjectPath);
+      // console.log(chalk.blue('Wrangler config result:'), wranglerResult);
+    
+      if (!wranglerResult || !wranglerResult.config) {
+        console.error(chalk.red('\nError: No wrangler.toml found in current directory'));
+        console.log(chalk.yellow('Make sure you are in a Cloudflare Workers project directory'));
+        console.log(chalk.yellow('with a valid wrangler.toml file.'));
+        process.exit(1);
+      }
+    
+      const { config, projectPath } = wranglerResult;
+      // console.log(chalk.blue('Resolved wrangler.toml project path:'), projectPath);
+    
+      if (!config.d1_databases?.length) {
+        console.error(chalk.red('\nError: No D1 databases configured in wrangler.toml'));
+        console.log(chalk.yellow('\nAdd D1 configuration to your wrangler.toml:'));
+        console.log(chalk.gray(`
+    [[d1_databases]]
+    binding = "DB"
+    database_name = "my-database"
+    database_id = "<your-database-id>"
+        `));
+        process.exit(1);
+      }
+    
+      // Display found databases
+      console.log(chalk.green('\nFound D1 databases:'));
+      config.d1_databases.forEach((db) => {
+        console.log(chalk.blue(`  - ${db.database_name} (${db.binding})`));
+      });
+
+      const port = 4000;
+      const url = `http://localhost:${port}`;
+
+      await startServer(port, projectPath);
+
+      console.log(chalk.green(`
+    ┌─────────────────────────────────────────┐
+    │                                         │
+    │   D1 Studio is running on port ${port}    │
+    │                                         │
+    │   Local:  ${url}        │
+    │                                         │
+    └─────────────────────────────────────────┘
+      `));
+
+      // Add delay before opening browser
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      try {
+        await open(url, {
+          wait: false,
+          url: true,
+          app: {
+            name: open.apps.chrome
+          }
+        }).catch(() => {
+          return open(url, {
+            wait: false,
+            url: true
+          });
+        });
+      } catch (browserError) {
+        console.log(chalk.yellow('\nCould not automatically open browser.'));
+        console.log(chalk.blue('Please open your browser and navigate to:'), url);
+      }
+
+    } catch (configError) {
+      console.error(chalk.red('\nConfiguration error:'), configError.message);
+      process.exit(1);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('\nFailed to start D1 Studio:'), error);
+    process.exit(1);
+  }
+}
+
+// Handle termination
+process.on('SIGINT', () => {
+  console.log(chalk.yellow('\nShutting down D1 Studio...'));
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.log(chalk.yellow('\nShutting down D1 Studio...'));
+  process.exit(0);
+});
+
+startStudio().catch((error) => {
+  console.error(chalk.red('\nFailed to start D1 Studio:'), error);
+  process.exit(1);
+});

package/scripts/test.js

@@ -0,0 +1,168 @@
+// scripts/test.js
+import { findWranglerConfig } from '../src/lib/find-wrangler-config.js';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function testWranglerConfig() {
+  console.log('\nTesting Wrangler configuration...');
+
+  // Test with valid wrangler.toml
+  const validConfig = `
+[[d1_databases]]
+binding = "DB"
+database_name = "test_db"
+database_id = "test-id"
+  `;
+
+  const tempDir = await fs.mkdtemp(join(os.tmpdir(), 'd1-studio-test-'));
+  await fs.writeFile(join(tempDir, 'wrangler.toml'), validConfig);
+
+  try {
+    const config = await findWranglerConfig(tempDir);
+    if (!config || !config.config.d1_databases) {
+      console.warn(chalk.yellow('⚠ Valid wrangler.toml test: Config parsing incomplete'));
+    } else {
+      console.log(chalk.green('✓ Valid wrangler.toml test passed'));
+    }
+  } catch (error) {
+    console.warn(chalk.yellow('⚠ Valid wrangler.toml test issues:'), error.message);
+  }
+
+  // Test with invalid wrangler.toml
+  try {
+    await fs.writeFile(join(tempDir, 'wrangler.toml'), 'invalid: config: {');
+    await findWranglerConfig(tempDir);
+    console.warn(chalk.yellow('⚠ Invalid wrangler.toml test: Did not catch invalid config'));
+  } catch (error) {
+    console.log(chalk.green('✓ Invalid wrangler.toml handling test passed'));
+  }
+
+  // Cleanup
+  await fs.rm(tempDir, { recursive: true }).catch(() => {});
+}
+
+async function testProjectStructure() {
+  console.log('\nTesting project structure...');
+
+  // Check required directories exist
+  const requiredDirs = ['src', 'scripts', 'dist'];
+  for (const dir of requiredDirs) {
+    try {
+      await fs.access(join(__dirname, '..', dir));
+      console.log(chalk.green(`✓ ${dir} directory exists`));
+    } catch {
+      console.warn(chalk.yellow(`⚠ ${dir} directory missing`));
+    }
+  }
+
+  // Check required files exist
+  const requiredFiles = [
+    'package.json',
+    'next.config.js',
+    'tailwind.config.js',
+    'scripts/studio.js'
+  ];
+  
+  for (const file of requiredFiles) {
+    try {
+      await fs.access(join(__dirname, '..', file));
+      console.log(chalk.green(`✓ ${file} exists`));
+    } catch {
+      console.warn(chalk.yellow(`⚠ ${file} missing`));
+    }
+  }
+}
+
+async function testStudioScript() {
+  console.log('\nTesting studio.js script...');
+
+  try {
+    const studioPath = join(__dirname, 'studio.js');
+    const stats = await fs.stat(studioPath);
+
+    // Check file permissions (should be executable)
+    const isExecutable = (stats.mode & 0o111) !== 0;
+    if (!isExecutable) {
+      console.warn(chalk.yellow('⚠ studio.js is not executable'));
+    } else {
+      console.log(chalk.green('✓ studio.js has correct permissions'));
+    }
+
+    // Check file content
+    const content = await fs.readFile(studioPath, 'utf8');
+    const requiredImports = ['chalk', 'open', 'findWranglerConfig'];
+    
+    let missingImports = [];
+    for (const imp of requiredImports) {
+      if (!content.includes(imp)) {
+        missingImports.push(imp);
+      }
+    }
+
+    if (missingImports.length > 0) {
+      console.warn(chalk.yellow(`⚠ studio.js missing imports: ${missingImports.join(', ')}`));
+    } else {
+      console.log(chalk.green('✓ studio.js contains required imports'));
+    }
+
+  } catch (error) {
+    console.warn(chalk.yellow('⚠ studio.js test issues:'), error.message);
+  }
+}
+
+async function testUserConfig() {
+  console.log('\nTesting user configuration...');
+
+  const homeDir = os.homedir();
+  const d1StudioDir = join(homeDir, '.d1studio');
+
+  try {
+    await fs.access(d1StudioDir);
+    console.log(chalk.green('✓ D1 Studio config directory exists'));
+
+    const licenseFile = join(d1StudioDir, 'license.json');
+    try {
+      await fs.access(licenseFile);
+      console.log(chalk.green('✓ License file exists'));
+      
+      // Validate license file structure
+      const license = JSON.parse(await fs.readFile(licenseFile, 'utf8'));
+      const requiredFields = ['licenseKey', 'email', 'hardwareId'];
+      
+      const missingFields = requiredFields.filter(field => !license[field]);
+      if (missingFields.length > 0) {
+        console.warn(chalk.yellow(`⚠ License file missing fields: ${missingFields.join(', ')}`));
+      }
+    } catch {
+      console.warn(chalk.yellow('⚠ License file not found or invalid'));
+    }
+  } catch {
+    console.warn(chalk.yellow('⚠ D1 Studio config directory not found'));
+  }
+}
+
+async function runTests() {
+  console.log(chalk.blue('Running D1 Studio tests...'));
+  
+  try {
+    await testProjectStructure();
+    await testWranglerConfig();
+    await testStudioScript();
+    await testUserConfig();
+
+    console.log(chalk.green('\nTests completed! 🎉'));
+    console.log(chalk.blue('Check warnings above for any issues that need attention.'));
+  } catch (error) {
+    console.warn(chalk.yellow('\nSome tests encountered issues:'), error.message);
+  }
+}
+
+runTests().catch(error => {
+  console.warn(chalk.yellow('Test suite encountered issues:'), error.message);
+});

package/src/app/api/cloudflare/route.js

@@ -0,0 +1,146 @@
+// api/cloudflare/route.js
+
+import { NextResponse } from 'next/server';
+import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+
+/**
+ * Validates the provided Cloudflare credentials by fetching databases.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ */
+async function validateCredentials(accountId, apiToken) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database`, {
+    headers: {
+      'Authorization': `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Invalid Cloudflare credentials');
+  }
+
+  return response.json();
+}
+
+/**
+ * Fetches the list of databases from Cloudflare and returns the one that matches the given name.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ * @param {string} databaseName - The name of the database to find.
+ */
+async function findDatabase(accountId, apiToken, databaseName) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database`, {
+    headers: {
+      'Authorization': `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch databases');
+  }
+
+  const { result } = await response.json();
+  return result.find(db => db.name === databaseName);
+}
+
+/**
+ * Creates a new database on Cloudflare.
+ * @param {string} accountId - Cloudflare account ID.
+ * @param {string} apiToken - Cloudflare API token.
+ * @param {string} databaseName - The name for the new database.
+ */
+async function createDatabase(accountId, apiToken, databaseName) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/d1/database`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      name: databaseName,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to create database');
+  }
+
+  return response.json();
+}
+
+/**
+ * API POST handler to validate credentials, read the Wrangler configuration, and ensure the D1 database exists.
+ */
+export async function POST(req) {
+  try {
+    // Parse accountId and apiToken from the request body.
+    const { accountId, apiToken } = await req.json();
+    const projectDir = process.env.D1_PROJECT_DIR;
+
+    // Check if the project directory is set.
+    if (!projectDir) {
+      return NextResponse.json(
+        { error: 'Project directory not configured' },
+        { status: 500 }
+      );
+    }
+
+    // Validate Cloudflare credentials.
+    await validateCredentials(accountId, apiToken);
+
+    // Retrieve the Wrangler configuration using the centralized helper.
+    const wranglerResult = await findWranglerConfig(projectDir);
+    if (!wranglerResult || !wranglerResult.config) {
+      return NextResponse.json(
+        { error: 'No Wrangler configuration file found in project directory' },
+        { status: 404 }
+      );
+    }
+    const config = wranglerResult.config;
+
+    // Ensure that at least one D1 database is configured.
+    if (!config.d1_databases?.length) {
+      return NextResponse.json(
+        { error: 'No D1 databases configured in Wrangler configuration' },
+        { status: 400 }
+      );
+    }
+
+    // Use the first configured D1 database.
+    const localDb = config.d1_databases[0];
+    
+    // Check if the database exists on Cloudflare.
+    let database = await findDatabase(accountId, apiToken, localDb.database_name);
+    
+    // If not found, create the database.
+    if (!database) {
+      const result = await createDatabase(accountId, apiToken, localDb.database_name);
+      database = result.result;
+    }
+
+    // Return the database details in the response.
+    return NextResponse.json({
+      success: true,
+      database: {
+        id: database.uuid,
+        name: database.name,
+      }
+    });
+
+  } catch (error) {
+    console.error('Cloudflare API error:', error);
+    return NextResponse.json(
+      { error: error.message },
+      { status: error.message.includes('Invalid credentials') ? 401 : 500 }
+    );
+  }
+}
+
+/**
+ * OPTIONS handler for pre-flight requests.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, { status: 204 });
+}