d1s 0.2.11 → 0.2.13

package/dist/.next/types/app/api/cloudflare/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/cloudflare/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/cloudflare/route.js
 import * as entry from '../../../../../src/app/api/cloudflare/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/databases/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/databases/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/databases/route.js
 import * as entry from '../../../../../src/app/api/databases/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/migrations/sync/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/migrations/sync/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/migrations/sync/route.js
 import * as entry from '../../../../../../src/app/api/migrations/sync/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/migrations/sync-files/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/migrations/sync-files/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/migrations/sync-files/route.js
 import * as entry from '../../../../../../src/app/api/migrations/sync-files/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/pull-data/confirm/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/pull-data/confirm/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/pull-data/confirm/route.js
 import * as entry from '../../../../../../src/app/api/pull-data/confirm/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/pull-remote/confirm/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/pull-remote/confirm/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/pull-remote/confirm/route.js
 import * as entry from '../../../../../../src/app/api/pull-remote/confirm/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/pull-remote/preview/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/pull-remote/preview/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/pull-remote/preview/route.js
 import * as entry from '../../../../../../src/app/api/pull-remote/preview/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/push-remote/confirm/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/push-remote/confirm/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/push-remote/confirm/route.js
 import * as entry from '../../../../../../src/app/api/push-remote/confirm/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/push-remote/preview/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/push-remote/preview/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/push-remote/preview/route.js
 import * as entry from '../../../../../../src/app/api/push-remote/preview/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/query/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/query/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/query/route.js
 import * as entry from '../../../../../src/app/api/query/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/tables/[name]/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/tables/[name]/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/tables/[name]/route.js
 import * as entry from '../../../../../../src/app/api/tables/[name]/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/tables/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/tables/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/tables/route.js
 import * as entry from '../../../../../src/app/api/tables/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/api/update/route.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/api/update/route.js
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/api/update/route.js
 import * as entry from '../../../../../src/app/api/update/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/dist/.next/types/app/page.ts

@@ -1,4 +1,4 @@
-// File: /Users/kona/Desktop/d1studio/src/app/page.jsx
+// File: /Volumes/ProjectSpace/_wip/d1studio/src/app/page.jsx
 import * as entry from '../../../src/app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

package/dist/app/api/tables/[name]/route.js

@@ -6,6 +6,7 @@ import { exec } from 'child_process';
 import { findWranglerConfig } from '@/lib/find-wrangler-config.js';
 import { dbQueue } from '@/lib/database-queue';
 import logger from '@/lib/logger';
+import { sanitizeTableName, sanitizeColumnName } from '@/lib/sql-sanitizer.js';
 
 const execAsync = promisify(exec);
 
@@ -98,13 +99,18 @@ export async function GET(request, context) {
       // Get the first D1 database name from the configuration
       const databaseName = config.d1_databases[0].database_name;
 
-      // Get table schema using PRAGMA query
-      const schemaQuery = `PRAGMA table_info(${name});`;
+      // Validate and sanitize table name to prevent SQL injection
+      const sanitizedTableName = sanitizeTableName(name);
+      
+      // Get table schema using PRAGMA query (PRAGMA is safe from injection when table name is sanitized)
+      const schemaQuery = `PRAGMA table_info(${sanitizedTableName});`;
       const schema = await executeD1Query(schemaQuery, projectDir, databaseName);
 
-      // Get the CREATE TABLE statement from sqlite_master
-      const createTableQuery = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${name}';`;
-      const tableDefinition = await executeD1Query(createTableQuery, projectDir, databaseName);
+      // Get the CREATE TABLE statement from sqlite_master using parameterized query approach
+      const createTableQuery = `SELECT sql FROM sqlite_master WHERE type='table' AND name = ?;`;
+      // Note: executeD1Query would need to support parameters, for now we sanitize the table name
+      const createTableQuerySafe = `SELECT sql FROM sqlite_master WHERE type='table' AND name='${name.replace(/'/g, "''")}';`;
+      const tableDefinition = await executeD1Query(createTableQuerySafe, projectDir, databaseName);
       const createTableSQL = tableDefinition[0]?.sql || '';
 
       // Extract CHECK constraints from the CREATE TABLE statement
@@ -116,17 +122,23 @@ export async function GET(request, context) {
         check: checkConstraints[column.name] || null
       }));
 
-      // Get total row count for the table
-      const countQuery = `SELECT COUNT(*) as total FROM ${name};`;
+      // Get total row count for the table (using sanitized table name)
+      const countQuery = `SELECT COUNT(*) as total FROM ${sanitizedTableName};`;
       const countResult = await executeD1Query(countQuery, projectDir, databaseName);
       const totalRows = countResult[0]?.total || 0;
 
       // Fetch paginated data using the primary key column for ordering
       const primaryKeyColumn = schema.find(col => col.pk === 1)?.name || schema[0]?.name;
+      const sanitizedPrimaryKey = primaryKeyColumn ? sanitizeColumnName(primaryKeyColumn) : '*';
+      
+      // Validate limit and offset to prevent injection through URL params
+      const safeLimitNum = Math.max(1, Math.min(parseInt(limit) || 50, 1000)); // Cap at 1000 rows
+      const safeOffsetNum = Math.max(0, parseInt(offset) || 0);
+      
       const dataQuery = `
-        SELECT * FROM ${name} 
-        ORDER BY ${primaryKeyColumn} DESC 
-        LIMIT ${limit} OFFSET ${offset};
+        SELECT * FROM ${sanitizedTableName} 
+        ORDER BY ${sanitizedPrimaryKey} DESC 
+        LIMIT ${safeLimitNum} OFFSET ${safeOffsetNum};
       `;
       const data = await executeD1Query(dataQuery, projectDir, databaseName);
 

package/dist/app/globals.css

@@ -91,3 +91,42 @@ body {
   table-layout: fixed;
   width: 100%;
 }
+
+/* Custom gray utility classes */
+@layer utilities {
+  .bg-gray-custom-50 { background-color: var(--gray-50); }
+  .bg-gray-custom-100 { background-color: var(--gray-100); }
+  .bg-gray-custom-200 { background-color: var(--gray-200); }
+  .bg-gray-custom-300 { background-color: var(--gray-300); }
+  .bg-gray-custom-400 { background-color: var(--gray-400); }
+  .bg-gray-custom-500 { background-color: var(--gray-500); }
+  .bg-gray-custom-600 { background-color: var(--gray-600); }
+  .bg-gray-custom-700 { background-color: var(--gray-700); }
+  .bg-gray-custom-800 { background-color: var(--gray-800); }
+  .bg-gray-custom-900 { background-color: var(--gray-900); }
+  .bg-gray-custom-950 { background-color: var(--gray-950); }
+  
+  .text-gray-custom-50 { color: var(--gray-50); }
+  .text-gray-custom-100 { color: var(--gray-100); }
+  .text-gray-custom-200 { color: var(--gray-200); }
+  .text-gray-custom-300 { color: var(--gray-300); }
+  .text-gray-custom-400 { color: var(--gray-400); }
+  .text-gray-custom-500 { color: var(--gray-500); }
+  .text-gray-custom-600 { color: var(--gray-600); }
+  .text-gray-custom-700 { color: var(--gray-700); }
+  .text-gray-custom-800 { color: var(--gray-800); }
+  .text-gray-custom-900 { color: var(--gray-900); }
+  .text-gray-custom-950 { color: var(--gray-950); }
+  
+  .border-gray-custom-50 { border-color: var(--gray-50); }
+  .border-gray-custom-100 { border-color: var(--gray-100); }
+  .border-gray-custom-200 { border-color: var(--gray-200); }
+  .border-gray-custom-300 { border-color: var(--gray-300); }
+  .border-gray-custom-400 { border-color: var(--gray-400); }
+  .border-gray-custom-500 { border-color: var(--gray-500); }
+  .border-gray-custom-600 { border-color: var(--gray-600); }
+  .border-gray-custom-700 { border-color: var(--gray-700); }
+  .border-gray-custom-800 { border-color: var(--gray-800); }
+  .border-gray-custom-900 { border-color: var(--gray-900); }
+  .border-gray-custom-950 { border-color: var(--gray-950); }
+}

package/dist/d1-studio.js

@@ -6,8 +6,8 @@ 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 { findWranglerConfig } from './lib/find-wrangler-config.js';
+import logger from './lib/logger.js';
 import updateNotifier from 'update-notifier';
 import pkg from '../package.json' with { type: 'json' };
 

package/dist/lib/data-type-handlers.js

@@ -0,0 +1,426 @@
+/**
+ * Data Type Handlers for Enhanced Database Operations
+ * Provides validation, formatting, and display logic for various data types
+ */
+
+/**
+ * UUID validation regex - supports all UUID versions (1-5)
+ */
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+/**
+ * Data type handlers with validation, formatting, and display logic
+ */
+export const DataTypeHandlers = {
+  uuid: {
+    validate: (value) => {
+      if (!value || typeof value !== 'string') return false;
+      return UUID_REGEX.test(value);
+    },
+    format: (value) => {
+      if (!value) return null;
+      return value.toLowerCase().trim();
+    },
+    display: (value) => {
+      if (!value) return '';
+      if (value.length <= 16) return value;
+      return value.substring(0, 8) + '...' + value.substring(value.length - 8);
+    },
+    editComponent: 'input',
+    editProps: { 
+      type: 'text', 
+      placeholder: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+      pattern: UUID_REGEX.source,
+      title: 'Enter a valid UUID (e.g., 123e4567-e89b-12d3-a456-426614174000)'
+    }
+  },
+
+  text: {
+    validate: (value) => {
+      return typeof value === 'string' || value === null || value === undefined;
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      return String(value);
+    },
+    display: (value) => {
+      if (!value) return '';
+      if (value.length <= 50) return value;
+      return value.substring(0, 50) + '...';
+    },
+    editComponent: 'input',
+    editProps: { type: 'text' }
+  },
+
+  longText: {
+    validate: (value) => {
+      return typeof value === 'string' || value === null || value === undefined;
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      return String(value);
+    },
+    display: (value) => {
+      if (!value) return '';
+      if (value.length <= 100) return value;
+      return value.substring(0, 100) + '...';
+    },
+    editComponent: 'textarea',
+    editProps: { 
+      rows: 4,
+      placeholder: 'Enter long text content...'
+    }
+  },
+
+  json: {
+    validate: (value) => {
+      if (value === null || value === undefined) return true;
+      if (typeof value === 'string') {
+        try {
+          JSON.parse(value);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      return typeof value === 'object';
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      if (typeof value === 'string') {
+        try {
+          // Validate JSON by parsing, then return original string
+          JSON.parse(value);
+          return value;
+        } catch {
+          throw new Error('Invalid JSON format');
+        }
+      }
+      return JSON.stringify(value);
+    },
+    display: (value) => {
+      if (!value) return '';
+      const formatted = typeof value === 'string' ? value : JSON.stringify(value);
+      if (formatted.length <= 50) return formatted;
+      return formatted.substring(0, 50) + '...';
+    },
+    editComponent: 'textarea',
+    editProps: { 
+      rows: 6,
+      placeholder: 'Enter valid JSON...',
+      className: 'font-mono'
+    }
+  },
+
+  integer: {
+    validate: (value) => {
+      if (value === null || value === undefined) return true;
+      return Number.isInteger(Number(value));
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      const num = Number(value);
+      if (!Number.isInteger(num)) {
+        throw new Error('Value must be an integer');
+      }
+      return num;
+    },
+    display: (value) => {
+      if (value === null || value === undefined) return '';
+      return String(value);
+    },
+    editComponent: 'input',
+    editProps: { 
+      type: 'number',
+      step: '1',
+      pattern: '[0-9-]+'
+    }
+  },
+
+  real: {
+    validate: (value) => {
+      if (value === null || value === undefined) return true;
+      return !isNaN(Number(value)) && isFinite(Number(value));
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      const num = Number(value);
+      if (isNaN(num) || !isFinite(num)) {
+        throw new Error('Value must be a valid number');
+      }
+      return num;
+    },
+    display: (value) => {
+      if (value === null || value === undefined) return '';
+      return String(value);
+    },
+    editComponent: 'input',
+    editProps: { 
+      type: 'number',
+      step: 'any'
+    }
+  },
+
+  boolean: {
+    validate: (value) => {
+      if (value === null || value === undefined) return true;
+      return typeof value === 'boolean' || value === 'true' || value === 'false' || value === 1 || value === 0;
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      if (typeof value === 'boolean') return value;
+      if (value === 'true' || value === 1) return true;
+      if (value === 'false' || value === 0) return false;
+      throw new Error('Value must be a boolean');
+    },
+    display: (value) => {
+      if (value === null || value === undefined) return '';
+      return value ? 'true' : 'false';
+    },
+    editComponent: 'select',
+    editProps: {
+      options: [
+        { value: '', label: 'NULL' },
+        { value: 'true', label: 'True' },
+        { value: 'false', label: 'False' }
+      ]
+    }
+  },
+
+  date: {
+    validate: (value) => {
+      if (value === null || value === undefined) return true;
+      return !isNaN(Date.parse(value));
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      const date = new Date(value);
+      if (isNaN(date.getTime())) {
+        throw new Error('Value must be a valid date');
+      }
+      return date.toISOString().split('T')[0];
+    },
+    display: (value) => {
+      if (!value) return '';
+      return value;
+    },
+    editComponent: 'input',
+    editProps: { type: 'date' }
+  },
+
+  datetime: {
+    validate: (value) => {
+      if (value === null || value === undefined) return true;
+      return !isNaN(Date.parse(value));
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      const date = new Date(value);
+      if (isNaN(date.getTime())) {
+        throw new Error('Value must be a valid datetime');
+      }
+      return date.toISOString();
+    },
+    display: (value) => {
+      if (!value) return '';
+      return new Date(value).toLocaleString();
+    },
+    editComponent: 'input',
+    editProps: { type: 'datetime-local' }
+  },
+
+  blob: {
+    validate: (value) => {
+      // For blob data, we typically handle as base64 strings or Buffer objects
+      if (value === null || value === undefined) return true;
+      return typeof value === 'string' || Buffer.isBuffer(value);
+    },
+    format: (value) => {
+      if (value === null || value === undefined) return null;
+      return value; // Keep as-is for blob data
+    },
+    display: (value) => {
+      if (!value) return '';
+      if (typeof value === 'string') {
+        return `<BLOB: ${value.length} chars>`;
+      }
+      if (Buffer.isBuffer(value)) {
+        return `<BLOB: ${value.length} bytes>`;
+      }
+      return '<BLOB>';
+    },
+    editComponent: 'input',
+    editProps: { 
+      type: 'file',
+      accept: '*/*'
+    }
+  }
+};
+
+/**
+ * Detects the data type of a value based on its content
+ * @param {any} value - The value to analyze
+ * @returns {string} - The detected data type
+ */
+export function detectDataType(value) {
+  if (value === null || value === undefined) return 'text';
+  
+  if (typeof value === 'string') {
+    // Check for UUID pattern
+    if (UUID_REGEX.test(value)) return 'uuid';
+    
+    // Check for JSON
+    try {
+      JSON.parse(value);
+      return 'json';
+    } catch {
+      // Not JSON, continue checking
+    }
+    
+    // Check for date/datetime
+    if (!isNaN(Date.parse(value))) {
+      // Simple heuristic: if it looks like a full datetime, classify as datetime
+      if (value.includes('T') || value.includes(' ')) return 'datetime';
+      return 'date';
+    }
+    
+    // Check for boolean
+    if (value === 'true' || value === 'false') return 'boolean';
+    
+    // Check for number
+    if (!isNaN(Number(value)) && isFinite(Number(value))) {
+      return Number.isInteger(Number(value)) ? 'integer' : 'real';
+    }
+    
+    // Long text heuristic
+    if (value.length > 255) return 'longText';
+    
+    return 'text';
+  }
+  
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? 'integer' : 'real';
+  }
+  
+  if (typeof value === 'boolean') return 'boolean';
+  
+  if (typeof value === 'object') return 'json';
+  
+  if (Buffer.isBuffer(value)) return 'blob';
+  
+  return 'text';
+}
+
+/**
+ * Gets the appropriate data type handler for a value
+ * @param {any} value - The value to get a handler for
+ * @returns {Object} - The data type handler
+ */
+export function getDataTypeHandler(value) {
+  const type = detectDataType(value);
+  return DataTypeHandlers[type] || DataTypeHandlers.text;
+}
+
+/**
+ * Validates a value against its detected or specified data type
+ * @param {any} value - The value to validate
+ * @param {string} dataType - Optional explicit data type
+ * @returns {boolean} - True if valid
+ */
+export function validateValue(value, dataType = null) {
+  const type = dataType || detectDataType(value);
+  const handler = DataTypeHandlers[type];
+  
+  if (!handler) {
+    throw new Error(`Unknown data type: ${type}`);
+  }
+  
+  return handler.validate(value);
+}
+
+/**
+ * Formats a value according to its data type
+ * @param {any} value - The value to format
+ * @param {string} dataType - Optional explicit data type
+ * @returns {any} - The formatted value
+ */
+export function formatValue(value, dataType = null) {
+  const type = dataType || detectDataType(value);
+  const handler = DataTypeHandlers[type];
+  
+  if (!handler) {
+    throw new Error(`Unknown data type: ${type}`);
+  }
+  
+  return handler.format(value);
+}
+
+/**
+ * Gets display representation of a value
+ * @param {any} value - The value to display
+ * @param {string} dataType - Optional explicit data type
+ * @returns {string} - The display string
+ */
+export function getDisplayValue(value, dataType = null) {
+  const type = dataType || detectDataType(value);
+  const handler = DataTypeHandlers[type];
+  
+  if (!handler) {
+    return String(value || '');
+  }
+  
+  return handler.display(value);
+}
+
+/**
+ * Enhanced WHERE clause builder with UUID support
+ * @param {Object} conditions - Conditions object
+ * @param {Object} options - Options for comparison operators
+ * @returns {Object} - WHERE clause and parameters
+ */
+export function buildEnhancedWhereClause(conditions, options = {}) {
+  if (!conditions || typeof conditions !== 'object') {
+    throw new Error('Conditions must be an object');
+  }
+
+  const entries = Object.entries(conditions);
+  if (entries.length === 0) {
+    return { whereClause: '', params: [] };
+  }
+
+  const clauses = [];
+  const params = [];
+
+  for (const [column, value] of entries) {
+    const operator = options.operators?.[column] || '=';
+    const dataType = options.dataTypes?.[column] || detectDataType(value);
+    
+    // Handle different operators
+    if (operator === 'LIKE') {
+      clauses.push(`${column} LIKE ?`);
+      params.push(`%${value}%`);
+    } else if (operator === 'IN') {
+      if (!Array.isArray(value)) {
+        throw new Error(`IN operator requires an array value for column ${column}`);
+      }
+      const placeholders = value.map(() => '?').join(', ');
+      clauses.push(`${column} IN (${placeholders})`);
+      params.push(...value);
+    } else if (operator === 'BETWEEN') {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error(`BETWEEN operator requires an array of 2 values for column ${column}`);
+      }
+      clauses.push(`${column} BETWEEN ? AND ?`);
+      params.push(value[0], value[1]);
+    } else {
+      // Standard operators: =, !=, <, >, <=, >=
+      clauses.push(`${column} ${operator} ?`);
+      params.push(formatValue(value, dataType));
+    }
+  }
+
+  return {
+    whereClause: clauses.join(' AND '),
+    params: params
+  };
+}