d1s 0.2.5 → 0.2.8

package/scripts/test.js

@@ -5,52 +5,88 @@ 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);
 
-async function testWranglerConfig() {
-  console.log('\nTesting Wrangler configuration...');
+// 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
+`;
 
-  // Test with valid wrangler.toml
-  const validConfig = `
+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"
-  `;
-
-  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);
-  }
+// 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);
+}
 
-  // 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'));
-  }
+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);
 
-  // Cleanup
-  await fs.rm(tempDir, { recursive: true }).catch(() => {});
+  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...');
-
-  // Check required directories exist
   const requiredDirs = ['src', 'scripts', 'dist'];
   for (const dir of requiredDirs) {
     try {
@@ -60,109 +96,271 @@ async function testProjectStructure() {
       console.warn(chalk.yellow(`⚠ ${dir} directory missing`));
     }
   }
-
-  // Check required files exist
+  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(__dirname, '..', file));
+      await fs.access(join(testDir, file));
       console.log(chalk.green(`✓ ${file} exists`));
     } catch {
-      console.warn(chalk.yellow(`⚠ ${file} missing`));
+      console.warn(chalk.yellow(`⚠ ${file} missing or not copied`));
     }
   }
+  return testDir;
 }
 
-async function testStudioScript() {
-  console.log('\nTesting studio.js script...');
+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 studioPath = join(__dirname, 'studio.js');
-    const stats = await fs.stat(studioPath);
+    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;
+  }
+}
 
-    // Check file permissions (should be executable)
+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'));
     }
-
-    // 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'));
     }
-
+    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 testUserConfig() {
-  console.log('\nTesting user configuration...');
-
-  const homeDir = os.homedir();
-  const d1StudioDir = join(homeDir, '.d1studio');
-
+async function testLicenseValidation(testDir) {
+  console.log('\nTesting license validation...');
+  const d1StudioDir = join(testDir, '.d1studio');
+  const licenseFile = join(d1StudioDir, 'license.json');
   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'));
+    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'));
     }
-  } catch {
-    console.warn(chalk.yellow('⚠ D1 Studio config directory not found'));
+    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 {
-    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.'));
+    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.warn(chalk.yellow('\nSome tests encountered issues:'), error.message);
+    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.warn(chalk.yellow('Test suite encountered issues:'), error.message);
-});
+  console.error(chalk.red('Test suite failed:', error));
+  process.exit(1);
+});

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

@@ -2,6 +2,7 @@
 
 import { NextResponse } from 'next/server';
 import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import logger from '@/lib/logger';
 
 /**
  * Validates the provided Cloudflare credentials by fetching databases.
@@ -81,6 +82,7 @@ export async function POST(req) {
 
     // Check if the project directory is set.
     if (!projectDir) {
+      logger.error('Project directory not configured');
       return NextResponse.json(
         { error: 'Project directory not configured' },
         { status: 500 }
@@ -93,6 +95,7 @@ export async function POST(req) {
     // Retrieve the Wrangler configuration using the centralized helper.
     const wranglerResult = await findWranglerConfig(projectDir);
     if (!wranglerResult || !wranglerResult.config) {
+      logger.error('No Wrangler configuration file found in project directory');
       return NextResponse.json(
         { error: 'No Wrangler configuration file found in project directory' },
         { status: 404 }
@@ -130,7 +133,7 @@ export async function POST(req) {
     });
 
   } catch (error) {
-    console.error('Cloudflare API error:', error);
+    logger.error('Cloudflare API error:', error);
     return NextResponse.json(
       { error: error.message },
       { status: error.message.includes('Invalid credentials') ? 401 : 500 }
@@ -144,3 +147,4 @@ export async function POST(req) {
 export async function OPTIONS() {
   return new NextResponse(null, { status: 204 });
 }
+

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

@@ -2,21 +2,20 @@
 
 import { NextResponse } from 'next/server';
 import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
+import logger from '@/lib/logger';
 
 export async function GET() {
   try {
     const projectDir = process.env.D1_PROJECT_DIR;
     
     if (!projectDir) {
-      console.error('D1_PROJECT_DIR environment variable is not set');
+      logger.error('D1_PROJECT_DIR environment variable is not set');
       return NextResponse.json(
         { error: 'Project directory not configured' },
         { status: 500 }
       );
     }
 
-    // console.log('Looking for Wrangler configuration in:', projectDir);
-    
     // Use findWranglerConfig helper
     const wranglerResult = await findWranglerConfig(projectDir);
     if (!wranglerResult || !wranglerResult.config) {
@@ -44,7 +43,7 @@ export async function GET() {
       }
     });
   } catch (error) {
-    console.error('Error reading database configuration:', error);
+    logger.error('Error reading database configuration:', error);
     
     return NextResponse.json(
       { 

package/src/app/api/migrations/sync/route.js

@@ -5,14 +5,13 @@ import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
 import { readFile } from 'fs/promises';
 import path from 'path';
 import {
-  initMigrationsTable,
   compareMigrations,
   trackMigration,
-  updateMigrationStatus,
   createChecksum
 } from '@/lib/migrations';
 import { promisify } from 'util';
 import { exec } from 'child_process';
+import logger from '@/lib/logger';
 
 const execAsync = promisify(exec);
 
@@ -21,11 +20,14 @@ const execAsync = promisify(exec);
  * Uses the centralized Wrangler configuration helper to determine the D1 database.
  */
 export async function POST(req) {
+  logger.logRequest('POST', '/api/migrations/sync');
+
   try {
     const { accountId, apiToken } = await req.json();
     const projectDir = process.env.D1_PROJECT_DIR;
 
     if (!projectDir) {
+      logger.error('Project directory not configured');
       return NextResponse.json(
         { error: 'Project directory not configured' },
         { status: 500 }
@@ -156,7 +158,7 @@ export async function POST(req) {
     });
 
   } catch (error) {
-    console.error('Migration sync error:', error);
+    logger.logError(error, 'migrations-sync-route');
     return NextResponse.json({
       success: false,
       error: {