@aphexcms/cms-core 0.1.11 → 0.1.13

package/dist/hooks.js

@@ -0,0 +1,164 @@
+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 } from './engine.js';
+import { createLocalAPI } from './local-api/index.js';
+let cmsInstances = null;
+let lastConfigHash = null;
+// Helper to generate a simple hash of schema types for change detection
+function getConfigHash(config) {
+    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() {
+    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}
+    });
+}
+/**
+ * Resolves a plugin configuration to an actual CMSPlugin instance
+ * Supports three formats:
+ * 1. String: '@aphexcms/graphql-plugin' - dynamically imports default export
+ * 2. Object with name/options: { name: '@aphexcms/graphql-plugin', options: {...} }
+ * 3. Already instantiated plugin: CMSPlugin object
+ */
+async function resolvePlugin(pluginConfig) {
+    // Format 3: Already an instantiated plugin
+    if (typeof pluginConfig === 'object' && 'install' in pluginConfig) {
+        return pluginConfig;
+    }
+    // Format 1: String reference
+    if (typeof pluginConfig === 'string') {
+        try {
+            const pluginModule = await import(/* @vite-ignore */ pluginConfig);
+            const plugin = pluginModule.default || pluginModule;
+            if (typeof plugin === 'function') {
+                // If it's a factory function, call it with no options
+                return plugin();
+            }
+            return plugin;
+        }
+        catch (error) {
+            throw new Error(`Failed to load plugin "${pluginConfig}". Make sure it's installed: npm install ${pluginConfig}\nError: ${error}`);
+        }
+    }
+    // Format 2: Object with name and options
+    if (typeof pluginConfig === 'object' && 'name' in pluginConfig) {
+        try {
+            const pluginModule = await import(/* @vite-ignore */ pluginConfig.name);
+            const pluginFactory = pluginModule.default || pluginModule;
+            if (typeof pluginFactory === 'function') {
+                // Call factory with options
+                return pluginFactory(pluginConfig.options || {});
+            }
+            // If not a factory, return as-is (assuming it's already a plugin)
+            return pluginFactory;
+        }
+        catch (error) {
+            throw new Error(`Failed to load plugin "${pluginConfig.name}". Make sure it's installed: npm install ${pluginConfig.name}\nError: ${error}`);
+        }
+    }
+    throw new Error(`Invalid plugin configuration: ${JSON.stringify(pluginConfig)}`);
+}
+export function createCMSHook(config) {
+    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);
+            // Initialize Local API (unified operations layer)
+            const localAPI = createLocalAPI(config, databaseAdapter);
+            await cmsEngine.initialize();
+            // Build plugin route map and install plugins (do this ONCE at startup)
+            const pluginRoutes = new Map();
+            // Resolve and install plugins
+            if (config.plugins && config.plugins.length > 0) {
+                for (const pluginConfig of config.plugins) {
+                    try {
+                        // Resolve plugin config to actual CMSPlugin instance (may involve dynamic import)
+                        const plugin = await resolvePlugin(pluginConfig);
+                        console.log(`🔌 Loading plugin: ${plugin.name}@${plugin.version}`);
+                        // Build route map before installation
+                        if (plugin.routes) {
+                            for (const [path, handler] of Object.entries(plugin.routes)) {
+                                pluginRoutes.set(path, { handler, pluginName: plugin.name });
+                            }
+                        }
+                        // Create temporary cmsInstances for installation (will be replaced below)
+                        const tempInstances = {
+                            config,
+                            databaseAdapter: databaseAdapter,
+                            assetService: assetService,
+                            storageAdapter: storageAdapter,
+                            emailAdapter: emailAdapter,
+                            cmsEngine: cmsEngine,
+                            localAPI: localAPI,
+                            auth: config.auth?.provider,
+                            pluginRoutes
+                        };
+                        // Install the plugin
+                        console.log(`🔌 Installing plugin: ${plugin.name}`);
+                        await plugin.install(tempInstances);
+                    }
+                    catch (error) {
+                        console.error(`❌ Failed to load/install plugin:`, error);
+                        throw error;
+                    }
+                }
+            }
+            cmsInstances = {
+                config,
+                databaseAdapter: databaseAdapter,
+                assetService: assetService,
+                storageAdapter: storageAdapter,
+                emailAdapter: emailAdapter,
+                cmsEngine: cmsEngine,
+                localAPI: localAPI,
+                auth: config.auth?.provider,
+                pluginRoutes
+            };
+            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/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC"}

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

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

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/{src/lib/is-mobile.svelte.ts → dist/is-mobile.svelte.js}

@@ -1,9 +1,7 @@
 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`);
-	}
+    constructor(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+        super(`max-width: ${breakpoint - 1}px`);
+    }
 }

package/dist/lib/auth/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/db/index.js

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

package/dist/lib/db/interfaces/asset.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/db/interfaces/document.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/db/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/db/interfaces/organization.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/db/interfaces/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/db/interfaces/user.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/email/index.js

@@ -0,0 +1,4 @@
+// Aphex CMS Email Layer
+// Ports and adapters for email sending operations
+// Interfaces
+export * from './interfaces/email.js';

package/dist/lib/email/interfaces/email.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/field-validation/rule.js

@@ -0,0 +1,221 @@
+export class Rule {
+    _required = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _rules = [];
+    _level = 'error';
+    _message;
+    static FIELD_REF = Symbol('fieldReference');
+    static valueOfField(path) {
+        return {
+            __fieldReference: true,
+            path
+        };
+    }
+    valueOfField(path) {
+        return Rule.valueOfField(path);
+    }
+    required() {
+        const newRule = this.clone();
+        newRule._required = true;
+        return newRule;
+    }
+    optional() {
+        const newRule = this.clone();
+        newRule._required = false;
+        return newRule;
+    }
+    min(len) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'min', constraint: len });
+        return newRule;
+    }
+    max(len) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'max', constraint: len });
+        return newRule;
+    }
+    length(len) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'length', constraint: len });
+        return newRule;
+    }
+    email() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'email' });
+        return newRule;
+    }
+    uri(options) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'uri', constraint: options });
+        return newRule;
+    }
+    regex(pattern, name) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'regex', constraint: { pattern, name } });
+        return newRule;
+    }
+    positive() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'positive' });
+        return newRule;
+    }
+    negative() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'negative' });
+        return newRule;
+    }
+    integer() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'integer' });
+        return newRule;
+    }
+    greaterThan(num) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'greaterThan', constraint: num });
+        return newRule;
+    }
+    lessThan(num) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'lessThan', constraint: num });
+        return newRule;
+    }
+    custom(fn) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'custom', constraint: fn });
+        return newRule;
+    }
+    error(message) {
+        const newRule = this.clone();
+        newRule._level = 'error';
+        newRule._message = message;
+        return newRule;
+    }
+    warning(message) {
+        const newRule = this.clone();
+        newRule._level = 'warning';
+        newRule._message = message;
+        return newRule;
+    }
+    info(message) {
+        const newRule = this.clone();
+        newRule._level = 'info';
+        newRule._message = message;
+        return newRule;
+    }
+    clone() {
+        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, context = {}) {
+        const markers = [];
+        // 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;
+    }
+    async validateRule(rule, value, context) {
+        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() {
+        return this._required;
+    }
+}

package/dist/lib/field-validation/utils.js

@@ -0,0 +1,99 @@
+import { Rule } from './rule.js';
+/**
+ * Check if a field is required based on its validation rules
+ */
+export function isFieldRequired(field) {
+    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, value, context = {}) {
+    if (!field.validation) {
+        return { isValid: true, errors: [] };
+    }
+    try {
+        const validationFunctions = Array.isArray(field.validation)
+            ? field.validation
+            : [field.validation];
+        const allErrors = [];
+        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) {
+    if (hasErrors) {
+        return 'border-destructive border-2';
+    }
+    // No green styling for success - only show red for errors
+    return '';
+}
+/**
+ * Validate an entire document's data against a schema
+ * This function validates all fields in a schema against the provided data
+ * and returns any validation errors found.
+ *
+ * @param schema - The schema type containing field definitions
+ * @param data - The document data to validate
+ * @param context - Optional context to pass to field validators
+ * @returns Validation result with isValid flag and array of field errors
+ */
+export async function validateDocumentData(schema, data, context = {}) {
+    const validationErrors = [];
+    // Validate each field in the schema
+    for (const field of schema.fields) {
+        const value = data[field.name];
+        const result = await validateField(field, value, { ...context, ...data });
+        if (!result.isValid) {
+            const errorMessages = result.errors
+                .filter((e) => e.level === 'error')
+                .map((e) => e.message);
+            if (errorMessages.length > 0) {
+                validationErrors.push({
+                    field: field.name,
+                    errors: errorMessages
+                });
+            }
+        }
+    }
+    return {
+        isValid: validationErrors.length === 0,
+        errors: validationErrors
+    };
+}

package/dist/lib/storage/interfaces/index.js

@@ -0,0 +1,2 @@
+// Storage interfaces
+export * from './storage.js';

package/dist/lib/storage/interfaces/storage.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/asset.js

@@ -0,0 +1,2 @@
+// types/asset.ts
+export {};

package/dist/lib/types/auth.js

@@ -0,0 +1,41 @@
+// Access control utilities
+/**
+ * Check if a user has write permissions based on their organization role
+ * Viewers have read-only access
+ */
+export function canWrite(auth) {
+    if (auth.type === 'api_key') {
+        return auth.permissions.includes('write');
+    }
+    // Viewers are read-only
+    return auth.organizationRole !== 'viewer';
+}
+/**
+ * Check if a user can manage organization members
+ * Only owners and admins can manage members
+ */
+export function canManageMembers(auth) {
+    if (auth.type === 'api_key') {
+        return false;
+    }
+    return auth.organizationRole === 'owner' || auth.organizationRole === 'admin';
+}
+/**
+ * Check if a user can manage API keys
+ * Only owners and admins can manage API keys
+ */
+export function canManageApiKeys(auth) {
+    if (auth.type === 'api_key') {
+        return false;
+    }
+    return auth.organizationRole === 'owner' || auth.organizationRole === 'admin';
+}
+/**
+ * Check if a user is a viewer (read-only access)
+ */
+export function isViewer(auth) {
+    if (auth.type === 'api_key') {
+        return !auth.permissions.includes('write');
+    }
+    return auth.organizationRole === 'viewer';
+}

package/dist/lib/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/document.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/filters.js

@@ -0,0 +1,5 @@
+// types/filters.ts
+//
+// Database-agnostic filter types for the unified Local API
+// These interfaces define the contract that all database adapters must implement
+export {};

package/dist/lib/types/index.js

@@ -0,0 +1,9 @@
+export * from './asset.js';
+export * from './auth.js';
+export * from './document.js';
+export * from './schemas.js';
+export * from './config.js';
+export * from './user.js';
+export * from './sidebar.js';
+export * from './organization.js';
+export * from './filters.js';

package/dist/lib/types/organization.js

@@ -0,0 +1,3 @@
+// Organization types for multi-tenancy
+// These match the inferred types from Drizzle schema
+export {};

package/dist/lib/types/schemas.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/sidebar.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/user.js

@@ -0,0 +1 @@
+export {};