@objectql/server 1.8.0 → 1.8.2

package/test/file-upload-integration.example.ts

@@ -0,0 +1,201 @@
+/**
+ * Integration Test Example for File Upload/Download
+ * 
+ * This example demonstrates how to use the file upload/download API
+ * with a complete ObjectQL server setup.
+ */
+
+import { ObjectQL } from '@objectql/core';
+import { SqlDriver } from '@objectql/driver-sql';
+import { createNodeHandler, MemoryFileStorage } from '../src';
+import * as http from 'http';
+
+async function setupServer() {
+    // 1. Initialize Driver (In-Memory SQLite)
+    const driver = new SqlDriver({
+        client: 'sqlite3',
+        connection: { filename: ':memory:' },
+        useNullAsDefault: true
+    });
+
+    // 2. Initialize Engine
+    const app = new ObjectQL({
+        datasources: { default: driver }
+    });
+
+    // 3. Define Schema with File Attachment
+    app.registerObject({
+        name: 'expense',
+        label: 'Expense',
+        fields: {
+            expense_number: {
+                type: 'text',
+                required: true,
+                label: 'Expense Number'
+            },
+            amount: {
+                type: 'number',
+                required: true,
+                label: 'Amount'
+            },
+            description: {
+                type: 'textarea',
+                label: 'Description'
+            },
+            receipt: {
+                type: 'file',
+                label: 'Receipt',
+                accept: ['.pdf', '.jpg', '.jpeg', '.png'],
+                max_size: 5242880 // 5MB
+            }
+        }
+    });
+
+    await app.init();
+
+    // 4. Create HTTP Server with File Storage
+    const fileStorage = new MemoryFileStorage({
+        baseUrl: 'http://localhost:3000/api/files'
+    });
+
+    const handler = createNodeHandler(app, { fileStorage });
+    const server = http.createServer(handler);
+
+    return { server, app, fileStorage };
+}
+
+async function demonstrateUsage() {
+    console.log('=== ObjectQL File Upload/Download Integration Example ===\n');
+
+    const { server, app, fileStorage } = await setupServer();
+
+    // Start server
+    await new Promise<void>((resolve) => {
+        server.listen(3000, () => {
+            console.log('✓ Server started on http://localhost:3000');
+            resolve();
+        });
+    });
+
+    try {
+        // Example 1: Upload a file
+        console.log('\n1. Uploading a file...');
+        const fileContent = Buffer.from('Sample receipt content');
+        const uploadedFile = await fileStorage.save(
+            fileContent,
+            'receipt.pdf',
+            'application/pdf',
+            { userId: 'user_123' }
+        );
+        console.log('✓ File uploaded:', uploadedFile);
+
+        // Example 2: Create an expense with the uploaded file
+        console.log('\n2. Creating expense record with attachment...');
+        const ctx = app.createContext({ isSystem: true });
+        const expenseRepo = ctx.object('expense');
+        
+        const expense = await expenseRepo.create({
+            expense_number: 'EXP-2024-001',
+            amount: 125.50,
+            description: 'Office supplies',
+            receipt: uploadedFile
+        });
+        console.log('✓ Expense created:', {
+            id: expense.id,
+            expense_number: expense.expense_number,
+            receipt: expense.receipt
+        });
+
+        // Example 3: Retrieve the file
+        console.log('\n3. Downloading the file...');
+        const downloadedFile = await fileStorage.get(uploadedFile.id!);
+        console.log('✓ File downloaded:', {
+            size: downloadedFile?.length,
+            content: downloadedFile?.toString().substring(0, 50) + '...'
+        });
+
+        // Example 4: Query expenses with attachments
+        console.log('\n4. Querying expenses with attachments...');
+        const expenses = await expenseRepo.find({
+            filters: [['receipt', '!=', null]]
+        });
+        console.log('✓ Found expenses with receipts:', expenses.length);
+        expenses.forEach((exp: any) => {
+            console.log(`  - ${exp.expense_number}: ${exp.receipt?.name}`);
+        });
+
+        // Example 5: Update attachment
+        console.log('\n5. Uploading and updating receipt...');
+        const newFileContent = Buffer.from('Updated receipt content');
+        const newFile = await fileStorage.save(
+            newFileContent,
+            'updated_receipt.pdf',
+            'application/pdf',
+            { userId: 'user_123' }
+        );
+        
+        await expenseRepo.update(expense.id, {
+            receipt: newFile
+        });
+        console.log('✓ Receipt updated');
+
+        // Example 6: Multiple file upload (product gallery)
+        console.log('\n6. Multiple file upload example...');
+        app.registerObject({
+            name: 'product',
+            label: 'Product',
+            fields: {
+                name: { type: 'text', required: true },
+                price: { type: 'number' },
+                gallery: {
+                    type: 'image',
+                    label: 'Product Gallery',
+                    multiple: true,
+                    accept: ['.jpg', '.jpeg', '.png'],
+                    max_size: 2097152 // 2MB per image
+                }
+            }
+        });
+
+        const productRepo = ctx.object('product');
+        
+        // Upload multiple images
+        const images = await Promise.all([
+            fileStorage.save(
+                Buffer.from('Image 1 content'),
+                'product_1.jpg',
+                'image/jpeg',
+                { userId: 'user_123' }
+            ),
+            fileStorage.save(
+                Buffer.from('Image 2 content'),
+                'product_2.jpg',
+                'image/jpeg',
+                { userId: 'user_123' }
+            )
+        ]);
+
+        const product = await productRepo.create({
+            name: 'Premium Laptop',
+            price: 1299.99,
+            gallery: images
+        });
+        console.log('✓ Product created with gallery:', {
+            id: product.id,
+            name: product.name,
+            images: product.gallery.length
+        });
+
+    } finally {
+        // Cleanup
+        server.close();
+        console.log('\n✓ Server stopped');
+    }
+}
+
+// Run the example
+if (require.main === module) {
+    demonstrateUsage().catch(console.error);
+}
+
+export { setupServer, demonstrateUsage };

package/test/file-validation.test.ts

@@ -0,0 +1,131 @@
+import { validateFile } from '../src/file-handler';
+import { FieldConfig } from '@objectql/types';
+
+describe('File Validation', () => {
+    describe('validateFile', () => {
+        it('should pass validation when no field config is provided', () => {
+            const file = {
+                filename: 'test.pdf',
+                mimeType: 'application/pdf',
+                buffer: Buffer.from('test content')
+            };
+
+            const result = validateFile(file);
+
+            expect(result.valid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+
+        it('should validate file size limits', () => {
+            const file = {
+                filename: 'test.pdf',
+                mimeType: 'application/pdf',
+                buffer: Buffer.from('a'.repeat(1000)) // 1000 bytes
+            };
+
+            const fieldConfig: FieldConfig = {
+                type: 'file',
+                max_size: 500 // 500 bytes max
+            };
+
+            const result = validateFile(file, fieldConfig);
+
+            expect(result.valid).toBe(false);
+            expect(result.error?.code).toBe('FILE_TOO_LARGE');
+            expect(result.error?.message).toContain('exceeds maximum');
+        });
+
+        it('should validate minimum file size', () => {
+            const file = {
+                filename: 'test.pdf',
+                mimeType: 'application/pdf',
+                buffer: Buffer.from('small')
+            };
+
+            const fieldConfig: FieldConfig = {
+                type: 'file',
+                min_size: 100 // 100 bytes minimum
+            };
+
+            const result = validateFile(file, fieldConfig);
+
+            expect(result.valid).toBe(false);
+            expect(result.error?.code).toBe('FILE_TOO_SMALL');
+            expect(result.error?.message).toContain('below minimum');
+        });
+
+        it('should validate accepted file extensions', () => {
+            const file = {
+                filename: 'test.exe',
+                mimeType: 'application/x-msdownload',
+                buffer: Buffer.from('test content')
+            };
+
+            const fieldConfig: FieldConfig = {
+                type: 'file',
+                accept: ['.pdf', '.jpg', '.png']
+            };
+
+            const result = validateFile(file, fieldConfig);
+
+            expect(result.valid).toBe(false);
+            expect(result.error?.code).toBe('FILE_TYPE_NOT_ALLOWED');
+            expect(result.error?.message).toContain('not allowed');
+        });
+
+        it('should accept file when extension is in allowed list', () => {
+            const file = {
+                filename: 'document.pdf',
+                mimeType: 'application/pdf',
+                buffer: Buffer.from('test content')
+            };
+
+            const fieldConfig: FieldConfig = {
+                type: 'file',
+                accept: ['.pdf', '.docx']
+            };
+
+            const result = validateFile(file, fieldConfig);
+
+            expect(result.valid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+
+        it('should handle case-insensitive extension matching', () => {
+            const file = {
+                filename: 'document.PDF',
+                mimeType: 'application/pdf',
+                buffer: Buffer.from('test content')
+            };
+
+            const fieldConfig: FieldConfig = {
+                type: 'file',
+                accept: ['.pdf']
+            };
+
+            const result = validateFile(file, fieldConfig);
+
+            expect(result.valid).toBe(true);
+        });
+
+        it('should pass all validations for valid file', () => {
+            const file = {
+                filename: 'receipt.jpg',
+                mimeType: 'image/jpeg',
+                buffer: Buffer.from('a'.repeat(500))
+            };
+
+            const fieldConfig: FieldConfig = {
+                type: 'image',
+                accept: ['.jpg', '.jpeg', '.png'],
+                max_size: 1000,
+                min_size: 100
+            };
+
+            const result = validateFile(file, fieldConfig);
+
+            expect(result.valid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+    });
+});

package/test/storage.test.ts

@@ -0,0 +1,104 @@
+import { MemoryFileStorage } from '../src/storage';
+import { AttachmentData } from '../src/types';
+
+describe('MemoryFileStorage', () => {
+    let storage: MemoryFileStorage;
+
+    beforeEach(() => {
+        storage = new MemoryFileStorage({
+            baseUrl: 'http://localhost:3000/api/files'
+        });
+    });
+
+    afterEach(() => {
+        storage.clear();
+    });
+
+    describe('save', () => {
+        it('should save a file and return attachment metadata', async () => {
+            const fileBuffer = Buffer.from('test file content');
+            const filename = 'test.txt';
+            const mimeType = 'text/plain';
+
+            const result = await storage.save(fileBuffer, filename, mimeType);
+
+            expect(result).toHaveProperty('id');
+            expect(result).toHaveProperty('name');
+            expect(result.url).toContain('http://localhost:3000/api/files');
+            expect(result.size).toBe(fileBuffer.length);
+            expect(result.type).toBe(mimeType);
+            expect(result.original_name).toBe(filename);
+            expect(result).toHaveProperty('uploaded_at');
+        });
+
+        it('should include user ID when provided', async () => {
+            const fileBuffer = Buffer.from('test file content');
+            const filename = 'test.txt';
+            const mimeType = 'text/plain';
+            const userId = 'user_123';
+
+            const result = await storage.save(fileBuffer, filename, mimeType, { userId });
+
+            expect(result.uploaded_by).toBe(userId);
+        });
+
+        it('should preserve file extension in stored filename', async () => {
+            const fileBuffer = Buffer.from('test file content');
+            const filename = 'document.pdf';
+            const mimeType = 'application/pdf';
+
+            const result = await storage.save(fileBuffer, filename, mimeType);
+
+            expect(result.name).toMatch(/\.pdf$/);
+        });
+    });
+
+    describe('get', () => {
+        it('should retrieve a saved file', async () => {
+            const fileBuffer = Buffer.from('test file content');
+            const filename = 'test.txt';
+            const mimeType = 'text/plain';
+
+            const attachment = await storage.save(fileBuffer, filename, mimeType);
+            const retrieved = await storage.get(attachment.id!);
+
+            expect(retrieved).not.toBeNull();
+            expect(retrieved!.toString()).toBe(fileBuffer.toString());
+        });
+
+        it('should return null for non-existent file', async () => {
+            const result = await storage.get('non_existent_id');
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('delete', () => {
+        it('should delete a file', async () => {
+            const fileBuffer = Buffer.from('test file content');
+            const filename = 'test.txt';
+            const mimeType = 'text/plain';
+
+            const attachment = await storage.save(fileBuffer, filename, mimeType);
+            const deleted = await storage.delete(attachment.id!);
+
+            expect(deleted).toBe(true);
+
+            const retrieved = await storage.get(attachment.id!);
+            expect(retrieved).toBeNull();
+        });
+
+        it('should return false when deleting non-existent file', async () => {
+            const result = await storage.delete('non_existent_id');
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('getPublicUrl', () => {
+        it('should generate a public URL', () => {
+            const filePath = 'uploads/test.txt';
+            const url = storage.getPublicUrl(filePath);
+
+            expect(url).toBe('http://localhost:3000/api/files/uploads/test.txt');
+        });
+    });
+});