@package-broker/adapter-node 0.5.1 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@package-broker/adapter-node",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "type": "module",
   "keywords": [],
   "scripts": {

package/scripts/migrate.cjs

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 
 /**
- * Database Migration Script
- * Runs Drizzle migrations for SQLite database
+ * Database Migration Script (Self-contained)
+ * Runs SQL migrations for SQLite database
  * 
  * Usage:
- *   node scripts/migrate.js <db_path> [migrations_path]
+ *   node scripts/migrate.cjs <db_path> [migrations_path]
  * 
  * Example:
- *   node scripts/migrate.js /data/database.sqlite
- *   node scripts/migrate.js /data/database.sqlite /app/packages/main/migrations
+ *   node scripts/migrate.cjs /data/database.sqlite
+ *   node scripts/migrate.cjs /data/database.sqlite /app/packages/main/migrations
  */
 
-const { SqliteDriver } = require('../dist/drivers/sqlite-driver.cjs');
+const Database = require('better-sqlite3');
+const fs = require('fs');
 const path = require('path');
 
 const dbPath = process.argv[2];
@@ -20,23 +21,84 @@ const migrationsPath = process.argv[3] || 'packages/main/migrations';
 
 if (!dbPath) {
     console.error('❌ Error: Database path is required');
-    console.error('Usage: node scripts/migrate.js <db_path> [migrations_path]');
+    console.error('Usage: node scripts/migrate.cjs <db_path> [migrations_path]');
     process.exit(1);
 }
 
-async function runMigrations() {
+function runMigrations() {
     try {
         console.log(`Initializing database at: ${dbPath}`);
-        const driver = new SqliteDriver(dbPath);
+        
+        // Create SQLite connection
+        const sqlite = new Database(dbPath);
         
         const absoluteMigrationsPath = path.isAbsolute(migrationsPath)
             ? migrationsPath
             : path.join(process.cwd(), migrationsPath);
         
         console.log(`Running migrations from: ${absoluteMigrationsPath}`);
-        await driver.runMigrations(absoluteMigrationsPath);
         
-        console.log('✅ Database migrations completed successfully');
+        // Create migrations tracking table if it doesn't exist
+        sqlite.exec(`
+            CREATE TABLE IF NOT EXISTS __applied_migrations (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT UNIQUE NOT NULL,
+                applied_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        
+        // Get list of already applied migrations
+        const appliedMigrations = new Set(
+            sqlite.prepare('SELECT name FROM __applied_migrations').all().map(row => row.name)
+        );
+        
+        // Get all SQL migration files sorted by name
+        const migrationFiles = fs.readdirSync(absoluteMigrationsPath)
+            .filter(file => file.endsWith('.sql'))
+            .sort();
+        
+        if (migrationFiles.length === 0) {
+            console.log('No migration files found.');
+            sqlite.close();
+            process.exit(0);
+        }
+        
+        let appliedCount = 0;
+        
+        for (const file of migrationFiles) {
+            if (appliedMigrations.has(file)) {
+                console.log(`  ⏭️  ${file} (already applied)`);
+                continue;
+            }
+            
+            const filePath = path.join(absoluteMigrationsPath, file);
+            const sql = fs.readFileSync(filePath, 'utf-8');
+            
+            console.log(`  📄 Applying: ${file}`);
+            
+            try {
+                // Run migration in a transaction
+                sqlite.exec('BEGIN TRANSACTION');
+                sqlite.exec(sql);
+                sqlite.prepare('INSERT INTO __applied_migrations (name) VALUES (?)').run(file);
+                sqlite.exec('COMMIT');
+                appliedCount++;
+            } catch (err) {
+                sqlite.exec('ROLLBACK');
+                // Check if error is due to already existing table/column (safe to ignore)
+                if (err.message.includes('already exists') || err.message.includes('duplicate column')) {
+                    console.log(`  ⚠️  ${file}: ${err.message} (continuing)`);
+                    sqlite.prepare('INSERT OR IGNORE INTO __applied_migrations (name) VALUES (?)').run(file);
+                } else {
+                    throw err;
+                }
+            }
+        }
+        
+        // Close connection
+        sqlite.close();
+        
+        console.log(`\n✅ Database migrations completed (${appliedCount} applied)`);
         process.exit(0);
     } catch (error) {
         console.error('❌ Migration failed:', error.message);

package/src/drivers/sqlite-driver.ts

@@ -31,15 +31,14 @@ export class SqliteDriver implements DatabaseDriver {
     }
 
     /**
-     * Check if database is initialized by checking for Drizzle's migrations table
-     * This is database-agnostic as Drizzle uses __drizzle_migrations for all databases
+     * Check if database is initialized by checking for the migrations tracking table
      */
     async isInitialized(): Promise<boolean> {
         const { sqlite } = this.connection;
         try {
-            // Check for Drizzle's migration tracking table (database-agnostic approach)
+            // Check for migration tracking table created by migrate.cjs script
             const result = sqlite.prepare(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name='__drizzle_migrations'"
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='__applied_migrations'"
             ).get();
             return !!result;
         } catch {

package/src/index.ts

@@ -1,6 +1,5 @@
 import { serve } from '@hono/node-server';
-import { Hono } from 'hono';
-import { createApp, type AppInstance, type DatabaseDriver } from '@package-broker/core';
+import { createApp } from '@package-broker/core';
 import { config } from 'dotenv';
 import { SqliteDriver } from './drivers/sqlite-driver.js';
 import { FileSystemDriver } from './drivers/fs-driver.js';
@@ -9,7 +8,7 @@ import { MemoryCacheDriver, MemoryQueueDriver } from '@package-broker/core';
 import path from 'node:path';
 import { serveStatic } from '@hono/node-server/serve-static';
 import { readFile } from 'node:fs/promises';
-import type { Context, Next } from 'hono';
+import type { Context } from 'hono';
 
 // Load environment variables
 config();
@@ -23,28 +22,13 @@ const STORAGE_PATH = process.env.STORAGE_PATH || './storage';
 const CACHE_DRIVER = process.env.CACHE_DRIVER || 'memory';
 const CACHE_URL = process.env.CACHE_URL || 'redis://localhost:6379';
 const QUEUE_DRIVER = process.env.QUEUE_DRIVER || 'memory';
-const MIGRATIONS_PATH = process.env.MIGRATIONS_PATH || 'packages/main/migrations';
-
-const DOCS_URL = 'https://package-broker.github.io/docs/installation/docker';
 
 console.log('Starting PACKAGE.broker Node Adapter...');
 console.log(`Configuration: DB=${DB_DRIVER}, STORAGE=${STORAGE_DRIVER}, CACHE=${CACHE_DRIVER}, QUEUE=${QUEUE_DRIVER}`);
 
-/**
- * Get the database not initialized error response
- * DRY: Single source of truth for error response structure
- */
-function getDatabaseNotInitializedError() {
-    return {
-        error: 'DATABASE_NOT_INITIALIZED',
-        message: 'Database not initialized. Please run migrations.',
-        docsUrl: DOCS_URL
-    };
-}
-
 async function start() {
-    // Initialize Database Driver (Port-Adapter pattern)
-    let databaseDriver: DatabaseDriver;
+    // Initialize Database Driver
+    let databaseDriver;
     
     if (DB_DRIVER === 'sqlite') {
         console.log(`Initializing SQLite at ${DB_URL}`);
@@ -53,31 +37,31 @@ async function start() {
         throw new Error(`Unsupported DB_DRIVER: ${DB_DRIVER}`);
     }
     
-    // Check if database needs initialization (database-agnostic check)
-    const isDatabaseReady = await databaseDriver.isInitialized();
-    
-    if (!isDatabaseReady) {
+    // Check if database is initialized (logging only)
+    const isInitialized = await databaseDriver.isInitialized();
+    if (!isInitialized) {
         console.warn('');
         console.warn('⚠️  DATABASE NOT INITIALIZED');
-        console.warn('   The database tables have not been created yet.');
-        console.warn('   A warning page will be shown to users until migrations are run.');
-        console.warn(`   📖 Documentation: ${DOCS_URL}`);
+        console.warn('   Run migration scripts to initialize the database:');
+        console.warn('');
+        console.warn('   docker exec <container> node packages/adapter-node/scripts/migrate.cjs /data/database.sqlite');
+        console.warn('');
+        console.warn('   📖 See: https://package.broker/docs/getting-started/quickstart-docker');
         console.warn('');
-    } else {
-        console.log('Database initialized and ready.');
     }
     
     const database = databaseDriver.getConnection();
 
+    // Initialize Storage
     let storage;
     if (STORAGE_DRIVER === 'fs') {
         console.log(`Initializing FS Storage at ${STORAGE_PATH}`);
         storage = new FileSystemDriver(STORAGE_PATH);
     } else {
-        // TODO: Add S3 support
         throw new Error(`Unsupported STORAGE_DRIVER: ${STORAGE_DRIVER}`);
     }
 
+    // Initialize Cache
     let cache;
     if (CACHE_DRIVER === 'redis') {
         console.log(`Initializing Redis Cache at ${CACHE_URL}`);
@@ -87,10 +71,11 @@ async function start() {
         cache = new MemoryCacheDriver();
     }
 
+    // Initialize Queue
     let queue;
     if (QUEUE_DRIVER === 'redis') {
         if (CACHE_DRIVER === 'redis') {
-            queue = cache as any; // RedisDriver implements both
+            queue = cache as any;
         } else {
             console.log(`Initializing Redis Queue at ${CACHE_URL}`);
             queue = new RedisDriver(CACHE_URL);
@@ -100,65 +85,26 @@ async function start() {
         queue = new MemoryQueueDriver();
     }
 
-    // If database is not ready, return error for API requests
-    if (!isDatabaseReady) {
-        const warningApp = new Hono();
-        const errorResponse = getDatabaseNotInitializedError();
-        
-        // Health endpoint returns warning status (200 OK with error status in body for CI compatibility)
-        warningApp.get('/health', (c) => {
-            return c.json({ 
-                status: 'error', 
-                ...errorResponse
-            }, 200); // Return 200 for CI health checks, but include error status
-        });
-        
-        // All API requests return JSON error (BEFORE static files)
-        warningApp.all('/api/*', (c) => {
-            return c.json(errorResponse, 503);
-        });
-        
-        // Serve static files if PUBLIC_DIR is set (UI will display the error)
-        if (process.env.PUBLIC_DIR) {
-            warningApp.use('/*', serveStatic({ root: process.env.PUBLIC_DIR }));
-            warningApp.get('*', async (c) => {
-                try {
-                    return c.html(await readFile(path.join(process.env.PUBLIC_DIR!, 'index.html'), 'utf-8'));
-                } catch (e) {
-                    return c.text('Not Found', 404);
-                }
-            });
-        }
-        
-        console.log(`Server listening on port ${PORT} (WARNING: Database not initialized)`);
-        serve({
-            fetch: warningApp.fetch,
-            port: PORT
-        });
-        return;
-    }
-
-    // Create App (API routes are registered inside createApp)
+    // Create App
     const app = createApp({
         database,
         storage,
         cache,
     });
 
-    // Serve config.js dynamically (AFTER API routes)
+    // Serve config.js dynamically
     app.get('/config.js', (c: Context) => {
         return c.text(`window.env = { API_URL: "${process.env.API_URL || '/'}" };`, 200, {
             'Content-Type': 'application/javascript',
         });
     });
 
-    // Static file serving and SPA fallback (MUST be AFTER API routes)
+    // Static file serving and SPA fallback
     if (process.env.PUBLIC_DIR) {
         console.log(`Serving static files from ${process.env.PUBLIC_DIR}`);
         app.use('/*', serveStatic({ root: process.env.PUBLIC_DIR }));
 
-        // SPA Fallback for client-side routing
-        // This catches any routes that weren't handled by API routes or static files
+        // SPA Fallback
         app.get('*', async (c: Context) => {
             try {
                 return c.html(await readFile(path.join(process.env.PUBLIC_DIR!, 'index.html'), 'utf-8'));