d1s 0.2.11 → 0.2.12

package/scripts/studio.js

@@ -1,199 +0,0 @@
-#!/usr/bin/env node
-import chalk from 'chalk';
-import open from 'open';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import express from 'express';
-import { createServer } from 'http';
-import next from 'next';
-import { findWranglerConfig } from '../src/lib/find-wrangler-config.js';
-import logger from '../src/lib/logger.js';
-import updateNotifier from 'update-notifier';
-import pkg from '../package.json' with { type: 'json' };
-
-// Check for debug flag
-const hasDebugFlag = process.argv.includes('--debug');
-if (hasDebugFlag) {
-  process.env.DEBUG = 'true';
-  logger.debug('Debug mode enabled');
-}
-
-const notifier = updateNotifier({ 
-  pkg,
-  updateCheckInterval: 1000 * 60 * 60 * 24,
-});
-
-// Check if update is available
-if (notifier.update) {
-  // Get current version and latest version
-  const currentVersion = pkg.version;
-  const latestVersion = notifier.update.latest;
-  
-  // Version-specific messages
-  const versionMessages = {
-    // Add specific version messages here
-    '0.2.11': 'Fixed table toolbar and table view horizontal/vertical scroll issues'
-    // Add more version messages as needed
-  };
-
-  // Create custom message
-  let message = `Update available ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}`;
-  
-  // Add version-specific message if available
-  if (versionMessages[latestVersion]) {
-    message += `\n${chalk.cyan('What\'s new:')} ${versionMessages[latestVersion]}`;
-  }
-  
-  // Add installation instructions
-  message += `\nRun ${chalk.cyan('npm i -g d1s@latest')} to update`;
-
-  // Display custom notification
-  notifier.notify({ message });
-}
-
-// Compute the absolute path of this file and its directory
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-async function startServer(port, projectDirectory) {
-  return new Promise((resolvePromise, rejectPromise) => {
-    // Determine Next.js app directory based on environment:
-    // In production (published package) __dirname is used.
-    // In development (npm link), assume the build is in the parent folder.
-    const isProduction = process.env.NODE_ENV !== 'development';
-    const nextAppDir = isProduction ? __dirname : join(__dirname, '..');
-
-    const dev = process.env.NODE_ENV === 'development';
-    const app = next({ 
-      dev,
-      dir: nextAppDir,
-      conf: {
-        distDir: '.next',
-        experimental: { appDir: true }
-      }
-    });
-    const handle = app.getRequestHandler();
-
-    app.prepare()
-      .then(() => {
-        const server = express();
-        process.env.PORT = port.toString();
-        process.env.D1_PROJECT_DIR = projectDirectory;
-        const httpServer = createServer((req, res) => handle(req, res));
-
-        server.all('*', (req, res) => handle(req, res));
-
-        httpServer.listen(port, (err) => {
-          if (err) {
-            logger.error(chalk.red(`Failed to start server: ${err}`));
-            rejectPromise(err);
-            return;
-          }
-          logger.info(chalk.green(`Server started on port ${port}`));
-          resolvePromise(httpServer);
-        });
-
-        httpServer.on('error', (err) => {
-          logger.error(chalk.red(`Server error: ${err}`));
-          rejectPromise(err);
-        });
-      })
-      .catch((err) => {
-        logger.error(chalk.red(`Failed to prepare Next.js app: ${err}`));
-        rejectPromise(err);
-      });
-  });
-}
-
-async function startStudio() {
-  try {
-    logger.info(chalk.green('Initializing D1 Studio...'));
-
-    // Get wrangler configuration
-    try {
-      const userProjectPath = process.cwd();
-      if (!userProjectPath) {
-        logger.error(chalk.red('Error: Could not determine project directory'));
-        process.exit(1);
-      }
-
-      const wranglerResult = await findWranglerConfig(userProjectPath);
-      if (!wranglerResult || !wranglerResult.config) {
-        logger.error(chalk.red('\nError: No wrangler.toml found in current directory'));
-        logger.info(chalk.yellow('Make sure you are in a Cloudflare Workers project directory'));
-        logger.info(chalk.yellow('with a valid wrangler.toml file.'));
-        process.exit(1);
-      }
-
-      const { config, projectPath } = wranglerResult;
-      if (!config.d1_databases?.length) {
-        logger.error(chalk.red('\nError: No D1 databases configured in wrangler.toml'));
-        logger.info(chalk.yellow('\nAdd D1 configuration to your wrangler.toml:'));
-        logger.info(chalk.gray(`
-    [[d1_databases]]
-    binding = "DB"
-    database_name = "my-database"
-    database_id = "<your-database-id>"
-        `));
-        process.exit(1);
-      }
-
-      logger.info(chalk.green('\nFound D1 databases:'));
-      config.d1_databases.forEach((db) => {
-        logger.info(chalk.blue(`  - ${db.database_name} (${db.binding})`));
-      });
-
-      const port = 4000;
-      const url = `http://localhost:${port}`;
-
-      await startServer(port, projectPath);
-
-      logger.info(chalk.green(`
-    ┌─────────────────────────────────────────┐
-    │                                         │
-    │   D1 Studio is running on port ${port}    │
-    │                                         │
-    │   Local:  ${url}        │
-    │                                         │
-    └─────────────────────────────────────────┘
-      `));
-
-      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) {
-        logger.info(chalk.yellow('\nCould not automatically open browser.'));
-        logger.info(chalk.blue(`Please open your browser and navigate to: ${url}`));
-      }
-    } catch (configError) {
-      logger.error(chalk.red(`\nConfiguration error: ${configError.message}`));
-      process.exit(1);
-    }
-  } catch (error) {
-    logger.error(chalk.red(`\nFailed to start D1 Studio: ${error}`));
-    process.exit(1);
-  }
-}
-
-// Handle termination
-process.on('SIGINT', () => {
-  logger.info(chalk.yellow('\nShutting down D1 Studio...'));
-  process.exit(0);
-});
-
-process.on('SIGTERM', () => {
-  logger.info(chalk.yellow('\nShutting down D1 Studio...'));
-  process.exit(0);
-});
-
-startStudio().catch((error) => {
-  logger.error(chalk.red(`\nFailed to start D1 Studio: ${error}`));
-  process.exit(1);
-});

package/scripts/test.js

@@ -1,366 +0,0 @@
-// 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';
-import { exec, execSync } from 'child_process';
-import { promisify } from 'util';
-import winston from 'winston';
-import logger from '../src/lib/logger.js';
-
-const execAsync = promisify(exec);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Mock license data for testing
-const mockLicenseData = {
-  licenseKey: 'test-license-key',
-  email: 'test@example.com',
-  hardwareId: 'mock-hardware-id',
-  end_date: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(), // 30 days from now
-  subscription_status: 'active',
-  type: 'test',
-  activatedAt: new Date().toISOString()
-};
-
-// Test configuration file contents
-const mockNextConfig = `
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  output: 'standalone',
-}
-module.exports = nextConfig
-`;
-
-const mockTailwindConfig = `
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: [
-    './src/**/*.{js,ts,jsx,tsx,mdx}',
-  ],
-  theme: {
-    extend: {},
-  },
-  plugins: [],
-}
-`;
-
-// Test Wrangler config file contents
-const mockWranglerConfig = `
-[[d1_databases]]
-binding = "DB"
-database_name = "test_db"
-database_id = "test-id"
-`;
-
-// Create mock configuration files in a given directory.
-async function createMockConfigs(testDir) {
-  await fs.writeFile(join(testDir, 'next.config.js'), mockNextConfig);
-  await fs.writeFile(join(testDir, 'tailwind.config.js'), mockTailwindConfig);
-  await fs.writeFile(join(testDir, 'wrangler.toml'), mockWranglerConfig);
-}
-
-async function createMockPackageAndDist(testDir) {
-  const packageJsonPath = join(testDir, 'package.json');
-  const packageJsonContent = JSON.stringify({
-    name: "d1-studio",
-    version: "1.0.0",
-    main: "dist/d1-studio.js"
-  }, null, 2);
-  await fs.writeFile(packageJsonPath, packageJsonContent);
-
-  const distDir = join(testDir, 'dist');
-  await fs.mkdir(distDir, { recursive: true });
-  const d1StudioPath = join(distDir, 'd1-studio.js');
-  const d1StudioContent = `#!/usr/bin/env node
-if (process.argv.includes('--version')) {
-  console.log('1.0.0');
-} else {
-  console.log('D1 Studio CLI');
-}
-`;
-  await fs.writeFile(d1StudioPath, d1StudioContent);
-  await fs.chmod(d1StudioPath, 0o755);
-}
-
-async function testProjectStructure() {
-  console.log('\nTesting project structure...');
-  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`));
-    }
-  }
-  const testDir = await fs.mkdtemp(join(os.tmpdir(), 'd1-studio-test-'));
-  await createMockConfigs(testDir);
-  await createMockPackageAndDist(testDir);
-  const requiredFiles = [
-    'package.json',
-    'next.config.js',
-    'tailwind.config.js',
-    'scripts/studio.js'
-  ];
-  for (const file of requiredFiles) {
-    try {
-      await fs.access(join(testDir, file));
-      console.log(chalk.green(`✓ ${file} exists`));
-    } catch {
-      console.warn(chalk.yellow(`⚠ ${file} missing or not copied`));
-    }
-  }
-  return testDir;
-}
-
-async function testWranglerConfig(testDir) {
-  console.log('\nTesting Wrangler configuration...');
-  try {
-    const config = await findWranglerConfig(testDir);
-    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);
-  }
-  try {
-    await fs.writeFile(join(testDir, 'wrangler.toml'), 'invalid: config: {');
-    await findWranglerConfig(testDir);
-    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'));
-  }
-}
-
-async function testCaching(testDir) {
-  console.log('\nTesting caching of findWranglerConfig...');
-  const config1 = await findWranglerConfig(testDir);
-  console.log(chalk.green('✓ First call completed.'));
-  const config2 = await findWranglerConfig(testDir);
-  console.log(chalk.green('✓ Second call completed.'));
-  if (JSON.stringify(config1) === JSON.stringify(config2)) {
-    console.log(chalk.green('✓ Caching works: configurations are identical'));
-  } else {
-    console.warn(chalk.yellow('⚠ Caching issue: configurations differ'));
-  }
-  const newTestDir = await fs.mkdtemp(join(os.tmpdir(), 'new-d1-studio-test-'));
-  await fs.writeFile(join(newTestDir, 'wrangler.toml'), mockWranglerConfig);
-  const configNew = await findWranglerConfig(newTestDir);
-  console.log(chalk.green('✓ New project configuration loaded.'));
-  await fs.rm(newTestDir, { recursive: true, force: true });
-}
-
-async function testLoggerBehavior() {
-  console.log('\nTesting logger behavior in production mode...');
-  const { combine, timestamp, colorize, printf } = winston.format;
-  const logFormat = printf(({ level, message, timestamp }) => {
-    return `${timestamp} ${level}: ${message}`;
-  });
-  const originalNodeEnv = process.env.NODE_ENV;
-  const originalDebug = process.env.DEBUG;
-  process.env.NODE_ENV = 'production';
-  process.env.DEBUG = 'false';
-  class MemoryTransport extends winston.Transport {
-    constructor(opts) {
-      super(opts);
-      this.logs = [];
-    }
-    log(info, callback) {
-      this.logs.push(info);
-      callback();
-    }
-  }
-  const memTransport = new MemoryTransport({ level: 'warn' });
-  logger.configure({
-    level: 'warn',
-    format: combine(
-      timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
-      colorize(),
-      logFormat
-    ),
-    transports: [
-      new winston.transports.Console({ level: 'warn', silent: true }),
-      memTransport
-    ]
-  });
-  logger.debug('Test debug message');
-  logger.info('Test info message');
-  logger.warn('Test warn message');
-  logger.error('Test error message');
-  await new Promise(resolve => setTimeout(resolve, 100));
-  const messages = memTransport.logs.map(log => log.message);
-  if (messages.includes('Test debug message') || messages.includes('Test info message')) {
-    console.warn(chalk.yellow('⚠ Logger behavior failed in production mode: debug or info messages were logged.'));
-  } else {
-    console.log(chalk.green('✓ Logger behavior in production mode passed: only warn/error messages logged.'));
-  }
-  logger.clear();
-  process.env.NODE_ENV = originalNodeEnv;
-  process.env.DEBUG = originalDebug;
-}
-
-async function testPackageExecution(testDir) {
-  console.log('\nTesting package execution...');
-  try {
-    const destDir = join(testDir, 'node_modules', 'd1studio');
-    await fs.mkdir(destDir, { recursive: true });
-    await fs.cp(join(testDir, 'dist'), destDir, { recursive: true });
-    const d1StudioPath = join(destDir, 'dist', 'd1-studio.js');
-    try {
-      await fs.access(d1StudioPath);
-      console.log(chalk.green(`✓ Found d1-studio.js at ${d1StudioPath}`));
-    } catch (err) {
-      throw new Error(`d1-studio.js not found at ${d1StudioPath}`);
-    }
-    process.env.NODE_ENV = 'development';
-    await execAsync('node ./dist/d1-studio.js --version', { cwd: testDir });
-    console.log(chalk.green('✓ Development mode execution test passed'));
-    process.env.NODE_ENV = 'production';
-    await execAsync('node ./node_modules/d1studio/dist/d1-studio.js --version', { cwd: testDir });
-    console.log(chalk.green('✓ Production mode execution test passed'));
-  } catch (error) {
-    console.error(chalk.red('Package execution test failed:', error));
-  }
-}
-
-async function setupTestPackage(testDir) {
-  console.log('\nSetting up test package structure...');
-  try {
-    const packageDir = join(testDir, 'node_modules', 'd1studio');
-    await fs.mkdir(packageDir, { recursive: true });
-    await fs.cp(join(__dirname, '..', 'dist'), packageDir, { recursive: true, force: true });
-    const packageJson = JSON.parse(
-      await fs.readFile(join(__dirname, '..', 'package.json'), 'utf8')
-    );
-    await fs.writeFile(join(packageDir, 'package.json'), JSON.stringify(packageJson, null, 2));
-    await fs.chmod(join(packageDir, 'd1-studio.js'), 0o755);
-    console.log(chalk.green('✓ Package structure created successfully'));
-    return packageDir;
-  } catch (error) {
-    console.error(chalk.red('Failed to setup test package:', error));
-    throw error;
-  }
-}
-
-async function copyStudioScript(testDir) {
-  try {
-    await fs.mkdir(join(testDir, 'scripts'), { recursive: true });
-    await fs.copyFile(join(__dirname, 'studio.js'), join(testDir, 'scripts', 'studio.js'));
-    await fs.chmod(join(testDir, 'scripts', 'studio.js'), 0o755);
-    console.log(chalk.green('✓ studio.js copied and made executable'));
-  } catch (error) {
-    console.error(chalk.red('Failed to copy studio.js:', error));
-    throw error;
-  }
-}
-
-async function testStudioScript(testDir) {
-  console.log('\nTesting studio.js script...');
-  try {
-    await copyStudioScript(testDir);
-    const studioPath = join(testDir, 'scripts', 'studio.js');
-    const stats = await fs.stat(studioPath);
-    const isExecutable = (stats.mode & 0o111) !== 0;
-    if (!isExecutable) {
-      console.warn(chalk.yellow('⚠ studio.js is not executable'));
-      await fs.chmod(studioPath, 0o755);
-      console.log(chalk.green('✓ Made studio.js executable'));
-    } else {
-      console.log(chalk.green('✓ studio.js has correct permissions'));
-    }
-    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'));
-    }
-    try {
-      await execAsync('node ./scripts/studio.js --version', { 
-        cwd: testDir,
-        env: { ...process.env, NODE_PATH: join(testDir, 'node_modules') }
-      });
-      console.log(chalk.green('✓ studio.js execution test passed'));
-    } catch (execError) {
-      console.warn(chalk.yellow('⚠ studio.js execution test failed:', execError.message));
-    }
-  } catch (error) {
-    console.warn(chalk.yellow('⚠ studio.js test issues:'), error.message);
-  }
-}
-
-async function testLicenseValidation(testDir) {
-  console.log('\nTesting license validation...');
-  const d1StudioDir = join(testDir, '.d1studio');
-  const licenseFile = join(d1StudioDir, 'license.json');
-  try {
-    await fs.mkdir(d1StudioDir, { recursive: true });
-    await fs.writeFile(licenseFile, JSON.stringify(mockLicenseData, null, 2));
-    console.log(chalk.green('✓ Successfully created test license file'));
-    const license = JSON.parse(await fs.readFile(licenseFile, 'utf8'));
-    const requiredFields = ['licenseKey', 'email', 'hardwareId', 'subscription_status', 'end_date'];
-    const missingFields = requiredFields.filter(field => !license[field]);
-    if (missingFields.length > 0) {
-      console.warn(chalk.yellow(`⚠ License file missing fields: ${missingFields.join(', ')}`));
-    } else {
-      console.log(chalk.green('✓ License file structure validated'));
-    }
-    const expiredLicense = {
-      ...mockLicenseData,
-      end_date: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString() // 1 day ago
-    };
-    await fs.writeFile(licenseFile, JSON.stringify(expiredLicense, null, 2));
-    console.log(chalk.green('✓ Successfully tested expired license scenario'));
-    const expiringSoonLicense = {
-      ...mockLicenseData,
-      end_date: new Date(Date.now() + 5 * 24 * 60 * 60 * 1000).toISOString() // 5 days from now
-    };
-    await fs.writeFile(licenseFile, JSON.stringify(expiringSoonLicense, null, 2));
-    console.log(chalk.green('✓ Successfully tested expiring soon scenario'));
-  } catch (error) {
-    console.error(chalk.red('License validation test failed:', error));
-  }
-}
-
-async function runTests() {
-  console.log(chalk.blue('Running D1 Studio tests...'));
-  let testDir = null;
-  try {
-    testDir = await testProjectStructure();
-    await testWranglerConfig(testDir);
-    await testCaching(testDir);
-    await testStudioScript(testDir);
-    await testLicenseValidation(testDir);
-    await testPackageExecution(testDir);
-    await testLoggerBehavior();
-    console.log(chalk.green('\nAll tests completed successfully! 🎉'));
-    console.log(chalk.blue('\nTest Summary:'));
-    console.log(chalk.blue('============'));
-    console.log(chalk.yellow('Check warnings above for any issues that need attention.'));
-    console.log(chalk.blue('\nTest directory:', testDir));
-  } catch (error) {
-    console.error(chalk.red('\nTests failed:', error));
-    process.exit(1);
-  } finally {
-    if (testDir) {
-      console.log(chalk.blue('\nCleaning up test directory...'));
-      await fs.rm(testDir, { recursive: true, force: true }).catch(() => {});
-    }
-  }
-}
-
-runTests().catch(error => {
-  console.error(chalk.red('Test suite failed:', error));
-  process.exit(1);
-});