@aphexcms/cms-core 0.1.10 → 0.1.11

package/src/lib/auth/provider.ts

@@ -0,0 +1,25 @@
+// packages/cms-core/src/auth/provider.ts
+import type { SessionAuth, ApiKeyAuth } from '../types/index';
+import type { DatabaseAdapter } from '../db/interfaces/index';
+
+export interface AuthProvider {
+	// Session auth (browser, admin UI)
+	getSession(request: Request, db: DatabaseAdapter): Promise<SessionAuth | null>;
+	requireSession(request: Request, db: DatabaseAdapter): Promise<SessionAuth>;
+
+	// API key auth (programmatic access)
+	validateApiKey(request: Request, db: DatabaseAdapter): Promise<ApiKeyAuth | null>;
+	requireApiKey(
+		request: Request,
+		db: DatabaseAdapter,
+		permission?: 'read' | 'write'
+	): Promise<ApiKeyAuth>;
+
+	// User management
+	getUserById(userId: string): Promise<{ id: string; name?: string; email: string } | null>;
+	changeUserName(userId: string, name: string): Promise<void>;
+
+	// Password reset
+	requestPasswordReset(email: string, redirectTo?: string): Promise<void>;
+	resetPassword(token: string, newPassword: string): Promise<void>;
+}

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

@@ -1,22 +1,30 @@
 // Aphex CMS Core - Client-side exports
 // These are safe to import in the browser (no Node.js dependencies)
+
 // Core types (shared between client and server)
-export * from '../types/index.js';
+export * from '../types/index';
+export type { SidebarUser, SidebarNavItem, SidebarBranding, SidebarData } from '../types/sidebar';
+
 // Field validation (client-side validation)
-export * from '../field-validation/rule.js';
-export * from '../field-validation/utils.js';
+export * from '../field-validation/rule';
+export * from '../field-validation/utils';
+
 // Content hashing utilities (for client-side change detection)
-export { createContentHash, hasUnpublishedChanges } from '../utils/content-hash.js';
+export { createContentHash, hasUnpublishedChanges } from '../utils/content-hash';
+
 // Schema context (for providing schemas to components)
 export { setSchemaContext, getSchemaContext } from '../schema-context.svelte';
+
 // Schema utilities (for working with schemas)
-export * from '../schema-utils/index.js';
+export * from '../schema-utils/index';
+
 // Components (UI components for the admin interface)
 export { default as DocumentEditor } from '../components/admin/DocumentEditor.svelte';
 export { default as DocumentTypesList } from '../components/admin/DocumentTypesList.svelte';
 export { default as SchemaField } from '../components/admin/SchemaField.svelte';
 export { default as AdminApp } from '../components/AdminApp.svelte';
 export { default as Sidebar } from '../components/layout/Sidebar.svelte';
+
 // Field components
 export { default as StringField } from '../components/admin/fields/StringField.svelte';
 export { default as TextareaField } from '../components/admin/fields/TextareaField.svelte';
@@ -26,6 +34,9 @@ export { default as ImageField } from '../components/admin/fields/ImageField.sve
 export { default as SlugField } from '../components/admin/fields/SlugField.svelte';
 export { default as ArrayField } from '../components/admin/fields/ArrayField.svelte';
 export { default as ReferenceField } from '../components/admin/fields/ReferenceField.svelte';
+
 // Utility functions (browser-safe)
-export * from '../utils/index.js';
-export * from '../api/index.js';
+export * from '../utils/index';
+
+export * from '../api/index';
+export type { ApiResponse } from '../api/index';

package/{dist → src/lib}/components/AdminApp.svelte

@@ -13,12 +13,13 @@
 	import DocumentEditor from './admin/DocumentEditor.svelte';
 	import type { DocumentType } from '../types/index';
 	import { documents } from '../api/index';
+	import { FileText } from 'lucide-svelte';
 
-	type InitDocumentType = Pick<DocumentType, 'name' | 'title' | 'description'>;
+	type InitDocumentType = Pick<DocumentType, 'name' | 'title' | 'description' | 'icon'>;
 
 	interface Props {
 		schemas: SchemaType[];
-		documentTypes: InitDocumentType[];
+		documentTypes: Array<{ name: string; title: string; description?: string }>;
 		schemaError?: { message: string } | null;
 		title?: string;
 		graphqlSettings?: { endpoint: string; enableGraphiQL: boolean } | null;
@@ -29,7 +30,7 @@
 
 	let {
 		schemas,
-		documentTypes,
+		documentTypes: documentTypesFromServer,
 		schemaError = null,
 		title = 'Aphex CMS',
 		graphqlSettings = null,
@@ -38,7 +39,16 @@
 		handleTabChange = () => {}
 	}: Props = $props();
 
-	// Set schema context for child components
+	// Merge document types with schema icons (schemas have icons, server data doesn't)
+	const documentTypes = $derived(
+		documentTypesFromServer.map((docType) => {
+			const schema = schemas.find((s) => s.name === docType.name);
+			return {
+				...docType,
+				icon: schema?.icon
+			};
+		})
+	);
 
 	const hasDocumentTypes = $derived(documentTypes.length > 0);
 
@@ -730,7 +740,12 @@
 												>
 													<div class="flex items-center gap-3">
 														<div class="flex h-6 w-6 items-center justify-center">
-															<span class="text-muted-foreground">📄</span>
+															{#if docType.icon}
+																{@const Icon = docType.icon}
+																<Icon class="text-muted-foreground h-4 w-4" />
+															{:else}
+																<FileText class="text-muted-foreground h-4 w-4" />
+															{/if}
 														</div>
 														<div>
 															<h3 class="text-sm font-medium">{docType.title}s</h3>
@@ -763,7 +778,7 @@
 												<div
 													class="bg-muted/50 mx-auto mb-4 flex h-16 w-16 items-center justify-center rounded-full"
 												>
-													<span class="text-muted-foreground text-xl">📄</span>
+													<FileText class="text-muted-foreground h-8 w-8" />
 												</div>
 												<h3 class="mb-2 font-medium">No content types found</h3>
 												<p class="text-muted-foreground mb-4 text-sm">
@@ -806,19 +821,26 @@
 											</div>
 										</button>
 									{:else}
+										{@const currentDocType = documentTypes.find(
+											(t) => t.name === selectedDocumentType
+										)}
 										<div class="border-border bg-muted/20 border-b p-3">
 											<div class="flex items-center justify-between">
 												<div class="flex items-center gap-3">
 													{#if windowWidth > 620}
 														<!-- Desktop: Icon -->
 														<div class="flex h-6 w-6 items-center justify-center">
-															<span class="text-muted-foreground">📄</span>
+															{#if currentDocType?.icon}
+																{@const Icon = currentDocType.icon}
+																<Icon class="text-muted-foreground h-4 w-4" />
+															{:else}
+																<FileText class="text-muted-foreground h-4 w-4" />
+															{/if}
 														</div>
 													{/if}
 													<div>
 														<h3 class="text-sm font-medium">
-															{(documentTypes.find((t) => t.name === selectedDocumentType)?.title ||
-																selectedDocumentType) + 's'}
+															{(currentDocType?.title || selectedDocumentType) + 's'}
 														</h3>
 														<p class="text-muted-foreground text-xs">
 															{documentsList.length} document{documentsList.length !== 1 ? 's' : ''}
@@ -870,7 +892,12 @@
 													>
 														<div class="flex min-w-0 flex-1 items-center gap-3">
 															<div class="flex h-6 w-6 items-center justify-center">
-																<span class="text-muted-foreground">📄</span>
+																{#if currentDocType?.icon}
+																	{@const Icon = currentDocType.icon}
+																	<Icon class="text-muted-foreground h-4 w-4" />
+																{:else}
+																	<FileText class="text-muted-foreground h-4 w-4" />
+																{/if}
 															</div>
 															<div class="min-w-0 flex-1">
 																<h3 class="truncate text-sm font-medium">{doc.title}</h3>
@@ -895,7 +922,12 @@
 													<div
 														class="bg-muted/50 mx-auto mb-4 flex h-16 w-16 items-center justify-center rounded-full"
 													>
-														<span class="text-muted-foreground text-xl">📄</span>
+														{#if currentDocType?.icon}
+															{@const Icon = currentDocType.icon}
+															<Icon class="text-muted-foreground h-8 w-8" />
+														{:else}
+															<FileText class="text-muted-foreground h-8 w-8" />
+														{/if}
 													</div>
 													<h3 class="mb-2 font-medium">No documents found</h3>
 													<p class="text-muted-foreground text-sm">

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

@@ -1,12 +1,16 @@
 // Aphex CMS Components
 // All admin interface components -- is this being used?
+
 // Main admin app
 export { default as AdminApp } from './AdminApp.svelte';
+
 // Sidebar
 export { default as Sidebar } from './layout/Sidebar.svelte';
+
 // Admin components (will be migrated from your current structure)
 export { default as DocumentEditor } from './admin/DocumentEditor.svelte';
 export { default as DocumentTypesList } from './admin/DocumentTypesList.svelte';
 export { default as SchemaField } from './admin/SchemaField.svelte';
+
 // Field components
-export * from './fields/index.js';
+export * from './fields/index';

package/src/lib/config.ts

@@ -0,0 +1,18 @@
+// Aphex CMS Configuration System
+import type { CMSConfig } from './types/index';
+
+export function createCMSConfig(config: CMSConfig): CMSConfig {
+	return {
+		// Start with the user's config and apply defaults for missing properties
+		...config,
+		storage: config.storage ?? null, // Default to null if not provided
+		customization: {
+			branding: {
+				title: 'Aphex CMS',
+				...config.customization?.branding
+			},
+			...config.customization
+		},
+		plugins: config.plugins ?? []
+	};
+}

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

@@ -1,4 +1,3 @@
-"use strict";
 // Database adapters are now in separate packages
 // e.g., @aphexcms/postgresql-adapter, @aphexcms/mongodb-adapter
 // This file is kept for backwards compatibility but exports nothing - and potentially default adapters or something. maybe sqlite?

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

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

package/src/lib/db/interfaces/asset.ts

@@ -0,0 +1,61 @@
+// Asset interface for asset operations
+import type { Asset } from '../../types/index';
+
+export interface AssetFilters {
+	organizationId: string; // Required for multi-tenancy (user's current org for RLS context)
+	assetType?: 'image' | 'file';
+	mimeType?: string;
+	search?: string;
+	limit?: number;
+	offset?: number;
+	filterOrganizationIds?: string[]; // Optional: Filter to specific org(s). RLS still enforces access.
+}
+
+export interface CreateAssetData {
+	organizationId: string; // Required for multi-tenancy
+	assetType: 'image' | 'file';
+	filename: string;
+	originalFilename: string;
+	mimeType: string;
+	size: number;
+	url: string;
+	path: string;
+	storageAdapter: string; // Which storage adapter was used
+	width?: number;
+	height?: number;
+	metadata?: any;
+	title?: string;
+	description?: string;
+	alt?: string;
+	creditLine?: string;
+	createdBy?: string; // User ID (optional for backward compatibility)
+}
+
+export interface UpdateAssetData {
+	url?: string; // Allow updating URL (for local storage after asset creation)
+	title?: string;
+	description?: string;
+	alt?: string;
+	creditLine?: string;
+	updatedBy?: string; // User ID (optional for backward compatibility)
+}
+
+/**
+ * Asset adapter interface for asset-specific operations
+ */
+export interface AssetAdapter {
+	// Asset CRUD operations
+	createAsset(data: CreateAssetData): Promise<Asset>;
+	findAssetById(organizationId: string, id: string): Promise<Asset | null>;
+	findAssets(
+		organizationId: string,
+		filters?: Omit<AssetFilters, 'organizationId'>
+	): Promise<Asset[]>;
+	updateAsset(organizationId: string, id: string, data: UpdateAssetData): Promise<Asset | null>;
+	deleteAsset(organizationId: string, id: string): Promise<boolean>;
+
+	// Asset analytics
+	countAssets(organizationId: string): Promise<number>;
+	countAssetsByType(organizationId: string): Promise<Record<string, number>>;
+	getTotalAssetsSize(organizationId: string): Promise<number>;
+}

package/src/lib/db/interfaces/document.ts

@@ -0,0 +1,53 @@
+// Document interface for document operations
+import type { Document } from '../../types/index';
+
+export interface DocumentFilters {
+	organizationId: string; // Required for multi-tenancy (user's current org for RLS context)
+	type?: string;
+	status?: string;
+	limit?: number;
+	offset?: number;
+	depth?: number; // How deep to resolve nested references (0 = no resolution, default = 0)
+	filterOrganizationIds?: string[]; // Optional: Filter to specific org(s). RLS still enforces access.
+}
+
+export interface CreateDocumentData {
+	organizationId: string; // Required for multi-tenancy
+	type: string;
+	draftData: any;
+	createdBy?: string; // User ID (optional for backward compatibility)
+}
+
+export interface UpdateDocumentData {
+	draftData?: any;
+	status?: string;
+	updatedBy?: string; // User ID (optional for backward compatibility)
+}
+
+/**
+ * Document adapter interface for document-specific operations
+ */
+export interface DocumentAdapter {
+	// Document CRUD operations
+	findManyDoc(
+		organizationId: string,
+		filters?: Omit<DocumentFilters, 'organizationId'>
+	): Promise<Document[]>;
+	findByDocId(organizationId: string, id: string, depth?: number): Promise<Document | null>;
+	createDocument(data: CreateDocumentData): Promise<Document>;
+	updateDocDraft(
+		organizationId: string,
+		id: string,
+		data: any,
+		updatedBy?: string
+	): Promise<Document | null>;
+	deleteDocById(organizationId: string, id: string): Promise<boolean>;
+
+	// Publishing operations
+	publishDoc(organizationId: string, id: string): Promise<Document | null>;
+	unpublishDoc(organizationId: string, id: string): Promise<Document | null>;
+
+	// Analytics/counts
+	countDocsByType(organizationId: string, type: string): Promise<number>;
+	getDocCountsByType(organizationId: string): Promise<Record<string, number>>;
+}

package/src/lib/db/interfaces/index.ts

@@ -0,0 +1,98 @@
+// Combined database interface
+import type { DocumentAdapter } from './document';
+import type { AssetAdapter } from './asset';
+import type { UserProfileAdapter } from './user';
+import type { SchemaAdapter } from './schema';
+import type { OrganizationAdapter } from './organization';
+
+// Re-export individual interfaces
+export type {
+	DocumentAdapter,
+	DocumentFilters,
+	CreateDocumentData,
+	UpdateDocumentData
+} from './document';
+export type { AssetAdapter, CreateAssetData, UpdateAssetData } from './asset';
+export type { UserProfileAdapter, NewUserProfileData } from './user';
+export type { SchemaAdapter } from './schema';
+export type { OrganizationAdapter } from './organization';
+
+/**
+ * Combined database adapter interface
+ * Extends all entity-specific adapters for full database functionality
+ */
+export interface DatabaseAdapter
+	extends DocumentAdapter,
+		AssetAdapter,
+		UserProfileAdapter,
+		SchemaAdapter,
+		OrganizationAdapter {
+	// Connection management
+	connect?(): Promise<void>;
+	disconnect?(): Promise<void>;
+
+	// Health check
+	isHealthy(): Promise<boolean>;
+
+	// Multi-tenancy RLS methods (optional - only for adapters that support RLS)
+	/**
+	 * Initialize RLS (enable/disable) on tables - call after migrations
+	 */
+	initializeRLS?(): Promise<void>;
+
+	/**
+	 * Execute a function within a transaction with organization context set for RLS
+	 * Ensures proper isolation with connection pooling
+	 */
+	withOrgContext?<T>(organizationId: string, fn: () => Promise<T>): Promise<T>;
+
+	/**
+	 * Get all child organizations for a parent (for hierarchy support)
+	 */
+	getChildOrganizations?(parentOrganizationId: string): Promise<string[]>;
+
+	/**
+	 * Check if any user profiles exist in the system (for first-user detection)
+	 */
+	hasAnyUserProfiles?(): Promise<boolean>;
+}
+
+/**
+ * Database provider factory interface
+ * Providers are pre-configured and create adapters on demand
+ */
+export interface DatabaseProvider {
+	name: string;
+	createAdapter(): DatabaseAdapter;
+}
+
+/**
+ * Generic database configuration
+ */
+export interface DatabaseConfig {
+	connectionString?: string; // Optional if client is provided
+	client?: any; // Pre-initialized database client (recommended for database agnosticism)
+	options?: {
+		maxConnections?: number;
+		timeout?: number;
+		ssl?: boolean;
+		[key: string]: any;
+	};
+}
+
+/**
+ * Database transaction interface (optional for advanced providers)
+ */
+export interface DatabaseTransaction {
+	commit(): Promise<void>;
+	rollback(): Promise<void>;
+	isActive(): boolean;
+}
+
+/**
+ * Extended database adapter with transaction support
+ */
+export interface TransactionalDatabaseAdapter extends DatabaseAdapter {
+	beginTransaction(): Promise<DatabaseTransaction>;
+	withTransaction<T>(fn: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
+}

package/src/lib/db/interfaces/organization.ts

@@ -0,0 +1,51 @@
+// Organization adapter interface for multi-tenancy operations
+import type {
+	Organization,
+	NewOrganization,
+	OrganizationMember,
+	NewOrganizationMember,
+	Invitation,
+	NewInvitation,
+	UserSession,
+	OrganizationMembership
+} from '../../types/organization';
+
+export interface OrganizationAdapter {
+	// Organization CRUD
+	createOrganization(data: NewOrganization): Promise<Organization>;
+	findOrganizationById(id: string): Promise<Organization | null>;
+	findOrganizationBySlug(slug: string): Promise<Organization | null>;
+	updateOrganization(
+		id: string,
+		data: Partial<Omit<Organization, 'id' | 'createdAt' | 'createdBy'>>
+	): Promise<Organization | null>;
+	deleteOrganization(id: string): Promise<boolean>;
+
+	// Member management
+	addMember(data: NewOrganizationMember): Promise<OrganizationMember>;
+	removeMember(organizationId: string, userId: string): Promise<boolean>;
+	removeAllMembers(organizationId: string): Promise<boolean>;
+	updateMemberRole(
+		organizationId: string,
+		userId: string,
+		role: 'owner' | 'admin' | 'editor' | 'viewer'
+	): Promise<OrganizationMember | null>;
+	findUserMembership(userId: string, organizationId: string): Promise<OrganizationMember | null>;
+	findUserOrganizations(userId: string): Promise<OrganizationMembership[]>;
+	findOrganizationMembers(organizationId: string): Promise<OrganizationMember[]>;
+
+	// Invitation management
+	createInvitation(data: NewInvitation): Promise<Invitation>;
+	findInvitationByToken(token: string): Promise<Invitation | null>;
+	findOrganizationInvitations(organizationId: string): Promise<Invitation[]>;
+	findInvitationsByEmail(email: string): Promise<Invitation[]>;
+	acceptInvitation(token: string, userId: string): Promise<OrganizationMember>;
+	deleteInvitation(id: string): Promise<boolean>;
+	removeAllInvitations(organizationId: string): Promise<boolean>;
+	cleanupExpiredInvitations(): Promise<number>;
+
+	// User session management
+	updateUserSession(userId: string, organizationId: string): Promise<void>;
+	findUserSession(userId: string): Promise<UserSession | null>;
+	deleteUserSession(userId: string): Promise<boolean>;
+}

package/src/lib/db/interfaces/schema.ts

@@ -0,0 +1,13 @@
+import type { SchemaType } from '../../types/index';
+
+/**
+ * Defines database operations for managing schemas.
+ */
+export interface SchemaAdapter {
+	registerSchemaType(schemaType: SchemaType): Promise<void>;
+	getSchemaType(name: string): Promise<SchemaType | null>;
+	listSchemas(): Promise<SchemaType[]>;
+	listDocumentTypes(): Promise<Array<{ name: string; title: string; description?: string }>>;
+	listObjectTypes(): Promise<Array<{ name: string; title: string; description?: string }>>;
+	deleteSchemaType(name: string): Promise<void>;
+}

package/src/lib/db/interfaces/user.ts

@@ -0,0 +1,16 @@
+import type { UserProfile } from '../../types/index';
+
+export interface NewUserProfileData {
+	userId: string;
+	role?: 'super_admin' | 'admin' | 'editor' | 'viewer';
+	preferences?: Record<string, any>;
+}
+
+/**
+ * Defines database operations for managing user profiles.
+ */
+export interface UserProfileAdapter {
+	createUserProfile(data: NewUserProfileData): Promise<UserProfile>;
+	findUserProfileById(userId: string): Promise<UserProfile | null>;
+	deleteUserProfile(userId: string): Promise<boolean>;
+}

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

@@ -0,0 +1,119 @@
+// Reference resolution utility for resolving nested document references
+import type { Document } from '../../types/index';
+import type { DocumentAdapter } from '../interfaces/document';
+
+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/lib/define.ts

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