@aphexcms/cms-core 0.1.1 → 0.1.4

package/src/db/utils/reference-resolver.ts

@@ -1,119 +0,0 @@
-// Reference resolution utility for resolving nested document references
-import type { Document } from '../../types/index.js';
-import type { DocumentAdapter } from '../interfaces/document.js';
-
-interface ResolveOptions {
-	depth: number;
-	currentDepth?: number;
-	visited?: Set<string>; // Track visited documents to prevent circular references
-}
-
-/**
- * Recursively resolves reference fields in a document
- * @param document - The document to resolve references for
- * @param adapter - Document adapter for fetching referenced documents
- * @param organizationId - Organization ID for filtering referenced documents
- * @param options - Resolution options (depth, tracking)
- * @returns Document with resolved references
- */
-export async function resolveReferences(
-	document: Document,
-	adapter: DocumentAdapter,
-	organizationId: string,
-	options: ResolveOptions
-): Promise<Document> {
-	const { depth, currentDepth = 0, visited = new Set() } = options;
-
-	// Base case: no more depth to resolve or already visited (circular reference)
-	if (currentDepth >= depth || visited.has(document.id)) {
-		return document;
-	}
-
-	// Mark as visited
-	visited.add(document.id);
-
-	// Clone the document to avoid mutations
-	const resolvedDocument = { ...document };
-
-	// Resolve references in draftData
-	if (document.draftData) {
-		resolvedDocument.draftData = await resolveDataReferences(
-			document.draftData,
-			adapter,
-			organizationId,
-			{
-				depth,
-				currentDepth: currentDepth + 1,
-				visited
-			}
-		);
-	}
-
-	// Resolve references in publishedData
-	if (document.publishedData) {
-		resolvedDocument.publishedData = await resolveDataReferences(
-			document.publishedData,
-			adapter,
-			organizationId,
-			{
-				depth,
-				currentDepth: currentDepth + 1,
-				visited
-			}
-		);
-	}
-
-	return resolvedDocument;
-}
-
-/**
- * Resolves references within document data (recursive)
- */
-async function resolveDataReferences(
-	data: any,
-	adapter: DocumentAdapter,
-	organizationId: string,
-	options: ResolveOptions
-): Promise<any> {
-	if (!data || typeof data !== 'object') {
-		return data;
-	}
-
-	// Handle arrays
-	if (Array.isArray(data)) {
-		return Promise.all(
-			data.map((item) => resolveDataReferences(item, adapter, organizationId, options))
-		);
-	}
-
-	// Clone object
-	const resolved: any = {};
-
-	for (const [key, value] of Object.entries(data)) {
-		// Check if this looks like a reference field (string ID)
-		if (typeof value === 'string' && key !== '_type' && key !== '_key') {
-			// Try to fetch the referenced document
-			try {
-				const referencedDoc = await adapter.findByDocId(organizationId, value);
-				if (referencedDoc) {
-					// Recursively resolve nested references
-					resolved[key] = await resolveReferences(referencedDoc, adapter, organizationId, options);
-				} else {
-					// Reference not found, keep the ID
-					resolved[key] = value;
-				}
-			} catch (error) {
-				// On error, keep the original value
-				resolved[key] = value;
-			}
-		} else if (value && typeof value === 'object') {
-			// Recursively resolve nested objects/arrays
-			resolved[key] = await resolveDataReferences(value, adapter, organizationId, options);
-		} else {
-			// Primitive value, keep as is
-			resolved[key] = value;
-		}
-	}
-
-	return resolved;
-}

package/src/define.ts

@@ -1,7 +0,0 @@
-// CMS configuration helper
-import type { CMSConfig } from './types/index.js';
-
-// CMS config helper
-export function defineCMSConfig(config: CMSConfig): CMSConfig {
-	return config;
-}

package/src/email/interfaces/email.ts

@@ -1,45 +0,0 @@
-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/engine.ts

@@ -1,85 +0,0 @@
-import type { CMSConfig } from './types/config.js';
-import type { SchemaType } from './types/schemas.js';
-import type { DatabaseAdapter } from './db/interfaces/index.js';
-
-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/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 '';
-}