playcademy 0.14.32 → 0.14.33

package/dist/db.d.ts

@@ -30,9 +30,17 @@ import { Miniflare } from 'miniflare';
 declare function getDevDbPath(): string;
 
 /**
- * Seed Worker Bundler
- *
- * Bundles user's seed file into standalone Cloudflare Worker
+ * Environment context passed to seed functions
+ */
+interface SeedContext {
+    env: {
+        DB: unknown;
+        BUCKET?: unknown;
+        secrets?: Record<string, string>;
+    };
+}
+/**
+ * Result of bundling a seed file into a Cloudflare Worker
  */
 interface SeedWorkerBundle {
     /** Bundled worker code */
@@ -40,13 +48,29 @@ interface SeedWorkerBundle {
     /** Size in bytes */
     size: number;
 }
+
 /**
- * Bundle seed file into a Cloudflare Worker
+ * Seed Worker Bundler
+ *
+ * Bundles user's seed file into standalone Cloudflare Worker
+ * with enhanced logging capture and structured error reporting.
+ */
+
+/**
+ * Generate the worker entry code that wraps the user's seed function.
+ *
+ * The generated worker:
+ * - Imports the user's seed function from the specified path
+ * - Captures console output (log/warn/error/info) with timestamps
+ * - Parses D1/SQLite errors into structured details
+ * - Returns success/error as JSON with logs and timing
  *
- * Creates a minimal worker that:
- * 1. Imports user's seed function
- * 2. Wraps it in fetch handler
- * 3. Returns success/error as JSON
+ * @param seedFilePath - Absolute path to user's seed file
+ * @returns Worker entry code as a string
+ */
+declare function createSeedWorkerEntry(seedFilePath: string): Promise<string>;
+/**
+ * Bundle seed file into a Cloudflare Worker
  *
  * @param seedFilePath - Absolute path to seed file
  * @param projectPath - Project root (for resolving imports)
@@ -75,17 +99,6 @@ declare function resetDatabase(workspace: string, mf: Miniflare, options?: {
     debug?: boolean;
 }): Promise<void>;
 
-/**
- * Environment context passed to seed functions
- */
-interface SeedContext {
-    env: {
-        DB: unknown;
-        BUCKET?: unknown;
-        secrets?: Record<string, string>;
-    };
-}
-
 /**
  * Database Seed Utilities
  *
@@ -110,5 +123,40 @@ declare function getBucket(mf: Miniflare): Promise<unknown | null>;
  */
 declare function executeSeedFile(seedFilePath: string, mf: Miniflare, envSecrets?: Record<string, string>): Promise<void>;
 
-export { bundleSeedWorker, executeSeedFile, getBucket, getDevDbPath as getPath, importSeedModule, resetDatabase };
+/** Log entry captured from seed worker console output */
+interface SeedLogEntry {
+    /** Log level (log, warn, error, info) */
+    level: 'log' | 'warn' | 'error' | 'info';
+    /** Log message content */
+    message: string;
+    /** Milliseconds since seed execution started */
+    timestamp: number;
+}
+
+/**
+ * Seed Output Utilities
+ *
+ * Functions for displaying seed execution results and handling errors.
+ */
+
+/**
+ * Display captured logs from seed execution.
+ * Uses a vertical line to indicate output is from another source (the seed file).
+ *
+ * @param logs - Captured log entries
+ * @param status - 'success' for green bar, 'error' for red bar
+ */
+declare function displaySeedLogs(logs: SeedLogEntry[], status?: 'success' | 'error'): void;
+/**
+ * Handle seed-specific errors with helpful messages.
+ *
+ * For seed execution errors, displays captured logs with error styling.
+ * For infrastructure errors (network, auth, etc.), shows admonitions.
+ *
+ * Returns true if the error was handled (caller should show simple failure message).
+ * Returns false if not handled (caller should show the error message).
+ */
+declare function handleSeedError(error: unknown): boolean;
+
+export { bundleSeedWorker, createSeedWorkerEntry, displaySeedLogs, executeSeedFile, getBucket, getDevDbPath as getPath, handleSeedError, importSeedModule, resetDatabase };
 export type { SeedWorkerBundle };

package/dist/db.js

@@ -89,7 +89,7 @@ var package_default = {
     sort: "bunx sort-package-json **/package.json",
     test: "bun test",
     "test:unit": "bun scripts/test-unit.ts",
-    "test:integration": "bun scripts/test-integration.ts",
+    "test:e2e": "bun scripts/test-e2e.ts",
     "test:watch": "bun test --watch",
     "docker:relay": "bun run scripts/docker-relay.ts",
     "debug:leaderboard-notifications": "bunx sst shell -- bun scripts/debug/leaderboard-notifications.ts",
@@ -216,6 +216,104 @@ var CLI_FILES = {
   INITIAL_DATABASE: "initial.sqlite"
 };
 
+// ../constants/src/achievements.ts
+var ACHIEVEMENT_IDS = {
+  PLAY_ANY_GAME_DAILY: "play_any_game_daily",
+  DAILY_CHEST_OPEN: "daily_chest_open",
+  LEADERBOARD_TOP3_DAILY: "leaderboard_top3_daily",
+  LEADERBOARD_TOP3_WEEKLY: "leaderboard_top3_weekly",
+  FIRST_SCORE_ANY_GAME: "first_score_any_game",
+  PERSONAL_BEST_ANY_GAME: "personal_best_any_game"
+};
+var ACHIEVEMENT_DEFINITIONS = [
+  {
+    id: ACHIEVEMENT_IDS.PLAY_ANY_GAME_DAILY,
+    title: "Play any game",
+    description: "Play any arcade game for at least 60 seconds in a single session.",
+    scope: "daily",
+    rewardCredits: 10,
+    limit: 1,
+    completionType: "time_played_session",
+    completionConfig: { minSeconds: 60 },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.DAILY_CHEST_OPEN,
+    title: "Opened the daily chest",
+    description: "Find the chest on the map and open it to claim your reward.",
+    scope: "daily",
+    rewardCredits: 10,
+    limit: 1,
+    completionType: "interaction",
+    completionConfig: { triggerId: "bunny_chest" },
+    target: { map: "arcade" },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_DAILY,
+    title: "Daily Champion",
+    description: "Finish in the top 3 of any game leaderboard for the day.",
+    scope: "daily",
+    rewardCredits: 25,
+    // Base reward, overridden by rankRewards
+    limit: 1,
+    completionType: "leaderboard_rank",
+    completionConfig: {
+      rankRewards: [50, 30, 15]
+      // [1st place, 2nd place, 3rd place]
+    },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.LEADERBOARD_TOP3_WEEKLY,
+    title: "Weekly Legend",
+    description: "Finish in the top 3 of any game leaderboard for the week.",
+    scope: "weekly",
+    rewardCredits: 50,
+    // Base reward, overridden by rankRewards
+    limit: 1,
+    completionType: "leaderboard_rank",
+    completionConfig: {
+      rankRewards: [100, 60, 30]
+      // [1st place, 2nd place, 3rd place]
+    },
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.FIRST_SCORE_ANY_GAME,
+    title: "First Score",
+    description: "Submit your first score in any arcade game.",
+    scope: "game",
+    // Scoped per game, no time limit
+    rewardCredits: 5,
+    limit: 1,
+    completionType: "first_score",
+    completionConfig: {},
+    target: { anyArcadeGame: true },
+    active: true
+  },
+  {
+    id: ACHIEVEMENT_IDS.PERSONAL_BEST_ANY_GAME,
+    title: "Personal Best",
+    description: "Beat your personal best score in any arcade game.",
+    scope: "daily",
+    rewardCredits: 5,
+    limit: 3,
+    // Can earn 3 times per day
+    completionType: "personal_best",
+    completionConfig: {},
+    target: { anyArcadeGame: true },
+    active: true
+  }
+];
+
+// ../constants/src/typescript.ts
+var TSC_PACKAGE = "@typescript/native-preview";
+var USE_NATIVE_TSC = TSC_PACKAGE.includes("native-preview");
+
 // ../constants/src/overworld.ts
 var ITEM_SLUGS = {
   /** Primary platform currency */
@@ -278,29 +376,196 @@ function getDevDbPath() {
   return initialDbPath;
 }
 
+// src/lib/core/transpile.ts
+import * as esbuild from "esbuild";
+async function transpileTypeScript(code) {
+  const result = await esbuild.transform(code, {
+    loader: "ts",
+    format: "esm",
+    target: "esnext"
+  });
+  return result.code;
+}
+
+// src/lib/db/seed-runtime/parse-d1-error.ts
+function parseD1Error(error) {
+  if (!(error instanceof Error)) return void 0;
+  const details = {};
+  const msg = error.message || "";
+  if (msg.includes("SQLITE_CONSTRAINT")) {
+    details.code = "CONSTRAINT_VIOLATION";
+    const uniqueMatch = msg.match(/UNIQUE constraint failed: (\w+)\.(\w+)/);
+    if (uniqueMatch) {
+      details.table = uniqueMatch[1];
+      details.constraint = uniqueMatch[2];
+      details.constraintType = "UNIQUE";
+    }
+    if (msg.includes("FOREIGN KEY constraint failed")) {
+      details.constraintType = "FOREIGN_KEY";
+    }
+    const notNullMatch = msg.match(/NOT NULL constraint failed: (\w+)\.(\w+)/);
+    if (notNullMatch) {
+      details.table = notNullMatch[1];
+      details.constraint = notNullMatch[2];
+      details.constraintType = "NOT_NULL";
+    }
+  }
+  if (msg.includes("SQLITE_ERROR") || msg.includes("syntax error")) {
+    details.code = "SQL_ERROR";
+    const tableMatch = msg.match(/no such table: (\w+)/);
+    if (tableMatch) {
+      details.table = tableMatch[1];
+      details.errorType = "TABLE_NOT_FOUND";
+    }
+    const syntaxMatch = msg.match(/near "([^"]+)": syntax error/);
+    if (syntaxMatch) {
+      details.nearToken = syntaxMatch[1];
+      details.errorType = "SYNTAX_ERROR";
+    }
+  }
+  if (msg.includes("SQLITE_BUSY") || msg.includes("database is locked")) {
+    details.code = "DATABASE_BUSY";
+  }
+  return Object.keys(details).length > 0 ? details : void 0;
+}
+async function getParseD1ErrorSource() {
+  return transpileTypeScript(parseD1Error.toString());
+}
+
+// src/lib/db/seed-runtime/runtime.ts
+function createLogCapture(startTime) {
+  const logs = [];
+  const originalConsole = {
+    // eslint-disable-next-line no-console
+    log: console.log.bind(console),
+    // eslint-disable-next-line no-console
+    warn: console.warn.bind(console),
+    // eslint-disable-next-line no-console
+    error: console.error.bind(console),
+    // eslint-disable-next-line no-console
+    info: console.info.bind(console)
+  };
+  const isSilent = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.LOG_SILENT === "true";
+  const captureLog = (level, args) => {
+    const message = args.map((arg) => {
+      if (typeof arg === "object") {
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      }
+      return String(arg);
+    }).join(" ");
+    logs.push({
+      level,
+      message,
+      timestamp: Date.now() - startTime
+    });
+    if (!isSilent) {
+      originalConsole[level](...args);
+    }
+  };
+  console.log = (...args) => captureLog("log", args);
+  console.warn = (...args) => captureLog("warn", args);
+  console.error = (...args) => captureLog("error", args);
+  console.info = (...args) => captureLog("info", args);
+  return {
+    logs,
+    restore: () => {
+      console.log = originalConsole.log;
+      console.warn = originalConsole.warn;
+      console.error = originalConsole.error;
+      console.info = originalConsole.info;
+    }
+  };
+}
+function buildSuccessResponse(logs, duration) {
+  return {
+    success: true,
+    logs,
+    duration
+  };
+}
+function buildErrorResponse(error, logs, duration, details) {
+  logs.push({
+    level: "error",
+    message: error instanceof Error ? error.message : String(error),
+    timestamp: duration
+  });
+  return {
+    success: false,
+    error: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : void 0,
+    details,
+    logs,
+    duration
+  };
+}
+function createSeedFetchHandler(seedFn, parseD1ErrorFn) {
+  return async function fetch(req, env, ctx) {
+    const startTime = Date.now();
+    const { logs, restore } = createLogCapture(startTime);
+    try {
+      const c = { env, ctx, req };
+      await seedFn(c);
+      const duration = Date.now() - startTime;
+      restore();
+      return Response.json(buildSuccessResponse(logs, duration));
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const details = parseD1ErrorFn(error);
+      restore();
+      return Response.json(buildErrorResponse(error, logs, duration, details));
+    }
+  };
+}
+async function getCreateLogCaptureSource() {
+  return transpileTypeScript(createLogCapture.toString());
+}
+async function getBuildSuccessResponseSource() {
+  return transpileTypeScript(buildSuccessResponse.toString());
+}
+async function getBuildErrorResponseSource() {
+  return transpileTypeScript(buildErrorResponse.toString());
+}
+async function getCreateSeedFetchHandlerSource() {
+  return transpileTypeScript(createSeedFetchHandler.toString());
+}
+
 // src/lib/db/bundle-seed.ts
+async function createSeedWorkerEntry(seedFilePath) {
+  const [
+    parseD1ErrorSource,
+    createLogCaptureSource,
+    buildSuccessResponseSource,
+    buildErrorResponseSource,
+    createSeedFetchHandlerSource
+  ] = await Promise.all([
+    getParseD1ErrorSource(),
+    getCreateLogCaptureSource(),
+    getBuildSuccessResponseSource(),
+    getBuildErrorResponseSource(),
+    getCreateSeedFetchHandlerSource()
+  ]);
+  return `import { seed } from '${seedFilePath}'
+
+${parseD1ErrorSource}
+
+${createLogCaptureSource}
+
+${buildSuccessResponseSource}
+
+${buildErrorResponseSource}
+
+${createSeedFetchHandlerSource}
+
+export default { fetch: createSeedFetchHandler(seed, parseD1Error) }
+`;
+}
 async function bundleSeedWorker(seedFilePath, projectPath) {
-  const esbuild2 = await import("esbuild");
-  const entryCode = `
-        import { seed } from '${seedFilePath}'
-        
-        export default {
-            async fetch(req, env, ctx) {
-                try {
-                    // Create Hono-like context
-                    const c = { env, ctx, req }
-                    await seed(c)
-                    return Response.json({ success: true })
-                } catch (error) {
-                    return Response.json({ 
-                        success: false, 
-                        error: error instanceof Error ? error.message : String(error),
-                        stack: error instanceof Error ? error.stack : undefined,
-                    }, 500)
-                }
-            }
-        }
-    `;
+  const esbuild3 = await import("esbuild");
+  const entryCode = await createSeedWorkerEntry(seedFilePath);
   const buildConfig = {
     stdin: {
       contents: entryCode,
@@ -318,7 +583,7 @@ async function bundleSeedWorker(seedFilePath, projectPath) {
     sourcemap: false,
     logLevel: "error"
   };
-  const result = await esbuild2.build(buildConfig);
+  const result = await esbuild3.build(buildConfig);
   if (!result.outputFiles?.[0]) {
     throw new Error("Seed worker bundling failed: no output");
   }
@@ -689,17 +954,11 @@ function displayApiError(error, indent) {
     return;
   }
   const statusCode = errorInfo.status;
-  let displayMessage = errorInfo.statusText;
+  let displayMessage = errorInfo.message;
   displayMessage = removeStatusPrefix(displayMessage, statusCode);
   const { cleanMessage, json: embeddedJson } = extractEmbeddedJson(displayMessage);
   displayMessage = cleanMessageSuffix(cleanMessage);
-  let errorCode;
-  if (error.details && typeof error.details === "object") {
-    const details = error.details;
-    if ("code" in details && typeof details.code === "string") {
-      errorCode = details.code;
-    }
-  }
+  const errorCode = error.code;
   let errorHeader = "API Error";
   if (errorCode) {
     errorHeader += ` ${redBright(`[${errorCode}]`)}`;
@@ -958,6 +1217,9 @@ var logger = {
   }
 };
 
+// src/lib/core/errors.ts
+import { ApiError as ApiError2 } from "@playcademy/sdk/internal";
+
 // src/lib/secrets/env.ts
 init_file_loader();
 
@@ -974,12 +1236,12 @@ import { mkdtempSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import { join as join8 } from "path";
 import { pathToFileURL } from "url";
-import * as esbuild from "esbuild";
+import * as esbuild2 from "esbuild";
 async function importTypescriptFile(filePath, bundleOptions) {
   const tempDir = mkdtempSync(join8(tmpdir(), "playcademy-import-"));
   const outFile = join8(tempDir, "bundle.mjs");
   try {
-    await esbuild.build({
+    await esbuild2.build({
       entryPoints: [filePath],
       outfile: outFile,
       bundle: true,
@@ -1024,6 +1286,96 @@ async function resetDatabase(workspace, mf, options = { debug: false }) {
   );
 }
 
+// src/lib/db/seed.ts
+import { dim as dim4 } from "colorette";
+
+// src/lib/db/seed-output.ts
+import { green as green2, red as red2, yellow as yellow2 } from "colorette";
+function getLogPrefix(level) {
+  switch (level) {
+    case "warn":
+      return yellow2("\u26A0") + " ";
+    default:
+      return "";
+  }
+}
+function displaySeedLogs(logs, status = "success") {
+  const barColor = status === "error" ? red2 : green2;
+  const bar = barColor("\u2502");
+  let trimmedLogs = logs;
+  while (trimmedLogs.length > 0 && !trimmedLogs[trimmedLogs.length - 1]?.message.trim()) {
+    trimmedLogs = trimmedLogs.slice(0, -1);
+  }
+  for (const log of trimmedLogs) {
+    const prefix = getLogPrefix(log.level);
+    logger.raw(`  ${bar}  ${prefix}${log.message}`);
+  }
+}
+function handleSeedError(error) {
+  let seedLogs;
+  if (error && typeof error === "object" && "details" in error) {
+    const details = error.details;
+    if (details && typeof details === "object" && "logs" in details) {
+      const logs = details.logs;
+      if (Array.isArray(logs)) {
+        seedLogs = logs;
+      }
+    }
+  }
+  if (seedLogs && seedLogs.length > 0) {
+    displaySeedLogs(seedLogs, "error");
+    return true;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message;
+  const errorName = error.name;
+  if (errorName === "TimeoutError" || message.includes("timed out")) {
+    logger.admonition("warning", "Seed Timed Out", [
+      "Your seed operation took too long to complete.",
+      "",
+      "Possible causes:",
+      "\u2022 Inserting too many records at once",
+      "\u2022 Complex queries or missing indexes",
+      "\u2022 Database under heavy load",
+      "",
+      "Try breaking your seed into smaller batches."
+    ]);
+    return true;
+  }
+  if (errorName === "ServiceUnavailableError" || message.includes("worker failed") || message.includes("Cloudflare")) {
+    logger.admonition("warning", "Service Unavailable", [
+      "Unable to deploy the seed worker to Cloudflare.",
+      "",
+      "This could be a temporary issue. Please:",
+      "1. Wait a moment and try again",
+      "2. Check status.cloudflare.com for outages",
+      "3. Verify your deployment is working with `playcademy deploy`"
+    ]);
+    return true;
+  }
+  if (message.includes("ECONNREFUSED") || message.includes("fetch failed") || message.includes("network")) {
+    logger.admonition("warning", "Network Error", [
+      "Unable to connect to the Playcademy API.",
+      "",
+      "Please check your internet connection and try again."
+    ]);
+    return true;
+  }
+  if (errorName === "UnauthorizedError" || errorName === "AccessDeniedError" || message.includes("Unauthorized") || message.includes("Access denied")) {
+    logger.admonition("warning", "Authentication Error", [
+      "You do not have permission to seed this database.",
+      "",
+      "Make sure you:",
+      "\u2022 Are logged in: `playcademy login`",
+      "\u2022 Own this project + have developer access"
+    ]);
+    return true;
+  }
+  return false;
+}
+
 // src/lib/db/seed.ts
 async function importSeedModule(seedPath) {
   return await importTypescriptFile(seedPath);
@@ -1035,6 +1387,44 @@ async function getBucket(mf) {
     return null;
   }
 }
+function captureConsole() {
+  const logs = [];
+  const startTime = Date.now();
+  const original = {
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console)
+  };
+  const capture = (level) => {
+    return (...args) => {
+      const message = args.map((arg) => {
+        if (typeof arg === "object") {
+          try {
+            return JSON.stringify(arg);
+          } catch {
+            return String(arg);
+          }
+        }
+        return String(arg);
+      }).filter((arg) => arg !== void 0 && arg !== null && arg !== "").join(" ");
+      logs.push({ level, message, timestamp: Date.now() - startTime });
+    };
+  };
+  console.log = capture("log");
+  console.warn = capture("warn");
+  console.error = capture("error");
+  console.info = capture("info");
+  return {
+    logs,
+    restore: () => {
+      console.log = original.log;
+      console.warn = original.warn;
+      console.error = original.error;
+      console.info = original.info;
+    }
+  };
+}
 async function executeSeedFile(seedFilePath, mf, envSecrets = {}) {
   const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
   const seedModule = await importSeedModule(seedFilePath);
@@ -1050,23 +1440,49 @@ async function executeSeedFile(seedFilePath, mf, envSecrets = {}) {
   }
   const bucket = await getBucket(mf);
   const hasSecrets = Object.keys(envSecrets).length > 0;
-  await runStep(
-    "Seeding database...",
-    async () => {
-      const env = { DB: d1 };
-      if (bucket) env.BUCKET = bucket;
-      if (hasSecrets) env.secrets = envSecrets;
-      return seedModule.seed?.({ env });
-    },
-    "Database seeded successfully!"
-  );
+  const env = { DB: d1 };
+  if (bucket) env.BUCKET = bucket;
+  if (hasSecrets) env.secrets = envSecrets;
+  const { logs, restore } = captureConsole();
+  const startTime = Date.now();
+  let seedError = null;
+  try {
+    await seedModule.seed?.({ env });
+  } catch (error) {
+    seedError = error;
+  } finally {
+    restore();
+  }
+  const duration = Date.now() - startTime;
+  const hasLogs = logs.length > 0;
+  if (hasLogs) {
+    logger.newLine();
+    displaySeedLogs(logs, seedError ? "error" : "success");
+  }
+  if (seedError) {
+    logger.newLine();
+    const handled = handleSeedError(seedError);
+    if (!handled && !hasLogs) {
+      const errorMessage = seedError instanceof Error ? seedError.message : String(seedError);
+      logger.error(`Seeding failed: ${errorMessage} ${dim4(`[${duration}ms]`)}`);
+    } else {
+      logger.error(`Seeding failed ${dim4(`[${duration}ms]`)}`);
+    }
+    logger.newLine();
+    process.exit(1);
+  }
+  logger.newLine();
+  logger.success(`Database seeded ${dim4(`[${duration}ms]`)}`);
   logger.newLine();
 }
 export {
   bundleSeedWorker,
+  createSeedWorkerEntry,
+  displaySeedLogs,
   executeSeedFile,
   getBucket,
   getDevDbPath as getPath,
+  handleSeedError,
   importSeedModule,
   resetDatabase
 };