@aphexcms/cms-core 0.1.7 → 0.1.8

package/src/lib/field-validation/rule.ts

@@ -0,0 +1,287 @@
+// Sanity-style validation Rule implementation
+export interface ValidationMarker {
+	level: 'error' | 'warning' | 'info';
+	message: string;
+	path?: string[];
+}
+
+export interface ValidationContext {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	document?: any;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	parent?: any;
+	path?: string[];
+}
+
+export interface CustomValidator<T = unknown> {
+	(
+		value: T,
+		context: ValidationContext
+	): ValidationMarker[] | string | boolean | Promise<ValidationMarker[] | string | boolean>;
+}
+
+export interface FieldReference {
+	__fieldReference: true;
+	path: string | string[];
+}
+
+export class Rule {
+	private _required: boolean = false;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	private _rules: Array<{ type: string; constraint?: any; message?: string }> = [];
+	private _level: 'error' | 'warning' | 'info' = 'error';
+	private _message?: string;
+
+	static FIELD_REF = Symbol('fieldReference');
+
+	static valueOfField(path: string | string[]): FieldReference {
+		return {
+			__fieldReference: true,
+			path
+		};
+	}
+
+	valueOfField(path: string | string[]): FieldReference {
+		return Rule.valueOfField(path);
+	}
+
+	required(): Rule {
+		const newRule = this.clone();
+		newRule._required = true;
+		return newRule;
+	}
+
+	optional(): Rule {
+		const newRule = this.clone();
+		newRule._required = false;
+		return newRule;
+	}
+
+	min(len: number | string | FieldReference): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'min', constraint: len });
+		return newRule;
+	}
+
+	max(len: number | string | FieldReference): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'max', constraint: len });
+		return newRule;
+	}
+
+	length(len: number | FieldReference): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'length', constraint: len });
+		return newRule;
+	}
+
+	email(): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'email' });
+		return newRule;
+	}
+
+	uri(options?: { scheme?: RegExp[]; allowRelative?: boolean }): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'uri', constraint: options });
+		return newRule;
+	}
+
+	regex(pattern: RegExp, name?: string): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'regex', constraint: { pattern, name } });
+		return newRule;
+	}
+
+	positive(): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'positive' });
+		return newRule;
+	}
+
+	negative(): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'negative' });
+		return newRule;
+	}
+
+	integer(): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'integer' });
+		return newRule;
+	}
+
+	greaterThan(num: number | FieldReference): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'greaterThan', constraint: num });
+		return newRule;
+	}
+
+	lessThan(num: number | FieldReference): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'lessThan', constraint: num });
+		return newRule;
+	}
+
+	custom<T = unknown>(fn: CustomValidator<T>): Rule {
+		const newRule = this.clone();
+		newRule._rules.push({ type: 'custom', constraint: fn });
+		return newRule;
+	}
+
+	error(message?: string): Rule {
+		const newRule = this.clone();
+		newRule._level = 'error';
+		newRule._message = message;
+		return newRule;
+	}
+
+	warning(message?: string): Rule {
+		const newRule = this.clone();
+		newRule._level = 'warning';
+		newRule._message = message;
+		return newRule;
+	}
+
+	info(message?: string): Rule {
+		const newRule = this.clone();
+		newRule._level = 'info';
+		newRule._message = message;
+		return newRule;
+	}
+
+	clone(): Rule {
+		const newRule = new Rule();
+		newRule._required = this._required;
+		newRule._rules = [...this._rules];
+		newRule._level = this._level;
+		newRule._message = this._message;
+		return newRule;
+	}
+
+	async validate(value: unknown, context: ValidationContext = {}): Promise<ValidationMarker[]> {
+		const markers: ValidationMarker[] = [];
+
+		// Check required
+		if (this._required && (value === undefined || value === null || value === '')) {
+			markers.push({
+				level: this._level,
+				message: this._message || 'Required',
+				path: context.path
+			});
+		}
+
+		// If value is empty and not required, skip other validations
+		if (!this._required && (value === undefined || value === null || value === '')) {
+			return markers;
+		}
+
+		// Run other validations
+		for (const rule of this._rules) {
+			try {
+				const result = await this.validateRule(rule, value, context);
+				if (result) {
+					markers.push({
+						level: this._level,
+						message: this._message || result,
+						path: context.path
+					});
+				}
+			} catch (error) {
+				markers.push({
+					level: 'error',
+					message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+					path: context.path
+				});
+			}
+		}
+
+		return markers;
+	}
+
+	private async validateRule(
+		rule: { type: string; constraint?: any },
+		value: unknown,
+		context: ValidationContext
+	): Promise<string | null> {
+		switch (rule.type) {
+			case 'min':
+				if (typeof value === 'string' && value.length < rule.constraint) {
+					return `Must be at least ${rule.constraint} characters`;
+				}
+				if (typeof value === 'number' && value < rule.constraint) {
+					return `Must be at least ${rule.constraint}`;
+				}
+				break;
+
+			case 'max':
+				if (typeof value === 'string' && value.length > rule.constraint) {
+					return `Must be at most ${rule.constraint} characters`;
+				}
+				if (typeof value === 'number' && value > rule.constraint) {
+					return `Must be at most ${rule.constraint}`;
+				}
+				break;
+
+			case 'email':
+				if (typeof value === 'string' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+					return 'Must be a valid email address';
+				}
+				break;
+
+			case 'uri':
+				if (typeof value === 'string') {
+					try {
+						new URL(value);
+					} catch {
+						return 'Must be a valid URL';
+					}
+				}
+				break;
+
+			case 'regex':
+				if (typeof value === 'string' && !rule.constraint.pattern.test(value)) {
+					return `Must match pattern${rule.constraint.name ? ` (${rule.constraint.name})` : ''}`;
+				}
+				break;
+
+			case 'positive':
+				if (typeof value === 'number' && value <= 0) {
+					return 'Must be positive';
+				}
+				break;
+
+			case 'negative':
+				if (typeof value === 'number' && value >= 0) {
+					return 'Must be negative';
+				}
+				break;
+
+			case 'integer':
+				if (typeof value === 'number' && !Number.isInteger(value)) {
+					return 'Must be an integer';
+				}
+				break;
+
+			case 'custom': {
+				const customResult = await rule.constraint(value, context);
+				if (customResult === false) {
+					return 'Validation failed';
+				}
+				if (typeof customResult === 'string') {
+					return customResult;
+				}
+				if (Array.isArray(customResult) && customResult.length > 0) {
+					return customResult[0].message;
+				}
+				break;
+			}
+		}
+
+		return null;
+	}
+
+	isRequired(): boolean {
+		return this._required;
+	}
+}

package/src/lib/field-validation/utils.ts

@@ -0,0 +1,91 @@
+import type { Field } from '../types/index';
+import { Rule } from './rule';
+
+export interface ValidationError {
+	level: 'error' | 'warning' | 'info';
+	message: string;
+}
+
+/**
+ * Check if a field is required based on its validation rules
+ */
+export function isFieldRequired(field: Field): boolean {
+	if (!field.validation) return false;
+	try {
+		const validationFn = Array.isArray(field.validation) ? field.validation[0] : field.validation;
+		if (!validationFn) return false;
+		const rule = validationFn(new Rule());
+		return rule.isRequired();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Validate a field value against its validation rules
+ */
+export async function validateField(
+	field: Field,
+	value: any,
+	context: any = {}
+): Promise<{
+	isValid: boolean;
+	errors: ValidationError[];
+}> {
+	if (!field.validation) {
+		return { isValid: true, errors: [] };
+	}
+
+	try {
+		const validationFunctions = Array.isArray(field.validation)
+			? field.validation
+			: [field.validation];
+
+		const allErrors: ValidationError[] = [];
+
+		for (const validationFn of validationFunctions) {
+			const rule = validationFn(new Rule());
+
+			if (!(rule instanceof Rule)) {
+				console.error(
+					`Validation function for field "${field.name}" did not return a Rule object. Make sure you are chaining validation methods and returning the result.`
+				);
+				continue;
+			}
+
+			const markers = await rule.validate(value, {
+				path: [field.name],
+				...context
+			});
+
+			allErrors.push(
+				...markers.map((marker) => ({
+					level: marker.level,
+					message: marker.message
+				}))
+			);
+		}
+
+		const isValid = allErrors.filter((e) => e.level === 'error').length === 0;
+
+		return { isValid, errors: allErrors };
+	} catch (error) {
+		console.error('Validation error:', error);
+		return {
+			isValid: false,
+			errors: [{ level: 'error', message: 'Validation failed' }]
+		};
+	}
+}
+
+/**
+ * Get validation CSS classes for input styling
+ */
+export function getValidationClasses(hasErrors: boolean): string {
+	if (hasErrors) {
+		return 'border-destructive border-2';
+	}
+
+	// No green styling for success - only show red for errors
+	return '';
+}

package/src/lib/hooks.ts

@@ -0,0 +1,142 @@
+import type { Handle } from '@sveltejs/kit';
+import type { CMSConfig } from './types/index';
+import type { DatabaseAdapter } from './db/index';
+import type { AssetService } from './services/asset-service';
+import type { StorageAdapter } from './storage/interfaces/storage';
+import type { EmailAdapter } from './email/index';
+import type { AuthProvider } from './auth/provider';
+import { handleAuthHook } from './auth/auth-hooks';
+import { createStorageAdapter as createStorageAdapterProvider } from './storage/providers/storage';
+import { AssetService as AssetServiceClass } from './services/asset-service';
+import { createCMS, CMSEngine } from './engine';
+
+// Singleton instances - created once per application lifecycle
+export interface CMSInstances {
+	config: CMSConfig;
+	assetService: AssetService;
+	storageAdapter: StorageAdapter;
+	databaseAdapter: DatabaseAdapter;
+	emailAdapter?: EmailAdapter | null;
+	cmsEngine: CMSEngine;
+	auth?: AuthProvider;
+	pluginRoutes?: Map<
+		string,
+		{ handler: (event: any) => Promise<Response> | Response; pluginName: string }
+	>;
+}
+
+let cmsInstances: CMSInstances | null = null;
+let lastConfigHash: string | null = null;
+
+// Helper to generate a simple hash of schema types for change detection
+function getConfigHash(config: CMSConfig): string {
+	const schemaNames = config.schemaTypes
+		.map((s) => `${s.name}:${s.fields.length}:${JSON.stringify(s.fields)}`)
+		.join(',');
+	return schemaNames;
+}
+
+// Factory function to create the default local storage adapter
+function createDefaultStorageAdapter(): StorageAdapter {
+	return createStorageAdapterProvider('local', {
+		basePath: './storage/assets', // Private storage - not in static/, not served in production
+		baseUrl: '' // No direct URL - all access through /assets/{id}/{filename}
+	});
+}
+
+export function createCMSHook(config: CMSConfig): Handle {
+	return async ({ event, resolve }) => {
+		// Note: In dev mode, /storage/ might be accessible via Vite dev server
+		// In production, only /static/ folder is served - /storage/ is private
+
+		const currentConfigHash = getConfigHash(config);
+		const configChanged = lastConfigHash !== null && currentConfigHash !== lastConfigHash;
+
+		// Initialize CMS instances once at application startup
+		if (!cmsInstances) {
+			console.log('🚀 Initializing CMS...');
+			const databaseAdapter = config.database;
+			// Use the storage adapter from config, or create the default local one.
+			const storageAdapter = config.storage ?? createDefaultStorageAdapter();
+			const emailAdapter = config.email ?? null;
+			const assetService = new AssetServiceClass(storageAdapter, databaseAdapter);
+			const cmsEngine = createCMS(config, databaseAdapter);
+
+			await cmsEngine.initialize();
+
+			// Build plugin route map (do this ONCE at startup)
+			const pluginRoutes = new Map<
+				string,
+				{ handler: (event: any) => Promise<Response> | Response; pluginName: string }
+			>();
+			if (config.plugins && config.plugins.length > 0) {
+				for (const plugin of config.plugins) {
+					if (plugin.routes) {
+						for (const [path, handler] of Object.entries(plugin.routes)) {
+							pluginRoutes.set(path, { handler, pluginName: plugin.name });
+						}
+					}
+				}
+			}
+
+			cmsInstances = {
+				config,
+				databaseAdapter: databaseAdapter,
+				assetService: assetService,
+				storageAdapter: storageAdapter,
+				emailAdapter: emailAdapter,
+				cmsEngine: cmsEngine,
+				auth: config.auth?.provider,
+				pluginRoutes
+			};
+
+			// Install plugins
+			if (config.plugins && config.plugins.length > 0) {
+				for (const plugin of config.plugins) {
+					console.log(`🔌 Installing plugin: ${plugin.name}`);
+					await plugin.install(cmsInstances);
+				}
+			}
+
+			lastConfigHash = currentConfigHash;
+		} else if (configChanged) {
+			// HMR: Config changed, re-sync schemas
+			console.log('🔄 Schema types changed, re-syncing...');
+			console.log('Old hash:', lastConfigHash?.substring(0, 100) + '...');
+			console.log('New hash:', currentConfigHash.substring(0, 100) + '...');
+			console.log(
+				'Schema types being updated:',
+				config.schemaTypes.map((s) => s.name)
+			);
+			cmsInstances.cmsEngine.updateConfig(config);
+			await cmsInstances.cmsEngine.initialize();
+			lastConfigHash = currentConfigHash;
+			console.log('✅ Schema sync complete');
+		}
+
+		// Inject shared CMS services into locals (reuse singleton instances)
+		event.locals.aphexCMS = cmsInstances;
+
+		// Auth protection if configured
+		if (cmsInstances.auth) {
+			const authResponse = await handleAuthHook(
+				event,
+				config,
+				cmsInstances.auth,
+				cmsInstances.databaseAdapter
+			);
+			if (authResponse) return authResponse;
+		}
+
+		// Check if a plugin handles this route (O(1) lookup)
+		if (cmsInstances.pluginRoutes && cmsInstances.pluginRoutes.size > 0) {
+			const pluginRoute = cmsInstances.pluginRoutes.get(event.url.pathname);
+			if (pluginRoute) {
+				console.log(`🔌 Plugin ${pluginRoute.pluginName} handling route: ${event.url.pathname}`);
+				return pluginRoute.handler(event);
+			}
+		}
+
+		return resolve(event);
+	};
+}

package/{dist/index.js → src/lib/index.ts}

@@ -1,4 +1,5 @@
 // Aphex CMS Core - Main exports (client-safe only)
 // For server-side functionality, import from '@aphexcms/cms-core/server'
+
 // Re-export all client-safe functionality
-export * from './client/index.js';
+export * from './client/index';

package/{dist/is-mobile.svelte.js → src/lib/is-mobile.svelte.ts}

@@ -1,7 +1,9 @@
 import { MediaQuery } from 'svelte/reactivity';
+
 const DEFAULT_MOBILE_BREAKPOINT = 768;
+
 export class IsMobile extends MediaQuery {
-    constructor(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
-        super(`max-width: ${breakpoint - 1}px`);
-    }
+	constructor(breakpoint: number = DEFAULT_MOBILE_BREAKPOINT) {
+		super(`max-width: ${breakpoint - 1}px`);
+	}
 }

package/src/lib/routes/assets-by-id.ts

@@ -0,0 +1,161 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from '@sveltejs/kit';
+import { Asset } from '../types/asset';
+
+export const GET: RequestHandler = async ({ params, locals }) => {
+	try {
+		const { assetService } = locals.aphexCMS;
+		const auth = locals.auth;
+		const { id } = params;
+
+		if (!auth) {
+			return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+		}
+
+		if (!id) {
+			return json({ success: false, error: 'Asset ID is required' }, { status: 400 });
+		}
+
+		const asset = await assetService.findAssetById(auth.organizationId, id);
+
+		if (!asset) {
+			return json({ success: false, error: 'Asset not found' }, { status: 404 });
+		}
+
+		// Return JSON metadata for admin UI
+		return json({
+			success: true,
+			data: {
+				_type: asset.assetType === 'image' ? 'sanity.imageAsset' : 'sanity.fileAsset',
+				_id: asset.id,
+				url: asset.url,
+				originalFilename: asset.originalFilename,
+				mimeType: asset.mimeType,
+				size: asset.size,
+				metadata: {
+					dimensions:
+						asset.width && asset.height
+							? {
+									width: asset.width,
+									height: asset.height
+								}
+							: undefined,
+					...asset.metadata
+				},
+				title: asset.title,
+				description: asset.description,
+				alt: asset.alt,
+				creditLine: asset.creditLine,
+				_createdAt: asset.createdAt,
+				_updatedAt: asset.updatedAt
+			}
+		});
+	} catch (error) {
+		console.error('[Asset API] Error fetching asset:', error);
+		return json({ success: false, error: 'Failed to fetch asset' }, { status: 500 });
+	}
+};
+
+export const DELETE: RequestHandler = async ({ params, locals }) => {
+	try {
+		const { id } = params;
+		const { assetService } = locals.aphexCMS;
+		const auth = locals.auth;
+
+		if (!auth) {
+			return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+		}
+
+		if (!id) {
+			return json({ success: false, error: 'Asset ID is required' }, { status: 400 });
+		}
+
+		const result = await assetService.deleteAsset(auth.organizationId, id);
+
+		if (!result) {
+			return json(
+				{ success: false, error: 'Asset not found or could not be deleted' },
+				{ status: 404 }
+			);
+		}
+
+		return json({ success: true });
+	} catch (error) {
+		console.error('Error deleting asset:', error);
+		return json({ success: false, error: 'Failed to delete asset' }, { status: 500 });
+	}
+};
+
+export const PATCH: RequestHandler = async ({ params, locals, request }) => {
+	try {
+		const { assetService } = locals.aphexCMS;
+		const auth = locals.auth;
+		const { id } = params;
+
+		if (!auth) {
+			return json({ success: false, error: 'Unauthorized' }, { status: 401 });
+		}
+
+		if (!id) {
+			return json({ success: false, error: 'Asset ID is required' }, { status: 400 });
+		}
+
+		const { title, description, alt, creditLine } = await request.json();
+
+		let updatedAsset: Asset | null;
+
+		if (auth.type == 'session') {
+			updatedAsset = await assetService.updateAssetMetadata(auth.organizationId, id, {
+				title,
+				description,
+				alt,
+				creditLine,
+				updatedBy: auth.user.id
+			});
+		} else {
+			updatedAsset = await assetService.updateAssetMetadata(auth.organizationId, id, {
+				title,
+				description,
+				alt,
+				creditLine,
+				updatedBy: auth.keyId
+			});
+		}
+
+		if (!updatedAsset) {
+			return json({ success: false, error: 'Asset not found' }, { status: 404 });
+		}
+
+		// Return API response with success wrapper
+		return json({
+			success: true,
+			data: {
+				_type: updatedAsset.assetType === 'image' ? 'sanity.imageAsset' : 'sanity.fileAsset',
+				_id: updatedAsset.id,
+				url: updatedAsset.url,
+				originalFilename: updatedAsset.originalFilename,
+				mimeType: updatedAsset.mimeType,
+				size: updatedAsset.size,
+				metadata: {
+					dimensions:
+						updatedAsset.width && updatedAsset.height
+							? {
+									width: updatedAsset.width,
+									height: updatedAsset.height
+								}
+							: undefined,
+					...updatedAsset.metadata
+				},
+				title: updatedAsset.title,
+				description: updatedAsset.description,
+				alt: updatedAsset.alt,
+				creditLine: updatedAsset.creditLine,
+				_createdAt: updatedAsset.createdAt,
+				_updatedAt: updatedAsset.updatedAt
+			}
+		});
+	} catch (error) {
+		console.error('Error updating asset:', error);
+		return json({ success: false, error: 'Failed to update asset' }, { status: 500 });
+	}
+};