playcademy 0.13.23 → 0.14.1

package/dist/constants.d.ts

@@ -9,6 +9,45 @@ export { GAME_WORKER_DOMAINS, PLAYCADEMY_BASE_URLS, PLAYCADEMY_DOMAINS } from '@
  */
 declare const DEFAULT_API_ROUTES_DIRECTORY = "server/api";
 
+/**
+ * Bucket-related constants
+ */
+/**
+ * Files and directories that are always excluded from bucket bulk uploads
+ *
+ * These are automatically skipped regardless of .gitignore patterns:
+ * - .git - Git repository data
+ * - .DS_Store - macOS filesystem metadata
+ * - .gitignore - Git ignore configuration (shouldn't be uploaded to storage)
+ * - .env* - Environment files (should never be uploaded to storage)
+ */
+declare const BUCKET_ALWAYS_SKIP: readonly [".git", ".DS_Store", ".gitignore", ".env", ".env.development", ".env.local"];
+
+/**
+ * Cloudflare-related constants
+ */
+/**
+ * Cloudflare Workers compatibility date
+ * Update when adopting new Cloudflare features or breaking changes
+ */
+declare const CLOUDFLARE_COMPATIBILITY_DATE = "2024-01-01";
+/**
+ * Cloudflare binding names for local development (Miniflare)
+ */
+declare const CLOUDFLARE_BINDINGS: {
+    /** R2 bucket binding name */
+    readonly BUCKET: "BUCKET";
+    /** KV namespace binding name */
+    readonly KV: "KV";
+    /** D1 database binding name */
+    readonly DB: "DB";
+};
+/**
+ * Miniflare D1 database directory name
+ * Created by Miniflare when running local development with D1 databases
+ */
+declare const MINIFLARE_D1_DIRECTORY = "miniflare-D1DatabaseObject";
+
 /**
  * Configuration file constants
  *
@@ -40,17 +79,21 @@ declare const TSCONFIG_FILES: readonly ["tsconfig.app.json", "tsconfig.json"];
  * Database-related constants
  */
 /**
- * Default directory for database files
+ * Default directory for database files (configurable via playcademy.config)
  */
 declare const DEFAULT_DATABASE_DIRECTORY = "db";
 /**
- * Default directory for database schema files
+ * Schema subdirectory name within database directory (fixed structure)
+ */
+declare const SCHEMA_SUBDIRECTORY = "schema";
+/**
+ * Schema entry point file name (fixed structure)
  */
-declare const DEFAULT_SCHEMA_DIRECTORY = "db/schema";
+declare const SCHEMA_INDEX_FILE = "index.ts";
 /**
- * Default path for seed file
+ * Default seed file name (can be overridden with --file option)
  */
-declare const DEFAULT_SEED_FILE = "db/seed.ts";
+declare const DEFAULT_SEED_FILE_NAME = "seed.ts";
 
 /**
  * HTTP server constants for CLI OAuth callback handling
@@ -120,10 +163,4 @@ declare const DEFAULT_PORTS: {
  */
 declare const CONFIG_FILE_NAMES: string[];
 
-/**
- * Cloudflare Workers compatibility date
- * Update when adopting new Cloudflare features or breaking changes
- */
-declare const CLOUDFLARE_COMPATIBILITY_DATE = "2024-01-01";
-
-export { CALLBACK_PATH, CALLBACK_PORT, CLI_DEFAULT_OUTPUTS, CLI_DIRECTORIES, CLI_FILES, CLI_USER_DIRECTORIES, CLOUDFLARE_COMPATIBILITY_DATE, CONFIG_FILE_NAMES, DEFAULT_API_ROUTES_DIRECTORY, DEFAULT_DATABASE_DIRECTORY, DEFAULT_PORTS, DEFAULT_SCHEMA_DIRECTORY, DEFAULT_SEED_FILE, ENV_FILES, SSO_AUTH_TIMEOUT_MS, TSCONFIG_FILES, WORKSPACE_NAME };
+export { BUCKET_ALWAYS_SKIP, CALLBACK_PATH, CALLBACK_PORT, CLI_DEFAULT_OUTPUTS, CLI_DIRECTORIES, CLI_FILES, CLI_USER_DIRECTORIES, CLOUDFLARE_BINDINGS, CLOUDFLARE_COMPATIBILITY_DATE, CONFIG_FILE_NAMES, DEFAULT_API_ROUTES_DIRECTORY, DEFAULT_DATABASE_DIRECTORY, DEFAULT_PORTS, DEFAULT_SEED_FILE_NAME, ENV_FILES, MINIFLARE_D1_DIRECTORY, SCHEMA_INDEX_FILE, SCHEMA_SUBDIRECTORY, SSO_AUTH_TIMEOUT_MS, TSCONFIG_FILES, WORKSPACE_NAME };

package/dist/constants.js

@@ -17,10 +17,26 @@ var TSCONFIG_FILES = [
   // Standard (fallback)
 ];
 
+// src/constants/bucket.ts
+var BUCKET_ALWAYS_SKIP = [".git", ".DS_Store", ".gitignore", ...ENV_FILES];
+
+// src/constants/cloudflare.ts
+var CLOUDFLARE_COMPATIBILITY_DATE = "2024-01-01";
+var CLOUDFLARE_BINDINGS = {
+  /** R2 bucket binding name */
+  BUCKET: "BUCKET",
+  /** KV namespace binding name */
+  KV: "KV",
+  /** D1 database binding name */
+  DB: "DB"
+};
+var MINIFLARE_D1_DIRECTORY = "miniflare-D1DatabaseObject";
+
 // src/constants/database.ts
 var DEFAULT_DATABASE_DIRECTORY = "db";
-var DEFAULT_SCHEMA_DIRECTORY = "db/schema";
-var DEFAULT_SEED_FILE = "db/seed.ts";
+var SCHEMA_SUBDIRECTORY = "schema";
+var SCHEMA_INDEX_FILE = "index.ts";
+var DEFAULT_SEED_FILE_NAME = "seed.ts";
 
 // src/constants/http-server.ts
 var CALLBACK_PORT = 6175;
@@ -120,27 +136,28 @@ var BADGES = {
   EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
   FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
 };
-
-// src/constants/index.ts
-var CLOUDFLARE_COMPATIBILITY_DATE = "2024-01-01";
 export {
+  BUCKET_ALWAYS_SKIP,
   CALLBACK_PATH,
   CALLBACK_PORT,
   CLI_DEFAULT_OUTPUTS,
   CLI_DIRECTORIES,
   CLI_FILES,
   CLI_USER_DIRECTORIES,
+  CLOUDFLARE_BINDINGS,
   CLOUDFLARE_COMPATIBILITY_DATE,
   CONFIG_FILE_NAMES,
   DEFAULT_API_ROUTES_DIRECTORY,
   DEFAULT_DATABASE_DIRECTORY,
   DEFAULT_PORTS,
-  DEFAULT_SCHEMA_DIRECTORY,
-  DEFAULT_SEED_FILE,
+  DEFAULT_SEED_FILE_NAME,
   ENV_FILES,
   GAME_WORKER_DOMAINS,
+  MINIFLARE_D1_DIRECTORY,
   PLAYCADEMY_BASE_URLS,
   PLAYCADEMY_DOMAINS,
+  SCHEMA_INDEX_FILE,
+  SCHEMA_SUBDIRECTORY,
   SSO_AUTH_TIMEOUT_MS,
   TSCONFIG_FILES,
   WORKSPACE_NAME

package/dist/db.d.ts

@@ -1,4 +1,4 @@
-import Database from 'better-sqlite3';
+import { Miniflare } from 'miniflare';
 
 /**
  * Development Database Path Helper
@@ -29,6 +29,31 @@ import Database from 'better-sqlite3';
  */
 declare function getDevDbPath(): string;
 
+/**
+ * Seed Worker Bundler
+ *
+ * Bundles user's seed file into standalone Cloudflare Worker
+ */
+interface SeedWorkerBundle {
+    /** Bundled worker code */
+    code: string;
+    /** Size in bytes */
+    size: number;
+}
+/**
+ * Bundle seed file into a Cloudflare Worker
+ *
+ * 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 seed file
+ * @param projectPath - Project root (for resolving imports)
+ * @returns Bundled worker code
+ */
+declare function bundleSeedWorker(seedFilePath: string, projectPath: string): Promise<SeedWorkerBundle>;
+
 /**
  * Database Reset Utility
  *
@@ -36,26 +61,45 @@ declare function getDevDbPath(): string;
  */
 
 /**
- * Reset the database by dropping all tables and recreating from schema
+ * Reset local database
  *
- * This function:
- * 1. Drops all user tables dynamically (queries sqlite_master)
- * 2. Runs `drizzle-kit push` to recreate tables from your schema
- * 3. Returns a connected drizzle instance ready for seeding
+ * Shared utility for db reset and db seed commands.
+ * Deletes the database directory and runs drizzle-kit push to recreate schema.
  *
- * @returns Better-sqlite3 Database instance with schema applied
+ * @param workspace - Workspace root path
+ * @param mf - Miniflare instance to verify recreation
+ * @param options - Options for the reset
+ * @param options.debug - Enable debug output for drizzle-kit push
+ */
+declare function resetDatabase(workspace: string, mf: Miniflare, options?: {
+    debug?: boolean;
+}): Promise<void>;
+
+/**
+ * Database Seed Utilities
  *
- * @example
- * ```ts
- * import { drizzle } from 'drizzle-orm/better-sqlite3'
- * import { resetDatabase } from 'playcademy/db'
- * import * as schema from './schema'
+ * Helpers for importing and executing seed files
+ */
+
+/**
+ * Import user's seed module
  *
- * const sqlite = resetDatabase()
- * const db = drizzle(sqlite, { schema })
- * await db.insert(schema.users).values({ ... })
- * ```
+ * Bundles all deps for portability.
+ */
+declare function importSeedModule(seedPath: string): Promise<{
+    seed?: (c: {
+        env: {
+            DB: unknown;
+        };
+    }) => Promise<void>;
+}>;
+/**
+ * Execute a seed file against a Miniflare D1 instance
+ *
+ * @param seedFilePath - Path to seed file
+ * @param mf - Miniflare instance with D1 database
  */
-declare function resetDatabase(): Database.Database;
+declare function executeSeedFile(seedFilePath: string, mf: Miniflare): Promise<void>;
 
-export { getDevDbPath as getPath, resetDatabase };
+export { bundleSeedWorker, executeSeedFile, getDevDbPath as getPath, importSeedModule, resetDatabase };
+export type { SeedWorkerBundle };

package/dist/db.js

@@ -21,7 +21,30 @@ var init_file_loader = __esm({
 // src/lib/db/path.ts
 import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "fs";
 import { join as join2 } from "path";
-import Database from "better-sqlite3";
+
+// src/constants/config.ts
+var ENV_FILES = [
+  ".env",
+  // Loaded first
+  ".env.development",
+  // Overrides .env
+  ".env.local"
+  // Overrides all (highest priority)
+];
+
+// src/constants/bucket.ts
+var BUCKET_ALWAYS_SKIP = [".git", ".DS_Store", ".gitignore", ...ENV_FILES];
+
+// src/constants/cloudflare.ts
+var CLOUDFLARE_BINDINGS = {
+  /** R2 bucket binding name */
+  BUCKET: "BUCKET",
+  /** KV namespace binding name */
+  KV: "KV",
+  /** D1 database binding name */
+  DB: "DB"
+};
+var MINIFLARE_D1_DIRECTORY = "miniflare-D1DatabaseObject";
 
 // src/constants/paths.ts
 import { join } from "path";
@@ -84,12 +107,8 @@ var ensureDirectoryExists = (dir) => {
     mkdirSync(dir, { recursive: true });
   }
 };
-var createEmptyDatabase = (path) => {
-  const db = new Database(path);
-  db.close();
-};
 var findMiniflareDatabase = (dbDir) => {
-  const miniflareDir = join2(dbDir, "miniflare-D1DatabaseObject");
+  const miniflareDir = join2(dbDir, MINIFLARE_D1_DIRECTORY);
   if (!existsSync(miniflareDir)) return null;
   const sqliteFiles = readdirSync(miniflareDir).filter((file) => file.endsWith(".sqlite"));
   if (sqliteFiles.length === 0) return null;
@@ -108,15 +127,64 @@ function getDevDbPath() {
     migrateInitialDbToTarget(initialDbPath, miniflareDbPath);
     return miniflareDbPath;
   }
-  if (!existsSync(initialDbPath)) {
-    createEmptyDatabase(initialDbPath);
-  }
   return initialDbPath;
 }
 
+// src/lib/db/bundle-seed.ts
+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 buildConfig = {
+    stdin: {
+      contents: entryCode,
+      resolveDir: projectPath,
+      loader: "ts"
+    },
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
+    external: [],
+    // Bundle everything for self-contained worker
+    write: false,
+    minify: false,
+    sourcemap: false,
+    logLevel: "error"
+  };
+  const result = await esbuild2.build(buildConfig);
+  if (!result.outputFiles?.[0]) {
+    throw new Error("Seed worker bundling failed: no output");
+  }
+  const code = result.outputFiles[0].text;
+  return {
+    code,
+    size: code.length
+  };
+}
+
 // src/lib/db/reset.ts
 import { execSync as execSync2 } from "child_process";
-import Database2 from "better-sqlite3";
+import { rmSync as rmSync2 } from "fs";
+import { join as join5 } from "path";
 
 // ../utils/src/ansi.ts
 var colors = {
@@ -339,6 +407,9 @@ async function runStep(text, action, successText, options) {
   }
 }
 
+// ../utils/src/pure/index.ts
+init_package_json();
+
 // ../utils/src/package-manager.ts
 import { execSync } from "child_process";
 import { existsSync as existsSync2 } from "fs";
@@ -619,19 +690,6 @@ var logger = {
   }
 };
 
-// src/lib/core/errors.ts
-function getErrorMessage(error) {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  if (error && typeof error === "object" && "message" in error) {
-    return String(error.message);
-  }
-  return "Unknown error";
-}
-
-// ../utils/src/pure/index.ts
-init_package_json();
-
 // src/lib/config/loader.ts
 init_file_loader();
 
@@ -641,45 +699,88 @@ import { fileURLToPath } from "url";
 var currentDir = dirname(fileURLToPath(import.meta.url));
 
 // src/lib/core/import.ts
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+import { pathToFileURL } from "url";
 import * as esbuild from "esbuild";
+async function importTypescriptFile(filePath, bundleOptions) {
+  const tempDir = mkdtempSync(join4(tmpdir(), "playcademy-import-"));
+  const outFile = join4(tempDir, "bundle.mjs");
+  try {
+    await esbuild.build({
+      entryPoints: [filePath],
+      outfile: outFile,
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      target: "node20",
+      sourcemap: false,
+      minify: false,
+      ...bundleOptions
+    });
+    const module = await import(pathToFileURL(outFile).href);
+    return module;
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
 
 // src/lib/db/reset.ts
-function resetDatabase() {
-  const dbPath = getDevDbPath();
-  const sqlite = new Database2(dbPath);
-  const TURN_FOREIGN_KEYS_OFF_SQL = "PRAGMA foreign_keys = OFF";
-  const TURN_FOREIGN_KEYS_ON_SQL = "PRAGMA foreign_keys = ON";
-  const DROP_ALL_USER_TABLES_SQL = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
-  const DROP_TABLE_SQL = (tableName) => `DROP TABLE IF EXISTS ${tableName}`;
-  runStep(
-    "Dropping all tables",
+async function resetDatabase(workspace, mf, options = { debug: false }) {
+  const { debug } = options;
+  const dbDir = join5(workspace, CLI_DIRECTORIES.DATABASE);
+  await runStep(
+    "Resetting database...",
     async () => {
-      sqlite.prepare(TURN_FOREIGN_KEYS_OFF_SQL).run();
-      const tables = sqlite.prepare(DROP_ALL_USER_TABLES_SQL).all();
-      for (const table of tables) {
-        sqlite.prepare(DROP_TABLE_SQL(table.name)).run();
+      rmSync2(dbDir, { recursive: true, force: true });
+      try {
+        const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
+        await d1.exec("SELECT 1");
+      } catch {
+        logger.error("Database recreation failed");
+        logger.newLine();
+        process.exit(1);
       }
-      sqlite.prepare(TURN_FOREIGN_KEYS_ON_SQL).run();
+      const pm = getPackageManager();
+      const pushCommand = getRunCommand(pm, "db:push");
+      execSync2(pushCommand, {
+        cwd: workspace,
+        stdio: debug ? ["inherit", "inherit", "inherit"] : ["inherit", "ignore", "ignore"]
+      });
     },
-    "Dropped all tables"
+    "Database reset"
   );
-  try {
-    const pm = getPackageManager();
-    const pushCommand = getRunCommand(pm, "db:push");
-    runStep(
-      "Pushing schema",
-      async () => {
-        execSync2(pushCommand, { stdio: ["inherit", "ignore", "inherit"] });
-      },
-      "Pushed schema"
-    );
-    return sqlite;
-  } catch (error) {
-    logger.error(`Failed to push schema: ${getErrorMessage(error)}`);
+}
+
+// src/lib/db/seed.ts
+async function importSeedModule(seedPath) {
+  return await importTypescriptFile(seedPath);
+}
+async function executeSeedFile(seedFilePath, mf) {
+  const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
+  const seedModule = await importSeedModule(seedFilePath);
+  if (typeof seedModule.seed !== "function") {
+    logger.error("Seed file must export a seed function");
+    logger.newLine();
+    logger.admonition("warning", "Invalid Seed File", [
+      `Expected: \`export async function seed(c: Context) { ... }\``,
+      `Found in: <${seedFilePath}>`
+    ]);
+    logger.newLine();
     process.exit(1);
   }
+  await runStep(
+    "Seeding database...",
+    async () => seedModule.seed?.({ env: { DB: d1 } }),
+    "Database seeded successfully!"
+  );
+  logger.newLine();
 }
 export {
+  bundleSeedWorker,
+  executeSeedFile,
   getDevDbPath as getPath,
+  importSeedModule,
   resetDatabase
 };

package/dist/index.d.ts

@@ -207,6 +207,35 @@ type BucketPutOptions = BaseBucketOptions;
  * Options for the bucket delete command
  */
 type BucketDeleteOptions = BaseBucketOptions;
+/**
+ * Options for the bucket bulk command
+ */
+interface BucketBulkOptions extends BaseBucketOptions {
+    /** Add prefix to all uploaded keys */
+    prefix?: string;
+    /** Show what would be uploaded without uploading */
+    dryRun?: boolean;
+}
+/**
+ * File collection result
+ */
+interface CollectedFile {
+    /** Absolute path to the file */
+    absolutePath: string;
+    /** Relative path from base directory (used as bucket key) */
+    relativePath: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Result of collecting files for bulk upload
+ */
+interface BulkCollectionResult {
+    /** Files collected for upload */
+    files: CollectedFile[];
+    /** Total size of all files in bytes */
+    totalSize: number;
+}
 
 /**
  * @fileoverview Server SDK Type Definitions
@@ -993,4 +1022,4 @@ interface KeyMetadata {
     valueType?: 'json' | 'string';
 }
 
-export type { ApiConfig, ApiErrorResponse, ApiKeyListItem, ApiKeyWithSecret, ApiRequestOptions, AuthProfile, AuthStore, BackendBundle, BackendDeploymentWithHash, BackendDiff, BackendFeatures, BucketDeleteOptions, BucketGetOptions, BucketListOptions, BucketPutOptions, BuildDiff, BundleOptions, CallbackServerResult, ConfigDiff, CreateApiKeyResponse, CustomRoutesIntegrationOptions, DatabaseIntegrationOptions, DeployConfig, DeployNewGameOptions, DeployedGameInfo, DeploymentChanges, DeploymentContext, DeploymentDiffOptions, DeploymentPlan, DeploymentResult, DevServerOptions, EmbeddedSourcePaths, EnvironmentAuthProfiles, GameStore, IntegrationChangeDetector, IntegrationChangeDetectors, IntegrationConfigChange, IntegrationsConfig, IntegrationsDiff, KeyMetadata, KeyStats, LoginCredentials, LoginResponse, PlaycademyConfig, PreviewOptions, PreviewResponse, SecretsDiff, SignInResponse, SsoCallbackData, TimebackIntegrationConfig, TokenType, UpdateExistingGameOptions };
+export type { ApiConfig, ApiErrorResponse, ApiKeyListItem, ApiKeyWithSecret, ApiRequestOptions, AuthProfile, AuthStore, BackendBundle, BackendDeploymentWithHash, BackendDiff, BackendFeatures, BucketBulkOptions, BucketDeleteOptions, BucketGetOptions, BucketListOptions, BucketPutOptions, BuildDiff, BulkCollectionResult, BundleOptions, CallbackServerResult, CollectedFile, ConfigDiff, CreateApiKeyResponse, CustomRoutesIntegrationOptions, DatabaseIntegrationOptions, DeployConfig, DeployNewGameOptions, DeployedGameInfo, DeploymentChanges, DeploymentContext, DeploymentDiffOptions, DeploymentPlan, DeploymentResult, DevServerOptions, EmbeddedSourcePaths, EnvironmentAuthProfiles, GameStore, IntegrationChangeDetector, IntegrationChangeDetectors, IntegrationConfigChange, IntegrationsConfig, IntegrationsDiff, KeyMetadata, KeyStats, LoginCredentials, LoginResponse, PlaycademyConfig, PreviewOptions, PreviewResponse, SecretsDiff, SignInResponse, SsoCallbackData, TimebackIntegrationConfig, TokenType, UpdateExistingGameOptions };