@aphexcms/cms-core 0.1.11 → 0.1.13

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

@@ -1,116 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,40 +0,0 @@
-// 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

@@ -1,256 +0,0 @@
-// 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

@@ -1,6 +0,0 @@
-// 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

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