@aphexcms/cms-core 0.1.0

package/dist/is-mobile.svelte.d.ts

@@ -0,0 +1,5 @@
+import { MediaQuery } from 'svelte/reactivity';
+export declare class IsMobile extends MediaQuery {
+    constructor(breakpoint?: number);
+}
+//# sourceMappingURL=is-mobile.svelte.d.ts.map

package/dist/is-mobile.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-mobile.svelte.d.ts","sourceRoot":"","sources":["../src/lib/is-mobile.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI/C,qBAAa,QAAS,SAAQ,UAAU;gBAC3B,UAAU,GAAE,MAAkC;CAG1D"}

package/dist/is-mobile.svelte.js

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

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;
+export type WithoutChild<T> = T extends {
+    child?: any;
+} ? Omit<T, 'child'> : T;
+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;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAG7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAGD,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;AAE/E,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;AACxF,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AACzE,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,WAAW,IAAI,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;CAAE,CAAC"}

package/dist/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/package.json

@@ -0,0 +1,99 @@
+{
+	"name": "@aphexcms/cms-core",
+	"version": "0.1.0",
+	"description": "Aphex CMS Core - A Sanity-style CMS with ports and adapters architecture",
+	"type": "module",
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"svelte": "./src/index.ts",
+			"default": "./src/index.ts"
+		},
+		"./server": {
+			"types": "./src/server/index.ts",
+			"default": "./src/server/index.ts"
+		},
+		"./client": {
+			"types": "./src/client/index.ts",
+			"default": "./src/client/index.ts"
+		},
+		"./app": {
+			"types": "./src/app.d.ts"
+		}
+	},
+	"typesVersions": {
+		"*": {
+			"app": [
+				"./src/app.d.ts"
+			]
+		}
+	},
+	"files": [
+		"dist",
+		"src",
+		"package.json",
+		"README.md"
+	],
+	"svelte": "./src/index.ts",
+	"scripts": {
+		"build": "svelte-package",
+		"check": "svelte-check --tsconfig ./tsconfig.json",
+		"format": "prettier --write .",
+		"lint": "prettier --check . && eslint .",
+		"package": "pnpm build && pnpm pack",
+		"prepublishOnly": "pnpm build"
+	},
+	"keywords": [
+		"cms",
+		"svelte",
+		"sveltekit",
+		"content-management",
+		"sanity-style",
+		"typescript",
+		"aphex"
+	],
+	"author": "Your Name",
+	"license": "MIT",
+	"peerDependencies": {
+		"@aphexcms/ui": "workspace:*",
+		"@lucide/svelte": "^0.544.0",
+		"@sveltejs/kit": "^2.22.0",
+		"bits-ui": "^2.11.1",
+		"clsx": "^2.1.1",
+		"lucide-svelte": "^0.544.0",
+		"mode-watcher": "^1.1.0",
+		"svelte": "^5.0.0",
+		"tailwind-merge": "^3.3.1",
+		"tailwind-variants": "^3.1.1"
+	},
+	"dependencies": {
+		"s3mini": "^0.5.0",
+		"sharp": "^0.34.4"
+	},
+	"devDependencies": {
+		"@eslint/compat": "^1.2.5",
+		"@eslint/js": "^9.22.0",
+		"@internationalized/date": "^3.9.0",
+		"@sveltejs/adapter-auto": "^6.0.0",
+		"@sveltejs/kit": "^2.22.0",
+		"@sveltejs/package": "^2.5.4",
+		"@sveltejs/vite-plugin-svelte": "^6.0.0",
+		"@tailwindcss/vite": "^4.0.0",
+		"@types/node": "^22",
+		"eslint": "^9.22.0",
+		"eslint-config-prettier": "^10.0.1",
+		"eslint-plugin-svelte": "^3.0.0",
+		"globals": "^16.0.0",
+		"prettier": "^3.4.2",
+		"prettier-plugin-svelte": "^3.3.3",
+		"prettier-plugin-tailwindcss": "^0.6.11",
+		"svelte": "^5.0.0",
+		"svelte-check": "^4.0.0",
+		"tailwindcss": "^4.0.0",
+		"typescript": "^5.0.0",
+		"typescript-eslint": "^8.20.0",
+		"vite": "^7.0.4"
+	}
+}

package/src/api/assets.ts

@@ -0,0 +1,75 @@
+// Assets API client - manage uploaded files and images
+import { apiClient } from './client.js';
+import type { Asset } from '../types/asset.js';
+import type { ApiResponse } from './types.js';
+
+export interface AssetFilters {
+	assetType?: 'image' | 'file';
+	mimeType?: string;
+	search?: string;
+	limit?: number;
+	offset?: number;
+}
+
+export interface UpdateAssetData {
+	title?: string;
+	description?: string;
+	alt?: string;
+	creditLine?: string;
+}
+
+export class AssetsApi {
+	/**
+	 * List assets with optional filters
+	 */
+	static async list(filters?: AssetFilters): Promise<ApiResponse<Asset[]>> {
+		const params = new URLSearchParams();
+		if (filters) {
+			Object.entries(filters).forEach(([key, value]) => {
+				if (value !== undefined) {
+					params.append(key, String(value));
+				}
+			});
+		}
+		const query = params.toString();
+		return apiClient.get<Asset[]>(`/assets${query ? `?${query}` : ''}`);
+	}
+
+	/**
+	 * Get asset by ID
+	 */
+	static async getById(id: string): Promise<ApiResponse<Asset>> {
+		return apiClient.get<Asset>(`/assets/${id}`);
+	}
+
+	/**
+	 * Upload a new asset (multipart/form-data)
+	 * Note: Use FormData for file uploads
+	 */
+	static async upload(formData: FormData): Promise<ApiResponse<Asset>> {
+		return apiClient.post<Asset>('/assets', formData);
+	}
+
+	/**
+	 * Update asset metadata
+	 */
+	static async update(id: string, data: UpdateAssetData): Promise<ApiResponse<Asset>> {
+		return apiClient.patch<Asset>(`/assets/${id}`, data);
+	}
+
+	/**
+	 * Delete an asset
+	 */
+	static async delete(id: string): Promise<ApiResponse<{ success: boolean }>> {
+		return apiClient.delete<{ success: boolean }>(`/assets/${id}`);
+	}
+}
+
+// Export convenience functions for direct use
+export const assets = {
+	list: AssetsApi.list.bind(AssetsApi),
+	getById: AssetsApi.getById.bind(AssetsApi),
+	upload: AssetsApi.upload.bind(AssetsApi),
+	update: AssetsApi.update.bind(AssetsApi),
+	delete: AssetsApi.delete.bind(AssetsApi)
+};

package/src/api/client.ts

@@ -0,0 +1,150 @@
+// Base API client with common functionality
+import type { ApiResponse } from './types.js';
+
+// Default configuration
+const DEFAULT_BASE_URL = '/api';
+const DEFAULT_TIMEOUT = 10000; // 10 seconds
+
+export class ApiError extends Error {
+	constructor(
+		public status: number,
+		public response: any,
+		message?: string
+	) {
+		super(message || `API Error: ${status}`);
+		this.name = 'ApiError';
+	}
+}
+
+export class ApiClient {
+	private baseUrl: string;
+	private timeout: number;
+
+	constructor(baseUrl = DEFAULT_BASE_URL, timeout = DEFAULT_TIMEOUT) {
+		this.baseUrl = baseUrl;
+		this.timeout = timeout;
+	}
+
+	/**
+	 * Make HTTP request with proper error handling
+	 */
+	private async request<T>(endpoint: string, options: RequestInit = {}): Promise<ApiResponse<T>> {
+		const url = `${this.baseUrl}${endpoint}`;
+
+		// Set up request with defaults
+		// Don't set Content-Type for FormData (browser will set it with boundary)
+		const headers: Record<string, string> = {};
+		if (!(options.body instanceof FormData)) {
+			headers['Content-Type'] = 'application/json';
+		}
+
+		const requestOptions: RequestInit = {
+			headers: {
+				...headers,
+				...options.headers
+			},
+			...options
+		};
+
+		// Add timeout
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+		requestOptions.signal = controller.signal;
+
+		try {
+			const response = await fetch(url, requestOptions);
+			clearTimeout(timeoutId);
+
+			const data: ApiResponse<T> = await response.json();
+
+			// Handle HTTP errors
+			if (!response.ok) {
+				throw new ApiError(response.status, data, data.message || data.error);
+			}
+
+			// Handle API-level errors
+			if (!data.success) {
+				throw new ApiError(response.status, data, data.message || data.error);
+			}
+
+			return data;
+		} catch (error) {
+			clearTimeout(timeoutId);
+
+			if (error instanceof ApiError) {
+				throw error;
+			}
+
+			// Handle fetch errors (network, timeout, etc.)
+			throw new ApiError(0, null, error instanceof Error ? error.message : 'Network error');
+		}
+	}
+
+	/**
+	 * GET request
+	 */
+	async get<T>(endpoint: string, params?: Record<string, any>): Promise<ApiResponse<T>> {
+		let url = endpoint;
+
+		if (params) {
+			const searchParams = new URLSearchParams();
+			Object.entries(params).forEach(([key, value]) => {
+				if (value !== undefined && value !== null) {
+					searchParams.append(key, String(value));
+				}
+			});
+
+			if (searchParams.toString()) {
+				url += `?${searchParams.toString()}`;
+			}
+		}
+
+		return this.request<T>(url, { method: 'GET' });
+	}
+
+	/**
+	 * POST request
+	 */
+	async post<T>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+		return this.request<T>(endpoint, {
+			method: 'POST',
+			// Don't stringify FormData - pass it directly
+			body: body instanceof FormData ? body : body ? JSON.stringify(body) : undefined
+		});
+	}
+
+	/**
+	 * PUT request
+	 */
+	async put<T>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+		return this.request<T>(endpoint, {
+			method: 'PUT',
+			// Don't stringify FormData - pass it directly
+			body: body instanceof FormData ? body : body ? JSON.stringify(body) : undefined
+		});
+	}
+
+	/**
+	 * DELETE request
+	 */
+	async delete<T>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+		return this.request<T>(endpoint, {
+			method: 'DELETE',
+			body: body ? JSON.stringify(body) : undefined
+		});
+	}
+
+	/**
+	 * PATCH request
+	 */
+	async patch<T>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+		return this.request<T>(endpoint, {
+			method: 'PATCH',
+			// Don't stringify FormData - pass it directly
+			body: body instanceof FormData ? body : body ? JSON.stringify(body) : undefined
+		});
+	}
+}
+
+// Export singleton instance
+export const apiClient = new ApiClient();

package/src/api/documents.ts

@@ -0,0 +1,102 @@
+// Documents API client - composable document operations
+import { apiClient } from './client.js';
+import type {
+	Document,
+	DocumentListParams,
+	CreateDocumentData,
+	UpdateDocumentData,
+	ApiResponse
+} from './types.js';
+
+export class DocumentsApi {
+	/**
+	 * List documents with optional filtering
+	 */
+	static async list(params: DocumentListParams = {}): Promise<ApiResponse<Document[]>> {
+		return apiClient.get<Document[]>('/documents', params);
+	}
+
+	/**
+	 * Get document by ID
+	 */
+	static async getById(id: string): Promise<ApiResponse<Document>> {
+		return apiClient.get<Document>(`/documents/${id}`);
+	}
+
+	/**
+	 * Create new document
+	 */
+	static async create(data: CreateDocumentData): Promise<ApiResponse<Document>> {
+		return apiClient.post<Document>('/documents', data);
+	}
+
+	/**
+	 * Update document draft by ID (auto-save)
+	 */
+	static async updateById(id: string, data: UpdateDocumentData): Promise<ApiResponse<Document>> {
+		return apiClient.put<Document>(`/documents/${id}`, data);
+	}
+
+	/**
+	 * Publish document (copy draft -> published)
+	 */
+	static async publish(id: string): Promise<ApiResponse<Document>> {
+		return apiClient.post<Document>(`/documents/${id}/publish`);
+	}
+
+	/**
+	 * Unpublish document (revert to draft only)
+	 */
+	static async unpublish(id: string): Promise<ApiResponse<Document>> {
+		return apiClient.delete<Document>(`/documents/${id}/publish`);
+	}
+
+	/**
+	 * Delete document by ID
+	 */
+	static async deleteById(id: string): Promise<ApiResponse<void>> {
+		return apiClient.delete<void>(`/documents/${id}`);
+	}
+
+	/**
+	 * Get documents by type (convenience method)
+	 */
+	static async getByType(
+		docType: string,
+		params: Omit<DocumentListParams, 'docType'> = {}
+	): Promise<ApiResponse<Document[]>> {
+		return this.list({ ...params, docType });
+	}
+
+	/**
+	 * Get published documents only (convenience method)
+	 */
+	static async getPublished(
+		params: Omit<DocumentListParams, 'status'> = {}
+	): Promise<ApiResponse<Document[]>> {
+		return this.list({ ...params, status: 'published' });
+	}
+
+	/**
+	 * Get draft documents only (convenience method)
+	 */
+	static async getDrafts(
+		params: Omit<DocumentListParams, 'status'> = {}
+	): Promise<ApiResponse<Document[]>> {
+		return this.list({ ...params, status: 'draft' });
+	}
+}
+
+// Export convenience functions for direct use
+export const documents = {
+	list: DocumentsApi.list.bind(DocumentsApi),
+	getById: DocumentsApi.getById.bind(DocumentsApi),
+	create: DocumentsApi.create.bind(DocumentsApi),
+	updateById: DocumentsApi.updateById.bind(DocumentsApi),
+	publish: DocumentsApi.publish.bind(DocumentsApi),
+	unpublish: DocumentsApi.unpublish.bind(DocumentsApi),
+	deleteById: DocumentsApi.deleteById.bind(DocumentsApi),
+	getByType: DocumentsApi.getByType.bind(DocumentsApi),
+	getPublished: DocumentsApi.getPublished.bind(DocumentsApi),
+	getDrafts: DocumentsApi.getDrafts.bind(DocumentsApi)
+};

package/src/api/index.ts

@@ -0,0 +1,7 @@
+// API Client exports
+export { type ApiClient, ApiError, apiClient } from './client.js';
+export { type ApiResponse } from './types.js';
+export { documents } from './documents.js';
+export { organizations } from './organizations.js';
+export { assets } from './assets.js';
+export type * from '../types/index.js';

package/src/api/organizations.ts

@@ -0,0 +1,154 @@
+// Organizations API client - composable organization operations
+import { apiClient } from './client.js';
+import type { Organization, OrganizationMember, OrganizationRole } from '../types/organization.js';
+import type { ApiResponse } from './types.js';
+
+export interface CreateOrganizationData {
+	name: string;
+	slug: string;
+	metadata?: any;
+	parentOrganizationId?: string;
+}
+
+export interface OrganizationListItem extends Organization {
+	role: OrganizationRole;
+	joinedAt: Date;
+	isActive: boolean;
+}
+
+export interface SwitchOrganizationData {
+	organizationId: string;
+}
+
+export interface InviteMemberData {
+	email: string;
+	role: OrganizationRole;
+}
+
+export interface UpdateMemberRoleData {
+	userId: string;
+	role: OrganizationRole;
+}
+
+export interface RemoveMemberData {
+	userId: string;
+}
+
+export interface CancelInvitationData {
+	invitationId: string;
+}
+
+export interface UpdateOrganizationData {
+	name?: string;
+	slug?: string;
+	metadata?: any;
+}
+
+export class OrganizationsApi {
+	/**
+	 * List user's organizations
+	 */
+	static async list(): Promise<ApiResponse<OrganizationListItem[]>> {
+		return apiClient.get<OrganizationListItem[]>('/organizations');
+	}
+
+	/**
+	 * Create new organization (super_admin only)
+	 */
+	static async create(data: CreateOrganizationData): Promise<ApiResponse<Organization>> {
+		return apiClient.post<Organization>('/organizations', data);
+	}
+
+	/**
+	 * Switch to a different organization
+	 */
+	static async switch(data: SwitchOrganizationData): Promise<ApiResponse<{ success: boolean }>> {
+		return apiClient.post<{ success: boolean }>('/organizations/switch', data);
+	}
+
+	/**
+	 * Get organization by ID
+	 */
+	static async getById(id: string): Promise<ApiResponse<Organization>> {
+		return apiClient.get<Organization>(`/organizations/${id}`);
+	}
+
+	/**
+	 * Get active organization
+	 */
+	static async getActive(): Promise<ApiResponse<Organization>> {
+		const result = await this.list();
+		const active = result.data?.find((org) => org.isActive);
+		if (!active) {
+			throw new Error('No active organization found');
+		}
+		return {
+			success: true,
+			data: active
+		};
+	}
+
+	/**
+	 * Get organization members
+	 */
+	static async getMembers(): Promise<ApiResponse<OrganizationMember[]>> {
+		return apiClient.get<OrganizationMember[]>('/organizations/members');
+	}
+
+	/**
+	 * Invite a member to the organization
+	 */
+	static async inviteMember(data: InviteMemberData): Promise<ApiResponse<OrganizationMember>> {
+		return apiClient.post<OrganizationMember>('/organizations/invitations', data);
+	}
+
+	/**
+	 * Remove a member from the organization
+	 */
+	static async removeMember(data: RemoveMemberData): Promise<ApiResponse<{ success: boolean }>> {
+		return apiClient.delete<{ success: boolean }>('/organizations/members', data);
+	}
+
+	/**
+	 * Update a member's role
+	 */
+	static async updateMemberRole(
+		data: UpdateMemberRoleData
+	): Promise<ApiResponse<OrganizationMember>> {
+		return apiClient.patch<OrganizationMember>('/organizations/members', data);
+	}
+
+	/**
+	 * Update organization settings
+	 */
+	static async update(
+		id: string,
+		data: UpdateOrganizationData
+	): Promise<ApiResponse<Organization>> {
+		return apiClient.patch<Organization>(`/organizations/${id}`, data);
+	}
+
+	/**
+	 * Cancel a pending invitation
+	 */
+	static async cancelInvitation(
+		data: CancelInvitationData
+	): Promise<ApiResponse<{ success: boolean }>> {
+		return apiClient.delete<{ success: boolean }>('/organizations/invitations', data);
+	}
+}
+
+// Export convenience functions for direct use
+export const organizations = {
+	list: OrganizationsApi.list.bind(OrganizationsApi),
+	create: OrganizationsApi.create.bind(OrganizationsApi),
+	switch: OrganizationsApi.switch.bind(OrganizationsApi),
+	getById: OrganizationsApi.getById.bind(OrganizationsApi),
+	getActive: OrganizationsApi.getActive.bind(OrganizationsApi),
+	update: OrganizationsApi.update.bind(OrganizationsApi),
+	getMembers: OrganizationsApi.getMembers.bind(OrganizationsApi),
+	inviteMember: OrganizationsApi.inviteMember.bind(OrganizationsApi),
+	removeMember: OrganizationsApi.removeMember.bind(OrganizationsApi),
+	updateMemberRole: OrganizationsApi.updateMemberRole.bind(OrganizationsApi),
+	cancelInvitation: OrganizationsApi.cancelInvitation.bind(OrganizationsApi)
+};

package/src/api/types.ts

@@ -0,0 +1,34 @@
+// API client types
+import type { Document, NewDocument } from '../types/index.js';
+
+// API Response wrappers
+export interface ApiResponse<T> {
+	success: boolean;
+	data?: T;
+	error?: string;
+	message?: string;
+	meta?: {
+		count: number;
+		limit: number;
+		offset: number;
+		filters: Record<string, any>;
+	};
+}
+
+// Document-related types
+export interface DocumentListParams {
+	docType?: string;
+	status?: string;
+	limit?: number;
+	offset?: number;
+}
+
+// Use database types directly instead of duplicating
+export type CreateDocumentData = Omit<
+	NewDocument,
+	'id' | 'createdAt' | 'updatedAt' | 'publishedAt'
+>;
+export type UpdateDocumentData = Partial<Pick<Document, 'draftData' | 'status'>>;
+
+// Re-export database types for convenience
+export type { Document, NewDocument };

package/src/app.d.ts

@@ -0,0 +1,19 @@
+// See https://svelte.dev/docs/kit/types#app.d.ts
+// for information about these interfaces
+//
+import type { CMSInstances } from './hooks.js';
+import type { Auth } from './types/index.js';
+declare global {
+	namespace App {
+		// interface Error {}
+		interface Locals {
+			aphexCMS: CMSInstances;
+			auth?: Auth; // Available in protected routes
+		}
+		// interface PageData {}
+		// interface PageState {}
+		// interface Platform {}
+	}
+}
+
+export {};