@opensaas/stack-cli 0.1.0 → 0.1.1

package/src/generator/context.ts

@@ -12,11 +12,81 @@ export function generateContext(config: OpenSaasConfig): string {
   // Check if custom Prisma client constructor is provided
   const hasCustomConstructor = !!config.db.prismaClientConstructor
 
+  // Check if storage is configured
+  const hasStorage = !!config.storage && Object.keys(config.storage).length > 0
+
   // Generate the Prisma client instantiation code
   const prismaInstantiation = hasCustomConstructor
     ? `config.db.prismaClientConstructor!(PrismaClient)`
     : `new PrismaClient()`
 
+  // Generate storage utilities if storage is configured
+  const storageUtilities = hasStorage
+    ? `
+/**
+ * Lazy-loaded storage runtime functions
+ * Prevents sharp and other storage dependencies from being bundled in client code
+ */
+let storageRuntime: typeof import('@opensaas/stack-storage/runtime') | null = null
+
+async function getStorageRuntime() {
+  if (!storageRuntime) {
+    try {
+      storageRuntime = await import('@opensaas/stack-storage/runtime')
+    } catch (error) {
+      throw new Error(
+        'Failed to load @opensaas/stack-storage/runtime. Make sure @opensaas/stack-storage is installed.'
+      )
+    }
+  }
+  return storageRuntime
+}
+
+/**
+ * Storage utilities for file/image uploads
+ */
+const storage = {
+  uploadFile: async (providerName: string, file: File, buffer: Buffer, options?: unknown) => {
+    const runtime = await getStorageRuntime()
+    return runtime.uploadFile(config, providerName, { file, buffer }, options as any)
+  },
+
+  uploadImage: async (providerName: string, file: File, buffer: Buffer, options?: unknown) => {
+    const runtime = await getStorageRuntime()
+    return runtime.uploadImage(config, providerName, { file, buffer }, options as any)
+  },
+
+  deleteFile: async (providerName: string, filename: string) => {
+    const runtime = await getStorageRuntime()
+    return runtime.deleteFile(config, providerName, filename)
+  },
+
+  deleteImage: async (metadata: unknown) => {
+    const runtime = await getStorageRuntime()
+    return runtime.deleteImage(config, metadata as any)
+  },
+}
+`
+    : `
+/**
+ * Storage utilities (not configured)
+ */
+const storage = {
+  uploadFile: async () => {
+    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
+  },
+  uploadImage: async () => {
+    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
+  },
+  deleteFile: async () => {
+    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
+  },
+  deleteImage: async () => {
+    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
+  },
+}
+`
+
   return `/**
  * Auto-generated context factory
  *
@@ -27,14 +97,16 @@ export function generateContext(config: OpenSaasConfig): string {
  */
 
 import { getContext as getOpensaasContext } from '@opensaas/stack-core'
+import type { Session as OpensaasSession } from '@opensaas/stack-core'
 import { PrismaClient } from './prisma-client'
+import type { Context } from './types'
 import config from '../opensaas.config'
 
 // Internal Prisma singleton - managed automatically
 const globalForPrisma = globalThis as unknown as { prisma: PrismaClient | undefined }
 const prisma = globalForPrisma.prisma ?? ${prismaInstantiation}
 if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
-
+${storageUtilities}
 /**
  * Get OpenSaas context with optional session
  *
@@ -49,10 +121,15 @@ if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
  * // Authenticated access
  * const context = getContext({ userId: 'user-123' })
  * const myPosts = await context.db.post.findMany()
+ *
+ * // With custom session type
+ * type CustomSession = { userId: string; email: string; role: string } | null
+ * const context = getContext<CustomSession>({ userId: '123', email: 'user@example.com', role: 'admin' })
+ * // context.session is now typed as CustomSession
  * \`\`\`
  */
-export function getContext(session?: { userId?: string; [key: string]: unknown } | null) {
-  return getOpensaasContext(config, prisma, session ?? null)
+export function getContext<TSession extends OpensaasSession = OpensaasSession>(session?: TSession): Context<TSession> {
+  return getOpensaasContext(config, prisma, session ?? null, storage) as Context<TSession>
 }
 
 export const rawOpensaasContext = getContext()

package/src/generator/index.ts

@@ -2,3 +2,4 @@ export { generatePrismaSchema, writePrismaSchema } from './prisma.js'
 export { generateTypes, writeTypes } from './types.js'
 export { patchPrismaTypes } from './type-patcher.js'
 export { generateContext, writeContext } from './context.js'
+export { generateMcp, writeMcp } from './mcp.js'

package/src/generator/mcp.test.ts

@@ -0,0 +1,393 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { generateMcp } from './mcp.js'
+import type { OpenSaasConfig } from '@opensaas/stack-core'
+import { text } from '@opensaas/stack-core/fields'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+
+describe('MCP Generator', () => {
+  let tempDir: string
+
+  beforeEach(() => {
+    // Create a temporary directory for each test
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-test-'))
+  })
+
+  afterEach(() => {
+    // Clean up temporary directory
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  describe('generateMcp', () => {
+    it('should return false when MCP is not enabled', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      const generated = generateMcp(config, tempDir)
+
+      expect(generated).toBe(false)
+    })
+
+    it('should return true when MCP is enabled', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      const generated = generateMcp(config, tempDir)
+
+      expect(generated).toBe(true)
+    })
+
+    it('should create MCP directory when enabled', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {},
+      }
+
+      generateMcp(config, tempDir)
+
+      const mcpDir = path.join(tempDir, '.opensaas', 'mcp')
+      expect(fs.existsSync(mcpDir)).toBe(true)
+    })
+
+    it('should generate tools.json with default CRUD tools', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      expect(fs.existsSync(toolsPath)).toBe(true)
+
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+      expect(tools).toHaveLength(4) // query, create, update, delete
+
+      const toolNames = tools.map((t: { name: string }) => t.name)
+      expect(toolNames).toContain('list_user_query')
+      expect(toolNames).toContain('list_user_create')
+      expect(toolNames).toContain('list_user_update')
+      expect(toolNames).toContain('list_user_delete')
+    })
+
+    it('should respect list-level MCP enabled flag', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+            mcp: {
+              enabled: false,
+            },
+          },
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+
+      // Only Post tools should be generated
+      const userTools = tools.filter((t: { listKey: string }) => t.listKey === 'User')
+      const postTools = tools.filter((t: { listKey: string }) => t.listKey === 'Post')
+
+      expect(userTools).toHaveLength(0)
+      expect(postTools).toHaveLength(4)
+    })
+
+    it('should respect custom tool configuration', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+            mcp: {
+              tools: {
+                read: true,
+                create: false,
+                update: false,
+                delete: false,
+              },
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+
+      expect(tools).toHaveLength(1)
+      expect(tools[0].name).toBe('list_user_query')
+    })
+
+    it('should include custom tools', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+            mcp: {
+              tools: {
+                read: false,
+                create: false,
+                update: false,
+                delete: false,
+              },
+              customTools: [
+                {
+                  name: 'user_verify_email',
+                  description: 'Verify a user email address',
+                  inputSchema: {},
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  handler: async () => ({}) as any,
+                },
+              ],
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+
+      expect(tools).toHaveLength(1)
+      expect(tools[0].name).toBe('user_verify_email')
+      expect(tools[0].operation).toBe('custom')
+    })
+
+    it('should generate README.md with usage instructions', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const readmePath = path.join(tempDir, '.opensaas', 'mcp', 'README.md')
+      expect(fs.existsSync(readmePath)).toBe(true)
+
+      const readme = fs.readFileSync(readmePath, 'utf-8')
+      expect(readme).toContain('# MCP Tools Reference')
+      expect(readme).toContain('Available Tools')
+      expect(readme).toContain('Usage')
+      expect(readme).toContain('createMcpHandlers')
+      expect(readme).toContain('Connecting to Claude Desktop')
+    })
+
+    it('should list tools in README', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const readmePath = path.join(tempDir, '.opensaas', 'mcp', 'README.md')
+      const readme = fs.readFileSync(readmePath, 'utf-8')
+
+      expect(readme).toContain('list_user_query')
+      expect(readme).toContain('list_user_create')
+      expect(readme).toContain('list_user_update')
+      expect(readme).toContain('list_user_delete')
+      expect(readme).toContain('4 tool(s) available')
+    })
+
+    it('should handle multiple lists', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+
+      expect(tools).toHaveLength(8) // 4 tools per list
+    })
+
+    it('should respect global defaultTools config', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+          defaultTools: {
+            read: true,
+            create: true,
+            update: false,
+            delete: false,
+          },
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+
+      expect(tools).toHaveLength(2)
+      const toolNames = tools.map((t: { name: string }) => t.name)
+      expect(toolNames).toContain('list_user_query')
+      expect(toolNames).toContain('list_user_create')
+    })
+
+    it('should use correct dbKey for tool names', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+          url: 'file:./dev.db',
+        },
+        mcp: {
+          enabled: true,
+        },
+        lists: {
+          BlogPost: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      generateMcp(config, tempDir)
+
+      const toolsPath = path.join(tempDir, '.opensaas', 'mcp', 'tools.json')
+      const tools = JSON.parse(fs.readFileSync(toolsPath, 'utf-8'))
+
+      const toolNames = tools.map((t: { name: string }) => t.name)
+      expect(toolNames).toContain('list_blogPost_query')
+      expect(toolNames).toContain('list_blogPost_create')
+    })
+  })
+})