@aphexcms/cms-core 0.1.0 → 0.1.3

package/src/field-validation/rule.ts

@@ -1,287 +0,0 @@
-// 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/field-validation/utils.ts

@@ -1,91 +0,0 @@
-import type { Field } from '../types';
-import { Rule } from './rule.js';
-
-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/hooks.ts

@@ -1,142 +0,0 @@
-import type { Handle } from '@sveltejs/kit';
-import type { CMSConfig } from './types/index.js';
-import type { DatabaseAdapter } from './db/index.js';
-import type { AssetService } from './services/asset-service.js';
-import type { StorageAdapter } from './storage/interfaces/storage.js';
-import type { EmailAdapter } from './email/index.js';
-import type { AuthProvider } from './auth/provider.js';
-import { handleAuthHook } from './auth/auth-hooks.js';
-import { createStorageAdapter as createStorageAdapterProvider } from './storage/providers/storage.js';
-import { AssetService as AssetServiceClass } from './services/asset-service.js';
-import { createCMS, CMSEngine } from './engine.js';
-
-// 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/src/index.ts

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

package/src/lib/is-mobile.svelte.ts

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

package/src/lib/utils.ts

@@ -1,13 +0,0 @@
-import { clsx, type ClassValue } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-
-export function cn(...inputs: ClassValue[]) {
-	return twMerge(clsx(inputs));
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type WithoutChild<T> = T extends { child?: any } ? Omit<T, 'child'> : T;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type WithoutChildren<T> = T extends { children?: any } ? Omit<T, 'children'> : T;
-export type WithoutChildrenOrChild<T> = WithoutChildren<WithoutChild<T>>;
-export type WithElementRef<T, U extends HTMLElement = HTMLElement> = T & { ref?: U | null };

package/src/plugins/README.md

@@ -1,154 +0,0 @@
-# Plugin Architecture: A Sanity-like "Parts" System
-
-This document outlines a vision for a highly extensible, decoupled plugin architecture for Aphex CMS, inspired by the "parts" system used in Sanity Studio.
-
-## Core Concept: The "Parts" System
-
-The goal is to move away from a specialized plugin system, where the core application knows about specific plugin properties like `routes` or `adminUI`, to a generic one.
-
-The core concept is a **"parts" system**. A "part" is a formally defined, named extension point in the application that a plugin can provide an implementation for. The core application doesn't know what a "GraphQL Plugin" is; it only knows how to find and render a "tool" in the admin bar, or how to register a "server route".
-
----
-
-## The Plugin Contract
-
-We would redefine the `CMSPlugin` interface to be centered around this "parts" concept.
-
-```typescript
-/**
- * A generic definition for any piece of functionality a plugin can provide.
- */
-export interface PluginPart {
-	/**
-	 * The name of the part this plugin implements.
-	 * @example 'aphex/admin/tool', 'aphex/server/route'
-	 */
-	implements: string;
-
-	/** The actual implementation (can be a component, a function, etc.) */
-	component?: any; // In practice, a SvelteComponent constructor
-
-	/** The handler function for a route part */
-	handler?: (event: import('@sveltejs/kit').RequestEvent) => Response | Promise<Response>;
-
-	/** Other metadata the part might need for rendering or execution */
-	[key: string]: any;
-}
-
-/**
- * The new plugin contract. A plugin is a collection of parts.
- */
-export interface CMSPlugin {
-	name: string;
-	version: string;
-	parts?: PluginPart[];
-	/** `install` can still be used for complex, one-time setup logic */
-	install?: (cms: any) => Promise<void>;
-}
-```
-
----
-
-## Defining Core Parts
-
-We would define a set of core "parts" for Aphex CMS. This list can grow over time as more extension points are needed.
-
-- `aphex/server/route`: Implemented by plugins that need to add a server-side API endpoint. The part would include a `path` and a `handler`.
-- `aphex/admin/tool`: For adding a top-level, navigable tool (like a tab) to the main admin UI. The part would include an `id`, `title`, and a `component` to render.
-- `aphex/field/component`: For registering a custom Svelte component to use for a specific schema field type (e.g., a special string input, a map selector, etc.).
-- `aphex/document/action`: For adding a custom action button to the document editor (e.g., "Duplicate", "Translate", "Preview").
-
----
-
-## Implementation with SvelteKit and Svelte 5
-
-This architecture fits beautifully with SvelteKit's and Svelte 5's features.
-
-### The Part Resolver Service
-
-A singleton service, the "Part Resolver," would be the heart of the system.
-
-1.  **Initialization:** At application startup, the main `hooks.server.ts` would process the `cmsConfig.plugins` array once. It would loop through every plugin and every part, organizing them into a `Map<string, PluginPart[]>`. For example, the key `'aphex/admin/tool'` would hold an array of all tool parts from all installed plugins.
-2.  **Injection:** This resolver instance would be attached to SvelteKit's `event.locals`, making it universally available in `load` functions, server-side hooks, and API routes without needing global variables.
-
-### Rendering UI Parts with Svelte 5
-
-Dynamically rendering plugin components becomes trivial and efficient with Svelte 5.
-
-1.  **Data Loading:** In the `+page.server.ts` for the admin UI, the `load` function would use the resolver from `locals` to fetch the necessary parts.
-    ```typescript
-    // in /routes/admin/+page.server.ts
-    export async function load({ locals }) {
-    	const { partResolver } = locals.aphexCMS;
-    	const adminTools = partResolver.getParts('aphex/admin/tool');
-    	return { adminTools };
-    }
-    ```
-2.  **Dynamic Rendering:** The `AdminApp.svelte` component would receive `adminTools` as a prop. It can then dynamically render the tabs and their content using `<svelte:component>`.
-
-    ```svelte
-    <!-- AdminApp.svelte -->
-    <script lang="ts">
-    	let { adminTools = [] } = $props();
-    </script>
-
-    <Tabs.Root>
-    	<Tabs.List>
-    		<!-- Render a trigger for each tool -->
-    		{#each adminTools as tool}
-    			<Tabs.Trigger value={tool.id}>{tool.title}</Tabs.Trigger>
-    		{/each}
-    	</Tabs.List>
-
-    	<!-- Render the content for each tool -->
-    	{#each adminTools as tool}
-    		<Tabs.Content value={tool.id}>
-    			<svelte:component this={tool.component} />
-    		</Tabs.Content>
-    	{/each}
-    </Tabs.Root>
-    ```
-
-### Handling Server Parts in SvelteKit
-
-The main `hooks.server.ts` would use the resolver to handle non-UI parts. For example, it would get all `aphex/server/route` parts and register their handlers in a dynamic routing map, similar to how `pluginRoutes` works now but in a fully generic way.
-
----
-
-## Example: The GraphQL Plugin Revisited
-
-Under this system, the GraphQL plugin becomes a clean, declarative manifest of its parts.
-
-```typescript
-// In packages/graphql-plugin/src/index.ts
-import GraphQLTabComponent from './GraphQLTab.svelte';
-import { createYoga } from 'graphql-yoga';
-
-// ... (yoga setup)
-
-export function createGraphQLPlugin(config: GraphQLPluginConfig = {}): CMSPlugin {
-    const endpoint = config.endpoint ?? '/api/graphql';
-    const yogaApp = /* ... create yoga instance ... */;
-
-    return {
-        name: '@aphex/graphql-plugin',
-        parts: [
-            // Part 1: The API endpoint
-            {
-                implements: 'aphex/server/route',
-                path: endpoint,
-                handler: (event) => yogaApp.fetch(event.request, event)
-            },
-            // Part 2: The UI tab in the admin interface
-            {
-                implements: 'aphex/admin/tool',
-                id: 'graphql',
-                title: 'GraphQL',
-                component: GraphQLTabComponent
-            }
-        ]
-    };
-}
-```
-
-With this, the core system remains completely agnostic. It doesn't know what "GraphQL" is, it simply knows how to render a "tool" and route a "server route". This is the foundation of a truly configurable and powerful plugin architecture.