@aphexcms/cms-core 0.1.10 → 0.1.11

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

@@ -1,4 +1,5 @@
 // Aphex CMS Email Layer
 // Ports and adapters for email sending operations
+
 // Interfaces
-export * from './interfaces/email.js';
+export * from './interfaces/email';

package/src/lib/email/interfaces/email.ts

@@ -0,0 +1,45 @@
+export interface EmailAddress {
+	email: string;
+	name?: string;
+}
+
+export interface SendEmailOptions {
+	from: string;
+	to: string | string[];
+	subject: string;
+	html?: string;
+	text?: string;
+	cc?: string | string[];
+	bcc?: string | string[];
+	replyTo?: string;
+	tags?: Array<{ name: string; value: string }>;
+	attachments?: Array<{
+		filename: string;
+		content: Buffer | string;
+	}>;
+}
+
+export interface SendEmailResult {
+	id: string;
+	error?: string;
+}
+
+export interface EmailAdapter {
+	readonly name: string;
+
+	send(options: SendEmailOptions): Promise<SendEmailResult>;
+
+	sendBatch?(emails: SendEmailOptions[]): Promise<SendEmailResult[]>;
+}
+
+export interface EmailProvider {
+	name: string;
+	createAdapter(config: EmailConfig): EmailAdapter;
+}
+
+export interface EmailConfig {
+	apiKey?: string;
+	options?: {
+		[key: string]: any;
+	};
+}

package/src/lib/engine.ts

@@ -0,0 +1,85 @@
+import type { CMSConfig } from './types/config';
+import type { SchemaType } from './types/schemas';
+import type { DatabaseAdapter } from './db/interfaces/index';
+
+export class CMSEngine {
+	private db: DatabaseAdapter;
+	public config: CMSConfig;
+
+	constructor(config: CMSConfig, dbAdapter: DatabaseAdapter) {
+		this.config = config;
+		this.db = dbAdapter;
+	}
+
+	// Update config dynamically (for schema hot-reloading)
+	updateConfig(newConfig: CMSConfig): void {
+		this.config = newConfig;
+		console.log('🔄 CMS config updated:', {
+			schemaTypes: newConfig.schemaTypes.length,
+			documents: newConfig.schemaTypes.filter((t) => t.type === 'document').length,
+			objects: newConfig.schemaTypes.filter((t) => t.type === 'object').length
+		});
+	}
+
+	// Initialize CMS - register schema types in database
+	async initialize(): Promise<void> {
+		console.log('🚀 Initializing CMS...');
+
+		// Get existing schemas from database
+		const existingSchemas = await this.db.listSchemas();
+		const existingNames = new Set(existingSchemas.map((s) => s.name));
+		const currentNames = new Set(this.config.schemaTypes.map((s) => s.name));
+
+		// Delete schemas that are no longer in config
+		for (const existingName of existingNames) {
+			if (!currentNames.has(existingName)) {
+				await this.db.deleteSchemaType(existingName);
+			}
+		}
+
+		// Register all schema types (updates if exists, creates if new)
+		for (const schemaType of this.config.schemaTypes) {
+			await this.db.registerSchemaType(schemaType);
+		}
+
+		console.log('✅ CMS initialized successfully');
+	}
+
+	// Schema Type utility methods
+	async getSchemaType(name: string): Promise<SchemaType | null> {
+		return this.db.getSchemaType(name);
+	}
+
+	async listSchemas(): Promise<SchemaType[]> {
+		return this.db.listSchemas();
+	}
+
+	getSchemaTypeByName(name: string): SchemaType | null {
+		return this.config.schemaTypes.find((s) => s.name === name) || null;
+	}
+
+	async listDocumentTypes(): Promise<Array<{ name: string; title: string; description?: string }>> {
+		return this.db.listDocumentTypes();
+	}
+
+	async listObjectTypes(): Promise<Array<{ name: string; title: string; description?: string }>> {
+		return this.db.listObjectTypes();
+	}
+}
+
+// Global CMS instance
+let cmsInstance: CMSEngine | null = null;
+
+export function createCMS(config: CMSConfig, dbAdapter: DatabaseAdapter): CMSEngine {
+	if (!cmsInstance) {
+		cmsInstance = new CMSEngine(config, dbAdapter);
+	}
+	return cmsInstance;
+}
+
+export function getCMS(): CMSEngine {
+	if (!cmsInstance) {
+		throw new Error('CMS not initialized. Call createCMS() first.');
+	}
+	return cmsInstance;
+}

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`);
+	}
 }