1485 lines
36 KiB
Markdown
1485 lines
36 KiB
Markdown
# 스토리지 드라이버 시스템 (StorageInterface)
|
|
|
|
> **모듈/플러그인에서 파일을 저장하고 관리하기 위한 표준화된 인터페이스**
|
|
|
|
## TL;DR (5초 요약)
|
|
|
|
```text
|
|
1. 모든 파일 저장은 StorageInterface 사용 (Storage::disk() 직접 호출 금지)
|
|
2. BaseModuleServiceProvider에서 storageServices 배열에 Service 클래스 등록
|
|
3. Category로 파일 분류 (attachments, images, settings, cache, temp)
|
|
4. 경로: modules/{identifier}/{category}/{path} (기본 disk: 'modules')
|
|
5. Service 생성자에서 StorageInterface 타입힌트하면 자동 주입
|
|
6. response() 메서드로 StreamedResponse 생성 (파일 다운로드/표시)
|
|
```
|
|
|
|
---
|
|
|
|
## 📋 목차
|
|
|
|
- [개요](#개요)
|
|
- [주요 개념](#주요-개념)
|
|
- [모듈에서 사용하기](#모듈에서-사용하기)
|
|
- [카테고리 네이밍 규칙](#카테고리-네이밍-규칙)
|
|
- [예제 코드](#예제-코드)
|
|
- [마이그레이션 가이드](#마이그레이션-가이드)
|
|
- [API 레퍼런스](#api-레퍼런스)
|
|
- [트러블슈팅](#트러블슈팅)
|
|
- [FAQ](#faq)
|
|
|
|
---
|
|
|
|
## 개요
|
|
|
|
### 목적
|
|
|
|
스토리지 드라이버 시스템은 모듈/플러그인에서 파일을 저장하고 관리하기 위한 **표준화된 인터페이스**를 제공합니다.
|
|
|
|
### 해결하는 문제
|
|
|
|
**Before (❌ 문제점)**:
|
|
```php
|
|
// 각 모듈마다 다른 disk 사용
|
|
$disk = config('sirsoft-board.attachment.disk', 'local');
|
|
|
|
// 불일치한 경로 패턴
|
|
$path = "attachments/modules/sirsoft/board/{$slug}/{$date}/{$filename}";
|
|
$path = "attachments/modules/sirsoft/ecommerce/category-images/{$date}/{$filename}";
|
|
|
|
// Storage Facade 직접 호출
|
|
Storage::disk($disk)->put($path, $contents);
|
|
```
|
|
|
|
**After (✅ 해결)**:
|
|
```php
|
|
// 표준화된 인터페이스
|
|
private StorageInterface $storage;
|
|
|
|
// 일관된 경로 패턴
|
|
// modules/{identifier}/{category}/{path}
|
|
$this->storage->put('attachments', "{$slug}/{$date}/{$filename}", $contents);
|
|
```
|
|
|
|
### 핵심 장점
|
|
|
|
| 장점 | 설명 |
|
|
|------|------|
|
|
| **일관성** | 모든 모듈/플러그인이 동일한 API 사용 |
|
|
| **격리성** | 모듈별 디렉토리 자동 분리 (`modules/{identifier}/`) |
|
|
| **확장성** | S3, CDN 등 다른 백엔드로 전환 용이 |
|
|
| **테스트 용이** | Mock 인터페이스로 단위 테스트 작성 가능 |
|
|
| **표준 경로** | 예측 가능한 파일 경로 구조 |
|
|
|
|
---
|
|
|
|
## 주요 개념
|
|
|
|
### 1. StorageInterface
|
|
|
|
모든 파일 작업의 표준 인터페이스입니다.
|
|
|
|
```php
|
|
interface StorageInterface
|
|
{
|
|
public function put(string $category, string $path, mixed $content): bool;
|
|
public function get(string $category, string $path): ?string;
|
|
public function exists(string $category, string $path): bool;
|
|
public function delete(string $category, string $path): bool;
|
|
public function url(string $category, string $path): ?string;
|
|
public function files(string $category, string $directory = ''): array;
|
|
public function deleteDirectory(string $category, string $directory = ''): bool;
|
|
public function getBasePath(string $category): string;
|
|
public function getDisk(): string;
|
|
public function deleteAll(string $category): bool;
|
|
public function response(string $category, string $path, string $filename, array $headers = []): ?\Symfony\Component\HttpFoundation\StreamedResponse;
|
|
}
|
|
```
|
|
|
|
### 2. 카테고리 시스템
|
|
|
|
파일을 **용도별로 분류**하여 관리합니다.
|
|
|
|
```
|
|
modules/{identifier}/
|
|
├── attachments/ # 첨부파일 (게시글, 댓글 등)
|
|
├── images/ # 이미지 파일 (상품, 카테고리 등)
|
|
├── settings/ # 환경설정 파일 (JSON, INI 등)
|
|
├── cache/ # 캐시 데이터
|
|
└── temp/ # 임시 파일
|
|
```
|
|
|
|
### 3. 경로 패턴
|
|
|
|
**표준 경로 구조**:
|
|
```
|
|
storage/app/modules/{identifier}/{category}/{path}
|
|
```
|
|
|
|
**예시**:
|
|
```
|
|
storage/app/modules/sirsoft-board/attachments/notice/2024/01/19/uuid.pdf
|
|
storage/app/modules/sirsoft-ecommerce/images/category/2024/01/19/uuid.jpg
|
|
storage/app/modules/sirsoft-ecommerce/settings/setting.json
|
|
```
|
|
|
|
### 4. ModuleStorageDriver
|
|
|
|
`StorageInterface`의 구현체로, 모듈별 격리된 저장소를 제공합니다.
|
|
|
|
```php
|
|
class ModuleStorageDriver implements StorageInterface
|
|
{
|
|
public function __construct(
|
|
string $identifier, // 모듈 식별자
|
|
string $disk = 'modules' // 사용할 디스크 (기본: 'modules')
|
|
) {}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 모듈에서 사용하기
|
|
|
|
### STEP 1: ServiceProvider 설정
|
|
|
|
`BaseModuleServiceProvider`를 상속받고 `$storageServices` 배열에 Service 클래스를 등록합니다.
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Providers;
|
|
|
|
use App\Extension\BaseModuleServiceProvider;
|
|
use Modules\Sirsoft\Board\Services\AttachmentService;
|
|
|
|
class BoardServiceProvider extends BaseModuleServiceProvider
|
|
{
|
|
/**
|
|
* 모듈 식별자
|
|
*/
|
|
protected string $moduleIdentifier = 'sirsoft-board';
|
|
|
|
/**
|
|
* StorageInterface가 필요한 서비스 목록
|
|
*
|
|
* 이 배열에 추가된 서비스는 자동으로 StorageInterface를 주입받습니다.
|
|
*/
|
|
protected array $storageServices = [
|
|
AttachmentService::class,
|
|
];
|
|
|
|
/**
|
|
* Repository 인터페이스와 구현체 매핑
|
|
*/
|
|
protected array $repositories = [
|
|
// ...
|
|
];
|
|
}
|
|
```
|
|
|
|
### STEP 2: Service에서 주입받기
|
|
|
|
Service 생성자에서 `StorageInterface`를 타입힌트하면 자동으로 주입됩니다.
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Services;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use Illuminate\Http\UploadedFile;
|
|
|
|
class AttachmentService
|
|
{
|
|
/**
|
|
* AttachmentService 생성자
|
|
*/
|
|
public function __construct(
|
|
private AttachmentRepositoryInterface $repository,
|
|
private StorageInterface $storage // 자동 주입
|
|
) {}
|
|
|
|
/**
|
|
* 파일 업로드
|
|
*/
|
|
public function upload(string $slug, UploadedFile $file, ?int $postId = null): DynamicAttachment
|
|
{
|
|
// 경로 생성
|
|
$storedFilename = Str::uuid() . '.' . $file->getClientOriginalExtension();
|
|
$datePath = date('Y/m/d');
|
|
$path = "{$slug}/{$datePath}/{$storedFilename}";
|
|
|
|
// 스토리지에 저장 (category: 'attachments')
|
|
$this->storage->put('attachments', $path, file_get_contents($file->getRealPath()));
|
|
|
|
// Disk 정보 가져오기
|
|
$disk = $this->storage->getDisk();
|
|
|
|
// DB에 레코드 생성
|
|
return $this->repository->create($slug, [
|
|
'post_id' => $postId,
|
|
'path' => $path,
|
|
'original_filename' => $file->getClientOriginalName(),
|
|
'disk' => $disk,
|
|
'mime_type' => $file->getMimeType(),
|
|
'size' => $file->getSize(),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* 파일 삭제
|
|
*/
|
|
public function delete(string $slug, int $id): bool
|
|
{
|
|
$attachment = $this->repository->findById($slug, $id);
|
|
|
|
// 스토리지에서 파일 삭제
|
|
if ($this->storage->exists('attachments', $attachment->path)) {
|
|
$this->storage->delete('attachments', $attachment->path);
|
|
}
|
|
|
|
// DB에서 삭제
|
|
return $this->repository->delete($slug, $id);
|
|
}
|
|
}
|
|
```
|
|
|
|
### STEP 3: Disk 설정 (선택)
|
|
|
|
기본값은 `modules` disk를 사용하지만, 모듈 설정 파일에서 변경 가능합니다.
|
|
|
|
**모듈 설정 파일** (`config/sirsoft-board.php`):
|
|
```php
|
|
return [
|
|
'attachment' => [
|
|
'disk' => env('SIRSOFT_BOARD_ATTACHMENT_DISK', 'modules'),
|
|
],
|
|
];
|
|
```
|
|
|
|
**AbstractModule에서 오버라이드**:
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board;
|
|
|
|
use App\Extension\AbstractModule;
|
|
|
|
class BoardModule extends AbstractModule
|
|
{
|
|
/**
|
|
* 스토리지 디스크를 반환합니다.
|
|
*/
|
|
public function getStorageDisk(): string
|
|
{
|
|
return config('sirsoft-board.attachment.disk', 'modules');
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 카테고리 네이밍 규칙
|
|
|
|
### 표준 카테고리
|
|
|
|
| 카테고리 | 용도 | 예시 |
|
|
|----------|------|------|
|
|
| `attachments` | 첨부파일 (게시글, 댓글 등) | PDF, DOCX, ZIP 등 |
|
|
| `images` | 이미지 파일 | 상품 이미지, 카테고리 이미지 |
|
|
| `settings` | 환경설정 파일 | JSON, INI 설정 |
|
|
| `cache` | 캐시 데이터 | 임시 계산 결과 |
|
|
| `temp` | 임시 파일 | 업로드 중인 파일 |
|
|
|
|
### 커스텀 카테고리
|
|
|
|
필요시 새로운 카테고리를 추가할 수 있습니다.
|
|
|
|
**예시**:
|
|
```php
|
|
// 로그 파일 저장
|
|
$this->storage->put('logs', 'error.log', $logContent);
|
|
|
|
// 백업 파일 저장
|
|
$this->storage->put('backups', 'backup-2024-01-19.sql', $backupData);
|
|
```
|
|
|
|
**네이밍 규칙**:
|
|
- **소문자**: 모두 소문자 사용
|
|
- **복수형**: 복수형 명사 사용 (logs, backups)
|
|
- **단어 구분**: 하이픈 사용 (user-uploads, product-images)
|
|
|
|
---
|
|
|
|
## 예제 코드
|
|
|
|
### 예제 1: 이미지 업로드 및 썸네일 생성
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Ecommerce\Services;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use Illuminate\Http\UploadedFile;
|
|
use Intervention\Image\Facades\Image;
|
|
|
|
class CategoryImageService
|
|
{
|
|
public function __construct(
|
|
private CategoryImageRepositoryInterface $repository,
|
|
private StorageInterface $storage
|
|
) {}
|
|
|
|
/**
|
|
* 이미지 업로드 및 썸네일 생성
|
|
*/
|
|
public function upload(UploadedFile $file, int $categoryId): CategoryImage
|
|
{
|
|
// 원본 이미지 저장
|
|
$storedFilename = Str::uuid() . '.' . $file->getClientOriginalExtension();
|
|
$datePath = date('Y/m/d');
|
|
$path = "category/{$datePath}/{$storedFilename}";
|
|
|
|
$this->storage->put('images', $path, file_get_contents($file->getRealPath()));
|
|
|
|
// 썸네일 생성
|
|
$thumbnail = Image::make($file)->fit(300, 300)->encode('jpg', 80);
|
|
$thumbnailPath = "category/{$datePath}/thumb_{$storedFilename}";
|
|
$this->storage->put('images', $thumbnailPath, (string) $thumbnail);
|
|
|
|
// DB 레코드 생성
|
|
$disk = $this->storage->getDisk();
|
|
|
|
return $this->repository->create([
|
|
'category_id' => $categoryId,
|
|
'path' => $path,
|
|
'thumbnail_path' => $thumbnailPath,
|
|
'disk' => $disk,
|
|
'original_filename' => $file->getClientOriginalName(),
|
|
'width' => getimagesize($file->getRealPath())[0],
|
|
'height' => getimagesize($file->getRealPath())[1],
|
|
]);
|
|
}
|
|
}
|
|
```
|
|
|
|
### 예제 2: 환경설정 파일 저장
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
|
|
class ModuleSettingsService
|
|
{
|
|
private const SETTINGS_FILENAME = 'setting.json';
|
|
|
|
/**
|
|
* 환경설정 저장
|
|
*/
|
|
public function save(string $identifier, array $settings): bool
|
|
{
|
|
// 모듈 인스턴스 가져오기
|
|
$module = $this->moduleManager->getModule($identifier);
|
|
if (!$module) {
|
|
return false;
|
|
}
|
|
|
|
$storage = $module->getStorage();
|
|
|
|
// JSON 인코딩
|
|
$content = json_encode($settings, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
|
|
|
|
// 저장
|
|
return $storage->put('settings', self::SETTINGS_FILENAME, $content);
|
|
}
|
|
|
|
/**
|
|
* 환경설정 로드
|
|
*/
|
|
public function load(string $identifier): array
|
|
{
|
|
$module = $this->moduleManager->getModule($identifier);
|
|
if (!$module) {
|
|
return [];
|
|
}
|
|
|
|
$storage = $module->getStorage();
|
|
|
|
// 파일 존재 여부 확인
|
|
if (!$storage->exists('settings', self::SETTINGS_FILENAME)) {
|
|
return [];
|
|
}
|
|
|
|
// 파일 읽기
|
|
$content = $storage->get('settings', self::SETTINGS_FILENAME);
|
|
|
|
return json_decode($content, true) ?? [];
|
|
}
|
|
}
|
|
```
|
|
|
|
### 예제 3: 임시 파일 관리
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Services;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
|
|
class TempFileService
|
|
{
|
|
public function __construct(
|
|
private StorageInterface $storage
|
|
) {}
|
|
|
|
/**
|
|
* 임시 파일 저장
|
|
*/
|
|
public function storeTempFile(string $sessionId, UploadedFile $file): string
|
|
{
|
|
$filename = Str::uuid() . '.' . $file->getClientOriginalExtension();
|
|
$path = "{$sessionId}/{$filename}";
|
|
|
|
$this->storage->put('temp', $path, file_get_contents($file->getRealPath()));
|
|
|
|
return $path;
|
|
}
|
|
|
|
/**
|
|
* 세션의 모든 임시 파일 삭제
|
|
*/
|
|
public function cleanupSession(string $sessionId): bool
|
|
{
|
|
return $this->storage->deleteDirectory('temp', $sessionId);
|
|
}
|
|
|
|
/**
|
|
* 24시간 이상 된 임시 파일 정리
|
|
*/
|
|
public function cleanupOldFiles(): int
|
|
{
|
|
$files = $this->storage->files('temp', '');
|
|
$deletedCount = 0;
|
|
$cutoffTime = now()->subDay()->timestamp;
|
|
|
|
foreach ($files as $file) {
|
|
$fullPath = $this->storage->getBasePath('temp') . '/' . $file;
|
|
if (filemtime($fullPath) < $cutoffTime) {
|
|
$this->storage->delete('temp', $file);
|
|
$deletedCount++;
|
|
}
|
|
}
|
|
|
|
return $deletedCount;
|
|
}
|
|
}
|
|
```
|
|
|
|
### 예제 4: 파일 다운로드 컨트롤러
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Http\Controllers\Api;
|
|
|
|
use App\Http\Controllers\BaseApiController;
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use Illuminate\Http\Response;
|
|
|
|
class AttachmentController extends BaseApiController
|
|
{
|
|
public function __construct(
|
|
private AttachmentService $attachmentService,
|
|
private StorageInterface $storage
|
|
) {}
|
|
|
|
/**
|
|
* 첨부파일 다운로드
|
|
*/
|
|
public function download(string $slug, int $id): Response
|
|
{
|
|
$attachment = $this->attachmentService->getById($slug, $id);
|
|
|
|
// 권한 확인 로직...
|
|
|
|
// 파일 존재 여부 확인
|
|
if (!$this->storage->exists('attachments', $attachment->path)) {
|
|
return response()->json(['message' => '파일을 찾을 수 없습니다.'], 404);
|
|
}
|
|
|
|
// 파일 내용 가져오기
|
|
$content = $this->storage->get('attachments', $attachment->path);
|
|
|
|
// 다운로드 응답
|
|
return response($content, 200)
|
|
->header('Content-Type', $attachment->mime_type)
|
|
->header('Content-Disposition', 'attachment; filename="' . $attachment->original_filename . '"');
|
|
}
|
|
}
|
|
```
|
|
|
|
### 예제 5: StreamedResponse를 사용한 이미지 다운로드
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Ecommerce\Services;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Modules\Sirsoft\Ecommerce\Models\ProductImage;
|
|
use Modules\Sirsoft\Ecommerce\Repositories\Contracts\ProductImageRepositoryInterface;
|
|
use Symfony\Component\HttpFoundation\StreamedResponse;
|
|
|
|
/**
|
|
* 상품 이미지 서비스
|
|
*/
|
|
class ProductImageService
|
|
{
|
|
public function __construct(
|
|
protected ProductImageRepositoryInterface $repository,
|
|
protected StorageInterface $storage
|
|
) {
|
|
// StorageInterface는 EcommerceServiceProvider에서 자동 주입됨
|
|
}
|
|
|
|
/**
|
|
* 해시로 이미지 조회
|
|
*/
|
|
public function findByHash(string $hash): ?ProductImage
|
|
{
|
|
return $this->repository->findByHash($hash);
|
|
}
|
|
|
|
/**
|
|
* 이미지 다운로드 응답 생성
|
|
*
|
|
* @param string $hash 이미지 해시 (12자)
|
|
* @return StreamedResponse|null 이미지 스트림 또는 없을 경우 null
|
|
*/
|
|
public function download(string $hash): ?StreamedResponse
|
|
{
|
|
$image = $this->repository->findByHash($hash);
|
|
|
|
if (! $image) {
|
|
return null;
|
|
}
|
|
|
|
// ModuleStorageDriver가 자동으로 경로를 해결함
|
|
// DB path: products/{id}/{filename}.jpg
|
|
// 실제 경로: modules/sirsoft-ecommerce/images/products/{id}/{filename}.jpg
|
|
$response = $this->storage->response(
|
|
'images',
|
|
$image->path,
|
|
$image->original_filename,
|
|
[
|
|
'Content-Type' => $image->mime_type,
|
|
'Cache-Control' => 'public, max-age=31536000',
|
|
]
|
|
);
|
|
|
|
if (! $response) {
|
|
Log::error('상품 이미지 스토리지에 없음', [
|
|
'product_image_id' => $image->id,
|
|
'path' => $image->path,
|
|
'disk' => $this->storage->getDisk(),
|
|
]);
|
|
|
|
return null;
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 마이그레이션 가이드
|
|
|
|
### 기존 코드 전환하기
|
|
|
|
#### Before (기존 패턴)
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Services;
|
|
|
|
use Illuminate\Support\Facades\Storage;
|
|
|
|
class AttachmentService
|
|
{
|
|
public function upload(string $slug, UploadedFile $file, ?int $postId = null): DynamicAttachment
|
|
{
|
|
// Config에서 disk 가져오기
|
|
$disk = config('sirsoft-board.attachment.disk', 'local');
|
|
|
|
// 경로 생성
|
|
$storedFilename = Str::uuid() . '.' . $file->getClientOriginalExtension();
|
|
$datePath = date('Y/m/d');
|
|
$path = "attachments/modules/sirsoft/board/{$slug}/{$datePath}/{$storedFilename}";
|
|
|
|
// Storage Facade 직접 호출
|
|
Storage::disk($disk)->put($path, file_get_contents($file->getRealPath()));
|
|
|
|
// DB 저장
|
|
return $this->repository->create($slug, [
|
|
'path' => $path,
|
|
'disk' => $disk,
|
|
// ...
|
|
]);
|
|
}
|
|
|
|
public function delete(string $slug, int $id): bool
|
|
{
|
|
$attachment = $this->repository->findById($slug, $id);
|
|
|
|
// Storage Facade 직접 호출
|
|
if (Storage::disk($attachment->disk)->exists($attachment->path)) {
|
|
Storage::disk($attachment->disk)->delete($attachment->path);
|
|
}
|
|
|
|
return $this->repository->delete($slug, $id);
|
|
}
|
|
}
|
|
```
|
|
|
|
#### After (StorageInterface 패턴)
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Services;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
|
|
class AttachmentService
|
|
{
|
|
/**
|
|
* StorageInterface 주입
|
|
*/
|
|
public function __construct(
|
|
private AttachmentRepositoryInterface $repository,
|
|
private StorageInterface $storage // 추가
|
|
) {}
|
|
|
|
public function upload(string $slug, UploadedFile $file, ?int $postId = null): DynamicAttachment
|
|
{
|
|
// 경로 생성 (모듈 prefix 제거)
|
|
$storedFilename = Str::uuid() . '.' . $file->getClientOriginalExtension();
|
|
$datePath = date('Y/m/d');
|
|
$path = "{$slug}/{$datePath}/{$storedFilename}"; // 변경됨
|
|
|
|
// StorageInterface 사용 (category 추가)
|
|
$this->storage->put('attachments', $path, file_get_contents($file->getRealPath()));
|
|
|
|
// Disk 정보 가져오기
|
|
$disk = $this->storage->getDisk();
|
|
|
|
// DB 저장
|
|
return $this->repository->create($slug, [
|
|
'path' => $path,
|
|
'disk' => $disk,
|
|
// ...
|
|
]);
|
|
}
|
|
|
|
public function delete(string $slug, int $id): bool
|
|
{
|
|
$attachment = $this->repository->findById($slug, $id);
|
|
|
|
// StorageInterface 사용
|
|
if ($this->storage->exists('attachments', $attachment->path)) {
|
|
$this->storage->delete('attachments', $attachment->path);
|
|
}
|
|
|
|
return $this->repository->delete($slug, $id);
|
|
}
|
|
}
|
|
```
|
|
|
|
### 전환 체크리스트
|
|
|
|
```
|
|
□ 1. ServiceProvider를 BaseModuleServiceProvider 상속으로 변경
|
|
□ 2. storageServices 배열에 Service 클래스 추가
|
|
□ 3. Service 생성자에 StorageInterface 파라미터 추가
|
|
□ 4. Storage::disk() 호출을 $this->storage-> 호출로 변경
|
|
□ 5. 경로에서 모듈 prefix 제거 (자동으로 추가됨)
|
|
□ 6. Category 파라미터 추가 (attachments, images 등)
|
|
□ 7. config()로 disk 가져오는 코드를 $this->storage->getDisk()으로 변경
|
|
□ 8. 단위 테스트 작성/수정 (StorageInterface Mock 사용)
|
|
□ 9. 테스트 실행 및 검증
|
|
```
|
|
|
|
### 주의 사항
|
|
|
|
**경로 패턴 변경**:
|
|
```php
|
|
// ❌ Before
|
|
"attachments/modules/sirsoft/board/{$slug}/{$date}/{$filename}"
|
|
|
|
// ✅ After
|
|
"{$slug}/{$date}/{$filename}"
|
|
// → 실제 저장 경로: modules/sirsoft-board/attachments/{$slug}/{$date}/{$filename}
|
|
```
|
|
|
|
**기존 파일 마이그레이션**:
|
|
|
|
기존 파일이 있는 경우 마이그레이션 스크립트를 작성해야 합니다.
|
|
|
|
```php
|
|
<?php
|
|
|
|
use Illuminate\Support\Facades\Storage;
|
|
|
|
// 기존 경로: attachments/modules/sirsoft/board/notice/2024/01/19/file.pdf
|
|
// 새 경로: modules/sirsoft-board/attachments/notice/2024/01/19/file.pdf
|
|
|
|
$oldPath = "attachments/modules/sirsoft/board/notice/2024/01/19/file.pdf";
|
|
$newPath = "modules/sirsoft-board/attachments/notice/2024/01/19/file.pdf";
|
|
|
|
if (Storage::disk('local')->exists($oldPath)) {
|
|
Storage::disk('local')->move($oldPath, $newPath);
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## API 레퍼런스
|
|
|
|
### put()
|
|
|
|
파일을 저장합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function put(string $category, string $path, mixed $content): bool
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리 (attachments, images, settings 등)
|
|
- `$path` (string): 카테고리 하위 상대 경로
|
|
- `$content` (string|resource): 파일 내용
|
|
|
|
**반환값**:
|
|
- `bool`: 저장 성공 여부
|
|
|
|
**예시**:
|
|
```php
|
|
$this->storage->put('images', 'product/2024/01/19/uuid.jpg', $imageData);
|
|
```
|
|
|
|
---
|
|
|
|
### get()
|
|
|
|
파일 내용을 가져옵니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function get(string $category, string $path): ?string
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
- `$path` (string): 카테고리 하위 상대 경로
|
|
|
|
**반환값**:
|
|
- `string|null`: 파일 내용 (파일이 없으면 null)
|
|
|
|
**예시**:
|
|
```php
|
|
$content = $this->storage->get('settings', 'setting.json');
|
|
if ($content) {
|
|
$settings = json_decode($content, true);
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### exists()
|
|
|
|
파일이 존재하는지 확인합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function exists(string $category, string $path): bool
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
- `$path` (string): 카테고리 하위 상대 경로
|
|
|
|
**반환값**:
|
|
- `bool`: 파일 존재 여부
|
|
|
|
**예시**:
|
|
```php
|
|
if ($this->storage->exists('images', 'product/2024/01/19/uuid.jpg')) {
|
|
// 파일이 존재함
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### delete()
|
|
|
|
파일을 삭제합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function delete(string $category, string $path): bool
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
- `$path` (string): 카테고리 하위 상대 경로
|
|
|
|
**반환값**:
|
|
- `bool`: 삭제 성공 여부
|
|
|
|
**예시**:
|
|
```php
|
|
$this->storage->delete('temp', 'session-123/upload.tmp');
|
|
```
|
|
|
|
---
|
|
|
|
### url()
|
|
|
|
파일의 공개 URL을 반환합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function url(string $category, string $path): ?string
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
- `$path` (string): 카테고리 하위 상대 경로
|
|
|
|
**반환값**:
|
|
- `string|null`: 파일 URL (private disk인 경우 null)
|
|
|
|
**예시**:
|
|
```php
|
|
// public disk인 경우
|
|
$url = $this->storage->url('images', 'product/2024/01/19/uuid.jpg');
|
|
// → http://example.com/storage/modules/sirsoft-ecommerce/images/product/2024/01/19/uuid.jpg
|
|
|
|
// local (private) disk인 경우
|
|
$url = $this->storage->url('attachments', 'notice/2024/01/19/file.pdf');
|
|
// → null (별도 API 엔드포인트 사용해야 함)
|
|
```
|
|
|
|
---
|
|
|
|
### files()
|
|
|
|
디렉토리 내 모든 파일 목록을 반환합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function files(string $category, string $directory = ''): array
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
- `$directory` (string): 디렉토리 경로 (빈 문자열이면 카테고리 루트)
|
|
|
|
**반환값**:
|
|
- `array`: 파일 경로 배열
|
|
|
|
**예시**:
|
|
```php
|
|
$files = $this->storage->files('temp', 'session-123');
|
|
// → ['session-123/upload1.tmp', 'session-123/upload2.tmp']
|
|
```
|
|
|
|
---
|
|
|
|
### deleteDirectory()
|
|
|
|
디렉토리와 그 하위의 모든 파일을 삭제합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function deleteDirectory(string $category, string $directory = ''): bool
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
- `$directory` (string): 디렉토리 경로 (빈 문자열이면 카테고리 루트)
|
|
|
|
**반환값**:
|
|
- `bool`: 삭제 성공 여부
|
|
|
|
**예시**:
|
|
```php
|
|
// 특정 디렉토리 삭제
|
|
$this->storage->deleteDirectory('temp', 'session-123');
|
|
|
|
// 카테고리 전체 삭제
|
|
$this->storage->deleteDirectory('temp', '');
|
|
```
|
|
|
|
---
|
|
|
|
### getBasePath()
|
|
|
|
카테고리의 전체 파일 시스템 경로를 반환합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function getBasePath(string $category): string
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
|
|
**반환값**:
|
|
- `string`: 전체 경로
|
|
|
|
**예시**:
|
|
```php
|
|
$basePath = $this->storage->getBasePath('images');
|
|
// → /path/to/g7/storage/app/modules/sirsoft-ecommerce/images
|
|
```
|
|
|
|
---
|
|
|
|
### getDisk()
|
|
|
|
사용 중인 디스크 이름을 반환합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function getDisk(): string
|
|
```
|
|
|
|
**반환값**:
|
|
- `string`: 디스크 이름 (local, public, s3 등)
|
|
|
|
**예시**:
|
|
```php
|
|
$disk = $this->storage->getDisk();
|
|
// → 'local'
|
|
```
|
|
|
|
---
|
|
|
|
### deleteAll()
|
|
|
|
카테고리의 모든 파일을 삭제합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function deleteAll(string $category): bool
|
|
```
|
|
|
|
**파라미터**:
|
|
- `$category` (string): 카테고리
|
|
|
|
**반환값**:
|
|
- `bool`: 삭제 성공 여부
|
|
|
|
**예시**:
|
|
```php
|
|
$this->storage->deleteAll('temp');
|
|
```
|
|
|
|
---
|
|
|
|
### response()
|
|
|
|
파일을 스트리밍 응답으로 반환합니다.
|
|
|
|
**시그니처**:
|
|
```php
|
|
public function response(string $category, string $path, string $filename, array $headers = []): ?\Symfony\Component\HttpFoundation\StreamedResponse
|
|
```
|
|
|
|
**파라미터**:
|
|
|
|
- `$category` (string): 카테고리
|
|
- `$path` (string): 카테고리 하위 상대 경로
|
|
- `$filename` (string): 다운로드 시 표시될 파일명
|
|
- `$headers` (array): 추가 HTTP 헤더 (Content-Type, Cache-Control 등)
|
|
|
|
**반환값**:
|
|
|
|
- `StreamedResponse|null`: 파일 스트림 (파일이 없으면 null)
|
|
|
|
**예시**:
|
|
```php
|
|
// 이미지 다운로드
|
|
$response = $this->storage->response(
|
|
'images',
|
|
'products/123/image.jpg',
|
|
'product-image.jpg',
|
|
[
|
|
'Content-Type' => 'image/jpeg',
|
|
'Cache-Control' => 'public, max-age=31536000',
|
|
]
|
|
);
|
|
|
|
if ($response) {
|
|
return $response; // StreamedResponse 반환
|
|
}
|
|
|
|
// 첨부파일 다운로드
|
|
$response = $this->storage->response(
|
|
'attachments',
|
|
'notice/2024/01/19/document.pdf',
|
|
'important-document.pdf',
|
|
[
|
|
'Content-Type' => 'application/pdf',
|
|
'Content-Disposition' => 'attachment',
|
|
]
|
|
);
|
|
```
|
|
|
|
**장점**:
|
|
|
|
- 메모리 효율적 (대용량 파일도 스트리밍)
|
|
- Content-Type, Cache-Control 등 헤더 자동 설정 가능
|
|
- Laravel의 `Storage::response()` 메서드 활용
|
|
|
|
**주의사항**:
|
|
|
|
- 파일이 존재하지 않으면 `null` 반환
|
|
- null 체크 후 404 응답 처리 필요
|
|
- 권한 체크는 컨트롤러/서비스에서 별도 구현
|
|
|
|
---
|
|
|
|
## 트러블슈팅
|
|
|
|
### 문제 1: Service에서 StorageInterface가 주입되지 않음
|
|
|
|
**증상**:
|
|
```
|
|
Target [App\Contracts\Extension\StorageInterface] is not instantiable.
|
|
```
|
|
|
|
**원인**:
|
|
- `BaseModuleServiceProvider`의 `$storageServices` 배열에 Service 클래스가 등록되지 않았습니다.
|
|
|
|
**해결**:
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Providers;
|
|
|
|
use App\Extension\BaseModuleServiceProvider;
|
|
use Modules\Sirsoft\Board\Services\AttachmentService;
|
|
|
|
class BoardServiceProvider extends BaseModuleServiceProvider
|
|
{
|
|
protected string $moduleIdentifier = 'sirsoft-board';
|
|
|
|
protected array $storageServices = [
|
|
AttachmentService::class, // 추가 필수
|
|
];
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### 문제 2: 파일 경로가 잘못됨
|
|
|
|
**증상**:
|
|
- 파일이 `storage/app/modules/sirsoft-board/attachments/modules/sirsoft-board/...` 같은 중복된 경로에 저장됩니다.
|
|
|
|
**원인**:
|
|
- 경로에 모듈 prefix를 직접 포함했습니다.
|
|
|
|
**해결**:
|
|
```php
|
|
// ❌ 잘못된 코드
|
|
$path = "modules/sirsoft-board/attachments/{$slug}/{$date}/{$filename}";
|
|
$this->storage->put('attachments', $path, $content);
|
|
|
|
// ✅ 올바른 코드
|
|
$path = "{$slug}/{$date}/{$filename}"; // 모듈 prefix 제거
|
|
$this->storage->put('attachments', $path, $content);
|
|
```
|
|
|
|
---
|
|
|
|
### 문제 3: 테스트에서 Mock이 동작하지 않음
|
|
|
|
**증상**:
|
|
- 테스트 실행 시 실제 파일 시스템에 저장됩니다.
|
|
|
|
**원인**:
|
|
- StorageInterface를 Mock하지 않았습니다.
|
|
|
|
**해결**:
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Tests\Unit;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use Mockery;
|
|
use Tests\TestCase;
|
|
|
|
class AttachmentServiceTest extends TestCase
|
|
{
|
|
private AttachmentService $service;
|
|
private $storage;
|
|
|
|
protected function setUp(): void
|
|
{
|
|
parent::setUp();
|
|
|
|
// StorageInterface Mock 생성
|
|
$this->storage = Mockery::mock(StorageInterface::class);
|
|
|
|
// Service 생성
|
|
$this->service = new AttachmentService(
|
|
$this->repository,
|
|
$this->storage // Mock 주입
|
|
);
|
|
}
|
|
|
|
public function test_upload(): void
|
|
{
|
|
// Mock 동작 정의
|
|
$this->storage
|
|
->shouldReceive('put')
|
|
->once()
|
|
->withArgs(function ($category, $path, $contents) {
|
|
return $category === 'attachments'
|
|
&& str_contains($path, 'notice/')
|
|
&& str_ends_with($path, '.pdf');
|
|
})
|
|
->andReturn(true);
|
|
|
|
$this->storage
|
|
->shouldReceive('getDisk')
|
|
->andReturn('local');
|
|
|
|
// 테스트 실행...
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### 문제 4: disk 설정이 적용되지 않음
|
|
|
|
**증상**:
|
|
- config 파일에서 disk를 변경했지만 항상 'local'을 사용합니다.
|
|
|
|
**원인**:
|
|
- `AbstractModule`에서 `getStorageDisk()` 메서드를 오버라이드하지 않았습니다.
|
|
|
|
**해결**:
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board;
|
|
|
|
use App\Extension\AbstractModule;
|
|
|
|
class BoardModule extends AbstractModule
|
|
{
|
|
/**
|
|
* 스토리지 디스크를 반환합니다.
|
|
*/
|
|
public function getStorageDisk(): string
|
|
{
|
|
return config('sirsoft-board.attachment.disk', 'local');
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### 문제 5: URL이 null을 반환함
|
|
|
|
**증상**:
|
|
- `$this->storage->url()` 호출 시 항상 null이 반환됩니다.
|
|
|
|
**원인**:
|
|
- private disk (local, s3 등)를 사용 중입니다. URL 메서드는 public disk에서만 직접 URL을 반환합니다.
|
|
|
|
**해결**:
|
|
```php
|
|
// public disk를 사용하거나
|
|
$module->getStorageDisk(); // → 'public'
|
|
|
|
// 또는 별도 API 엔드포인트를 사용
|
|
Route::get('/api/attachments/{id}/download', [AttachmentController::class, 'download']);
|
|
```
|
|
|
|
---
|
|
|
|
## FAQ
|
|
|
|
### Q1: 기존 파일은 어떻게 되나요?
|
|
|
|
**A**: 새로운 경로 패턴으로 파일을 저장하므로, 기존 파일은 **마이그레이션 스크립트**로 이동해야 합니다.
|
|
|
|
```php
|
|
// 마이그레이션 예시
|
|
$oldPath = "attachments/modules/sirsoft/board/{$slug}/{$date}/{$filename}";
|
|
$newPath = "modules/sirsoft-board/attachments/{$slug}/{$date}/{$filename}";
|
|
|
|
if (Storage::disk('local')->exists($oldPath)) {
|
|
Storage::disk('local')->move($oldPath, $newPath);
|
|
|
|
// DB 업데이트
|
|
DB::table('board_notice_attachments')->update([
|
|
'path' => "{$slug}/{$date}/{$filename}",
|
|
]);
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### Q2: S3로 전환하려면 어떻게 하나요?
|
|
|
|
**A**: 다음 3단계만 수행하면 됩니다.
|
|
|
|
1. `.env` 파일에 S3 설정 추가:
|
|
```env
|
|
AWS_ACCESS_KEY_ID=your-key
|
|
AWS_SECRET_ACCESS_KEY=your-secret
|
|
AWS_DEFAULT_REGION=ap-northeast-2
|
|
AWS_BUCKET=your-bucket
|
|
```
|
|
|
|
2. 모듈 설정 변경:
|
|
```php
|
|
// config/sirsoft-board.php
|
|
return [
|
|
'attachment' => [
|
|
'disk' => env('SIRSOFT_BOARD_ATTACHMENT_DISK', 's3'),
|
|
],
|
|
];
|
|
```
|
|
|
|
3. `AbstractModule`에서 오버라이드:
|
|
```php
|
|
public function getStorageDisk(): string
|
|
{
|
|
return config('sirsoft-board.attachment.disk', 's3');
|
|
}
|
|
```
|
|
|
|
**끝!** Service 코드는 변경할 필요가 없습니다.
|
|
|
|
---
|
|
|
|
### Q3: 여러 disk를 동시에 사용할 수 있나요?
|
|
|
|
**A**: 네, 카테고리별로 다른 disk를 사용할 수 있습니다.
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Ecommerce;
|
|
|
|
use App\Extension\AbstractModule;
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use App\Extension\Storage\ModuleStorageDriver;
|
|
|
|
class EcommerceModule extends AbstractModule
|
|
{
|
|
/**
|
|
* 카테고리별 Storage 인스턴스 캐시
|
|
*/
|
|
private array $storageCache = [];
|
|
|
|
/**
|
|
* 카테고리별로 다른 Storage를 반환합니다.
|
|
*/
|
|
public function getStorage(string $category = 'default'): StorageInterface
|
|
{
|
|
if (isset($this->storageCache[$category])) {
|
|
return $this->storageCache[$category];
|
|
}
|
|
|
|
// 카테고리별 disk 설정
|
|
$disk = match ($category) {
|
|
'images' => config('sirsoft-ecommerce.image_disk', 's3'),
|
|
'attachments' => config('sirsoft-ecommerce.attachment_disk', 'local'),
|
|
default => $this->getStorageDisk(),
|
|
};
|
|
|
|
$this->storageCache[$category] = new ModuleStorageDriver($this->getIdentifier(), $disk);
|
|
|
|
return $this->storageCache[$category];
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### Q4: 플러그인에서도 사용할 수 있나요?
|
|
|
|
**A**: 네, `PluginStorageDriver`를 사용하면 됩니다.
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Plugins\Sirsoft\Payment;
|
|
|
|
use App\Extension\AbstractPlugin;
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use App\Extension\Storage\PluginStorageDriver;
|
|
|
|
class PaymentPlugin extends AbstractPlugin
|
|
{
|
|
public function getStorage(): StorageInterface
|
|
{
|
|
return new PluginStorageDriver($this->getIdentifier(), $this->getStorageDisk());
|
|
}
|
|
|
|
public function getStorageDisk(): string
|
|
{
|
|
return config('sirsoft-payment.storage_disk', 'local');
|
|
}
|
|
}
|
|
```
|
|
|
|
경로 패턴만 다릅니다:
|
|
```
|
|
plugins/{identifier}/{category}/{path}
|
|
```
|
|
|
|
---
|
|
|
|
### Q5: 단위 테스트는 어떻게 작성하나요?
|
|
|
|
**A**: `StorageInterface`를 Mock하여 테스트합니다.
|
|
|
|
```php
|
|
<?php
|
|
|
|
namespace Modules\Sirsoft\Board\Tests\Unit;
|
|
|
|
use App\Contracts\Extension\StorageInterface;
|
|
use Mockery;
|
|
use Tests\TestCase;
|
|
|
|
class AttachmentServiceTest extends TestCase
|
|
{
|
|
use RefreshDatabase;
|
|
|
|
private AttachmentService $service;
|
|
private $repository;
|
|
private $storage;
|
|
|
|
protected function setUp(): void
|
|
{
|
|
parent::setUp();
|
|
|
|
// Mock 생성
|
|
$this->repository = Mockery::mock(AttachmentRepositoryInterface::class);
|
|
$this->storage = Mockery::mock(StorageInterface::class);
|
|
|
|
// Service 생성
|
|
$this->service = new AttachmentService($this->repository, $this->storage);
|
|
}
|
|
|
|
protected function tearDown(): void
|
|
{
|
|
Mockery::close();
|
|
parent::tearDown();
|
|
}
|
|
|
|
public function test_upload_stores_file_and_creates_record(): void
|
|
{
|
|
// Arrange
|
|
$file = UploadedFile::fake()->create('document.pdf', 100);
|
|
|
|
// Storage Mock 설정
|
|
$this->storage
|
|
->shouldReceive('put')
|
|
->once()
|
|
->withArgs(function ($category, $path, $contents) {
|
|
return $category === 'attachments'
|
|
&& str_contains($path, 'notice/')
|
|
&& str_ends_with($path, '.pdf');
|
|
})
|
|
->andReturn(true);
|
|
|
|
$this->storage
|
|
->shouldReceive('getDisk')
|
|
->andReturn('local');
|
|
|
|
// Repository Mock 설정
|
|
$expectedAttachment = new DynamicAttachment(['id' => 1]);
|
|
$this->repository->shouldReceive('create')->andReturn($expectedAttachment);
|
|
|
|
// Act
|
|
$result = $this->service->upload('notice', $file, 1);
|
|
|
|
// Assert
|
|
$this->assertEquals(1, $result->id);
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
### Q6: 성능 최적화 팁이 있나요?
|
|
|
|
**A**: 다음 패턴을 권장합니다.
|
|
|
|
1. **대용량 파일은 스트리밍 사용**:
|
|
```php
|
|
// ❌ 메모리에 모두 로드
|
|
$content = file_get_contents($file->getRealPath());
|
|
$this->storage->put('attachments', $path, $content);
|
|
|
|
// ✅ 스트리밍 사용
|
|
$resource = fopen($file->getRealPath(), 'r');
|
|
$this->storage->put('attachments', $path, $resource);
|
|
fclose($resource);
|
|
```
|
|
|
|
2. **배치 삭제**:
|
|
```php
|
|
// ❌ 파일 하나씩 삭제
|
|
foreach ($files as $file) {
|
|
$this->storage->delete('temp', $file);
|
|
}
|
|
|
|
// ✅ 디렉토리 전체 삭제
|
|
$this->storage->deleteDirectory('temp', $sessionId);
|
|
```
|
|
|
|
3. **URL 캐싱**:
|
|
```php
|
|
// ✅ URL을 DB에 캐시
|
|
$url = $this->storage->url('images', $image->path);
|
|
$image->update(['cached_url' => $url]);
|
|
```
|
|
|
|
---
|
|
|
|
## 관련 문서
|
|
|
|
- [모듈 개발 가이드](module-basics.md)
|
|
- [플러그인 개발 가이드](plugin-development.md)
|
|
- [Service-Repository 패턴](../backend/service-repository.md)
|
|
- [테스트 작성 가이드](../testing-guide.md)
|
|
|
|
---
|
|
|
|
**작성일**: 2024-01-19
|
|
**최종 수정**: 2024-01-19
|
|
**버전**: 1.0.0
|