filter/sort, file, person

apps/server/src/core/attachment/attachment.controller.ts

@@ -47,6 +47,7 @@ import {
 } from '../casl/interfaces/workspace-ability.type';
 import WorkspaceAbilityFactory from '../casl/abilities/workspace-ability.factory';
 import { PageRepo } from '@docmost/db/repos/page/page.repo';
+import { BaseRepo } from '@docmost/db/repos/base/base.repo';
 import { AttachmentRepo } from '@docmost/db/repos/attachment/attachment.repo';
 import { validate as isValidUUID } from 'uuid';
 import { EnvironmentService } from '../../integrations/environment/environment.service';
@@ -71,6 +72,7 @@ export class AttachmentController {
     private readonly workspaceAbility: WorkspaceAbilityFactory,
     private readonly spaceAbility: SpaceAbilityFactory,
     private readonly pageRepo: PageRepo,
+    private readonly baseRepo: BaseRepo,
     private readonly attachmentRepo: AttachmentRepo,
     private readonly environmentService: EnvironmentService,
     private readonly tokenService: TokenService,
@@ -163,6 +165,87 @@ export class AttachmentController {
     }
   }
 
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  @Post('bases/files/upload')
+  @UseInterceptors(FileInterceptor)
+  async uploadBaseFile(
+    @Req() req: any,
+    @Res() res: FastifyReply,
+    @AuthUser() user: User,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    const maxFileSize = bytes(this.environmentService.getFileUploadSizeLimit());
+
+    let file = null;
+    try {
+      file = await req.file({
+        limits: { fileSize: maxFileSize, fields: 3, files: 1 },
+      });
+    } catch (err: any) {
+      this.logger.error(err.message);
+      if (err?.statusCode === 413) {
+        throw new BadRequestException(
+          `File too large. Exceeds the ${this.environmentService.getFileUploadSizeLimit()} limit`,
+        );
+      }
+    }
+
+    if (!file) {
+      throw new BadRequestException('Failed to upload file');
+    }
+
+    const baseId = file.fields?.baseId?.value;
+
+    if (!baseId) {
+      throw new BadRequestException('baseId is required');
+    }
+
+    if (!isValidUUID(baseId)) {
+      throw new BadRequestException('Invalid baseId');
+    }
+
+    const base = await this.baseRepo.findById(baseId);
+
+    if (!base) {
+      throw new NotFoundException('Base not found');
+    }
+
+    const spaceId = base.spaceId;
+
+    const spaceAbilityCheck = await this.spaceAbility.createForUser(
+      user,
+      spaceId,
+    );
+    if (
+      spaceAbilityCheck.cannot(
+        SpaceCaslAction.Edit,
+        SpaceCaslSubject.Base,
+      )
+    ) {
+      throw new ForbiddenException();
+    }
+
+    try {
+      const fileResponse = await this.attachmentService.uploadFile({
+        filePromise: file,
+        spaceId: spaceId,
+        userId: user.id,
+        workspaceId: workspace.id,
+      });
+
+      return res.send(fileResponse);
+    } catch (err: any) {
+      if (err?.statusCode === 413) {
+        const errMessage = `File too large. Exceeds the ${this.environmentService.getFileUploadSizeLimit()} limit`;
+        this.logger.error(errMessage);
+        throw new BadRequestException(errMessage);
+      }
+      this.logger.error(err);
+      throw new BadRequestException('Error processing file upload.');
+    }
+  }
+
   @UseGuards(JwtAuthGuard)
   @Get('/files/:fileId/:fileName')
   async getFile(

apps/server/src/core/attachment/services/attachment.service.ts

@@ -43,7 +43,7 @@ export class AttachmentService {
 
   async uploadFile(opts: {
     filePromise: Promise<MultipartFile>;
-    pageId: string;
+    pageId?: string;
     userId: string;
     spaceId: string;
     workspaceId: string;

apps/server/src/core/base/base.schemas.ts

@@ -119,10 +119,10 @@ const typeOptionsSchemaMap: Record<BasePropertyTypeValue, z.ZodType> = {
 export function validateTypeOptions(
   type: BasePropertyTypeValue,
   typeOptions: unknown,
-): z.SafeParseReturnType<unknown, unknown> {
+): z.ZodSafeParseResult<unknown> {
   const schema = typeOptionsSchemaMap[type];
   if (!schema) {
-    return { success: false, error: new z.ZodError([{ code: 'custom', message: `Unknown property type: ${type}`, path: ['type'] }]) } as z.SafeParseError<unknown>;
+    return { success: false, error: new z.ZodError([{ code: 'custom', message: `Unknown property type: ${type}`, path: ['type'] }]) } as z.ZodSafeParseError<unknown>;
   }
   return schema.safeParse(typeOptions ?? {});
 }
@@ -146,7 +146,13 @@ const cellValueSchemaMap: Partial<Record<BasePropertyTypeValue, z.ZodType>> = {
   [BasePropertyType.MULTI_SELECT]: z.array(z.string().uuid()),
   [BasePropertyType.DATE]: z.string(),
   [BasePropertyType.PERSON]: z.array(z.string().uuid()),
-  [BasePropertyType.FILE]: z.array(z.string().uuid()),
+  [BasePropertyType.FILE]: z.array(z.object({
+    id: z.string().uuid(),
+    fileName: z.string(),
+    mimeType: z.string().optional(),
+    fileSize: z.number().optional(),
+    filePath: z.string().optional(),
+  })),
   [BasePropertyType.CHECKBOX]: z.boolean(),
   [BasePropertyType.URL]: z.string().url(),
   [BasePropertyType.EMAIL]: z.string().email(),
@@ -161,10 +167,10 @@ export function getCellValueSchema(
 export function validateCellValue(
   type: BasePropertyTypeValue,
   value: unknown,
-): z.SafeParseReturnType<unknown, unknown> {
+): z.ZodSafeParseResult<unknown> {
   const schema = cellValueSchemaMap[type];
   if (!schema) {
-    return { success: false, error: new z.ZodError([{ code: 'custom', message: `Unknown property type: ${type}`, path: [] }]) } as z.SafeParseError<unknown>;
+    return { success: false, error: new z.ZodError([{ code: 'custom', message: `Unknown property type: ${type}`, path: [] }]) } as z.ZodSafeParseError<unknown>;
   }
   return schema.safeParse(value);
 }

apps/server/src/core/base/dto/update-row.dto.ts

@@ -1,4 +1,5 @@
-import { IsNotEmpty, IsObject, IsOptional, IsString, IsUUID } from 'class-validator';
+import { IsNotEmpty, IsObject, IsOptional, IsString, IsUUID, IsArray, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
 
 export class UpdateRowDto {
   @IsUUID()
@@ -27,6 +28,27 @@ export class RowIdDto {
   baseId: string;
 }
 
+class FilterDto {
+  @IsUUID()
+  propertyId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  operator: string;
+
+  @IsOptional()
+  value?: unknown;
+}
+
+class SortDto {
+  @IsUUID()
+  propertyId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  direction: string;
+}
+
 export class ListRowsDto {
   @IsUUID()
   baseId: string;
@@ -34,6 +56,18 @@ export class ListRowsDto {
   @IsOptional()
   @IsUUID()
   viewId?: string;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => FilterDto)
+  filters?: FilterDto[];
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => SortDto)
+  sorts?: SortDto[];
 }
 
 export class ReorderRowDto {

apps/server/src/core/base/services/base-row.service.ts

@@ -93,7 +93,23 @@ export class BaseRowService {
   }
 
   async list(dto: ListRowsDto, pagination: PaginationOptions) {
-    return this.baseRowRepo.findByBaseId(dto.baseId, pagination);
+    const hasFilters = dto.filters && dto.filters.length > 0;
+    const hasSorts = dto.sorts && dto.sorts.length > 0;
+
+    if (!hasFilters && !hasSorts) {
+      return this.baseRowRepo.findByBaseId(dto.baseId, pagination);
+    }
+
+    const properties = await this.basePropertyRepo.findByBaseId(dto.baseId);
+    const propertyTypeMap = new Map(properties.map((p) => [p.id, p.type]));
+
+    return this.baseRowRepo.findByBaseIdFiltered(
+      dto.baseId,
+      dto.filters ?? [],
+      dto.sorts ?? [],
+      propertyTypeMap,
+      pagination,
+    );
   }
 
   async reorder(dto: ReorderRowDto) {