@aphexcms/cms-core 0.1.10 → 0.1.11

package/src/lib/types/organization.ts

@@ -0,0 +1,119 @@
+// Organization types for multi-tenancy
+// These match the inferred types from Drizzle schema
+
+export type OrganizationRole = 'owner' | 'admin' | 'editor' | 'viewer';
+
+export interface Organization {
+	id: string;
+	name: string;
+	slug: string;
+	parentOrganizationId: string | null;
+	metadata: {
+		logo?: string;
+		theme?: {
+			primaryColor: string;
+			fontFamily: string;
+			logoUrl: string;
+		};
+		website?: string;
+		settings?: Record<string, any>;
+	} | null;
+	createdBy: string;
+	createdAt: Date;
+	updatedAt: Date;
+}
+
+export interface NewOrganization {
+	name: string;
+	slug: string;
+	createdBy: string;
+	id?: string;
+	parentOrganizationId?: string | null;
+	metadata?: {
+		logo?: string;
+		theme?: {
+			primaryColor: string;
+			fontFamily: string;
+			logoUrl: string;
+		};
+		website?: string;
+		settings?: Record<string, any>;
+	} | null;
+	createdAt?: Date;
+	updatedAt?: Date;
+}
+
+export interface OrganizationMember {
+	id: string;
+	createdAt: Date;
+	updatedAt: Date;
+	organizationId: string;
+	userId: string;
+	role: OrganizationRole;
+	preferences: Record<string, any> | null;
+	invitationId: string | null; // Link to invitation (get invitedBy, invitedEmail from there)
+}
+
+export interface NewOrganizationMember {
+	organizationId: string;
+	userId: string;
+	role: OrganizationRole;
+	id?: string;
+	createdAt?: Date;
+	updatedAt?: Date;
+	preferences?: Record<string, any> | null;
+	invitationId?: string | null;
+}
+
+export interface Invitation {
+	id: string;
+	createdAt: Date;
+	organizationId: string;
+	role: OrganizationRole;
+	invitedBy: string;
+	email: string;
+	token: string;
+	expiresAt: Date;
+	acceptedAt: Date | null;
+}
+
+export interface NewInvitation {
+	organizationId: string;
+	role: OrganizationRole;
+	invitedBy: string;
+	email: string;
+	token: string;
+	expiresAt: Date;
+	id?: string;
+	createdAt?: Date;
+	acceptedAt?: Date | null;
+}
+
+export interface UserSession {
+	updatedAt: Date;
+	userId: string;
+	activeOrganizationId: string | null;
+}
+
+export interface NewUserSession {
+	userId: string;
+	updatedAt?: Date;
+	activeOrganizationId?: string | null;
+}
+
+// Helper type for organization with member info
+export interface OrganizationMembership {
+	organization: Organization;
+	member: OrganizationMember;
+}
+
+// Helper type for member with user info
+export interface OrganizationMemberWithUser {
+	member: OrganizationMember;
+	user: {
+		id: string;
+		email: string;
+		name: string | null;
+		image: string | null;
+	};
+}

package/src/lib/types/schemas.ts

@@ -0,0 +1,156 @@
+// types/schemas.ts
+import type { Rule } from '../field-validation/rule';
+import type { Icon as LucideIcon } from 'lucide-svelte';
+
+// From root types.ts
+export type FieldType =
+	| 'string'
+	| 'text'
+	| 'number'
+	| 'boolean'
+	| 'slug'
+	| 'image'
+	| 'array'
+	| 'object'
+	| 'reference';
+
+export interface BaseField {
+	name: string;
+	type: FieldType;
+	title: string;
+	description?: string;
+	validation?: ((rule: Rule) => Rule) | Array<(rule: Rule) => Rule>;
+}
+
+export interface StringField extends BaseField {
+	type: 'string';
+	maxLength?: number;
+	placeholder?: string;
+}
+
+export interface TextField extends BaseField {
+	type: 'text';
+	rows?: number;
+	maxLength?: number;
+	placeholder?: string;
+}
+
+export interface NumberField extends BaseField {
+	type: 'number';
+	min?: number;
+	max?: number;
+}
+
+export interface BooleanField extends BaseField {
+	type: 'boolean';
+	initialValue?: boolean;
+}
+
+export interface SlugField extends BaseField {
+	type: 'slug';
+	source?: string;
+	maxLength?: number;
+}
+
+export interface ImageField extends BaseField {
+	type: 'image';
+	accept?: string;
+	hotspot?: boolean; // Enable hotspot/crop UI
+	metadata?: string[]; // e.g., ['palette', 'exif', 'location']
+	fields?: Field[]; // Additional fields like caption, attribution
+	private?: boolean; // Default: false (public). Set true to require auth for access
+}
+
+export interface TypeReference {
+	type: string; // References a SchemaType by name
+	title?: string;
+}
+
+export interface ArrayField extends BaseField {
+	type: 'array';
+	of: TypeReference[];
+	max?: number;
+}
+
+export interface ObjectField extends BaseField {
+	type: 'object';
+	fields: Field[];
+}
+
+export interface ReferenceField extends BaseField {
+	type: 'reference';
+	to: Array<{ type: string }>;
+}
+
+export type Field =
+	| StringField
+	| TextField
+	| NumberField
+	| BooleanField
+	| SlugField
+	| ImageField
+	| ArrayField
+	| ObjectField
+	| ReferenceField;
+
+export interface PreviewConfig {
+	select?: {
+		title?: string;
+		subtitle?: string;
+		media?: string;
+	};
+}
+
+export interface DocumentType {
+	id: string;
+	type: 'document';
+	name: string;
+	title: string;
+	description?: string;
+	icon?: typeof LucideIcon;
+	fields: Field[];
+	preview?: PreviewConfig;
+	createdAt: Date | null;
+	updatedAt: Date | null;
+}
+
+export interface ObjectType {
+	type: 'object';
+	name: string;
+	title: string;
+	description?: string;
+	icon?: typeof LucideIcon;
+	fields: Field[];
+	preview?: PreviewConfig;
+}
+
+// From db/types.ts
+/**
+ * Schema type - represents document and object type definitions stored in the DB
+ */
+// Schema type for all definitions
+export interface SchemaType {
+	id?: string;
+	type: 'document' | 'object';
+	name: string;
+	title: string;
+	description?: string;
+	icon?: typeof LucideIcon;
+	fields: Field[];
+	preview?: PreviewConfig;
+	createdAt?: Date | null;
+	updatedAt?: Date | null;
+}
+
+export interface NewSchemaType {
+	id?: string;
+	type: 'document' | 'object';
+	name: string;
+	title: string;
+	description?: string;
+	icon?: typeof LucideIcon;
+	fields: Field[];
+	preview?: PreviewConfig;
+	createdAt?: Date | null;
+	updatedAt?: Date | null;
+}

package/src/lib/types/sidebar.ts

@@ -0,0 +1,37 @@
+// Sidebar data types - extensible interfaces for admin UI
+export interface SidebarUser {
+	id: string;
+	email: string;
+	name?: string;
+	image?: string;
+	role?: string;
+}
+
+export interface SidebarNavItem {
+	href: string;
+	label: string;
+	icon?: string;
+	badge?: string | number;
+}
+
+export interface SidebarBranding {
+	title?: string;
+	logo?: string;
+}
+
+export interface SidebarOrganization {
+	id: string;
+	name: string;
+	slug: string;
+	role: 'owner' | 'admin' | 'editor' | 'viewer';
+	isActive: boolean;
+	metadata?: any;
+}
+
+export interface SidebarData {
+	user: SidebarUser;
+	branding?: SidebarBranding;
+	navItems?: SidebarNavItem[]; // Optional custom nav items (defaults to Content)
+	organizations?: SidebarOrganization[]; // User's organizations for organization switcher
+	activeOrganization?: SidebarOrganization; // Currently active organization
+}

package/src/lib/types/user.ts

@@ -0,0 +1,17 @@
+// Represents the data stored in the cms_user_profiles table.
+export interface UserProfile {
+	userId: string;
+	role: 'super_admin' | 'admin' | 'editor' | 'viewer';
+	preferences?: Record<string, any>;
+}
+
+// Represents the core user data from the auth provider.
+export interface AuthUser {
+	id: string;
+	email: string;
+	name?: string;
+	image?: string;
+}
+
+// The final, combined object, composed from the two types above.
+export interface CMSUser extends AuthUser, Omit<UserProfile, 'userId'> {}

package/src/lib/utils/content-hash.ts

@@ -0,0 +1,75 @@
+/**
+ * Content hashing utilities for document version tracking
+ * Includes timestamp for proper change detection and UX
+ */
+
+/**
+ * Recursively sort object keys for stable JSON serialization
+ */
+function sortObject(item: any): any {
+	if (item === null || typeof item !== 'object') return item;
+
+	if (Array.isArray(item)) {
+		return item.map(sortObject);
+	}
+
+	const sortedKeys = Object.keys(item).sort();
+	const sortedObj: any = {};
+	for (const key of sortedKeys) {
+		sortedObj[key] = sortObject(item[key]);
+	}
+	return sortedObj;
+}
+
+/**
+ * Create a stable hash from any object using a simple hash algorithm
+ */
+function simpleHash(str: string): string {
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash; // Convert to 32-bit integer
+	}
+	return Math.abs(hash).toString(36); // Base36 for shorter string
+}
+
+/**
+ * Create a content hash including timestamp for change tracking
+ * This matches Sanity's behavior where any interaction creates a publishable state
+ */
+export function createContentHash(data: any, includeTimestamp = true): string {
+	const hashData = includeTimestamp
+		? {
+				...data,
+				_lastModified: new Date().toISOString()
+			}
+		: data;
+
+	const stableJson = JSON.stringify(sortObject(hashData));
+	return simpleHash(stableJson);
+}
+
+/**
+ * Create a hash from published data (no timestamp needed as it's already stable)
+ */
+export function createPublishedHash(data: any): string {
+	return createContentHash(data, false);
+}
+
+/**
+ * Compare if current draft differs from published version
+ */
+export function hasUnpublishedChanges(draftData: any, publishedHash: string | null): boolean {
+	if (!publishedHash) return true; // No published version = has changes
+
+	const publishedDataHash = createPublishedHash(draftData);
+	return publishedDataHash !== publishedHash;
+}
+
+/**
+ * Utility to create a clean published hash when publishing
+ */
+export function createHashForPublishing(draftData: any): string {
+	return createPublishedHash(draftData);
+}

package/src/lib/utils/image-url.ts

@@ -0,0 +1,204 @@
+import type { ImageValue, ImageAsset, Asset } from '../types/asset';
+
+export interface ImageUrlBuilderOptions {
+	width?: number;
+	height?: number;
+	quality?: number;
+	format?: 'jpg' | 'jpeg' | 'png' | 'webp' | 'avif';
+	fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+	auto?: 'format';
+}
+
+export interface ImageUrlBuilderConfig {
+	baseUrl?: string;
+	/**
+	 * Function to sign asset URLs for secure, time-limited access
+	 * Used for multi-tenant access without exposing API keys
+	 */
+	signAssetUrl?: (assetId: string) => string;
+}
+
+/**
+ * Helper to extract URL from various image source types
+ * Works with GraphQL responses that include resolved asset data
+ */
+function extractUrl(source: any): string | null {
+	if (!source) return null;
+
+	// Direct URL string
+	if (typeof source === 'string') {
+		return source;
+	}
+
+	// Asset object with url property
+	if (typeof source === 'object' && 'url' in source && source.url) {
+		return source.url;
+	}
+
+	// ImageValue with resolved asset (from GraphQL)
+	if (typeof source === 'object' && 'asset' in source && source.asset) {
+		// Check if asset is resolved (has url property)
+		if (typeof source.asset === 'object' && 'url' in source.asset) {
+			return source.asset.url;
+		}
+	}
+
+	return null;
+}
+
+export class ImageUrlBuilder {
+	private _source: any = null;
+	private _options: ImageUrlBuilderOptions = {};
+
+	/**
+	 * Set the image source
+	 */
+	image(source: ImageValue | ImageAsset | string | Asset | null | undefined): this {
+		this._source = source;
+		return this;
+	}
+
+	/**
+	 * Set width (for future dynamic image rendering)
+	 */
+	width(width: number): this {
+		this._options.width = width;
+		return this;
+	}
+
+	/**
+	 * Set height (for future dynamic image rendering)
+	 */
+	height(height: number): this {
+		this._options.height = height;
+		return this;
+	}
+
+	/**
+	 * Set both width and height (for future dynamic image rendering)
+	 */
+	size(width: number, height: number): this {
+		this._options.width = width;
+		this._options.height = height;
+		return this;
+	}
+
+	/**
+	 * Set quality (for future dynamic image rendering)
+	 */
+	quality(quality: number): this {
+		this._options.quality = Math.max(1, Math.min(100, quality));
+		return this;
+	}
+
+	/**
+	 * Set format (for future dynamic image rendering)
+	 */
+	format(format: 'jpg' | 'jpeg' | 'png' | 'webp' | 'avif'): this {
+		this._options.format = format;
+		return this;
+	}
+
+	/**
+	 * Set fit mode (for future dynamic image rendering)
+	 */
+	fit(fit: 'cover' | 'contain' | 'fill' | 'inside' | 'outside'): this {
+		this._options.fit = fit;
+		return this;
+	}
+
+	/**
+	 * Enable automatic format selection (for future dynamic image rendering)
+	 */
+	auto(mode: 'format'): this {
+		this._options.auto = mode;
+		return this;
+	}
+
+	/**
+	 * Build the final URL
+	 * Returns /api/assets/{id}?dl=1 which redirects to the actual S3/R2 URL
+	 * Transformations (.width(), .quality(), etc) are stored but not yet applied
+	 *
+	 * For multi-tenant access, use signAssetUrl config to generate signed URLs
+	 * TODO: Add dynamic image rendering support
+	 */
+	url(): string | null {
+		console.log('[ImageUrlBuilder] url() called with source:', JSON.stringify(this._source));
+
+		if (!this._source) {
+			console.log('[ImageUrlBuilder] No source provided');
+			return null;
+		}
+
+		// First try to extract a direct URL (if asset was already resolved)
+		const directUrl = extractUrl(this._source);
+		if (directUrl) {
+			console.log('[ImageUrlBuilder] Using direct URL from resolved asset:', directUrl);
+			return directUrl;
+		}
+
+		// Otherwise, build an API URL from the asset reference
+		let assetId: string | null = null;
+
+		if (typeof this._source === 'string') {
+			console.log('[ImageUrlBuilder] Source is string:', this._source);
+			assetId = this._source;
+		} else if (typeof this._source === 'object') {
+			console.log('[ImageUrlBuilder] Source is object, checking for asset._ref or _ref');
+			if ('asset' in this._source && this._source.asset?._ref) {
+				assetId = this._source.asset._ref;
+				console.log('[ImageUrlBuilder] Found asset._ref:', assetId);
+			} else if ('_ref' in this._source) {
+				assetId = this._source._ref;
+				console.log('[ImageUrlBuilder] Found _ref:', assetId);
+			}
+		}
+
+		if (!assetId) {
+			console.warn('[ImageUrlBuilder] Could not extract asset ID from source:', this._source);
+			return null;
+		}
+
+		const finalUrl = `/media/${assetId}/image`;
+		console.log('[ImageUrlBuilder] Building CDN URL:', finalUrl);
+		return finalUrl;
+	}
+
+	/**
+	 * Alias for url()
+	 */
+	toString(): string | null {
+		return this.url();
+	}
+}
+
+/**
+ * Factory function to create an image URL builder
+ *
+ * Note: Currently returns direct S3/R2 URLs without transformations.
+ * The baseUrl parameter is accepted for future compatibility but not currently used
+ * since assets already contain their full public URLs.
+ *
+ * For multi-tenant access with API keys, provide a signAssetUrl function:
+ *   const urlFor = imageUrlBuilder({
+ *     signAssetUrl: (assetId) => `/api/assets/${assetId}?token=${generateToken(assetId)}`
+ *   })
+ *
+ * Usage:
+ *   const urlFor = imageUrlBuilder({ baseUrl: 'https://yourdomain.com' })
+ *   const url = urlFor(image).url() // Returns asset.url directly
+ *
+ * Future usage with transformations:
+ *   const url = urlFor(image).width(800).quality(80).url()
+ *   // Will return transformed image once dynamic rendering is implemented
+ */
+export function imageUrlBuilder() {
+	return (source?: ImageValue | ImageAsset | string | Asset | null) => {
+		const builder = new ImageUrlBuilder();
+		if (source) {
+			builder.image(source);
+		}
+		return builder;
+	};
+}

package/src/lib/utils/index.ts

@@ -0,0 +1,12 @@
+// Aphex CMS Utilities
+
+// Schema utilities
+export * from '../schema-utils/index';
+
+// Validation utilities
+export * from '../field-validation/utils';
+
+// Other utilities
+export * from './content-hash';
+export * from './slug';
+export * from './image-url';

package/src/lib/utils/slug.ts

@@ -0,0 +1,33 @@
+/**
+ * Generate a URL-friendly slug from a string
+ * @param text - The text to convert to a slug
+ * @returns A URL-safe slug string
+ */
+export function generateSlug(text: string): string {
+	if (!text) return '';
+
+	return (
+		text
+			.toString()
+			.toLowerCase()
+			.trim()
+			// Replace spaces and multiple special characters with single hyphens
+			.replace(/[^a-z0-9]+/g, '-')
+			// Remove leading and trailing hyphens
+			.replace(/^-+|-+$/g, '')
+	);
+}
+
+/**
+ * Validate if a string is a valid slug
+ * @param slug - The slug to validate
+ * @returns Boolean indicating if the slug is valid
+ */
+export function isValidSlug(slug: string): boolean {
+	if (!slug) return false;
+
+	// Valid slug: lowercase letters, numbers, and hyphens only
+	// Cannot start or end with hyphen
+	const slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+	return slugPattern.test(slug);
+}

package/src/lib/utils.ts

@@ -0,0 +1,13 @@
+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 };