d1s 0.2.11 → 0.2.13

package/src/lib/database-queue.js

@@ -1,37 +0,0 @@
-// utils/database-queue.js
-
-import logger from '@/lib/logger.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) {
-      logger.error('Error processing database queue operation:', error);
-      reject(error);
-    } finally {
-      this.isProcessing = false;
-      this.processNext();
-    }
-  }
-}
- 
-export const dbQueue = new DatabaseQueue();

package/src/lib/error.js

@@ -1,20 +0,0 @@
-// 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

@@ -1,74 +0,0 @@
-import { readFile } from 'fs/promises';
-import { findUp } from 'find-up';
-import { parse as parseToml } from '@iarna/toml';
-import stripJsonComments from 'strip-json-comments';
-import logger from './logger.js';
-
-let cachedConfig = null;
-let cachedProjectPath = null;
-
-/**
- * Finds and parses the Wrangler configuration file.
- * This function caches the result so that the configuration is read and logged only once per project path.
- * 
- * @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');
-    }
-
-    // Return the cached config if available for the same project path.
-    if (cachedConfig && cachedProjectPath === userProjectPath) {
-      return cachedConfig;
-    }
-
-    // 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) {
-      logger.warn(`No Wrangler configuration file found in: ${userProjectPath}`);
-      return null;
-    }
-
-    logger.info(`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);
-    }
-
-    // Cache the result.
-    cachedConfig = { config, projectPath: userProjectPath };
-    cachedProjectPath = userProjectPath;
-
-    return cachedConfig;
-
-  } catch (error) {
-    logger.error(`Error reading Wrangler configuration: ${error.message}`);
-    throw error;
-  }
-}

package/src/lib/license.js

@@ -1,99 +0,0 @@
-// 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/logger.js

@@ -1,58 +0,0 @@
-import winston from 'winston';
-
-const { combine, timestamp, printf, colorize } = winston.format;
-
-const isDevelopment = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === undefined;
-const isProduction = process.env.NODE_ENV === 'production';
-// Check for DEBUG env var which is set by --debug flag
-const isDebug = process.env.DEBUG === 'true';
-
-const logFormat = printf(({ level, message, timestamp, ...metadata }) => {
-  let msg = `${timestamp} ${level}: ${message}`;
-  // Add metadata if present
-  if (Object.keys(metadata).length > 0) {
-    msg += ` ${JSON.stringify(metadata)}`;
-  }
-  return msg;
-});
-
-const logger = winston.createLogger({
-  // Set log level based on environment and debug flag
-  level: isDebug ? 'debug' : (isProduction ? 'warn' : 'info'),
-  format: combine(
-    timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
-    colorize(),
-    logFormat
-  ),
-  transports: [
-    new winston.transports.Console({
-      level: isDebug ? 'debug' : (isProduction ? 'warn' : 'info'),
-      silent: process.env.NODE_ENV === 'test'
-    })
-  ]
-});
-
-// Add helper methods
-logger.logRequest = (method, path, params = {}) => {
-  logger.debug(`Request: ${method} ${path}`, params);
-};
-
-logger.logError = (error, source = 'unknown') => {
-  logger.error(`Error in ${source}: ${error.message}`, {
-    error: error.stack || error.message,
-    source
-  });
-};
-
-logger.shouldLog = (level) => {
-  const currentLevel = logger.level;
-  const levels = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3
-  };
-  return levels[level] <= levels[currentLevel];
-};
-
-export default logger;

package/src/lib/migrations.js

@@ -1,415 +0,0 @@
-// /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';
-import logger from './logger.js';
-
-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) {
-    logger.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 
- */
-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) {
-    logger.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) {
-    logger.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;
-  }
-}
-