@eldrin-project/eldrin-app-core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,582 @@
+'use strict';
+
+var react = require('react');
+var promises = require('fs/promises');
+var fs = require('fs');
+var path = require('path');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/app/createApp.tsx
+
+// src/migrations/checksum.ts
+var CHECKSUM_PREFIX = "sha256:";
+async function calculateChecksum(content, options = {}) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(content);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return options.prefixed ? `${CHECKSUM_PREFIX}${hex}` : hex;
+}
+async function calculatePrefixedChecksum(content) {
+  return calculateChecksum(content, { prefixed: true });
+}
+async function verifyChecksum(content, expectedChecksum) {
+  const normalizedExpected = expectedChecksum.startsWith(CHECKSUM_PREFIX) ? expectedChecksum.slice(CHECKSUM_PREFIX.length) : expectedChecksum;
+  const actualChecksum = await calculateChecksum(content);
+  return actualChecksum === normalizedExpected;
+}
+
+// src/migrations/sql-parser.ts
+function parseSQLStatements(sql) {
+  const statements = [];
+  let current = "";
+  let inString = false;
+  let stringChar = "";
+  let i = 0;
+  const lines = sql.split("\n");
+  const cleanedLines = [];
+  for (const line of lines) {
+    let cleanLine = "";
+    let lineInString = false;
+    let lineStringChar = "";
+    for (let j = 0; j < line.length; j++) {
+      const char = line[j];
+      const nextChar = line[j + 1];
+      if (!lineInString) {
+        if (char === "-" && nextChar === "-") {
+          break;
+        }
+        if (char === "'" || char === '"') {
+          lineInString = true;
+          lineStringChar = char;
+        }
+      } else {
+        if (char === lineStringChar) {
+          if (nextChar === lineStringChar) {
+            cleanLine += char;
+            j++;
+            cleanLine += line[j];
+            continue;
+          }
+          lineInString = false;
+        }
+      }
+      cleanLine += char;
+    }
+    cleanedLines.push(cleanLine);
+  }
+  const cleanedSql = cleanedLines.join("\n");
+  for (i = 0; i < cleanedSql.length; i++) {
+    const char = cleanedSql[i];
+    if (!inString) {
+      if (char === "'" || char === '"') {
+        inString = true;
+        stringChar = char;
+        current += char;
+      } else if (char === ";") {
+        const trimmed2 = current.trim();
+        if (trimmed2.length > 0) {
+          statements.push(trimmed2);
+        }
+        current = "";
+      } else {
+        current += char;
+      }
+    } else {
+      current += char;
+      if (char === stringChar) {
+        const nextChar = cleanedSql[i + 1];
+        if (nextChar === stringChar) {
+          i++;
+          current += nextChar;
+        } else {
+          inString = false;
+        }
+      }
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed.length > 0) {
+    statements.push(trimmed);
+  }
+  return statements;
+}
+function isValidMigrationFilename(filename) {
+  if (!filename.endsWith(".sql") || filename.endsWith(".rollback.sql")) {
+    return false;
+  }
+  const pattern = /^\d{14}-[a-z0-9-]+\.sql$/;
+  return pattern.test(filename);
+}
+function isValidRollbackFilename(filename) {
+  if (!filename.endsWith(".rollback.sql")) {
+    return false;
+  }
+  const pattern = /^\d{14}-[a-z0-9-]+\.rollback\.sql$/;
+  return pattern.test(filename);
+}
+function extractTimestamp(filename) {
+  const match = filename.match(/^(\d{14})-/);
+  return match ? match[1] : null;
+}
+function getRollbackFilename(migrationFilename) {
+  return migrationFilename.replace(/\.sql$/, ".rollback.sql");
+}
+
+// src/migrations/runner.ts
+var CREATE_MIGRATIONS_TABLE = `
+CREATE TABLE IF NOT EXISTS _eldrin_migrations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  filename TEXT NOT NULL UNIQUE,
+  checksum TEXT NOT NULL,
+  executed_at INTEGER NOT NULL,
+  execution_time_ms INTEGER
+)
+`;
+var defaultLogger = () => {
+};
+async function runMigrations(db, options = {}) {
+  const { migrations = [], skipChecksumVerification = false, onLog = defaultLogger } = options;
+  const log = (message, level = "info") => {
+    onLog(message, level);
+  };
+  const result = {
+    success: true,
+    executed: 0,
+    migrations: []
+  };
+  try {
+    log("Creating migrations tracking table if not exists...");
+    await db.batch([db.prepare(CREATE_MIGRATIONS_TABLE)]);
+    const validMigrations = migrations.filter((m) => isValidMigrationFilename(m.name)).sort((a, b) => a.name.localeCompare(b.name));
+    if (validMigrations.length === 0) {
+      log("No migration files found");
+      return result;
+    }
+    log(`Found ${validMigrations.length} migration file(s)`);
+    const { results: executed } = await db.prepare("SELECT filename, checksum FROM _eldrin_migrations ORDER BY filename").all();
+    const executedMap = new Map(executed?.map((e) => [e.filename, e.checksum]) ?? []);
+    if (!skipChecksumVerification) {
+      for (const migration of validMigrations) {
+        const storedChecksum = executedMap.get(migration.name);
+        if (storedChecksum) {
+          const currentChecksum = await calculateChecksum(migration.content);
+          if (currentChecksum !== storedChecksum) {
+            const error = new Error(
+              `Migration ${migration.name} has been modified after execution! Expected checksum: ${storedChecksum}, got: ${currentChecksum}`
+            );
+            log(error.message, "error");
+            return {
+              success: false,
+              executed: 0,
+              migrations: [],
+              error: {
+                migration: migration.name,
+                message: error.message
+              }
+            };
+          }
+        }
+      }
+    }
+    for (const [filename] of executedMap) {
+      const hasFile = validMigrations.some((m) => m.name === filename);
+      if (!hasFile) {
+        log(`Warning: Orphaned migration in database: ${filename}`, "warn");
+      }
+    }
+    const pending = validMigrations.filter((m) => !executedMap.has(m.name));
+    if (pending.length === 0) {
+      log("No pending migrations");
+      return result;
+    }
+    log(`Found ${pending.length} pending migration(s)`);
+    for (const migration of pending) {
+      log(`Executing migration: ${migration.name}`);
+      const startTime = Date.now();
+      try {
+        const statements = parseSQLStatements(migration.content);
+        if (statements.length === 0) {
+          log(`Warning: Migration ${migration.name} contains no SQL statements`, "warn");
+          continue;
+        }
+        const checksum = await calculateChecksum(migration.content);
+        const batch = [
+          // Execute all statements from the migration
+          ...statements.map((sql) => db.prepare(sql)),
+          // Record execution in tracking table
+          db.prepare(
+            `INSERT INTO _eldrin_migrations
+               (filename, checksum, executed_at, execution_time_ms)
+               VALUES (?, ?, ?, ?)`
+          ).bind(migration.name, checksum, Date.now(), Date.now() - startTime)
+        ];
+        await db.batch(batch);
+        const executionTime = Date.now() - startTime;
+        log(`Migration ${migration.name} completed (${executionTime}ms)`);
+        result.executed++;
+        result.migrations.push({
+          name: migration.name,
+          executionTimeMs: executionTime
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Migration ${migration.name} failed: ${errorMessage}`, "error");
+        return {
+          success: false,
+          executed: result.executed,
+          migrations: result.migrations,
+          error: {
+            migration: migration.name,
+            message: errorMessage
+          }
+        };
+      }
+    }
+    log(`Successfully executed ${result.executed} migration(s)`);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Migration system error: ${errorMessage}`, "error");
+    return {
+      success: false,
+      executed: result.executed,
+      migrations: result.migrations,
+      error: {
+        migration: "system",
+        message: errorMessage
+      }
+    };
+  }
+}
+async function getMigrationStatus(db, migrations) {
+  await db.batch([db.prepare(CREATE_MIGRATIONS_TABLE)]);
+  const { results: executed } = await db.prepare("SELECT * FROM _eldrin_migrations ORDER BY filename").all();
+  const executedMap = new Map(executed?.map((e) => [e.filename, e]) ?? []);
+  const validMigrations = migrations.filter((m) => isValidMigrationFilename(m.name));
+  const pending = validMigrations.filter((m) => !executedMap.has(m.name)).map((m) => m.name).sort();
+  const orphaned = [];
+  for (const [filename] of executedMap) {
+    if (!validMigrations.some((m) => m.name === filename)) {
+      orphaned.push(filename);
+    }
+  }
+  const checksumMismatches = [];
+  for (const migration of validMigrations) {
+    const record = executedMap.get(migration.name);
+    if (record) {
+      const currentChecksum = await calculateChecksum(migration.content);
+      if (currentChecksum !== record.checksum) {
+        checksumMismatches.push(migration.name);
+      }
+    }
+  }
+  return {
+    pending,
+    executed: executed ?? [],
+    orphaned,
+    checksumMismatches
+  };
+}
+
+// src/migrations/rollback.ts
+async function rollbackMigrations(db, options) {
+  const { rollbackFiles, targetMigration, onLog = () => {
+  } } = options;
+  const log = (message, level = "info") => {
+    onLog(message, level);
+  };
+  const result = {
+    success: true,
+    rolledBack: []
+  };
+  try {
+    const { results: executed } = await db.prepare("SELECT filename FROM _eldrin_migrations ORDER BY filename DESC").all();
+    if (!executed || executed.length === 0) {
+      log("No migrations to rollback");
+      return result;
+    }
+    let toRollback;
+    if (targetMigration) {
+      const targetIndex = executed.findIndex((m) => m.filename === targetMigration);
+      if (targetIndex === -1) {
+        return {
+          success: false,
+          rolledBack: [],
+          error: {
+            migration: targetMigration,
+            message: `Target migration not found: ${targetMigration}`
+          }
+        };
+      }
+      toRollback = executed.slice(0, targetIndex).map((m) => m.filename);
+    } else {
+      toRollback = [executed[0].filename];
+    }
+    if (toRollback.length === 0) {
+      log("No migrations to rollback");
+      return result;
+    }
+    const rollbackMap = new Map(
+      rollbackFiles.filter((f) => isValidRollbackFilename(f.name)).map((f) => [f.name, f])
+    );
+    for (const migrationFilename of toRollback) {
+      const rollbackFilename = getRollbackFilename(migrationFilename);
+      const rollbackFile = rollbackMap.get(rollbackFilename);
+      if (!rollbackFile) {
+        return {
+          success: false,
+          rolledBack: result.rolledBack,
+          error: {
+            migration: migrationFilename,
+            message: `Rollback file not found: ${rollbackFilename}`
+          }
+        };
+      }
+      log(`Rolling back: ${migrationFilename}`);
+      try {
+        const statements = parseSQLStatements(rollbackFile.content);
+        if (statements.length === 0) {
+          log(`Warning: Rollback file ${rollbackFilename} contains no SQL statements`, "warn");
+        }
+        const batch = [
+          ...statements.map((sql) => db.prepare(sql)),
+          db.prepare("DELETE FROM _eldrin_migrations WHERE filename = ?").bind(migrationFilename)
+        ];
+        await db.batch(batch);
+        log(`Rolled back: ${migrationFilename}`);
+        result.rolledBack.push(migrationFilename);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Rollback failed for ${migrationFilename}: ${errorMessage}`, "error");
+        return {
+          success: false,
+          rolledBack: result.rolledBack,
+          error: {
+            migration: migrationFilename,
+            message: errorMessage
+          }
+        };
+      }
+    }
+    log(`Successfully rolled back ${result.rolledBack.length} migration(s)`);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Rollback system error: ${errorMessage}`, "error");
+    return {
+      success: false,
+      rolledBack: result.rolledBack,
+      error: {
+        migration: "system",
+        message: errorMessage
+      }
+    };
+  }
+}
+async function readMigrationFiles(dir) {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files = await promises.readdir(dir);
+  const sqlFiles = files.filter((f) => isValidMigrationFilename(f)).sort();
+  const migrations = [];
+  for (const file of sqlFiles) {
+    const content = await promises.readFile(path.resolve(dir, file), "utf-8");
+    migrations.push({
+      name: path.basename(file),
+      content
+    });
+  }
+  return migrations;
+}
+async function generateMigrationManifest(options) {
+  const { migrationsDir, database } = options;
+  const files = await readMigrationFiles(migrationsDir);
+  const migrations = await Promise.all(
+    files.map(async (file) => {
+      const timestamp = extractTimestamp(file.name);
+      const checksum = await calculatePrefixedChecksum(file.content);
+      return {
+        id: timestamp || file.name.replace(".sql", ""),
+        file: file.name,
+        checksum
+      };
+    })
+  );
+  return {
+    manifest: {
+      database,
+      migrations
+    },
+    files
+  };
+}
+async function validateMigrationManifest(manifest, files) {
+  const errors = [];
+  for (const entry of manifest.migrations) {
+    const file = files.find((f) => f.name === entry.file);
+    if (!file) {
+      errors.push(`Missing file: ${entry.file}`);
+      continue;
+    }
+    const actualChecksum = await calculatePrefixedChecksum(file.content);
+    if (actualChecksum !== entry.checksum) {
+      errors.push(
+        `Checksum mismatch for ${entry.file}: expected ${entry.checksum}, got ${actualChecksum}`
+      );
+    }
+    const timestamp = extractTimestamp(file.name);
+    if (timestamp !== entry.id) {
+      errors.push(
+        `ID mismatch for ${entry.file}: expected ${timestamp}, got ${entry.id}`
+      );
+    }
+  }
+  for (const file of files) {
+    if (!manifest.migrations.some((m) => m.file === file.name)) {
+      errors.push(`File not in manifest: ${file.name}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+var EldrinDatabaseContext = react.createContext(null);
+function DatabaseProvider({
+  db,
+  migrationsComplete,
+  migrationResult,
+  children
+}) {
+  const value = {
+    db,
+    migrationsComplete,
+    migrationResult
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(EldrinDatabaseContext.Provider, { value, children });
+}
+function useDatabase() {
+  const context = react.useContext(EldrinDatabaseContext);
+  if (context === null) {
+    throw new Error("useDatabase must be used within a DatabaseProvider (via createApp)");
+  }
+  return context.db;
+}
+function useDatabaseContext() {
+  const context = react.useContext(EldrinDatabaseContext);
+  if (context === null) {
+    throw new Error("useDatabaseContext must be used within a DatabaseProvider (via createApp)");
+  }
+  return context;
+}
+function useMigrationsComplete() {
+  const context = react.useContext(EldrinDatabaseContext);
+  return context?.migrationsComplete ?? false;
+}
+
+// src/app/createApp.tsx
+function createApp(options) {
+  const { name, root: RootComponent, migrations = [], onMigrationsComplete, onMigrationError } = options;
+  const state = {
+    db: null,
+    migrationsComplete: false,
+    migrationResult: void 0,
+    mountedElement: void 0,
+    reactRoot: void 0
+  };
+  async function bootstrap(props) {
+    const db = props.db ?? null;
+    state.db = db;
+    if (db && migrations.length > 0) {
+      try {
+        const result = await runMigrations(db, {
+          migrations,
+          onLog: (message, level) => {
+            const prefix = `[${name}]`;
+            if (level === "error") {
+              console.error(prefix, message);
+            } else if (level === "warn") {
+              console.warn(prefix, message);
+            } else {
+              console.log(prefix, message);
+            }
+          }
+        });
+        state.migrationResult = result;
+        if (result.success) {
+          state.migrationsComplete = true;
+          onMigrationsComplete?.(result);
+        } else {
+          const error = new Error(result.error?.message ?? "Migration failed");
+          onMigrationError?.(error);
+          throw error;
+        }
+      } catch (error) {
+        state.migrationsComplete = false;
+        const err = error instanceof Error ? error : new Error(String(error));
+        onMigrationError?.(err);
+        throw err;
+      }
+    } else {
+      state.migrationsComplete = true;
+    }
+  }
+  async function mount(props) {
+    const domElement = props.domElement ?? document.getElementById(`app-${name}`);
+    if (!domElement) {
+      throw new Error(`No DOM element found for app "${name}". Expected element with id="app-${name}" or domElement prop.`);
+    }
+    state.mountedElement = domElement;
+    const rootElement = react.createElement(RootComponent, props.customProps ?? {});
+    const appElement = react.createElement(DatabaseProvider, {
+      db: state.db,
+      migrationsComplete: state.migrationsComplete,
+      migrationResult: state.migrationResult,
+      children: rootElement
+    });
+    const ReactDOM = await import('react-dom/client');
+    const root = ReactDOM.createRoot(domElement);
+    root.render(appElement);
+    state.reactRoot = root;
+  }
+  async function unmount(_props) {
+    if (state.reactRoot) {
+      state.reactRoot.unmount();
+      state.reactRoot = void 0;
+    }
+    if (state.mountedElement) {
+      state.mountedElement.innerHTML = "";
+      state.mountedElement = void 0;
+    }
+  }
+  return {
+    bootstrap,
+    mount,
+    unmount
+  };
+}
+
+exports.CHECKSUM_PREFIX = CHECKSUM_PREFIX;
+exports.DatabaseProvider = DatabaseProvider;
+exports.calculateChecksum = calculateChecksum;
+exports.calculatePrefixedChecksum = calculatePrefixedChecksum;
+exports.createApp = createApp;
+exports.extractTimestamp = extractTimestamp;
+exports.generateMigrationManifest = generateMigrationManifest;
+exports.getMigrationStatus = getMigrationStatus;
+exports.getRollbackFilename = getRollbackFilename;
+exports.isValidMigrationFilename = isValidMigrationFilename;
+exports.isValidRollbackFilename = isValidRollbackFilename;
+exports.parseSQLStatements = parseSQLStatements;
+exports.rollbackMigrations = rollbackMigrations;
+exports.runMigrations = runMigrations;
+exports.useDatabase = useDatabase;
+exports.useDatabaseContext = useDatabaseContext;
+exports.useMigrationsComplete = useMigrationsComplete;
+exports.validateMigrationManifest = validateMigrationManifest;
+exports.verifyChecksum = verifyChecksum;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map