d1s 0.2.1

package/src/lib/database-queue.js

@@ -0,0 +1,33 @@
+// utils/database-queue.js
+class DatabaseQueue {
+   constructor() {
+     this.queue = [];
+     this.isProcessing = false;
+   }
+ 
+   async add(operation) {
+     return new Promise((resolve, reject) => {
+       this.queue.push({ operation, resolve, reject });
+       this.processNext();
+     });
+   }
+ 
+   async processNext() {
+     if (this.isProcessing || this.queue.length === 0) return;
+     
+     this.isProcessing = true;
+     const { operation, resolve, reject } = this.queue.shift();
+     
+     try {
+       const result = await operation();
+       resolve(result);
+     } catch (error) {
+       reject(error);
+     } finally {
+       this.isProcessing = false;
+       this.processNext();
+     }
+   }
+ }
+ 
+ export const dbQueue = new DatabaseQueue();

package/src/lib/error.js

@@ -0,0 +1,20 @@
+// lib/errors.js
+export class LicenseError extends Error {
+   constructor(message, type = 'VALIDATION_ERROR') {
+     super(message);
+     this.name = 'LicenseError';
+     this.type = type;
+   }
+ }
+ 
+ export const ErrorTypes = {
+   LICENSE_NOT_FOUND: 'LICENSE_NOT_FOUND',
+   EMAIL_MISMATCH: 'EMAIL_MISMATCH',
+   INACTIVE_LICENSE: 'INACTIVE_LICENSE',
+   INACTIVE_SUBSCRIPTION: 'INACTIVE_SUBSCRIPTION',
+   EXPIRED_SUBSCRIPTION: 'EXPIRED_SUBSCRIPTION',
+   MAX_ACTIVATIONS: 'MAX_ACTIVATIONS',
+   CONNECTION_ERROR: 'CONNECTION_ERROR',
+   VALIDATION_ERROR: 'VALIDATION_ERROR',
+   SAVE_ERROR: 'SAVE_ERROR'
+ };

package/src/lib/find-wrangler-config.js

@@ -0,0 +1,67 @@
+// lib/find-wrangler-config.js
+import { readFile } from 'fs/promises';
+import { findUp } from 'find-up';
+import { parse as parseToml } from '@iarna/toml';
+import stripJsonComments from 'strip-json-comments';
+import chalk from 'chalk';
+
+/**
+ * Finds and parses the Wrangler configuration file.
+ * 
+ * @param {string} userProjectPath - The path where to look for the config file
+ * @returns {Promise<{config: object, projectPath: string}|null>}
+ */
+export async function findWranglerConfig(userProjectPath) {
+  try {
+    if (!userProjectPath || typeof userProjectPath !== 'string') {
+      throw new Error('Project path is required and must be a string');
+    }
+
+    console.log(chalk.blue('Looking for wrangler configuration in:'), userProjectPath);
+
+    // Define the possible configuration file names in priority order.
+    const possibleFiles = ['wrangler.toml', 'wrangler.json', 'wrangler.jsonc'];
+    let configPath = null;
+    let configFileUsed = null;
+
+    // Search for any of the possible config files
+    for (const file of possibleFiles) {
+      configPath = await findUp(file, { cwd: userProjectPath });
+      if (configPath) {
+        configFileUsed = file;
+        break;
+      }
+    }
+
+    if (!configPath) {
+      console.log(chalk.yellow('No Wrangler configuration file found in:'), userProjectPath);
+      return null;
+    }
+
+    console.log(chalk.green(`Found ${configFileUsed} at:`), configPath);
+
+    // Read the configuration file
+    let configContent = await readFile(configPath, 'utf-8');
+    let config;
+
+    // Parse based on file type
+    if (configFileUsed.endsWith('.toml')) {
+      config = parseToml(configContent);
+    } else {
+      // If it's JSONC, strip comments before parsing
+      if (configFileUsed.endsWith('.jsonc')) {
+        configContent = stripJsonComments(configContent);
+      }
+      config = JSON.parse(configContent);
+    }
+
+    return {
+      config,
+      projectPath: userProjectPath
+    };
+
+  } catch (error) {
+    console.error(chalk.red('Error reading Wrangler configuration:'), error.message);
+    throw error;
+  }
+}

package/src/lib/license.js

@@ -0,0 +1,99 @@
+// lib/license.js
+import os from 'os';
+import { join } from 'path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { createHash } from 'crypto';
+import { LicenseError } from './errors.js';
+
+export 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');
+}
+
+export async function checkLicenseFile() {
+  const licenseDir = join(os.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;
+  }
+}
+
+export async function saveLicenseFile(licenseData) {
+  const licenseDir = join(os.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');
+  }
+}
+
+export 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'
+    );
+  }
+}

package/src/lib/migrations.js

@@ -0,0 +1,415 @@
+// /lib/migrations.js
+
+import { readFile } from 'fs/promises';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { createHash } from 'crypto';
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+import { 
+  executeSQL, 
+  ErrorTypes, 
+  formatMigrationContent, 
+  parseStatement, 
+  validateStatement,
+  Operations,
+  tableExists
+} from './sql-operations.js';
+import { analyzeDependencies } from '@/lib/schema-operations';
+
+const execAsync = promisify(exec);
+
+/**
+ * Initializes the migrations table.
+ * For remote environments: table with (id, name, applied_at).
+ * For local environments: table with (id, name, checksum, applied_at),
+ * where checksum is optional.
+ *
+ * If reset is true (e.g. during a pull operation), the table is cleared.
+ *
+ * @param {string} projectDir 
+ * @param {string} databaseName 
+ * @param {('local'|'remote')} environment 
+ * @param {boolean} [reset=false] - If true, clear existing records.
+ */
+export async function initMigrationsTable(projectDir, databaseName, environment = 'local', reset = false) {
+  const flag = environment === 'remote' ? '--remote' : '--local';
+  // For remote, keep original D1 schema
+  const createTableSQL = environment === 'remote'
+    ? `
+      CREATE TABLE IF NOT EXISTS d1_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `
+    : `
+      CREATE TABLE IF NOT EXISTS d1_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        checksum TEXT NULL,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+
+  try {
+    // Create the table if it doesn't exist
+    await execAsync(
+      `wrangler d1 execute ${databaseName} ${flag} --command="${createTableSQL.replace(/"/g, '\\"')}"`,
+      { cwd: projectDir }
+    );
+    
+    if (reset) {
+      const deleteSQL = `DELETE FROM d1_migrations;`;
+      await execAsync(
+        `wrangler d1 execute ${databaseName} ${flag} --command="${deleteSQL.replace(/"/g, '\\"')}"`,
+        { cwd: projectDir }
+      );
+    }
+  } catch (error) {
+    console.error(`Failed to initialize migrations table in ${environment}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Generate a migration file name using a stable naming convention.
+ * Format: YYYYMMDDHHMMSS_operation_tablename[optional-description].sql
+ * 
+ * @param {Object} stmt - The SQL statement object containing type, tableName and optional description
+ * @returns {string} The formatted migration filename
+ */
+function getMigrationFileName(stmt) {
+  const timestamp = new Date().toISOString().replace(/[^0-9]/g, '').slice(0, -3);
+  const operation = stmt.type.toLowerCase().replace(/_/g, '-');
+  
+  // Map for non-index operations.
+  const operationMap = {
+    'create-table': 'create-table',
+    'alter-table': 'alter-table', 
+    'drop-table': 'drop-table',
+    'drop-index': 'drop-index',
+    'create-view': 'create-view',
+    'drop-view': 'drop-view',
+    'add-foreign-key': 'add-foreign-key',
+    'drop-foreign-key': 'drop-foreign-key',
+    'add-constraint': 'add-constraint',
+    'drop-constraint': 'drop-constraint'
+  };
+
+  if (stmt.type === 'CREATE_INDEX') {
+    // For index migrations, simply include the operation and the description.
+    const desc = stmt.description.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-_]/g, '');
+    return `${timestamp}_create-index_${desc}.sql`;
+  } else {
+    let fileName = `${timestamp}_${operationMap[operation] || operation}_${stmt.tableName}`;
+    // Append description for alter migrations if available.
+    if (stmt.type === 'ALTER_TABLE' && stmt.description) {
+      fileName += `_${stmt.description}`;
+    }
+    fileName = fileName.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-_]/g, '');
+    return fileName + '.sql';
+  }
+}
+
+/**
+ * Validates a migration file by reading, parsing, and validating its SQL.
+ *
+ * @param {string} filePath - Full path to the migration file.
+ * @returns {object} Object with `isValid` flag and either the parsed statement or errors.
+ */
+export async function validateMigrationFile(filePath) {
+  const content = await readFile(filePath, 'utf8');
+  try {
+    const statement = parseStatement(content);
+    validateStatement(statement);
+    return { isValid: true, statement };
+  } catch (error) {
+    return { isValid: false, errors: error };
+  }
+}
+
+// Get remote migrations
+export async function getRemoteMigrations(projectDir, databaseName, env) {
+  try {
+    const result = await executeSQL(
+      projectDir,
+      databaseName,
+      'SELECT name, applied_at FROM d1_migrations ORDER BY applied_at;',
+      env,
+      true
+    );
+
+    if (typeof result === 'string') {
+      const jsonStart = result.indexOf('[');
+      if (jsonStart !== -1) {
+        const jsonStr = result.substring(jsonStart);
+        const parsed = JSON.parse(jsonStr);
+        return parsed[0]?.results || [];
+      }
+    }
+    return [];
+  } catch (error) {
+    throw {
+      type: ErrorTypes.EXECUTION_ERROR,
+      message: 'Failed to get remote migrations',
+      details: {
+        error: error.message,
+        suggestions: [
+          'Check remote database permissions',
+          'Verify credentials and connection'
+        ]
+      }
+    };
+  }
+}
+
+/**
+ * Records (or tracks) a migration.
+ * For remote, skips checksum.
+ *
+ * @param {string} projectDir 
+ * @param {string} databaseName 
+ * @param {Object} migrationData { name, checksum }
+ * @param {('local'|'remote')} environment 
+ */
+// Update tracking function to handle both cases
+export async function trackMigration(projectDir, databaseName, { name, checksum }, environment = 'local') {
+  const flag = environment === 'remote' ? '--remote' : '--local';
+  
+  // For Studio-originated migrations (with checksum), check if we need to add the column
+  if (environment === 'local' && checksum) {
+    try {
+      // Check if checksum column exists
+      const hasChecksumColumn = await execAsync(
+        `wrangler d1 execute ${databaseName} ${flag} --command="SELECT checksum FROM d1_migrations LIMIT 1;"`,
+        { cwd: projectDir }
+      ).catch(() => false);
+
+      // If column doesn't exist, alter table to add it
+      if (!hasChecksumColumn) {
+        await execAsync(
+          `wrangler d1 execute ${databaseName} ${flag} --command="ALTER TABLE d1_migrations ADD COLUMN checksum TEXT;"`,
+          { cwd: projectDir }
+        );
+      }
+    } catch (error) {
+      // Ignore errors - the column might already exist
+    }
+  }
+
+  // For Studio migrations (with checksum)
+  const insertSQL = environment === 'remote' || !checksum
+    ? `
+      INSERT OR REPLACE INTO d1_migrations (name, applied_at)
+      VALUES ('${name}', CURRENT_TIMESTAMP);
+    `
+    : `
+      INSERT OR REPLACE INTO d1_migrations (name, checksum, applied_at)
+      VALUES ('${name}', '${checksum}', CURRENT_TIMESTAMP);
+    `;
+
+  try {
+    await execAsync(
+      `wrangler d1 execute ${databaseName} ${flag} --command="${insertSQL.replace(/"/g, '\\"')}"`,
+      { cwd: projectDir }
+    );
+  } catch (error) {
+    console.error('Failed to track migration:', error);
+    throw error;
+  }
+}
+
+/**
+ * Records a migration (used during push).
+ * For remote, checksum is omitted.
+ *
+ * @param {string} projectDir 
+ * @param {string} databaseName 
+ * @param {Object} migrationData { name, checksum }
+ * @param {object} env 
+ * @param {boolean} remote 
+ */
+export async function recordMigration(projectDir, databaseName, { name, checksum }, env = {}, remote = false) {
+  // For CLI migrations or remote, don't include checksum
+  const sql = remote || !checksum
+    ? `
+      INSERT OR REPLACE INTO d1_migrations (name, applied_at)
+      VALUES ('${name}', CURRENT_TIMESTAMP);
+    `
+    : `
+      INSERT OR REPLACE INTO d1_migrations (name, checksum, applied_at)
+      VALUES ('${name}', '${checksum}', CURRENT_TIMESTAMP);
+    `;
+
+  try {
+    await executeSQL(projectDir, databaseName, sql, env, remote);
+  } catch (error) {
+    throw {
+      type: ErrorTypes.EXECUTION_ERROR,
+      message: `Failed to record migration ${name}`,
+      details: {
+        file: name,
+        error: error.message,
+        suggestions: ['Check if migration is already recorded']
+      }
+    };
+  }
+}
+
+/**
+ * Compares local and remote migrations.
+ *
+ * @param {string} projectDir 
+ * @param {string} databaseName 
+ * @returns {Promise<Object>} { applied: Array, count: Number }
+ */
+export async function compareMigrations(projectDir, databaseName) {
+  try {
+    const migrations = await getRemoteMigrations(projectDir, databaseName, {});
+    const migrationMap = new Map(migrations.map(m => [m.name, m]));
+    return {
+      applied: Array.from(migrationMap.keys()),
+      count: migrationMap.size
+    };
+  } catch (error) {
+    console.error('Failed to compare migrations:', error);
+    throw error;
+  }
+}
+
+/**
+ * Generates a SHA256 checksum for migration content.
+ *
+ * @param {string} content 
+ * @returns {string}
+ */
+export function createChecksum(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Processes schema changes (DDL) and creates migration files.
+ * Uses a stable naming convention:
+ *   YYYYMMDDHHMMSS_operation_tablename[optional-description].sql
+ *
+ * Executes the SQL, writes the migration file, and tracks it.
+ * If any part fails, the process aborts (all-or-nothing).
+ *
+ * This updated version uses analyzeDependencies to order the changes.
+ *
+ * @param {string} projectDir 
+ * @param {string} databaseName 
+ * @param {Array<Object>} statements - Parsed schema change statements.
+ *        Each statement is expected to have at least a `tableName` (if applicable) and `sql` property.
+ * @returns {Promise<Array>} Array of migration records.
+ */
+export async function handleSchemaChange(projectDir, databaseName, statements) {
+  try {
+    const migrationsDir = path.join(projectDir, 'migrations');
+    await mkdir(migrationsDir, { recursive: true });
+    const results = [];
+
+    // Partition statements into schema changes and data modifications.
+    const schemaChanges = [];
+    const dataModifications = [];
+    for (const stmt of statements) {
+      if (stmt.type === Operations.DATA_MODIFICATION) {
+        dataModifications.push(stmt);
+      } else {
+        schemaChanges.push(stmt);
+      }
+    }
+
+    // Group schema change statements by table name.
+    const groupedStatements = new Map();
+    const NO_TABLE_KEY = '__no_table__';
+    for (const stmt of schemaChanges) {
+      const key = stmt.tableName ? stmt.tableName.toLowerCase() : NO_TABLE_KEY;
+      if (!groupedStatements.has(key)) {
+        groupedStatements.set(key, []);
+      }
+      groupedStatements.get(key).push(stmt);
+    }
+
+    // For those with a table name, get an ordered list using analyzeDependencies.
+    const tableKeys = [...groupedStatements.keys()].filter(key => key !== NO_TABLE_KEY);
+    let orderedTables = [];
+    if (tableKeys.length > 0) {
+      const sampleStatements = tableKeys.map(key => groupedStatements.get(key)[0]);
+      orderedTables = analyzeDependencies(sampleStatements);
+    }
+
+    // Process schema changes (create migration files).
+    for (const tableName of orderedTables) {
+      const stmts = groupedStatements.get(tableName) || [];
+      for (const stmt of stmts) {
+        try {
+          // For DROP TABLE statements, check if the table exists.
+          if (stmt.type === Operations.DROP_TABLE) {
+            const exists = await tableExists(projectDir, databaseName, {}, stmt.tableName, false);
+            if (!exists) {
+              throw new Error(`no such table: ${stmt.tableName}`);
+            }
+          }
+          // Execute the schema change SQL.
+          const result = await executeSQL(projectDir, databaseName, stmt.sql);
+          // Check the output for syntax error messages.
+          if (
+            result &&
+            (result.toLowerCase().includes('syntax error') ||
+             result.toLowerCase().includes('sqlite_error'))
+          ) {
+            throw new Error(result);
+          }
+          // Generate a migration file.
+          const migrationFileName = getMigrationFileName(stmt);
+          const migrationPath = path.join(migrationsDir, migrationFileName);
+          const formattedSQL = formatMigrationContent(stmt.sql);
+          await writeFile(migrationPath, formattedSQL, 'utf8');
+          // Compute checksum and track the migration.
+          const checksum = createChecksum(stmt.sql);
+          await trackMigration(projectDir, databaseName, { name: migrationFileName, checksum }, 'local');
+          results.push({ type: stmt.type, table: stmt.tableName, migration: migrationFileName, checksum });
+        } catch (error) {
+          throw error;
+        }
+      }
+      groupedStatements.delete(tableName);
+    }
+
+    // Process any remaining schema changes with no table name.
+    if (groupedStatements.has(NO_TABLE_KEY)) {
+      for (const stmt of groupedStatements.get(NO_TABLE_KEY)) {
+        try {
+          await executeSQL(projectDir, databaseName, stmt.sql);
+          const migrationFileName = getMigrationFileName(stmt);
+          const migrationPath = path.join(migrationsDir, migrationFileName);
+          const formattedSQL = formatMigrationContent(stmt.sql);
+          await writeFile(migrationPath, formattedSQL, 'utf8');
+          const checksum = createChecksum(stmt.sql);
+          await trackMigration(projectDir, databaseName, { name: migrationFileName, checksum }, 'local');
+          results.push({ type: stmt.type, table: stmt.tableName || null, migration: migrationFileName, checksum });
+        } catch (error) {
+          throw error;
+        }
+      }
+    }
+
+    // Now process data modification statements (execute them, but don't create migration files).
+    for (const stmt of dataModifications) {
+      try {
+        await executeSQL(projectDir, databaseName, stmt.sql);
+        // Record the success of the data modification execution.
+        results.push({ type: stmt.type, table: stmt.tableName || null, executed: true });
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    return results;
+  } catch (error) {
+    throw error;
+  }
+}
+