@aphexcms/cms-core 0.1.6 → 0.1.8

package/src/lib/schema-utils/cleanup.ts

@@ -0,0 +1,116 @@
+import type { SchemaType, Field, ArrayField } from '../types/schemas';
+
+export interface OrphanedField {
+	path: string;
+	key: string;
+	value: any;
+	level: 'document' | 'nested';
+}
+
+export interface SchemaCleanupResult {
+	hasOrphanedFields: boolean;
+	orphanedFields: OrphanedField[];
+	cleanedData: Record<string, any>;
+}
+
+/**
+ * Find orphaned fields in document data that no longer exist in the schema
+ */
+export function findOrphanedFields(
+	documentData: Record<string, any>,
+	schema: SchemaType
+): SchemaCleanupResult {
+	const orphanedFields: OrphanedField[] = [];
+
+	function checkObject(
+		obj: Record<string, any>,
+		fields: Field[],
+		pathPrefix = ''
+	): Record<string, any> {
+		const cleaned: Record<string, any> = {};
+		const fieldMap = new Map(fields.map((field) => [field.name, field]));
+
+		for (const [key, value] of Object.entries(obj)) {
+			const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+			const field = fieldMap.get(key);
+
+			if (!field) {
+				// Orphaned field found
+				orphanedFields.push({
+					path: currentPath,
+					key,
+					value,
+					level: pathPrefix ? 'nested' : 'document'
+				});
+				continue; // Skip this field in cleaned data
+			}
+
+			// Recursively check nested objects and arrays
+			if (field.type === 'object' && field.fields && value && typeof value === 'object') {
+				cleaned[key] = checkObject(value, field.fields, currentPath);
+			} else if (field.type === 'array' && Array.isArray(value)) {
+				cleaned[key] = checkArray(value, field, currentPath);
+			} else {
+				cleaned[key] = value;
+			}
+		}
+
+		return cleaned;
+	}
+
+	function checkArray(array: any[], arrayField: Field, pathPrefix: string): any[] {
+		if (arrayField.type !== 'array' || !arrayField.of) {
+			return array;
+		}
+
+		return array.map((item, index) => {
+			const itemPath = `${pathPrefix}[${index}]`;
+
+			if (item && typeof item === 'object' && item._type) {
+				// Find the schema for this array item type
+				const itemTypeSchema = getSchemaForArrayItem(item._type, arrayField);
+				if (itemTypeSchema && itemTypeSchema.fields) {
+					return checkObject(item, itemTypeSchema.fields, itemPath);
+				}
+			}
+
+			return item;
+		});
+	}
+
+	const cleanedData = checkObject(documentData, schema.fields);
+
+	return {
+		hasOrphanedFields: orphanedFields.length > 0,
+		orphanedFields,
+		cleanedData
+	};
+}
+
+/**
+ * Get the schema for an array item type (helper function)
+ * This would need to be integrated with your schema registry
+ */
+function getSchemaForArrayItem(typeName: string, arrayField: ArrayField): SchemaType | null {
+	// This is a placeholder - you'd need to integrate with your actual schema registry
+	// For now, we'll assume inline object schemas
+	if (arrayField.of) {
+		const typeRef = arrayField.of.find((ref) => ref.type === typeName);
+		if (typeRef && typeof typeRef !== 'string') {
+			// Handle inline schema definitions if needed
+			return null;
+		}
+	}
+	return null;
+}
+
+/**
+ * Apply cleanup by removing orphaned fields from document data
+ */
+export function applySchemaCleanup(
+	documentData: Record<string, any>,
+	schema: SchemaType
+): Record<string, any> {
+	const result = findOrphanedFields(documentData, schema);
+	return result.cleanedData;
+}

package/src/lib/schema-utils/index.ts

@@ -0,0 +1,4 @@
+// Schema utilities - all schema-related helper functions
+export * from './cleanup';
+export * from './utils';
+export * from './validator';

package/src/lib/schema-utils/utils.ts

@@ -0,0 +1,47 @@
+import type { SchemaType } from '../types/schemas';
+
+/**
+ * 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/lib/schema-utils/validator.ts

@@ -0,0 +1,58 @@
+import type { SchemaType, Field } from '../types/schemas';
+
+/**
+ * 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/lib/server/index.ts

@@ -0,0 +1,40 @@
+// Aphex CMS Core - Server-side exports
+// These require Node.js and should NOT be imported client-side
+
+// Export all core types from the new central location
+export * from '../types/index';
+
+export * from '../auth/provider';
+
+export * from '../email/index';
+
+// Authentication errors
+export { AuthError, type AuthErrorCode } from '../auth/auth-errors';
+
+// Configuration system
+export { createCMSConfig } from '../config';
+
+// Hooks integration (SvelteKit server hooks)
+export { createCMSHook, type CMSInstances } from '../hooks';
+
+// Database interfaces (no longer export registry or adapters - use adapter packages)
+export * from '../db/interfaces/index';
+
+// Storage adapters and interfaces
+export * from '../storage/index';
+export * from '../storage/interfaces/index';
+export * from '../storage/providers/storage';
+
+// Services (includes sharp for image processing)
+export * from '../services/index';
+export { AssetService } from '../services/asset-service';
+
+// API Route handlers (for re-exporting in your app's API routes)
+// Re-export from routes-exports to avoid .js extension issues in workspace
+export * from '../routes-exports';
+
+// Schema utilities
+export * from '../schema-utils/index';
+
+// Content hash utilities (server-side)
+export { createHashForPublishing } from '../utils/content-hash';

package/src/lib/services/asset-service.ts

@@ -0,0 +1,256 @@
+// Asset service - orchestrates storage and database operations
+import sharp from 'sharp';
+import type { StorageAdapter } from '../storage/interfaces/storage';
+import type { DatabaseAdapter } from '../db/interfaces/index';
+import type { Asset } from '../types/index';
+
+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/lib/services/index.ts

@@ -0,0 +1,6 @@
+// Aphex CMS Services
+// Business logic layer
+
+// Re-export services
+export { AssetService } from './asset-service';
+export type { AssetUploadData, AssetFilters } from './asset-service';

package/src/lib/storage/adapters/index.ts

@@ -0,0 +1,2 @@
+// Storage adapters
+export * from './local-storage-adapter';