486 lines
12 KiB
TypeScript
486 lines
12 KiB
TypeScript
import { randomUUID } from 'crypto';
|
|
import { Response, Router } from 'express';
|
|
import type { Router as RouterType } from 'express';
|
|
import { ImageService, AliasService } from '@/services/core';
|
|
import { StorageFactory } from '@/services/StorageFactory';
|
|
import { asyncHandler } from '@/middleware/errorHandler';
|
|
import { validateApiKey } from '@/middleware/auth/validateApiKey';
|
|
import { requireProjectKey } from '@/middleware/auth/requireProjectKey';
|
|
import { rateLimitByApiKey } from '@/middleware/auth/rateLimiter';
|
|
import { uploadSingleImage, handleUploadErrors } from '@/middleware/upload';
|
|
import { validateAndNormalizePagination } from '@/utils/validators';
|
|
import { buildPaginatedResponse } from '@/utils/helpers';
|
|
import { toImageResponse } from '@/types/responses';
|
|
import { db } from '@/db';
|
|
import { flows } from '@banatie/database';
|
|
import { eq } from 'drizzle-orm';
|
|
import type {
|
|
UploadImageResponse,
|
|
ListImagesResponse,
|
|
GetImageResponse,
|
|
UpdateImageResponse,
|
|
DeleteImageResponse,
|
|
ResolveAliasResponse,
|
|
} from '@/types/responses';
|
|
|
|
export const imagesRouter: RouterType = Router();
|
|
|
|
let imageService: ImageService;
|
|
let aliasService: AliasService;
|
|
|
|
const getImageService = (): ImageService => {
|
|
if (!imageService) {
|
|
imageService = new ImageService();
|
|
}
|
|
return imageService;
|
|
};
|
|
|
|
const getAliasService = (): AliasService => {
|
|
if (!aliasService) {
|
|
aliasService = new AliasService();
|
|
}
|
|
return aliasService;
|
|
};
|
|
|
|
/**
|
|
* POST /api/v1/images/upload
|
|
* Upload a single image file and create database record
|
|
*/
|
|
imagesRouter.post(
|
|
'/upload',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
rateLimitByApiKey,
|
|
uploadSingleImage,
|
|
handleUploadErrors,
|
|
asyncHandler(async (req: any, res: Response<UploadImageResponse>) => {
|
|
const service = getImageService();
|
|
const { alias, flowId, flowAlias, meta } = req.body;
|
|
|
|
if (!req.file) {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: {
|
|
message: 'No file provided',
|
|
code: 'VALIDATION_ERROR',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
const projectId = req.apiKey.projectId;
|
|
const apiKeyId = req.apiKey.id;
|
|
const orgId = req.apiKey.organizationSlug || 'default';
|
|
const projectSlug = req.apiKey.projectSlug;
|
|
const file = req.file;
|
|
|
|
// FlowId logic (Section 10.1 & 5.1):
|
|
// - If undefined (not provided) → generate new UUID
|
|
// - If null (explicitly null) → keep null
|
|
// - If string (specific value) → use that value
|
|
let finalFlowId: string | null;
|
|
if (flowId === undefined) {
|
|
finalFlowId = randomUUID();
|
|
} else if (flowId === null) {
|
|
finalFlowId = null;
|
|
} else {
|
|
finalFlowId = flowId;
|
|
}
|
|
|
|
try {
|
|
const storageService = await StorageFactory.getInstance();
|
|
|
|
const uploadResult = await storageService.uploadFile(
|
|
orgId,
|
|
projectSlug,
|
|
'uploads',
|
|
file.originalname,
|
|
file.buffer,
|
|
file.mimetype,
|
|
);
|
|
|
|
if (!uploadResult.success) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: {
|
|
message: 'File upload failed',
|
|
code: 'UPLOAD_ERROR',
|
|
details: uploadResult.error,
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
const imageRecord = await service.create({
|
|
projectId,
|
|
flowId: finalFlowId,
|
|
generationId: null,
|
|
apiKeyId,
|
|
storageKey: uploadResult.path!,
|
|
storageUrl: uploadResult.url!,
|
|
mimeType: file.mimetype,
|
|
fileSize: file.size,
|
|
fileHash: null,
|
|
source: 'uploaded',
|
|
alias: alias || null,
|
|
meta: meta ? JSON.parse(meta) : {},
|
|
});
|
|
|
|
// Eager flow creation if flowAlias is provided (Section 5.1)
|
|
if (flowAlias && finalFlowId) {
|
|
// Check if flow exists, create if not
|
|
const existingFlow = await db.query.flows.findFirst({
|
|
where: eq(flows.id, finalFlowId),
|
|
});
|
|
|
|
if (!existingFlow) {
|
|
await db.insert(flows).values({
|
|
id: finalFlowId,
|
|
projectId,
|
|
aliases: {},
|
|
meta: {},
|
|
});
|
|
}
|
|
|
|
// Assign flow alias to uploaded image
|
|
const flow = await db.query.flows.findFirst({
|
|
where: eq(flows.id, finalFlowId),
|
|
});
|
|
|
|
if (flow) {
|
|
const currentAliases = (flow.aliases as Record<string, string>) || {};
|
|
const updatedAliases = { ...currentAliases };
|
|
updatedAliases[flowAlias] = imageRecord.id;
|
|
|
|
await db
|
|
.update(flows)
|
|
.set({ aliases: updatedAliases, updatedAt: new Date() })
|
|
.where(eq(flows.id, finalFlowId));
|
|
}
|
|
}
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
data: toImageResponse(imageRecord),
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: {
|
|
message: error instanceof Error ? error.message : 'Upload failed',
|
|
code: 'UPLOAD_ERROR',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
})
|
|
);
|
|
|
|
/**
|
|
* GET /api/v1/images
|
|
* List images with filters and pagination
|
|
*/
|
|
imagesRouter.get(
|
|
'/',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
asyncHandler(async (req: any, res: Response<ListImagesResponse>) => {
|
|
const service = getImageService();
|
|
const { flowId, source, alias, limit, offset, includeDeleted } = req.query;
|
|
|
|
const paginationResult = validateAndNormalizePagination(limit, offset);
|
|
if (!paginationResult.valid) {
|
|
res.status(400).json({
|
|
success: false,
|
|
data: [],
|
|
pagination: { total: 0, limit: 20, offset: 0, hasMore: false },
|
|
});
|
|
return;
|
|
}
|
|
|
|
const { limit: validatedLimit, offset: validatedOffset } = paginationResult.params!;
|
|
const projectId = req.apiKey.projectId;
|
|
|
|
const result = await service.list(
|
|
{
|
|
projectId,
|
|
flowId: flowId as string | undefined,
|
|
source: source as 'generated' | 'uploaded' | undefined,
|
|
alias: alias as string | undefined,
|
|
deleted: includeDeleted === 'true' ? true : undefined,
|
|
},
|
|
validatedLimit,
|
|
validatedOffset
|
|
);
|
|
|
|
const responseData = result.images.map((img) => toImageResponse(img));
|
|
|
|
res.json(
|
|
buildPaginatedResponse(responseData, result.total, validatedLimit, validatedOffset)
|
|
);
|
|
})
|
|
);
|
|
|
|
/**
|
|
* GET /api/v1/images/resolve/:alias
|
|
* Resolve an alias to an image using 3-tier precedence (technical -> flow -> project)
|
|
*/
|
|
imagesRouter.get(
|
|
'/resolve/:alias',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
asyncHandler(async (req: any, res: Response<ResolveAliasResponse>) => {
|
|
const aliasServiceInstance = getAliasService();
|
|
const { alias } = req.params;
|
|
const { flowId } = req.query;
|
|
|
|
const projectId = req.apiKey.projectId;
|
|
|
|
try {
|
|
const resolution = await aliasServiceInstance.resolve(
|
|
alias,
|
|
projectId,
|
|
flowId as string | undefined
|
|
);
|
|
|
|
if (!resolution) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: `Alias '${alias}' not found`,
|
|
code: 'ALIAS_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Verify project ownership
|
|
if (resolution.image && resolution.image.projectId !== projectId) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Alias not found',
|
|
code: 'ALIAS_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
data: {
|
|
alias,
|
|
imageId: resolution.imageId,
|
|
scope: resolution.scope,
|
|
flowId: resolution.flowId,
|
|
image: resolution.image ? toImageResponse(resolution.image) : ({} as any),
|
|
},
|
|
});
|
|
} catch (error) {
|
|
res.status(500).json({
|
|
success: false,
|
|
error: {
|
|
message: error instanceof Error ? error.message : 'Failed to resolve alias',
|
|
code: 'RESOLUTION_ERROR',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
})
|
|
);
|
|
|
|
/**
|
|
* GET /api/v1/images/:id
|
|
* Get a single image by ID
|
|
*/
|
|
imagesRouter.get(
|
|
'/:id',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
asyncHandler(async (req: any, res: Response<GetImageResponse>) => {
|
|
const service = getImageService();
|
|
const { id } = req.params;
|
|
|
|
const image = await service.getById(id);
|
|
if (!image) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (image.projectId !== req.apiKey.projectId) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
res.json({
|
|
success: true,
|
|
data: toImageResponse(image),
|
|
});
|
|
})
|
|
);
|
|
|
|
/**
|
|
* PUT /api/v1/images/:id
|
|
* Update image metadata (alias, focal point, meta)
|
|
*/
|
|
imagesRouter.put(
|
|
'/:id',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
asyncHandler(async (req: any, res: Response<UpdateImageResponse>) => {
|
|
const service = getImageService();
|
|
const { id } = req.params;
|
|
const { focalPoint, meta } = req.body; // Removed alias (Section 6.1)
|
|
|
|
const image = await service.getById(id);
|
|
if (!image) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (image.projectId !== req.apiKey.projectId) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
const updates: {
|
|
focalPoint?: { x: number; y: number };
|
|
meta?: Record<string, unknown>;
|
|
} = {};
|
|
|
|
if (focalPoint !== undefined) updates.focalPoint = focalPoint;
|
|
if (meta !== undefined) updates.meta = meta;
|
|
|
|
const updated = await service.update(id, updates);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: toImageResponse(updated),
|
|
});
|
|
})
|
|
);
|
|
|
|
/**
|
|
* PUT /api/v1/images/:id/alias
|
|
* Assign a project-scoped alias to an image
|
|
*/
|
|
imagesRouter.put(
|
|
'/:id/alias',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
asyncHandler(async (req: any, res: Response<UpdateImageResponse>) => {
|
|
const service = getImageService();
|
|
const { id } = req.params;
|
|
const { alias } = req.body;
|
|
|
|
if (!alias || typeof alias !== 'string') {
|
|
res.status(400).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Alias is required and must be a string',
|
|
code: 'VALIDATION_ERROR',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
const image = await service.getById(id);
|
|
if (!image) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (image.projectId !== req.apiKey.projectId) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
const updated = await service.assignProjectAlias(id, alias);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: toImageResponse(updated),
|
|
});
|
|
})
|
|
);
|
|
|
|
/**
|
|
* DELETE /api/v1/images/:id
|
|
* Hard delete an image with MinIO cleanup and cascades (Section 7.1)
|
|
*/
|
|
imagesRouter.delete(
|
|
'/:id',
|
|
validateApiKey,
|
|
requireProjectKey,
|
|
asyncHandler(async (req: any, res: Response<DeleteImageResponse>) => {
|
|
const service = getImageService();
|
|
const { id } = req.params;
|
|
|
|
const image = await service.getById(id);
|
|
if (!image) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (image.projectId !== req.apiKey.projectId) {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: {
|
|
message: 'Image not found',
|
|
code: 'IMAGE_NOT_FOUND',
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
await service.hardDelete(id);
|
|
|
|
res.json({
|
|
success: true,
|
|
data: { id },
|
|
});
|
|
})
|
|
);
|