@aphexcms/cms-core 0.1.1 → 0.1.4

package/src/schema-utils/utils.ts

@@ -1,47 +0,0 @@
-import type { SchemaType } from '../types/schemas.js';
-
-/**
- * Schema utility functions that work with a schema registry
- * These functions accept schemas as parameters to avoid package-level dependencies
- */
-
-/**
- * Get a schema type by name from a collection of schemas
- */
-export function getSchemaByName(schemas: SchemaType[], name: string): SchemaType | null {
-	return schemas.find((schema) => schema.name === name) || null;
-}
-
-/**
- * Get all available object types (for array field dropdowns)
- */
-export function getObjectTypes(schemas: SchemaType[]): SchemaType[] {
-	return schemas.filter((schema) => schema.type === 'object');
-}
-
-/**
- * Get all available document types
- */
-export function getDocumentTypes(schemas: SchemaType[]): SchemaType[] {
-	return schemas.filter((schema) => schema.type === 'document');
-}
-
-/**
- * Check if a schema type exists
- */
-export function schemaExists(schemas: SchemaType[], name: string): boolean {
-	return schemas.some((schema) => schema.name === name);
-}
-
-/**
- * Get the available types for an array field
- */
-export function getArrayTypes(
-	schemas: SchemaType[],
-	arrayField: { of?: Array<{ type: string }> }
-): SchemaType[] {
-	if (!arrayField.of) return [];
-
-	const typeNames = arrayField.of.map((item) => item.type);
-	return schemas.filter((schema) => typeNames.includes(schema.name));
-}

package/src/schema-utils/validator.ts

@@ -1,58 +0,0 @@
-import type { SchemaType, Field } from '../types/schemas.js';
-
-/**
- * Validate all schema references to ensure they exist
- */
-export function validateSchemaReferences(schemas: SchemaType[]): void {
-	const schemaNames = new Set(schemas.map((schema) => schema.name));
-	const errors: string[] = [];
-
-	function validateField(field: Field, parentSchema: string): void {
-		// Check array field references
-		if (field.type === 'array' && field.of) {
-			for (const arrayType of field.of) {
-				if (!schemaNames.has(arrayType.type)) {
-					errors.push(
-						`Schema "${parentSchema}" field "${field.name}" references unknown type "${arrayType.type}"`
-					);
-				}
-			}
-		}
-
-		// Check object field references (if they reference external types)
-		if (field.type === 'object' && typeof field.fields === 'string') {
-			if (!schemaNames.has(field.fields)) {
-				errors.push(
-					`Schema "${parentSchema}" field "${field.name}" references unknown object type "${field.fields}"`
-				);
-			}
-		}
-
-		// Recursively check nested fields -- cast type later or something. cba
-		if ('fields' in field && Array.isArray(field.fields)) {
-			for (const nestedField of field.fields) {
-				validateField(nestedField, parentSchema);
-			}
-		}
-	}
-
-	// Validate each schema
-	for (const schema of schemas) {
-		if (schema.fields) {
-			for (const field of schema.fields) {
-				validateField(field, schema.name);
-			}
-		}
-	}
-
-	// Throw error if any validation issues found
-	if (errors.length > 0) {
-		console.error('\nSchema Validation Errors:');
-		errors.forEach((error) => console.error(error));
-
-		// Just throw the errors directly
-		throw new Error(errors.join('\n'));
-	}
-
-	console.log('✅ Schema validation passed - all references are valid');
-}

package/src/services/asset-service.ts

@@ -1,256 +0,0 @@
-// Asset service - orchestrates storage and database operations
-import sharp from 'sharp';
-import type { StorageAdapter } from '../storage/interfaces/storage.js';
-import type { DatabaseAdapter } from '../db/interfaces/index.js';
-import type { Asset } from '../types/index.js';
-
-export interface AssetUploadData {
-	buffer: Buffer;
-	originalFilename: string;
-	mimeType: string;
-	size: number;
-	title?: string;
-	description?: string;
-	alt?: string;
-	creditLine?: string;
-	createdBy?: string; // User ID who uploaded this asset
-	metadata?: {
-		schemaType?: string; // e.g., 'newsletterLanding'
-		fieldPath?: string; // e.g., 'logo' or 'seo.metaImage'
-		[key: string]: any; // Allow additional metadata
-	};
-}
-
-export interface AssetFilters {
-	assetType?: 'image' | 'file';
-	mimeType?: string;
-	search?: string;
-	limit?: number;
-	offset?: number;
-}
-
-/**
- * Asset service - coordinates storage and database operations
- * Maintains separation of concerns while providing unified asset management
- */
-export class AssetService {
-	constructor(
-		private storage: StorageAdapter,
-		private database: DatabaseAdapter
-	) {}
-
-	/**
-	 * Upload and store an asset
-	 */
-	async uploadAsset(organizationId: string, data: AssetUploadData): Promise<Asset> {
-		// Determine asset type
-		const assetType = data.mimeType.startsWith('image/') ? 'image' : 'file';
-
-		// Extract image metadata if it's an image
-		let width: number | undefined;
-		let height: number | undefined;
-		let metadata: any = {
-			// Include field metadata for privacy checking
-			...data.metadata
-		};
-
-		if (assetType === 'image') {
-			try {
-				const imageMetadata = await sharp(data.buffer).metadata();
-				width = imageMetadata.width;
-				height = imageMetadata.height;
-
-				// Merge image metadata with field metadata
-				metadata = {
-					...metadata, // Keep schemaType and fieldPath
-					format: imageMetadata.format,
-					space: imageMetadata.space,
-					channels: imageMetadata.channels,
-					density: imageMetadata.density,
-					hasProfile: imageMetadata.hasProfile,
-					hasAlpha: imageMetadata.hasAlpha
-				};
-
-				// Add dominant color
-				const stats = await sharp(data.buffer).stats();
-				metadata.dominantColor = stats.dominant;
-			} catch (error) {
-				console.warn('Could not extract image metadata:', error);
-			}
-		}
-
-		// 1. Store file using storage adapter
-		const storageFile = await this.storage.store({
-			buffer: data.buffer,
-			filename: data.originalFilename,
-			mimeType: data.mimeType,
-			size: data.size
-		});
-
-		// 2. Save asset metadata using database adapter
-		try {
-			const asset = await this.database.createAsset({
-				assetType,
-				filename: storageFile.path.split('/').pop() || data.originalFilename,
-				originalFilename: data.originalFilename,
-				mimeType: data.mimeType,
-				size: data.size,
-				url: storageFile.url || '', // Empty for local storage initially
-				path: storageFile.path,
-				storageAdapter: this.storage.name,
-				organizationId,
-				width,
-				height,
-				metadata,
-				title: data.title || undefined,
-				description: data.description || undefined,
-				alt: data.alt || undefined,
-				creditLine: data.creditLine || undefined,
-				createdBy: data.createdBy
-			});
-
-			// If using local storage, generate and store the CDN URL with the real asset ID
-			if (!storageFile.url) {
-				const cdnUrl = `/media/${asset.id}/${encodeURIComponent(asset.originalFilename)}`;
-
-				// Update both the object and the database
-				asset.url = cdnUrl;
-				await this.database.updateAsset(organizationId, asset.id, { url: cdnUrl });
-			}
-
-			return asset;
-		} catch (error) {
-			// If database save fails, clean up the stored file
-			await this.storage.delete(storageFile.path);
-			throw error;
-		}
-	}
-
-	/**
-	 * Find asset by ID
-	 */
-	async findAssetById(organizationId: string, id: string): Promise<Asset | null> {
-		return await this.database.findAssetById(organizationId, id);
-	}
-
-	/**
-	 * Find asset by ID globally (bypasses organization filter for public asset access)
-	 * Only available on PostgreSQL adapter with RLS bypass
-	 */
-	async findAssetByIdGlobal(id: string): Promise<Asset | null> {
-		// Check if the adapter has the global method
-		if (
-			'findAssetByIdGlobal' in this.database &&
-			typeof this.database.findAssetByIdGlobal === 'function'
-		) {
-			console.log('[AssetService] Using findAssetByIdGlobal from adapter');
-			return await this.database.findAssetByIdGlobal(id);
-		}
-		// Fallback: not supported
-		console.warn('[AssetService] findAssetByIdGlobal not supported by this database adapter');
-		console.warn('[AssetService] Database adapter type:', this.database.constructor.name);
-		console.warn(
-			'[AssetService] Available methods:',
-			Object.getOwnPropertyNames(Object.getPrototypeOf(this.database))
-		);
-		return null;
-	}
-
-	/**
-	 * Find multiple assets with filtering
-	 */
-	async findAssets(organizationId: string, filters: AssetFilters = {}): Promise<Asset[]> {
-		return await this.database.findAssets(organizationId, filters);
-	}
-
-	/**
-	 * Delete asset (both file and database record)
-	 *
-	 * Note: If the asset was stored by a different adapter (e.g., switching from R2 to local),
-	 * file deletion may fail. The database record will still be removed for a clean state.
-	 */
-	async deleteAsset(organizationId: string, id: string): Promise<boolean> {
-		const asset = await this.database.findAssetById(organizationId, id);
-		if (!asset) {
-			return false;
-		}
-
-		// Try to delete file from storage
-		// If the asset was stored by a different adapter, this may fail
-		if (asset.storageAdapter === this.storage.name) {
-			// Same adapter - delete should work
-			try {
-				await this.storage.delete(asset.path);
-			} catch (error) {
-				console.warn(`Failed to delete file from storage: ${asset.path}`, error);
-			}
-		} else {
-			// Different adapter - log warning but continue with database cleanup
-			console.warn(
-				`Asset ${id} was stored by '${asset.storageAdapter}' but current adapter is '${this.storage.name}'. ` +
-					`File at ${asset.path} may need manual cleanup.`
-			);
-		}
-
-		// Always delete database record for clean state
-		return await this.database.deleteAsset(organizationId, id);
-	}
-
-	/**
-	 * Update asset metadata
-	 */
-	async updateAssetMetadata(
-		organizationId: string,
-		id: string,
-		metadata: {
-			title?: string;
-			description?: string;
-			alt?: string;
-			creditLine?: string;
-			updatedBy?: string; // User ID who updated this asset
-		}
-	): Promise<Asset | null> {
-		return await this.database.updateAsset(organizationId, id, metadata);
-	}
-
-	/**
-	 * Get asset statistics
-	 */
-	async getAssetStats(organizationId: string): Promise<{
-		totalAssets: number;
-		totalImages: number;
-		totalFiles: number;
-		totalSize: number;
-	}> {
-		const [totalAssets, assetsByType, totalSize] = await Promise.all([
-			this.database.countAssets(organizationId),
-			this.database.countAssetsByType(organizationId),
-			this.database.getTotalAssetsSize(organizationId)
-		]);
-
-		return {
-			totalAssets,
-			totalImages: assetsByType.image || 0,
-			totalFiles: assetsByType.file || 0,
-			totalSize
-		};
-	}
-
-	/**
-	 * Get health status of both storage and database
-	 */
-	async getHealthStatus(): Promise<{
-		storage: boolean;
-		database: boolean;
-	}> {
-		const [storageHealthy, databaseHealthy] = await Promise.all([
-			this.storage.isHealthy(),
-			this.database.isHealthy()
-		]);
-
-		return {
-			storage: storageHealthy,
-			database: databaseHealthy
-		};
-	}
-}

package/src/storage/adapters/local-storage-adapter.ts

@@ -1,215 +0,0 @@
-// Pure local file system storage adapter - no database operations
-import { writeFile, mkdir, unlink, stat, readdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import type {
-	StorageAdapter,
-	StorageConfig,
-	UploadFileData,
-	StorageFile
-} from '../interfaces/storage.js';
-
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-const DEFAULT_ALLOWED_TYPES = [
-	'image/jpeg',
-	'image/png',
-	'image/webp',
-	'image/gif',
-	'image/avif',
-	'application/pdf',
-	'text/plain'
-];
-
-/**
- * Pure local file system storage adapter - only handles files
- */
-export class LocalStorageAdapter implements StorageAdapter {
-	readonly name = 'local';
-	private config: Required<StorageConfig>;
-
-	constructor(config: StorageConfig) {
-		this.config = {
-			basePath: config.basePath,
-			baseUrl: config.baseUrl || '',
-			maxFileSize: config.maxFileSize || DEFAULT_MAX_FILE_SIZE,
-			allowedTypes: config.allowedTypes || DEFAULT_ALLOWED_TYPES,
-			options: config.options || {}
-		};
-	}
-
-	/**
-	 * Generate unique filename preserving original name
-	 */
-	private async generateUniqueFilename(originalFilename: string): Promise<string> {
-		const { name, ext } = this.parseFilename(originalFilename);
-		let filename = originalFilename;
-		let counter = 1;
-
-		// Check if file exists on disk
-		while (await this.fileExistsOnDisk(filename)) {
-			filename = `${name} (${counter})${ext}`;
-			counter++;
-		}
-
-		return filename;
-	}
-
-	/**
-	 * Parse filename into name and extension
-	 */
-	private parseFilename(filename: string): { name: string; ext: string } {
-		const lastDotIndex = filename.lastIndexOf('.');
-		if (lastDotIndex === -1) {
-			return { name: filename, ext: '' };
-		}
-		return {
-			name: filename.substring(0, lastDotIndex),
-			ext: filename.substring(lastDotIndex)
-		};
-	}
-
-	/**
-	 * Check if file exists on disk
-	 */
-	private async fileExistsOnDisk(filename: string): Promise<boolean> {
-		try {
-			const filePath = join(this.config.basePath, filename);
-			await stat(filePath);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-
-	/**
-	 * Store a file and return storage info
-	 */
-	async store(data: UploadFileData): Promise<StorageFile> {
-		// Validate file type
-		if (!this.config.allowedTypes.includes(data.mimeType)) {
-			throw new Error(
-				`Invalid file type: ${data.mimeType}. Allowed types: ${this.config.allowedTypes.join(', ')}`
-			);
-		}
-
-		// Validate file size
-		if (data.size > this.config.maxFileSize) {
-			throw new Error(
-				`File too large: ${data.size} bytes. Maximum size: ${this.config.maxFileSize} bytes`
-			);
-		}
-
-		// Generate unique filename
-		const filename = await this.generateUniqueFilename(data.filename);
-		const filePath = join(this.config.basePath, filename);
-
-		// Store internal path only - URL will be generated by API with asset ID
-		// This forces all access through /assets/{id} for proper authorization
-		const url = ''; // Will be populated as /assets/{assetId}/{filename} by the API
-
-		console.log('[LocalStorageAdapter] Storing file:', {
-			filename,
-			filePath,
-			note: 'URL will be generated as /assets/{assetId}/{filename}',
-			basePath: this.config.basePath
-		});
-
-		// Ensure storage directory exists
-		await mkdir(dirname(filePath), { recursive: true });
-
-		// Save file to disk
-		await writeFile(filePath, data.buffer);
-
-		return {
-			path: filePath,
-			url, // Empty - API will generate clean URL with asset ID
-			size: data.size
-		};
-	}
-
-	/**
-	 * Read a file from storage
-	 * Used by API endpoint to serve files
-	 */
-	async getObject(path: string): Promise<Buffer> {
-		const { readFile } = await import('fs/promises');
-		return await readFile(path);
-	}
-
-	/**
-	 * Delete a file from storage
-	 */
-	async delete(path: string): Promise<boolean> {
-		try {
-			await unlink(path);
-			return true;
-		} catch (error) {
-			console.warn('Could not delete file from disk:', error);
-			return false;
-		}
-	}
-
-	/**
-	 * Check if file exists
-	 */
-	async exists(path: string): Promise<boolean> {
-		try {
-			await stat(path);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-
-	/**
-	 * Get public URL for a file path
-	 */
-	getUrl(path: string): string {
-		// Extract filename from path and construct URL
-		const filename = path.split('/').pop() || '';
-		return `${this.config.baseUrl}/${encodeURIComponent(filename)}`;
-	}
-
-	/**
-	 * Get storage information
-	 */
-	async getStorageInfo(): Promise<{ totalSize: number; availableSpace?: number }> {
-		try {
-			// Calculate total size of files in storage directory
-			const files = await readdir(this.config.basePath);
-			let totalSize = 0;
-
-			for (const file of files) {
-				try {
-					const filePath = join(this.config.basePath, file);
-					const stats = await stat(filePath);
-					if (stats.isFile()) {
-						totalSize += stats.size;
-					}
-				} catch {
-					// Skip files that can't be read
-				}
-			}
-
-			return { totalSize };
-		} catch (error) {
-			console.error('Error getting storage info:', error);
-			return { totalSize: 0 };
-		}
-	}
-
-	/**
-	 * Health check - test if we can write to storage
-	 */
-	async isHealthy(): Promise<boolean> {
-		try {
-			const testFile = join(this.config.basePath, `health-check-${Date.now()}.tmp`);
-			await mkdir(dirname(testFile), { recursive: true });
-			await writeFile(testFile, 'health check');
-			await unlink(testFile);
-			return true;
-		} catch (error) {
-			console.error('Storage health check failed:', error);
-			return false;
-		}
-	}
-}

package/src/storage/interfaces/storage.ts

@@ -1,114 +0,0 @@
-// Pure storage interface for file operations only
-export interface StorageFile {
-	path: string;
-	url: string;
-	size: number;
-}
-
-export interface UploadFileData {
-	buffer: Buffer;
-	filename: string;
-	mimeType: string;
-	size: number;
-}
-
-export interface StorageConfig {
-	basePath: string;
-	baseUrl?: string;
-	maxFileSize?: number;
-	allowedTypes?: string[];
-	options?: {
-		[key: string]: any;
-	};
-}
-
-export interface StorageObjectMetadata {
-	key: string;
-	size: number;
-	lastModified: Date;
-	contentType?: string;
-	etag?: string;
-}
-
-export interface ListObjectsOptions {
-	prefix?: string;
-	maxKeys?: number;
-	continuationToken?: string;
-}
-
-export interface ListObjectsResult {
-	objects: StorageObjectMetadata[];
-	isTruncated: boolean;
-	continuationToken?: string;
-}
-
-/**
- * Pure storage interface - only handles file operations
- * No database operations - completely agnostic
- */
-export interface StorageAdapter {
-	// Adapter identifier (used to track which adapter stored each file)
-	readonly name: string;
-
-	// Core file operations (required)
-	store(data: UploadFileData): Promise<StorageFile>;
-	delete(path: string): Promise<boolean>;
-	exists(path: string): Promise<boolean>;
-	getUrl(path: string): string;
-
-	// Storage info
-	getStorageInfo(): Promise<{
-		totalSize: number;
-		availableSpace?: number;
-	}>;
-
-	// Health check
-	isHealthy(): Promise<boolean>;
-
-	// Connection management (optional)
-	connect?(): Promise<void>;
-	disconnect?(): Promise<void>;
-
-	// Extended file operations (optional - for advanced storage features)
-
-	/**
-	 * Retrieve file contents as Buffer
-	 * Useful for: image processing, transformations, backups, migrations
-	 */
-	getObject?(path: string): Promise<Buffer>;
-
-	/**
-	 * List objects in storage with optional filtering
-	 * Useful for: admin UI file browser, asset management, cleanup operations
-	 */
-	listObjects?(options?: ListObjectsOptions): Promise<ListObjectsResult>;
-
-	/**
-	 * Copy/duplicate an object within storage
-	 * Useful for: versioning, backups, image variant generation
-	 */
-	copyObject?(sourcePath: string, destPath: string): Promise<boolean>;
-
-	/**
-	 * Get object metadata without downloading the file
-	 * Useful for: verifying file integrity, checking size/type
-	 */
-	getObjectMetadata?(path: string): Promise<StorageObjectMetadata>;
-
-	/**
-	 * Generate a signed URL for temporary access to a file
-	 * Useful for: access control, private files, secure downloads
-	 * @param path - File path
-	 * @param expiresIn - Expiration time in seconds (default: 3600)
-	 * @returns Signed URL that expires after the specified time
-	 */
-	getSignedUrl?(path: string, expiresIn?: number): Promise<string>;
-}
-
-/**
- * Storage provider factory interface
- */
-export interface StorageProvider {
-	name: string;
-	createAdapter(config: StorageConfig): StorageAdapter;
-}