launchbase 1.1.7 → 1.1.8

package/bin/launchbase.js

@@ -7,7 +7,7 @@ const crypto = require('crypto');
 const fs = require('fs-extra');
 const { execSync, spawn } = require('child_process');
 
-const VERSION = '1.1.7';
+const VERSION = '1.1.8';
 const program = new Command();
 
 function findAvailablePort(startPort = 5432, maxAttempts = 100) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchbase",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Generate production-ready NestJS backends with authentication, multi-tenancy, billing, and deployment in minutes",
   "author": "LaunchBase",
   "keywords": [

package/template/frontend/src/lib/api.ts

@@ -166,3 +166,96 @@ export const filesApi = {
     await api.delete(`/api/files/${id}`)
   },
 }
+
+// Edge Functions API
+export const edgeFunctionsApi = {
+  list: async (projectId: string) => {
+    const res = await api.get(`/api/projects/${projectId}/functions`)
+    return res.data
+  },
+  
+  create: async (projectId: string, data: { name: string; code: string; description?: string }) => {
+    const res = await api.post(`/api/projects/${projectId}/functions`, data)
+    return res.data
+  },
+  
+  get: async (projectId: string, functionId: string) => {
+    const res = await api.get(`/api/projects/${projectId}/functions/${functionId}`)
+    return res.data
+  },
+  
+  update: async (projectId: string, functionId: string, data: Partial<{ name: string; code: string; description: string }>) => {
+    const res = await api.put(`/api/projects/${projectId}/functions/${functionId}`, data)
+    return res.data
+  },
+  
+  delete: async (projectId: string, functionId: string) => {
+    await api.delete(`/api/projects/${projectId}/functions/${functionId}`)
+  },
+  
+  deploy: async (projectId: string, functionId: string) => {
+    const res = await api.post(`/api/projects/${projectId}/functions/${functionId}/deploy`)
+    return res.data
+  },
+  
+  execute: async (projectId: string, functionId: string, payload: any) => {
+    const res = await api.post(`/api/projects/${projectId}/functions/${functionId}/execute`, { payload })
+    return res.data
+  },
+  
+  getLogs: async (projectId: string, functionId: string) => {
+    const res = await api.get(`/api/projects/${projectId}/functions/${functionId}/logs`)
+    return res.data
+  },
+}
+
+// Vector Collections API
+export const vectorApi = {
+  listCollections: async (projectId: string) => {
+    const res = await api.get(`/api/projects/${projectId}/vector/collections`)
+    return res.data
+  },
+  
+  createCollection: async (projectId: string, data: { name: string; description?: string }) => {
+    const res = await api.post(`/api/projects/${projectId}/vector/collections`, data)
+    return res.data
+  },
+  
+  createEmbedding: async (projectId: string, data: { content: string; collectionId: string; metadata?: any }) => {
+    const res = await api.post(`/api/projects/${projectId}/vector/embeddings`, data)
+    return res.data
+  },
+  
+  search: async (projectId: string, data: { query: string; collectionId: string; limit?: number }) => {
+    const res = await api.post(`/api/projects/${projectId}/vector/search`, data)
+    return res.data
+  },
+  
+  query: async (projectId: string, query: string, collection?: string, limit?: number) => {
+    const res = await api.post(`/api/projects/${projectId}/vector/query`, { query, collection, limit })
+    return res.data
+  },
+}
+
+// Deployments API
+export const deploymentsApi = {
+  list: async (projectId: string) => {
+    const res = await api.get(`/api/projects/${projectId}/deployments`)
+    return res.data
+  },
+  
+  create: async (projectId: string, data: { version: string; description?: string }) => {
+    const res = await api.post(`/api/projects/${projectId}/deployments`, data)
+    return res.data
+  },
+  
+  get: async (projectId: string, deploymentId: string) => {
+    const res = await api.get(`/api/projects/${projectId}/deployments/${deploymentId}`)
+    return res.data
+  },
+  
+  retry: async (projectId: string, deploymentId: string) => {
+    const res = await api.post(`/api/projects/${projectId}/deployments/${deploymentId}/retry`)
+    return res.data
+  },
+}

package/template/frontend/src/pages/EdgeFunctions.tsx

@@ -37,7 +37,11 @@ const RUNTIMES = [
   { value: 'go121', label: 'Go 1.21' },
 ]
 
-export function EdgeFunctions() {
+interface EdgeFunctionsProps {
+  projectId: string
+}
+
+export function EdgeFunctions({ projectId }: EdgeFunctionsProps) {
   const queryClient = useQueryClient()
   const toast = useToast()
   
@@ -60,21 +64,21 @@ export function EdgeFunctions() {
 
   // Fetch functions
   const { data: functionsData, isLoading } = useQuery({
-    queryKey: ['edge-functions'],
+    queryKey: ['edge-functions', projectId],
     queryFn: async () => {
-      const res = await fetch('/api/functions')
+      const res = await fetch(`/api/projects/${projectId}/functions`)
       if (!res.ok) throw new Error('Failed to fetch functions')
       return res.json()
     }
   })
 
-  const functions = functionsData?.functions || []
+  const functions = functionsData?.functions || functionsData || []
   const stats = functionsData?.stats || { total: 0, deployed: 0, draft: 0, invocations: 0 }
 
   // Create function mutation
   const createMutation = useMutation({
     mutationFn: async () => {
-      const res = await fetch('/api/functions', {
+      const res = await fetch(`/api/projects/${projectId}/functions`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(newFunction)
@@ -86,7 +90,7 @@ export function EdgeFunctions() {
       return res.json()
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['edge-functions'] })
+      queryClient.invalidateQueries({ queryKey: ['edge-functions', projectId] })
       setShowCreateModal(false)
       setNewFunction({
         name: '',
@@ -107,7 +111,7 @@ export function EdgeFunctions() {
   // Deploy function mutation
   const deployMutation = useMutation({
     mutationFn: async (functionId: string) => {
-      const res = await fetch(`/api/functions/${functionId}/deploy`, {
+      const res = await fetch(`/api/projects/${projectId}/functions/${functionId}/deploy`, {
         method: 'POST'
       })
       if (!res.ok) {
@@ -117,7 +121,7 @@ export function EdgeFunctions() {
       return res.json()
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['edge-functions'] })
+      queryClient.invalidateQueries({ queryKey: ['edge-functions', projectId] })
       toast.success('Function deployed successfully')
     },
     onError: (error: Error) => {
@@ -128,7 +132,7 @@ export function EdgeFunctions() {
   // Delete function mutation
   const deleteMutation = useMutation({
     mutationFn: async (functionId: string) => {
-      const res = await fetch(`/api/functions/${functionId}`, {
+      const res = await fetch(`/api/projects/${projectId}/functions/${functionId}`, {
         method: 'DELETE'
       })
       if (!res.ok) {
@@ -138,7 +142,7 @@ export function EdgeFunctions() {
       return res.json()
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['edge-functions'] })
+      queryClient.invalidateQueries({ queryKey: ['edge-functions', projectId] })
       toast.success('Function deleted successfully')
     },
     onError: (error: Error) => {
@@ -149,10 +153,10 @@ export function EdgeFunctions() {
   // Fetch logs
   const fetchLogs = async (functionId: string) => {
     try {
-      const res = await fetch(`/api/functions/${functionId}/logs`)
+      const res = await fetch(`/api/projects/${projectId}/functions/${functionId}/logs`)
       if (res.ok) {
         const data = await res.json()
-        setFunctionLogs(data.logs || [])
+        setFunctionLogs(data.logs || data || [])
       }
     } catch (error) {
       console.error('Failed to fetch logs:', error)

package/template/src/modules/app/app.module.ts

@@ -15,6 +15,9 @@ import { WebsocketModule } from '../websocket/websocket.module';
 import { HealthModule } from '../health/health.module';
 import { DatabaseModule } from '../database/database.module';
 import { AiModule } from '../ai/ai.module';
+import { EdgeFunctionsModule } from '../edge-functions/edge-functions.module';
+import { VectorModule } from '../vector/vector.module';
+import { DeploymentsModule } from '../deployments/deployments.module';
 
 // QueueModule is optional - only loaded when Redis is configured
 let QueueModule: any = null;
@@ -47,7 +50,10 @@ try {
     DatabaseModule,
     // Only include QueueModule if Redis is configured
     ...(process.env.REDIS_HOST && QueueModule ? [QueueModule] : []),
-    AiModule
+    AiModule,
+    EdgeFunctionsModule,
+    VectorModule,
+    DeploymentsModule,
   ],
   providers: [
     {

package/template/src/modules/deployments/deployments.controller.ts

@@ -0,0 +1,47 @@
+import { Controller, Post, Get, Body, Param, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { JwtAuthGuard } from '../common/jwt-auth.guard';
+import { TenantGuard } from '../common/tenant.guard';
+import { DeploymentsService } from './deployments.service';
+import { CreateDeploymentDto } from './dto/create-deployment.dto';
+
+@ApiTags('deployments')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard, TenantGuard)
+@Controller('projects/:projectId/deployments')
+export class DeploymentsController {
+  constructor(private readonly deploymentsService: DeploymentsService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create a new deployment' })
+  async create(
+    @Param('projectId') projectId: string,
+    @Body() dto: CreateDeploymentDto,
+  ) {
+    return this.deploymentsService.create(projectId, dto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'List all deployments' })
+  async findAll(@Param('projectId') projectId: string) {
+    return this.deploymentsService.findAll(projectId);
+  }
+
+  @Get(':deploymentId')
+  @ApiOperation({ summary: 'Get deployment details' })
+  async findOne(
+    @Param('projectId') projectId: string,
+    @Param('deploymentId') deploymentId: string,
+  ) {
+    return this.deploymentsService.findOne(projectId, deploymentId);
+  }
+
+  @Post(':deploymentId/retry')
+  @ApiOperation({ summary: 'Retry a failed deployment' })
+  async retry(
+    @Param('projectId') projectId: string,
+    @Param('deploymentId') deploymentId: string,
+  ) {
+    return this.deploymentsService.retry(projectId, deploymentId);
+  }
+}

package/template/src/modules/deployments/deployments.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { DeploymentsController } from './deployments.controller';
+import { DeploymentsService } from './deployments.service';
+import { PrismaModule } from '../prisma/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  controllers: [DeploymentsController],
+  providers: [DeploymentsService],
+  exports: [DeploymentsService],
+})
+export class DeploymentsModule {}

package/template/src/modules/deployments/deployments.service.ts

@@ -0,0 +1,88 @@
+import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { CreateDeploymentDto } from './dto/create-deployment.dto';
+
+@Injectable()
+export class DeploymentsService {
+  constructor(private prisma: PrismaService) {}
+
+  async create(projectId: string, dto: CreateDeploymentDto) {
+    // Get project to verify it exists
+    const project = await this.prisma.project.findUnique({
+      where: { id: projectId },
+    });
+
+    if (!project) {
+      throw new NotFoundException('Project not found');
+    }
+
+    const deployment = await this.prisma.deployment.create({
+      data: {
+        version: dto.version,
+        description: dto.description,
+        projectId,
+        status: 'pending',
+      },
+    });
+
+    // Simulate deployment process (in real app, this would trigger CI/CD)
+    this.simulateDeployment(deployment.id);
+
+    return deployment;
+  }
+
+  async findAll(projectId: string) {
+    return this.prisma.deployment.findMany({
+      where: { projectId },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  async findOne(projectId: string, deploymentId: string) {
+    const deployment = await this.prisma.deployment.findFirst({
+      where: { id: deploymentId, projectId },
+    });
+
+    if (!deployment) {
+      throw new NotFoundException('Deployment not found');
+    }
+
+    return deployment;
+  }
+
+  async retry(projectId: string, deploymentId: string) {
+    const deployment = await this.findOne(projectId, deploymentId);
+
+    if (deployment.status !== 'failed') {
+      throw new BadRequestException('Only failed deployments can be retried');
+    }
+
+    const updated = await this.prisma.deployment.update({
+      where: { id: deploymentId },
+      data: { status: 'pending', error: null },
+    });
+
+    // Simulate deployment process
+    this.simulateDeployment(deploymentId);
+
+    return updated;
+  }
+
+  private simulateDeployment(deploymentId: string) {
+    // In a real implementation, this would trigger actual deployment
+    // For now, we just update the status after a delay
+    setTimeout(async () => {
+      try {
+        await this.prisma.deployment.update({
+          where: { id: deploymentId },
+          data: {
+            status: 'success',
+            deployedAt: new Date(),
+          },
+        });
+      } catch {
+        // Deployment might have been deleted
+      }
+    }, 5000);
+  }
+}

package/template/src/modules/deployments/dto/create-deployment.dto.ts

@@ -0,0 +1,12 @@
+import { IsString, IsOptional, MaxLength } from 'class-validator';
+
+export class CreateDeploymentDto {
+  @IsString()
+  @MaxLength(50)
+  version: string;
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(500)
+  description?: string;
+}

package/template/src/modules/edge-functions/edge-functions.controller.ts

@@ -8,80 +8,80 @@ import { CreateEdgeFunctionDto, UpdateEdgeFunctionDto, ExecuteEdgeFunctionDto }
 @ApiTags('edge-functions')
 @ApiBearerAuth()
 @UseGuards(JwtAuthGuard, TenantGuard)
-@Controller('organizations/:orgId/edge-functions')
+@Controller('projects/:projectId/functions')
 export class EdgeFunctionsController {
   constructor(private readonly edgeFunctionsService: EdgeFunctionsService) {}
 
   @Post()
   @ApiOperation({ summary: 'Create a new edge function' })
   async create(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Body() dto: CreateEdgeFunctionDto,
     @Request() req: any,
   ) {
-    return this.edgeFunctionsService.create(orgId, req.user.id, dto);
+    return this.edgeFunctionsService.create(projectId, req.user.id, dto);
   }
 
   @Get()
   @ApiOperation({ summary: 'List all edge functions' })
-  async findAll(@Param('orgId') orgId: string) {
-    return this.edgeFunctionsService.findAll(orgId);
+  async findAll(@Param('projectId') projectId: string) {
+    return this.edgeFunctionsService.findAll(projectId);
   }
 
   @Get(':functionId')
   @ApiOperation({ summary: 'Get edge function details' })
   async findOne(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('functionId') functionId: string,
   ) {
-    return this.edgeFunctionsService.findOne(orgId, functionId);
+    return this.edgeFunctionsService.findOne(projectId, functionId);
   }
 
   @Put(':functionId')
   @ApiOperation({ summary: 'Update edge function' })
   async update(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('functionId') functionId: string,
     @Body() dto: UpdateEdgeFunctionDto,
   ) {
-    return this.edgeFunctionsService.update(orgId, functionId, dto);
+    return this.edgeFunctionsService.update(projectId, functionId, dto);
   }
 
   @Delete(':functionId')
   @ApiOperation({ summary: 'Delete edge function' })
   async remove(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('functionId') functionId: string,
   ) {
-    return this.edgeFunctionsService.remove(orgId, functionId);
+    return this.edgeFunctionsService.remove(projectId, functionId);
   }
 
   @Post(':functionId/execute')
   @ApiOperation({ summary: 'Execute edge function' })
   async execute(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('functionId') functionId: string,
     @Body() dto: ExecuteEdgeFunctionDto,
     @Request() req: any,
   ) {
-    return this.edgeFunctionsService.execute(orgId, functionId, dto, req.user);
+    return this.edgeFunctionsService.execute(projectId, functionId, dto, req.user);
   }
 
   @Post(':functionId/deploy')
   @ApiOperation({ summary: 'Deploy edge function to edge network' })
   async deploy(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('functionId') functionId: string,
   ) {
-    return this.edgeFunctionsService.deploy(orgId, functionId);
+    return this.edgeFunctionsService.deploy(projectId, functionId);
   }
 
   @Get(':functionId/logs')
   @ApiOperation({ summary: 'Get edge function execution logs' })
   async getLogs(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('functionId') functionId: string,
   ) {
-    return this.edgeFunctionsService.getLogs(orgId, functionId);
+    return this.edgeFunctionsService.getLogs(projectId, functionId);
   }
 }

package/template/src/modules/edge-functions/edge-functions.service.ts

@@ -8,7 +8,7 @@ import * as crypto from 'crypto';
 export class EdgeFunctionsService {
   constructor(private prisma: PrismaService) {}
 
-  async create(orgId: string, userId: string, dto: CreateEdgeFunctionDto) {
+  async create(projectId: string, userId: string, dto: CreateEdgeFunctionDto) {
     // Validate the function code
     this.validateCode(dto.code);
 
@@ -22,7 +22,7 @@ export class EdgeFunctionsService {
         memory: dto.memory || 128,
         environment: dto.environment || {},
         triggers: dto.triggers || [],
-        organizationId: orgId,
+        projectId,
         createdBy: userId,
       },
     });
@@ -30,16 +30,16 @@ export class EdgeFunctionsService {
     return func;
   }
 
-  async findAll(orgId: string) {
+  async findAll(projectId: string) {
     return this.prisma.edgeFunction.findMany({
-      where: { organizationId: orgId },
+      where: { projectId },
       orderBy: { createdAt: 'desc' },
     });
   }
 
-  async findOne(orgId: string, functionId: string) {
+  async findOne(projectId: string, functionId: string) {
     const func = await this.prisma.edgeFunction.findFirst({
-      where: { id: functionId, organizationId: orgId },
+      where: { id: functionId, projectId },
     });
 
     if (!func) {
@@ -49,8 +49,8 @@ export class EdgeFunctionsService {
     return func;
   }
 
-  async update(orgId: string, functionId: string, dto: UpdateEdgeFunctionDto) {
-    await this.findOne(orgId, functionId);
+  async update(projectId: string, functionId: string, dto: UpdateEdgeFunctionDto) {
+    await this.findOne(projectId, functionId);
 
     if (dto.code) {
       this.validateCode(dto.code);
@@ -66,8 +66,8 @@ export class EdgeFunctionsService {
     });
   }
 
-  async remove(orgId: string, functionId: string) {
-    await this.findOne(orgId, functionId);
+  async remove(projectId: string, functionId: string) {
+    await this.findOne(projectId, functionId);
 
     await this.prisma.edgeFunction.delete({
       where: { id: functionId },
@@ -76,8 +76,8 @@ export class EdgeFunctionsService {
     return { success: true };
   }
 
-  async execute(orgId: string, functionId: string, dto: ExecuteEdgeFunctionDto, user: any) {
-    const func = await this.findOne(orgId, functionId);
+  async execute(projectId: string, functionId: string, dto: ExecuteEdgeFunctionDto, user: any) {
+    const func = await this.findOne(projectId, functionId);
 
     if (func.status !== 'deployed') {
       throw new BadRequestException('Function must be deployed before execution');
@@ -93,7 +93,7 @@ export class EdgeFunctionsService {
       result = await this.runInSandbox(func.code, {
         ...dto.payload,
         user: { id: user.id, email: user.email },
-        organizationId: orgId,
+        projectId,
         env: func.environment as Record<string, string>,
       });
     } catch (err: any) {
@@ -123,8 +123,8 @@ export class EdgeFunctionsService {
     return result;
   }
 
-  async deploy(orgId: string, functionId: string) {
-    const func = await this.findOne(orgId, functionId);
+  async deploy(projectId: string, functionId: string) {
+    const func = await this.findOne(projectId, functionId);
 
     // Generate deployment info
     const deploymentId = crypto.randomUUID();
@@ -147,8 +147,8 @@ export class EdgeFunctionsService {
     };
   }
 
-  async getLogs(orgId: string, functionId: string) {
-    await this.findOne(orgId, functionId);
+  async getLogs(projectId: string, functionId: string) {
+    await this.findOne(projectId, functionId);
 
     return this.prisma.edgeFunctionLog.findMany({
       where: { functionId },

package/template/src/modules/projects/projects.service.ts

@@ -7,27 +7,30 @@ import { UpdateProjectDto } from './dto/update-project.dto';
 export class ProjectsService {
   constructor(private readonly prisma: PrismaService) {}
 
-  async list(orgId: string) {
+  async list(organizationId: string) {
     const projects = await this.prisma.project.findMany({
-      where: { orgId },
+      where: { organizationId },
       orderBy: { createdAt: 'desc' }
     });
 
     return { projects };
   }
 
-  async create(orgId: string, dto: CreateProjectDto) {
+  async create(organizationId: string, dto: CreateProjectDto) {
+    // Generate slug from project name
+    const slug = dto.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    
     const project = await this.prisma.project.create({
-      data: { orgId, name: dto.name }
+      data: { organizationId, name: dto.name, slug }
     });
 
     return { project };
   }
 
-  async update(orgId: string, id: string, dto: UpdateProjectDto) {
+  async update(organizationId: string, id: string, dto: UpdateProjectDto) {
     const project = await this.prisma.project.findUnique({ where: { id } });
     if (!project) throw new NotFoundException('Project not found');
-    if (project.orgId !== orgId) throw new ForbiddenException('Forbidden');
+    if (project.organizationId !== organizationId) throw new ForbiddenException('Forbidden');
 
     const updated = await this.prisma.project.update({
       where: { id },
@@ -37,10 +40,10 @@ export class ProjectsService {
     return { project: updated };
   }
 
-  async remove(orgId: string, id: string) {
+  async remove(organizationId: string, id: string) {
     const project = await this.prisma.project.findUnique({ where: { id } });
     if (!project) throw new NotFoundException('Project not found');
-    if (project.orgId !== orgId) throw new ForbiddenException('Forbidden');
+    if (project.organizationId !== organizationId) throw new ForbiddenException('Forbidden');
 
     await this.prisma.project.delete({ where: { id } });
     return { deleted: true };

package/template/src/modules/vector/vector.controller.ts

@@ -8,88 +8,88 @@ import { CreateEmbeddingDto, SearchSimilarDto, CreateCollectionDto } from './dto
 @ApiTags('vector')
 @ApiBearerAuth()
 @UseGuards(JwtAuthGuard, TenantGuard)
-@Controller('organizations/:orgId/vector')
+@Controller('projects/:projectId/vector')
 export class VectorController {
   constructor(private readonly vectorService: VectorService) {}
 
   @Post('collections')
   @ApiOperation({ summary: 'Create a vector collection' })
   async createCollection(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Body() dto: CreateCollectionDto,
   ) {
-    return this.vectorService.createCollection(orgId, dto);
+    return this.vectorService.createCollection(projectId, dto);
   }
 
   @Get('collections')
   @ApiOperation({ summary: 'List all collections' })
-  async listCollections(@Param('orgId') orgId: string) {
-    return this.vectorService.listCollections(orgId);
+  async listCollections(@Param('projectId') projectId: string) {
+    return this.vectorService.listCollections(projectId);
   }
 
   @Post('embeddings')
   @ApiOperation({ summary: 'Create embedding from text' })
   async createEmbedding(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Body() dto: CreateEmbeddingDto,
     @Request() req: any,
   ) {
-    return this.vectorService.createEmbedding(orgId, req.user.id, dto);
+    return this.vectorService.createEmbedding(projectId, req.user.id, dto);
   }
 
   @Post('embeddings/batch')
   @ApiOperation({ summary: 'Create multiple embeddings' })
   async createEmbeddingsBatch(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Body() items: CreateEmbeddingDto[],
     @Request() req: any,
   ) {
-    return this.vectorService.createEmbeddingsBatch(orgId, req.user.id, items);
+    return this.vectorService.createEmbeddingsBatch(projectId, req.user.id, items);
   }
 
   @Post('search')
   @ApiOperation({ summary: 'Search similar vectors' })
   async searchSimilar(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Body() dto: SearchSimilarDto,
   ) {
-    return this.vectorService.searchSimilar(orgId, dto);
+    return this.vectorService.searchSimilar(projectId, dto);
   }
 
   @Get('embeddings/:id')
   @ApiOperation({ summary: 'Get embedding by ID' })
   async getEmbedding(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('id') id: string,
   ) {
-    return this.vectorService.getEmbedding(orgId, id);
+    return this.vectorService.getEmbedding(projectId, id);
   }
 
   @Post('embeddings/:id')
   @ApiOperation({ summary: 'Update embedding metadata' })
   async updateEmbedding(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('id') id: string,
     @Body() metadata: Record<string, any>,
   ) {
-    return this.vectorService.updateEmbedding(orgId, id, metadata);
+    return this.vectorService.updateEmbedding(projectId, id, metadata);
   }
 
   @Post('embeddings/:id/delete')
   @ApiOperation({ summary: 'Delete embedding' })
   async deleteEmbedding(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Param('id') id: string,
   ) {
-    return this.vectorService.deleteEmbedding(orgId, id);
+    return this.vectorService.deleteEmbedding(projectId, id);
   }
 
   @Post('query')
   @ApiOperation({ summary: 'Natural language query with RAG' })
   async query(
-    @Param('orgId') orgId: string,
+    @Param('projectId') projectId: string,
     @Body() body: { query: string; collection?: string; limit?: number },
   ) {
-    return this.vectorService.query(orgId, body.query, body.collection, body.limit);
+    return this.vectorService.query(projectId, body.query, body.collection, body.limit);
   }
 }

package/template/src/modules/vector/vector.service.ts

@@ -14,7 +14,7 @@ export class VectorService {
     this.openaiApiKey = this.config.get('OPENAI_API_KEY');
   }
 
-  async createCollection(orgId: string, dto: CreateCollectionDto) {
+  async createCollection(projectId: string, dto: CreateCollectionDto) {
     // Create the collection table with pgvector extension
     await this.prisma.$executeRaw`
       CREATE TABLE IF NOT EXISTS vector_embeddings_${dto.name} (
@@ -22,7 +22,7 @@ export class VectorService {
         content TEXT NOT NULL,
         embedding vector(1536),
         metadata JSONB DEFAULT '{}',
-        "organizationId" UUID NOT NULL,
+        "projectId" UUID NOT NULL,
         "createdBy" UUID NOT NULL,
         "createdAt" TIMESTAMP DEFAULT NOW(),
         "updatedAt" TIMESTAMP DEFAULT NOW()
@@ -42,26 +42,26 @@ export class VectorService {
         description: dto.description,
         dimension: dto.dimension || 1536,
         embeddingModel: dto.embeddingModel || 'text-embedding-3-small',
-        organizationId: orgId,
+        projectId,
       },
     });
 
     return collection;
   }
 
-  async listCollections(orgId: string) {
+  async listCollections(projectId: string) {
     return this.prisma.vectorCollection.findMany({
-      where: { organizationId: orgId },
+      where: { projectId },
       orderBy: { createdAt: 'desc' },
     });
   }
 
-  async createEmbedding(orgId: string, userId: string, dto: CreateEmbeddingDto) {
+  async createEmbedding(projectId: string, userId: string, dto: CreateEmbeddingDto) {
     // Generate embedding using OpenAI
     const embedding = await this.generateEmbedding(dto.content);
 
     const collection = await this.prisma.vectorCollection.findFirst({
-      where: { id: dto.collectionId, organizationId: orgId },
+      where: { id: dto.collectionId, projectId },
     });
 
     if (!collection) {
@@ -70,28 +70,28 @@ export class VectorService {
 
     // Insert into collection table
     const result = await this.prisma.$queryRaw`
-      INSERT INTO vector_embeddings_${collection.name} (content, embedding, metadata, "organizationId", "createdBy")
-      VALUES (${dto.content}, ${`[${embedding.join(',')}]`}::vector, ${dto.metadata || '{}'}::jsonb, ${orgId}::uuid, ${userId}::uuid)
+      INSERT INTO vector_embeddings_${collection.name} (content, embedding, metadata, "projectId", "createdBy")
+      VALUES (${dto.content}, ${`[${embedding.join(',')}]`}::vector, ${dto.metadata || '{}'}::jsonb, ${projectId}::uuid, ${userId}::uuid)
       RETURNING id, content, metadata, "createdAt";
     `;
 
     return (result as { id: string; content: string; metadata: any; createdAt: Date }[])[0];
   }
 
-  async createEmbeddingsBatch(orgId: string, userId: string, items: CreateEmbeddingDto[]) {
+  async createEmbeddingsBatch(projectId: string, userId: string, items: CreateEmbeddingDto[]) {
     const results: any[] = [];
     for (const item of items) {
-      const result = await this.createEmbedding(orgId, userId, item);
+      const result = await this.createEmbedding(projectId, userId, item);
       results.push(result as any);
     }
     return results;
   }
 
-  async searchSimilar(orgId: string, dto: SearchSimilarDto) {
+  async searchSimilar(projectId: string, dto: SearchSimilarDto) {
     const queryEmbedding = await this.generateEmbedding(dto.query);
 
     const collection = await this.prisma.vectorCollection.findFirst({
-      where: { id: dto.collectionId, organizationId: orgId },
+      where: { id: dto.collectionId, projectId },
     });
 
     if (!collection) {
@@ -110,7 +110,7 @@ export class VectorService {
         "createdAt",
         1 - (embedding <=> ${`[${queryEmbedding.join(',')}]`}::vector) as similarity
       FROM vector_embeddings_${collection.name}
-      WHERE "organizationId" = ${orgId}::uuid
+      WHERE "projectId" = ${projectId}::uuid
         AND 1 - (embedding <=> ${`[${queryEmbedding.join(',')}]`}::vector) > ${threshold}
       ORDER BY embedding <=> ${`[${queryEmbedding.join(',')}]`}::vector
       LIMIT ${limit};
@@ -119,15 +119,15 @@ export class VectorService {
     return results;
   }
 
-  async getEmbedding(orgId: string, id: string) {
-    const collections = await this.listCollections(orgId);
+  async getEmbedding(projectId: string, id: string) {
+    const collections = await this.listCollections(projectId);
     
     for (const collection of collections) {
       try {
         const result = await this.prisma.$queryRaw`
           SELECT id, content, metadata, "createdAt", "updatedAt"
           FROM vector_embeddings_${collection.name}
-          WHERE id = ${id}::uuid AND "organizationId" = ${orgId}::uuid
+          WHERE id = ${id}::uuid AND "projectId" = ${projectId}::uuid
         `;
         if ((result as any[]).length > 0) {
           return { ...(result as any[])[0], collection: collection.name };
@@ -140,32 +140,32 @@ export class VectorService {
     throw new NotFoundException('Embedding not found');
   }
 
-  async updateEmbedding(orgId: string, id: string, metadata: Record<string, any>) {
-    const embedding = await this.getEmbedding(orgId, id);
+  async updateEmbedding(projectId: string, id: string, metadata: Record<string, any>) {
+    const embedding = await this.getEmbedding(projectId, id);
     
     await this.prisma.$executeRaw`
       UPDATE vector_embeddings_${embedding.collection}
       SET metadata = ${metadata}::jsonb, "updatedAt" = NOW()
-      WHERE id = ${id}::uuid AND "organizationId" = ${orgId}::uuid
+      WHERE id = ${id}::uuid AND "projectId" = ${projectId}::uuid
     `;
 
-    return this.getEmbedding(orgId, id);
+    return this.getEmbedding(projectId, id);
   }
 
-  async deleteEmbedding(orgId: string, id: string) {
-    const embedding = await this.getEmbedding(orgId, id);
+  async deleteEmbedding(projectId: string, id: string) {
+    const embedding = await this.getEmbedding(projectId, id);
     
     await this.prisma.$executeRaw`
       DELETE FROM vector_embeddings_${embedding.collection}
-      WHERE id = ${id}::uuid AND "organizationId" = ${orgId}::uuid
+      WHERE id = ${id}::uuid AND "projectId" = ${projectId}::uuid
     `;
 
     return { success: true };
   }
 
-  async query(orgId: string, query: string, collectionName?: string, limit: number = 5) {
+  async query(projectId: string, query: string, collectionName?: string, limit: number = 5) {
     // RAG-style query: search similar and return context
-    let collections = await this.listCollections(orgId);
+    let collections = await this.listCollections(projectId);
     
     if (collectionName) {
       collections = collections.filter(c => c.name === collectionName);
@@ -174,7 +174,7 @@ export class VectorService {
     const contexts: any[] = [];
 
     for (const collection of collections) {
-      const results = await this.searchSimilar(orgId, {
+      const results = await this.searchSimilar(projectId, {
         query,
         collectionId: collection.id,
         limit,