playcademy 0.14.13 → 0.14.14-alpha.2

package/dist/templates/api/sample-database.ts.template

@@ -3,41 +3,39 @@
  *
  * This route will be available at: https://<your-game-slug>.playcademy.gg/api/sample/database
  *
+ * Demonstrates basic Drizzle ORM operations with the example schema.
  */
 
 import { desc } from 'drizzle-orm'
 
-import { getDb, schema } from 'db'
+import { getDb, schema } from '../../db'
 
 /**
  * GET /api/sample/database
  *
- * Example: Retrieve recent scores with user information
+ * Example: Retrieve items from the database
  */
 export async function GET(c: Context): Promise<Response> {
     try {
         const db = getDb(c.env.DB)
 
-        const scores = await db.query.scores.findMany({
+        const items = await db.query.items.findMany({
             limit: 10,
-            orderBy: desc(schema.scores.id),
-            with: {
-                user: true,
-            },
+            orderBy: desc(schema.items.id),
         })
 
         return c.json({
             success: true,
             data: {
-                scores,
-                total: scores.length,
+                items,
+                total: items.length,
             },
         })
     } catch (error) {
         return c.json(
             {
                 success: false,
-                error: 'Failed to fetch scores',
+                error: 'Failed to fetch items',
                 details: error instanceof Error ? error.message : String(error),
             },
             500,
@@ -48,55 +46,36 @@ export async function GET(c: Context): Promise<Response> {
 /**
  * POST /api/sample/database
  *
- * Example: Submit a new score for a user
+ * Example: Create a new item in the database
  */
 export async function POST(c: Context): Promise<Response> {
     try {
-        const { score, level } = await c.req.json()
+        const { name, data } = await c.req.json()
 
-        if (!score || score < 0) {
-            return c.json({ success: false, error: 'Invalid score value' }, 400)
+        if (!name || typeof name !== 'string') {
+            return c.json({ success: false, error: 'name is required' }, 400)
         }
 
         const db = getDb(c.env.DB)
 
-        // Get or create demo user
-        let user = await db.select().from(schema.users).limit(1).get()
-
-        if (!user) {
-            ;[user] = await db
-                .insert(schema.users)
-                .values({
-                    name: 'Demo Player',
-                    updatedAt: new Date().toISOString(),
-                    createdAt: new Date().toISOString(),
-                })
-                .returning()
-        }
-
-        if (!user) {
-            return c.json({ success: false, error: 'Failed to create user' }, 500)
-        }
-
-        const [newScore] = await db
-            .insert(schema.scores)
+        const [newItem] = await db
+            .insert(schema.items)
             .values({
-                userId: user.id,
-                score,
-                level: level ?? 1,
+                name,
+                data: data || {},
                 createdAt: new Date().toISOString(),
             })
             .returning()
 
         return c.json({
             success: true,
-            data: { score: newScore },
+            data: { item: newItem },
         })
     } catch (error) {
         return c.json(
             {
                 success: false,
-                error: 'Failed to save score',
+                error: 'Failed to create item',
                 details: error instanceof Error ? error.message : String(error),
             },
             500,

package/dist/templates/api/sample-kv.ts.template

@@ -2,52 +2,56 @@
  * Sample KV Storage API Route
  *
  * This route will be available at: https://<your-game-slug>.playcademy.gg/api/sample/kv
+ *
+ * Demonstrates KV storage patterns with user-scoped keys.
  */
 
 /**
- * Player state stored in KV
+ * Example data structure for KV storage
  */
-interface PlayerState {
-    /** Player's current score */
-    score: number
-    /** Current level */
-    level: number
-    /** Last played timestamp */
-    lastPlayed: string
+interface UserData {
+    /** Arbitrary data payload */
+    data: Record<string, unknown>
+    /** Last updated timestamp */
+    updatedAt: string
 }
 
 /**
  * GET /api/sample/kv
  *
- * Retrieve player state from KV storage
+ * Retrieve user data from KV storage
+ * Uses authenticated playcademyUser from Bearer token
  */
 export async function GET(c: Context): Promise<Response> {
     try {
-        // Get user ID from query parameter
-        const userId = c.req.query('userId') || 'demo-user'
+        const playcademyUser = c.get('playcademyUser')
+        
+        if (!playcademyUser?.sub) {
+            return c.json({ success: false, error: 'Authentication required' }, 401)
+        }
         
-        // Read from KV using user-specific key
-        const stateJson = await c.env.KV.get(`user:${userId}:state`)
+        // Read from KV using user-scoped key pattern
+        const dataJson = await c.env.KV.get(`user:${playcademyUser.sub}:data`)
         
-        if (!stateJson) {
+        if (!dataJson) {
             return c.json({
                 success: true,
                 data: null,
-                message: 'No saved state found',
+                message: 'No data found',
             })
         }
 
-        const state = JSON.parse(stateJson) as PlayerState
+        const userData = JSON.parse(dataJson) as UserData
 
         return c.json({
             success: true,
-            data: state,
+            data: userData,
         })
     } catch (error) {
         return c.json(
             {
                 success: false,
-                error: 'Failed to fetch player state',
+                error: 'Failed to fetch user data',
                 details: error instanceof Error ? error.message : String(error),
             },
             500,
@@ -58,44 +62,42 @@ export async function GET(c: Context): Promise<Response> {
 /**
  * POST /api/sample/kv
  *
- * Save player state to KV storage
+ * Save user data to KV storage
+ * Uses authenticated playcademyUser from Bearer token
  */
 export async function POST(c: Context): Promise<Response> {
     try {
-        const body = (await c.req.json()) as Partial<PlayerState> & { userId?: string }
-
-        if (typeof body.score !== 'number' || body.score < 0) {
-            return c.json(
-                {
-                    success: false,
-                    error: 'Invalid score value',
-                },
-                400,
-            )
+        const playcademyUser = c.get('playcademyUser')
+        
+        if (!playcademyUser?.sub) {
+            return c.json({ success: false, error: 'Authentication required' }, 401)
         }
 
-        const userId = body.userId || 'demo-user'
+        const body = (await c.req.json()) as { data: Record<string, unknown> }
 
-        // Prepare player state
-        const state: PlayerState = {
-            score: body.score,
-            level: body.level ?? 1,
-            lastPlayed: new Date().toISOString(),
+        if (!body.data || typeof body.data !== 'object') {
+            return c.json({ success: false, error: 'data object is required' }, 400)
         }
 
-        // Write to KV using user-specific key
-        await c.env.KV.put(`user:${userId}:state`, JSON.stringify(state))
+        // Prepare user data with timestamp
+        const userData: UserData = {
+            data: body.data,
+            updatedAt: new Date().toISOString(),
+        }
+
+        // Write to KV using user-scoped key pattern
+        await c.env.KV.put(`user:${playcademyUser.sub}:data`, JSON.stringify(userData))
 
         return c.json({
             success: true,
-            data: state,
-            message: 'Player state saved successfully',
+            data: userData,
+            message: 'Data saved successfully',
         })
     } catch (error) {
         return c.json(
             {
                 success: false,
-                error: 'Failed to save player state',
+                error: 'Failed to save data',
                 details: error instanceof Error ? error.message : String(error),
             },
             500,
@@ -106,24 +108,29 @@ export async function POST(c: Context): Promise<Response> {
 /**
  * DELETE /api/sample/kv
  *
- * Clear player state from KV storage
+ * Clear user data from KV storage
+ * Uses authenticated playcademyUser from Bearer token
  */
 export async function DELETE(c: Context): Promise<Response> {
     try {
-        const userId = c.req.query('userId') || 'demo-user'
+        const playcademyUser = c.get('playcademyUser')
+        
+        if (!playcademyUser?.sub) {
+            return c.json({ success: false, error: 'Authentication required' }, 401)
+        }
 
-        // Delete from KV
-        await c.env.KV.delete(`user:${userId}:state`)
+        // Delete from KV using user-scoped key pattern
+        await c.env.KV.delete(`user:${playcademyUser.sub}:data`)
 
         return c.json({
             success: true,
-            message: 'Player state cleared successfully',
+            message: 'Data cleared successfully',
         })
     } catch (error) {
         return c.json(
             {
                 success: false,
-                error: 'Failed to clear player state',
+                error: 'Failed to clear data',
                 details: error instanceof Error ? error.message : String(error),
             },
             500,

package/dist/templates/auth/auth.ts.template

@@ -9,7 +9,7 @@ import { drizzleAdapter } from 'better-auth/adapters/drizzle'
 
 import { playcademy } from '@playcademy/better-auth/server'
 
-import { getDb } from '../../db'
+import { getDb } from '../db'
 
 function getAuthSecret(c: Context): string {
     const secret = c.env.secrets?.BETTER_AUTH_SECRET

package/dist/templates/database/db-schema-example.ts.template

@@ -0,0 +1,29 @@
+/**
+ * Example Schema
+ *
+ * Define your database tables here using Drizzle ORM.
+ * This is a starter example - customize for your game's needs.
+ */
+
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+/**
+ * Example items table
+ *
+ * Demonstrates common Drizzle patterns:
+ * - Auto-incrementing primary key
+ * - Required and optional fields
+ * - JSON column for flexible data
+ * - Timestamp tracking
+ */
+export const items = sqliteTable('items', {
+    /** Unique item ID */
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    /** Item name */
+    name: text('name').notNull(),
+    /** Flexible JSON data column for item-specific attributes */
+    data: text('data', { mode: 'json' }).$type<Record<string, unknown>>(),
+    /** Timestamp when item was created */
+    createdAt: text('created_at').notNull(),
+})
+

package/dist/templates/database/db-schema-index.ts.template

@@ -4,5 +4,4 @@
  * Export all schema definitions from this file.
  */
 
-export * from './users'
-export * from './scores'
+export * from './example'

package/dist/templates/database/db-seed.ts.template

@@ -16,25 +16,17 @@ import * as schema from './schema'
 export async function seed(c: Context) {
     const db = getDb(c.env.DB)
 
-    // Seed users   
-    const [user] = await db
-        .insert(schema.users)
-        .values({
-            name: 'Demo User',
+    // Example: Seed some items
+    await db.insert(schema.items).values([
+        {
+            name: 'Example Item 1',
+            data: { type: 'demo', value: 42 },
             createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        })
-        .returning()
-
-    if (!user) {
-        throw new Error('Failed to seed user')
-    }
-
-    // Seed scores
-    await db.insert(schema.scores).values({
-        userId: user.id,
-        score: 100,
-        level: 1,
-        createdAt: new Date().toISOString(),
-    })
+        },
+        {
+            name: 'Example Item 2',
+            data: { type: 'demo', value: 100 },
+            createdAt: new Date().toISOString(),
+        },
+    ])
 }

package/dist/templates/database/db-types.ts.template

@@ -8,14 +8,6 @@ import * as schema from './schema'
 
 import type { InferSelectModel } from 'drizzle-orm'
 
-/** User record from database */
-export type User = InferSelectModel<typeof schema.users>
-
-/** Score record from database */
-export type Score = InferSelectModel<typeof schema.scores>
-
-/** Score with user information populated */
-export type ScoreWithUser = Score & {
-    user: User | null
-}
+/** Item record from database */
+export type Item = InferSelectModel<typeof schema.items>
 

package/dist/templates/database/drizzle-config.ts.template

@@ -3,8 +3,8 @@ import { getPath } from 'playcademy/db'
 import { defineConfig } from 'drizzle-kit'
 
 export default defineConfig({
-    schema: './db/schema/index.ts',
-    out: './db/migrations',
+    schema: './server/db/schema/index.ts',
+    // out: './server/db/migrations', optional
     dialect: 'sqlite',
     dbCredentials: {
         url: getPath(),