@eldrin-project/eldrin-app-core 0.0.1

package/dist/cli/release.js

@@ -0,0 +1,592 @@
+#!/usr/bin/env node
+import { readFile, writeFile, copyFile, readdir, mkdir, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, basename, relative } from 'path';
+import { execSync } from 'child_process';
+import { createInterface } from 'readline';
+
+// 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 });
+}
+
+// src/migrations/sql-parser.ts
+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 extractTimestamp(filename) {
+  const match = filename.match(/^(\d{14})-/);
+  return match ? match[1] : null;
+}
+
+// src/migrations/marketplace.ts
+async function readMigrationFiles(dir) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const files = await readdir(dir);
+  const sqlFiles = files.filter((f) => isValidMigrationFilename(f)).sort();
+  const migrations = [];
+  for (const file of sqlFiles) {
+    const content = await readFile(resolve(dir, file), "utf-8");
+    migrations.push({
+      name: 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
+  };
+}
+
+// src/cli/release.ts
+var DEFAULT_MARKETPLACE_URL = "https://eldrin.io";
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    switch (arg) {
+      case "--type":
+      case "-t":
+        if (nextArg === "patch" || nextArg === "minor" || nextArg === "major") {
+          options.bumpType = nextArg;
+        } else {
+          console.error(`Invalid bump type: ${nextArg}. Must be patch, minor, or major.`);
+          process.exit(1);
+        }
+        i++;
+        break;
+      case "--version":
+      case "-v":
+        options.version = nextArg;
+        i++;
+        break;
+      case "--skip-build":
+        options.skipBuild = true;
+        break;
+      case "--manifest":
+      case "-m":
+        options.manifestPath = nextArg;
+        i++;
+        break;
+      case "--bundle":
+      case "-b":
+        options.bundlePath = nextArg;
+        i++;
+        break;
+      case "--migrations":
+        options.migrationsDir = nextArg;
+        i++;
+        break;
+      case "--output":
+      case "-o":
+        options.outputDir = nextArg;
+        i++;
+        break;
+      case "--marketplace-url":
+      case "-u":
+        options.marketplaceUrl = nextArg;
+        i++;
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        process.exit(0);
+    }
+  }
+  return options;
+}
+function bumpVersion(version, type) {
+  const parts = version.split(".").map(Number);
+  if (parts.length !== 3 || parts.some(isNaN)) {
+    throw new Error(`Invalid version format: ${version}. Expected semver (e.g., 1.0.0)`);
+  }
+  const [major, minor, patch] = parts;
+  switch (type) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (partsA[i] < partsB[i]) return -1;
+    if (partsA[i] > partsB[i]) return 1;
+  }
+  return 0;
+}
+async function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve3) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve3(answer.trim());
+    });
+  });
+}
+async function promptChoice(question, options) {
+  console.log(question);
+  options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt}`));
+  while (true) {
+    const answer = await prompt(`Choose (1-${options.length}): `);
+    const choice = parseInt(answer, 10);
+    if (choice >= 1 && choice <= options.length) {
+      return choice - 1;
+    }
+    console.log(`Invalid choice. Please enter a number between 1 and ${options.length}.`);
+  }
+}
+async function fetchLatestVersion(marketplaceUrl, developerId, appId) {
+  const url = `${marketplaceUrl}/api/marketplace/versions?developerId=${encodeURIComponent(developerId)}&appId=${encodeURIComponent(appId)}`;
+  try {
+    const response = await fetch(url);
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("application/json")) {
+      throw new Error("Marketplace error, please try again later.");
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Marketplace error, please try again later.");
+    }
+    return data.latest || null;
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Marketplace")) {
+      throw error;
+    }
+    throw new Error("Marketplace error, please try again later.");
+  }
+}
+function printHelp() {
+  console.log(`
+Eldrin Release Tool
+
+Prepares an Eldrin app for marketplace submission.
+
+Usage:
+  npx eldrin-release [options]
+
+Options:
+  -t, --type <type>         Bump version: patch, minor, or major
+                            Fetches latest from marketplace and bumps accordingly
+  -v, --version <version>   Override version explicitly (ignores --type)
+  --skip-build              Skip running the build command
+  -m, --manifest <path>     Path to manifest (default: ./eldrin-app.manifest.json)
+  -b, --bundle <path>       Path to bundle (default: auto-detected from manifest)
+  --migrations <path>       Path to migrations directory (default: ./migrations)
+  -o, --output <path>       Output directory (default: ./dist/release/...)
+  -u, --marketplace-url     Marketplace URL (default: https://eldrin.io)
+  -h, --help                Show this help message
+
+Examples:
+  npx eldrin-release                    # Re-release current version
+  npx eldrin-release --type patch       # Bump patch (0.0.1 -> 0.0.2)
+  npx eldrin-release --type minor       # Bump minor (0.0.1 -> 0.1.0)
+  npx eldrin-release --type major       # Bump major (0.0.1 -> 1.0.0)
+  npx eldrin-release --version 2.0.0    # Set explicit version
+  npx eldrin-release --skip-build       # Skip build step
+`);
+}
+async function findManifest(projectRoot) {
+  const candidates = [
+    "eldrin-app.manifest.json",
+    "manifest.json"
+  ];
+  for (const candidate of candidates) {
+    const path = resolve(projectRoot, candidate);
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+async function findBundle(projectRoot, manifest) {
+  if (manifest.entry) {
+    const fromDist = resolve(projectRoot, "dist", manifest.entry);
+    if (existsSync(fromDist)) return fromDist;
+  }
+  const patterns = [
+    `dist/eldrin-${manifest.id}.js`,
+    `dist/${manifest.id}.js`,
+    "dist/bundle.js",
+    "dist/index.js"
+  ];
+  for (const pattern of patterns) {
+    const path = resolve(projectRoot, pattern);
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  const distDir = resolve(projectRoot, "dist");
+  if (existsSync(distDir)) {
+    const files = await readdir(distDir);
+    const jsFile = files.find((f) => f.endsWith(".js") && !f.endsWith(".d.js"));
+    if (jsFile) {
+      return resolve(distDir, jsFile);
+    }
+  }
+  return null;
+}
+async function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+async function loadConfig(projectRoot, options) {
+  const rcPath = resolve(projectRoot, ".eldrinrc.json");
+  let rcConfig = {};
+  if (existsSync(rcPath)) {
+    try {
+      rcConfig = JSON.parse(await readFile(rcPath, "utf-8"));
+    } catch {
+    }
+  }
+  return {
+    manifestPath: options.manifestPath || rcConfig.manifestPath || "./eldrin-app.manifest.json",
+    bundlePath: options.bundlePath || rcConfig.bundlePath || "",
+    migrationsDir: options.migrationsDir || rcConfig.migrationsDir || "./migrations",
+    buildCommand: rcConfig.buildCommand || "npm run build:lib",
+    clientDir: rcConfig.clientDir || "dist/client",
+    workerEntry: rcConfig.workerEntry || "dist/worker/index.js"
+  };
+}
+function getContentType(filename) {
+  const ext = filename.toLowerCase().split(".").pop();
+  const contentTypes = {
+    "html": "text/html",
+    "css": "text/css",
+    "js": "application/javascript",
+    "json": "application/json",
+    "svg": "image/svg+xml",
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "ico": "image/x-icon",
+    "woff": "font/woff",
+    "woff2": "font/woff2",
+    "ttf": "font/ttf",
+    "eot": "application/vnd.ms-fontobject",
+    "webp": "image/webp",
+    "gif": "image/gif",
+    "map": "application/json"
+  };
+  return contentTypes[ext || ""] || "application/octet-stream";
+}
+async function bundleClientAssets(clientDir) {
+  const assets = [];
+  async function processDir(dir, baseDir) {
+    const items = await readdir(dir);
+    for (const item of items) {
+      const fullPath = resolve(dir, item);
+      const stats = await stat(fullPath);
+      if (stats.isDirectory()) {
+        if (!item.startsWith(".")) {
+          await processDir(fullPath, baseDir);
+        }
+      } else {
+        if (item === ".dev.vars" || item === "wrangler.json") continue;
+        const relativePath = "/" + relative(baseDir, fullPath);
+        const content = await readFile(fullPath);
+        const base64 = content.toString("base64");
+        assets.push({
+          path: relativePath,
+          contentType: getContentType(item),
+          size: stats.size,
+          base64
+        });
+      }
+    }
+  }
+  await processDir(clientDir, clientDir);
+  return assets;
+}
+async function createDeploymentBundle(workerPath, clientDir, version) {
+  const workerScript = await readFile(workerPath, "utf-8");
+  const assets = await bundleClientAssets(clientDir);
+  return {
+    version,
+    worker: {
+      script: workerScript,
+      main_module: "index.js"
+    },
+    assets
+  };
+}
+async function loadVersionsManifest(appDir) {
+  const versionsPath = resolve(appDir, "versions.json");
+  if (existsSync(versionsPath)) {
+    try {
+      const content = await readFile(versionsPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  return { latest: "", versions: [] };
+}
+async function updateVersionsManifest(appDir, version, changelog) {
+  const manifest = await loadVersionsManifest(appDir);
+  const existingIndex = manifest.versions.findIndex((v) => v.version === version);
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const changes = {
+    features: [],
+    fixes: [],
+    breaking: []
+  };
+  if (existingIndex === -1) {
+    changes.features.push(`Release ${version}`);
+  }
+  const entry = {
+    version,
+    releaseDate: today,
+    changes
+  };
+  if (existingIndex >= 0) {
+    manifest.versions[existingIndex] = entry;
+  } else {
+    manifest.versions.unshift(entry);
+  }
+  manifest.latest = version;
+  await writeFile(
+    resolve(appDir, "versions.json"),
+    JSON.stringify(manifest, null, 2)
+  );
+}
+async function release(options = {}) {
+  const projectRoot = process.cwd();
+  const config = await loadConfig(projectRoot, options);
+  console.log("\n\u{1F4E6} Eldrin Release Tool\n");
+  const manifestPath = resolve(projectRoot, config.manifestPath);
+  if (!existsSync(manifestPath)) {
+    const found = await findManifest(projectRoot);
+    if (!found) {
+      throw new Error(
+        "Could not find eldrin-app.manifest.json. Create one or specify with --manifest"
+      );
+    }
+    config.manifestPath = found;
+  }
+  console.log(`\u{1F4C4} Loading manifest from ${config.manifestPath}`);
+  const manifest = JSON.parse(
+    await readFile(resolve(projectRoot, config.manifestPath), "utf-8")
+  );
+  const developerId = manifest.developer.id;
+  const appId = manifest.id;
+  const localVersion = manifest.version || "0.0.0";
+  const marketplaceUrl = options.marketplaceUrl || process.env.ELDRIN_MARKETPLACE_URL || DEFAULT_MARKETPLACE_URL;
+  console.log(`   App: ${appId} by ${developerId}`);
+  console.log(`   Local version: ${localVersion}`);
+  console.log(`   Fetching latest version from marketplace...`);
+  let remoteVersion = null;
+  try {
+    remoteVersion = await fetchLatestVersion(marketplaceUrl, developerId, appId);
+  } catch (error) {
+    console.log(`   \u26A0\uFE0F  Could not fetch remote version: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  if (remoteVersion) {
+    console.log(`   Remote version: ${remoteVersion}`);
+  } else {
+    console.log(`   Remote version: (none - new app)`);
+  }
+  let version;
+  if (options.version) {
+    version = options.version;
+    console.log(`   Using explicit version: ${version}
+`);
+  } else if (options.bumpType) {
+    const baseVersion = remoteVersion || localVersion;
+    version = bumpVersion(baseVersion, options.bumpType);
+    console.log(`   Bumping ${options.bumpType}: ${baseVersion} \u2192 ${version}
+`);
+  } else if (remoteVersion && compareVersions(remoteVersion, localVersion) > 0) {
+    console.log(`
+\u26A0\uFE0F  Remote version (${remoteVersion}) is higher than local (${localVersion})
+`);
+    const choice = await promptChoice("What would you like to do?", [
+      `Use remote version (${remoteVersion})`,
+      "Bump version"
+    ]);
+    if (choice === 0) {
+      version = remoteVersion;
+      console.log(`
+   Using remote version: ${version}
+`);
+    } else {
+      const bumpChoice = await promptChoice("\nSelect bump type:", [
+        `Patch (${bumpVersion(remoteVersion, "patch")})`,
+        `Minor (${bumpVersion(remoteVersion, "minor")})`,
+        `Major (${bumpVersion(remoteVersion, "major")})`
+      ]);
+      const bumpTypes = ["patch", "minor", "major"];
+      version = bumpVersion(remoteVersion, bumpTypes[bumpChoice]);
+      console.log(`
+   Bumping ${bumpTypes[bumpChoice]}: ${remoteVersion} \u2192 ${version}
+`);
+    }
+  } else if (remoteVersion && compareVersions(remoteVersion, localVersion) === 0) {
+    console.log(`
+   Local and remote versions match (${localVersion})`);
+    console.log(`   Re-releasing current version
+`);
+    version = localVersion;
+  } else {
+    version = localVersion;
+    console.log(`   Using local version: ${version}
+`);
+  }
+  if (version !== manifest.version) {
+    console.log(`\u{1F4DD} Updating manifest version: ${manifest.version} \u2192 ${version}`);
+    const updatedManifest = { ...manifest, version };
+    await writeFile(
+      resolve(projectRoot, config.manifestPath),
+      JSON.stringify(updatedManifest, null, 2) + "\n"
+    );
+    const packageJsonPath = resolve(projectRoot, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+      if (packageJson.version !== version) {
+        console.log(`\u{1F4DD} Updating package.json version: ${packageJson.version} \u2192 ${version}`);
+        packageJson.version = version;
+        await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+      }
+    }
+  }
+  if (!options.skipBuild) {
+    console.log("\u{1F528} Building library bundle...");
+    try {
+      execSync(config.buildCommand, { stdio: "inherit", cwd: projectRoot });
+    } catch {
+      throw new Error("Build failed. Fix errors and try again, or use --skip-build");
+    }
+  } else {
+    console.log("\u23ED\uFE0F  Skipping build (--skip-build)");
+  }
+  const bundlePath = config.bundlePath ? resolve(projectRoot, config.bundlePath) : await findBundle(projectRoot, manifest);
+  if (!bundlePath || !existsSync(bundlePath)) {
+    throw new Error(
+      `Bundle not found. Build the app first or specify with --bundle`
+    );
+  }
+  console.log(`\u{1F4E6} Found bundle: ${bundlePath}`);
+  const appDir = resolve(projectRoot, `dist/release/${developerId}/${appId}`);
+  const outputDir = options.outputDir || resolve(appDir, `v${version}`);
+  const migrationsOutputDir = resolve(appDir, "migrations");
+  console.log("\u{1F4C1} Creating output directories...");
+  await ensureDir(outputDir);
+  await ensureDir(migrationsOutputDir);
+  console.log("\u{1F4C4} Writing manifest...");
+  const outputManifest = { ...manifest, version };
+  await writeFile(
+    resolve(outputDir, "eldrin-app.manifest.json"),
+    JSON.stringify(outputManifest, null, 2)
+  );
+  console.log("\u{1F4E6} Copying bundle...");
+  await copyFile(bundlePath, resolve(outputDir, "bundle.js"));
+  const clientDir = resolve(projectRoot, config.clientDir || "dist/client");
+  const workerPath = resolve(projectRoot, config.workerEntry || "dist/worker/index.js");
+  if (existsSync(clientDir) && existsSync(workerPath)) {
+    console.log("\u{1F4E6} Creating deployment bundle...");
+    const deployBundle = await createDeploymentBundle(workerPath, clientDir, version);
+    await writeFile(
+      resolve(outputDir, "deploy-bundle.json"),
+      JSON.stringify(deployBundle)
+      // No pretty print to save space
+    );
+    console.log(`   \u2713 ${deployBundle.assets.length} client asset(s) bundled`);
+    console.log(`   \u2713 Worker script: ${deployBundle.worker.script.length} bytes`);
+  }
+  const migrationsDir = resolve(projectRoot, config.migrationsDir);
+  if (existsSync(migrationsDir)) {
+    console.log("\u{1F5C3}\uFE0F  Generating migration manifest...");
+    const result = await generateMigrationManifest({
+      migrationsDir,
+      database: appId
+    });
+    if (result.files.length > 0) {
+      await writeFile(
+        resolve(migrationsOutputDir, "index.json"),
+        JSON.stringify(result.manifest, null, 2)
+      );
+      for (const file of result.files) {
+        await writeFile(resolve(migrationsOutputDir, file.name), file.content);
+      }
+      console.log(`   \u2713 ${result.files.length} migration(s) processed`);
+    } else {
+      console.log("   \u2139\uFE0F  No migrations found");
+    }
+  } else {
+    console.log("\u2139\uFE0F  No migrations directory found");
+  }
+  console.log("\u{1F4CB} Updating versions manifest...");
+  await updateVersionsManifest(appDir, version);
+  console.log(`   \u2713 versions.json updated (latest: ${version})`);
+  console.log("\n\u2705 Release package created successfully!\n");
+  console.log(`\u{1F4CD} Output: ${outputDir}`);
+  console.log("\nFiles:");
+  console.log("  \u2022 eldrin-app.manifest.json");
+  console.log("  \u2022 bundle.js");
+  if (existsSync(resolve(outputDir, "deploy-bundle.json"))) {
+    console.log("  \u2022 deploy-bundle.json (deployment bundle with client assets)");
+  }
+  if (existsSync(migrationsDir)) {
+    console.log("  \u2022 migrations/index.json");
+    console.log("  \u2022 migrations/*.sql");
+  }
+  console.log("  \u2022 versions.json (at app level)");
+  console.log("\n\u{1F4CB} Next steps:");
+  console.log(`  npx eldrin-submit -d ${outputDir}`);
+  console.log("");
+}
+async function main() {
+  const options = parseArgs();
+  await release(options);
+}
+main().catch((error) => {
+  console.error("\n\u274C Release failed:", error.message);
+  process.exit(1);
+});
+
+export { release };
+//# sourceMappingURL=release.js.map
+//# sourceMappingURL=release.js.map