@package-broker/adapter-node 0.2.15

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@package-broker/adapter-node",
+  "version": "0.2.15",
+  "type": "module",
+  "keywords": [],
+  "scripts": {
+    "lint": "echo 'no linting configured'",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx watch src/index.ts",
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.11.1",
+    "@package-broker/core": "*",
+    "@package-broker/shared": "*",
+    "better-sqlite3": "^9.4.3",
+    "dotenv": "^16.4.5",
+    "drizzle-orm": "^0.29.0",
+    "hono": "^4.3.7",
+    "ioredis": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.9",
+    "@types/node": "^20.12.7",
+    "tsup": "^8.5.1",
+    "tsx": "^4.7.2",
+    "typescript": "^5.4.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/package-broker/server",
+    "directory": "packages/adapter-node"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/drivers/fs-driver.ts

@@ -0,0 +1,64 @@
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { type StorageDriver } from '@package-broker/core';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+
+export class FileSystemDriver implements StorageDriver {
+    private basePath: string;
+
+    constructor(basePath: string) {
+        this.basePath = basePath;
+    }
+
+    private getPath(key: string): string {
+        // Prevent directory traversal
+        const safeKey = key.replace(/\.\./g, '');
+        return path.join(this.basePath, safeKey);
+    }
+
+    async get(key: string): Promise<ReadableStream | null> {
+        const filePath = this.getPath(key);
+        try {
+            await fs.access(filePath);
+            // Convert Node.js Readable to Web ReadableStream
+            const nodeStream = createReadStream(filePath);
+            return Readable.toWeb(nodeStream) as unknown as ReadableStream;
+        } catch {
+            return null;
+        }
+    }
+
+    async put(key: string, data: ReadableStream | ArrayBuffer | Uint8Array): Promise<void> {
+        const filePath = this.getPath(key);
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+
+        if (data instanceof ReadableStream) {
+            const nodeStream = Readable.fromWeb(data as any);
+            const writeStream = createWriteStream(filePath);
+            await pipeline(nodeStream, writeStream);
+        } else {
+            await fs.writeFile(filePath, Buffer.from(data as any));
+        }
+    }
+
+    async delete(key: string): Promise<void> {
+        try {
+            await fs.unlink(this.getPath(key));
+        } catch (e: any) {
+            if (e.code !== 'ENOENT') throw e;
+        }
+    }
+
+    async exists(key: string): Promise<boolean> {
+        try {
+            await fs.access(this.getPath(key));
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}

package/src/drivers/redis-driver.ts

@@ -0,0 +1,65 @@
+
+import { Redis } from 'ioredis';
+import type { CachePort, QueuePort } from '@package-broker/core';
+
+export class RedisDriver implements CachePort, QueuePort {
+    private redis: Redis;
+
+    constructor(url: string) {
+        this.redis = new Redis(url);
+    }
+
+    // CachePort implementation
+    async get(key: string): Promise<string | null> {
+        return this.redis.get(key);
+    }
+
+    async getJson<T>(key: string): Promise<T | null> {
+        const value = await this.redis.get(key);
+        if (!value) return null;
+        try {
+            return JSON.parse(value);
+        } catch {
+            return null;
+        }
+    }
+
+    async put(key: string, value: string | ReadableStream | ArrayBuffer | FormData, options?: { expirationTtl?: number }): Promise<void> {
+        let stringValue: string;
+
+        if (typeof value === 'string') {
+            stringValue = value;
+        } else {
+            // Fallback for complex types - stringify if object/generic, or warn
+            try {
+                stringValue = JSON.stringify(value);
+            } catch {
+                stringValue = String(value);
+            }
+        }
+
+        if (options?.expirationTtl) {
+            await this.redis.set(key, stringValue, 'EX', options.expirationTtl);
+        } else {
+            await this.redis.set(key, stringValue);
+        }
+    }
+
+    async delete(key: string): Promise<void> {
+        await this.redis.del(key);
+    }
+
+    // QueuePort implementation
+    async send(message: any): Promise<void> {
+        await this.redis.rpush('jobs_queue', JSON.stringify(message));
+    }
+
+    async sendBatch(messages: any[]): Promise<void> {
+        if (messages.length === 0) return;
+        const pipeline = this.redis.pipeline();
+        for (const msg of messages) {
+            pipeline.rpush('jobs_queue', JSON.stringify(msg));
+        }
+        await pipeline.exec();
+    }
+}

package/src/drivers/sqlite-driver.ts

@@ -0,0 +1,23 @@
+
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import { schema, type DatabasePort } from '@package-broker/core';
+
+export function createSqliteDatabase(dbPath: string): DatabasePort {
+    const sqlite = new Database(dbPath);
+    const db = drizzle(sqlite, { schema });
+
+    // Create method to satisfy the DatabasePort interface if strictly typed, 
+    // but usually generic ORM usages work fine. 
+    // Note: DatabasePort in core is currently aliased to DrizzleD1Database<typeof schema>.
+    // We need to make sure core/db/index.ts types are flexible enough.
+    // Ideally, core should export a generic Drizzle type.
+
+    return db as any;
+}
+
+export async function migrateSqliteDatabase(db: ReturnType<typeof drizzle>, migrationsFolder: string) {
+    // This helper runs migrations on startup
+    await migrate(db, { migrationsFolder });
+}

package/src/index.ts

@@ -0,0 +1,118 @@
+
+import { serve } from '@hono/node-server';
+import { createApp, type AppInstance } from '@package-broker/core';
+import { config } from 'dotenv';
+import { createSqliteDatabase, migrateSqliteDatabase } from './drivers/sqlite-driver.js';
+import { FileSystemDriver } from './drivers/fs-driver.js';
+import { RedisDriver } from './drivers/redis-driver.js';
+import { MemoryCacheDriver, MemoryQueueDriver } from '@package-broker/core';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { readFile } from 'node:fs/promises';
+import type { Context, Next } from 'hono';
+
+// Load environment variables
+config();
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Configuration
+const PORT = Number(process.env.PORT) || 3000;
+const DB_DRIVER = process.env.DB_DRIVER || 'sqlite';
+const DB_URL = process.env.DB_URL || 'db.sqlite';
+const STORAGE_DRIVER = process.env.STORAGE_DRIVER || 'fs';
+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';
+
+console.log('Starting PACKAGE.broker Node Adapter...');
+console.log(`Configuration: DB=${DB_DRIVER}, STORAGE=${STORAGE_DRIVER}, CACHE=${CACHE_DRIVER}, QUEUE=${QUEUE_DRIVER}`);
+
+async function start() {
+    // Initialize Drivers
+    let database;
+    if (DB_DRIVER === 'sqlite') {
+        console.log(`Initializing SQLite at ${DB_URL}`);
+        database = createSqliteDatabase(DB_URL);
+        // Auto-migrate on start (simplified for MVP)
+        // In real deployment, migrations should be separate step
+    } else {
+        throw new Error(`Unsupported DB_DRIVER: ${DB_DRIVER}`);
+    }
+
+    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}`);
+    }
+
+    let cache;
+    if (CACHE_DRIVER === 'redis') {
+        console.log(`Initializing Redis Cache at ${CACHE_URL}`);
+        cache = new RedisDriver(CACHE_URL);
+    } else {
+        console.log('Initializing Memory Cache');
+        cache = new MemoryCacheDriver();
+    }
+
+    let queue;
+    if (QUEUE_DRIVER === 'redis') {
+        if (CACHE_DRIVER === 'redis') {
+            queue = cache as any; // RedisDriver implements both
+        } else {
+            console.log(`Initializing Redis Queue at ${CACHE_URL}`);
+            queue = new RedisDriver(CACHE_URL);
+        }
+    } else {
+        console.log('Initializing Memory Queue');
+        queue = new MemoryQueueDriver();
+    }
+
+    // Create App
+    const app = createApp({
+        database,
+        storage,
+        onInit: (appInstance: AppInstance) => {
+            // Inject non-standard drivers if needed or custom middleware
+            appInstance.use('*', async (c: Context, next: Next) => {
+                // We already passed database/storage to createApp, but we can set extra vars here
+                // Note: createApp factory handles database/storage injection if passed in options
+                await next();
+            });
+
+            // 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',
+                });
+            });
+
+            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
+                app.get('*', async (c: Context) => {
+                    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}`);
+    serve({
+        fetch: app.fetch,
+        port: PORT
+    });
+}
+
+start().catch(console.error);

package/src/mocks/cloudflare-workers.ts

@@ -0,0 +1,3 @@
+export class WorkflowEntrypoint { }
+export class WorkflowStep { }
+export class WorkflowEvent { }

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "outDir": "./dist",
+        "types": [
+            "node"
+        ],
+        "baseUrl": ".",
+        "paths": {
+            "@package-broker/core": [
+                "../core/src"
+            ],
+            "@package-broker/shared": [
+                "../shared/src"
+            ]
+        }
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "**/*.test.ts"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'tsup';
+import path from 'path';
+
+const cloudflarePlugin = {
+    name: 'cloudflare-workers-mock',
+    setup(build) {
+        build.onResolve({ filter: /^cloudflare:workers$/ }, args => {
+            return { path: path.resolve(__dirname, 'src/mocks/cloudflare-workers.ts') }
+        });
+    },
+};
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm'],
+    target: 'node20',
+    noExternal: ['@package-broker/core', '@package-broker/shared'],
+    clean: true,
+    esbuildPlugins: [cloudflarePlugin],
+});