@trokky/trokky 2.0.3

package/dist/integrations/express/integration.js

@@ -0,0 +1,730 @@
+import { Router } from 'express';
+import cors from 'cors';
+import { TrokkyRoutes } from '../../routes/index.js';
+import { ExpressAdapter } from './adapter.js';
+import { TrokkyExpressMiddleware } from './middleware.js';
+import { createLogger, TrokkyCore, } from '../../core/index.js';
+import { withDefaults } from './config.js';
+import { assertSingletonConsistency, checkSingletonStoredIds } from '../../core/schema/singleton.js';
+/**
+ * Main Express integration class for Trokky CMS
+ *
+ * Creates an Express router with all Trokky routes and middleware
+ */
+export class TrokkyExpress {
+    routes; // Make public for debugging
+    adapter;
+    middleware;
+    config;
+    logger = createLogger('express', 'TrokkyExpress');
+    mountedApiPath = null;
+    mountedStudioPath = null;
+    studioConfig = null;
+    i18nConfig = null;
+    structureConfig = null;
+    constructor(config) {
+        if (!config.core) {
+            throw new Error('TrokkyExpress requires config.core. Use TrokkyExpress.create() instead of constructing directly.');
+        }
+        this.config = config;
+        // Validate configuration to prevent common mounting issues
+        if (config.basePath && config.basePath.startsWith('/api')) {
+            this.logger.warn('basePath starts with "/api" but routes will be mounted on a path. ' +
+                'This may cause double paths like "/api/api/v1/*". ' +
+                'Consider using basePath: "" and mounting the router on your desired path.', { basePath: config.basePath });
+        }
+        this.routes = new TrokkyRoutes(config);
+        this.adapter = new ExpressAdapter({
+            maxFileSize: config.fileUpload?.maxFileSize || 50 * 1024 * 1024,
+        });
+        this.middleware = new TrokkyExpressMiddleware(config);
+    }
+    /**
+     * Create complete Express integration with router and middleware
+     */
+    async createIntegration() {
+        const router = this.createRouter();
+        const staticRouter = this.createStaticRouter();
+        const middleware = this.middleware.getMiddleware();
+        // Create Studio router if enabled
+        let studioRouter;
+        if (this.config.studio?.enabled !== false) {
+            studioRouter = await this.createStudioRouter();
+        }
+        // Create auto-mount function
+        const mount = (app, options) => {
+            const apiPath = options?.apiPath ?? '/api';
+            const studioPath = options?.studioPath ?? '/studio';
+            // Store the mounted paths for Studio config and external access
+            this.mountedApiPath = apiPath;
+            this.mountedStudioPath = studioPath;
+            // Update Studio config with correct apiBasePath if Studio is enabled
+            if (this.config.studio?.enabled && this.studioConfig) {
+                this.studioConfig.apiBasePath = apiPath;
+                if (this.studioConfig.mediaUrlGenerator) {
+                    this.studioConfig.mediaUrlGenerator.options.apiBasePath = apiPath;
+                }
+                this.logger.debug('Updated Studio config with apiBasePath', {
+                    apiBasePath: apiPath,
+                });
+            }
+            // Trust the first proxy hop (common for SSL termination)
+            // This allows Express to respect X-Forwarded-Proto for generating secure URLs
+            app.set('trust proxy', 1);
+            this.logger.info('Express trust proxy enabled to handle x-forwarded-proto');
+            // Apply CORS middleware FIRST (before any routes)
+            if (this.config.server?.cors) {
+                this.logger.debug('Applying CORS middleware', {
+                    cors: this.config.server.cors,
+                });
+                app.use(cors(this.config.server.cors));
+            }
+            this.logger.info('Auto-mounting Trokky routers', {
+                apiPath,
+                studioPath,
+                hasStudio: !!studioRouter,
+            });
+            // Mount API routes
+            app.use(apiPath, router);
+            // Mount static routes at root level (no authentication)
+            app.use('/', staticRouter);
+            // Mount Studio if enabled
+            if (studioRouter) {
+                app.use(studioPath, studioRouter);
+            }
+        };
+        return {
+            router,
+            staticRouter,
+            studioRouter,
+            middleware,
+            config: this.config,
+            core: this.config.core, // Expose core for mail and other integrations
+            mount,
+            getMountedApiPath: () => this.getMountedApiPath(),
+            getMountedStudioPath: () => this.getMountedStudioPath(),
+            getMountedPaths: () => this.getMountedPaths(),
+        };
+    }
+    /**
+     * Create Express router with API routes only (excludes static routes)
+     */
+    createRouter() {
+        const router = Router();
+        // Apply middleware to router first
+        const middleware = this.middleware.getMiddleware();
+        for (const middlewareFn of middleware) {
+            router.use(middlewareFn);
+        }
+        // Get only API routes from TrokkyRoutes (not static routes)
+        const routeDefinitions = this.routes.getApiRoutes();
+        this.logger.info('Creating Express router', {
+            routeCount: routeDefinitions.length,
+        });
+        // Add each route to Express router
+        for (const routeDef of routeDefinitions) {
+            this.logger.debug('Registering route', {
+                method: routeDef.method,
+                path: routeDef.path,
+            });
+            const expressHandler = this.adapter.handleRoute(routeDef.handler);
+            // Map HTTP methods to Express router methods - cast to any to handle type compatibility
+            switch (routeDef.method) {
+                case 'GET':
+                    router.get(routeDef.path, expressHandler);
+                    break;
+                case 'POST':
+                    router.post(routeDef.path, expressHandler);
+                    break;
+                case 'PUT':
+                    router.put(routeDef.path, expressHandler);
+                    break;
+                case 'DELETE':
+                    router.delete(routeDef.path, expressHandler);
+                    break;
+                case 'PATCH':
+                    router.patch(routeDef.path, expressHandler);
+                    break;
+                case 'OPTIONS':
+                    router.options(routeDef.path, expressHandler);
+                    break;
+                default:
+                    this.logger.warn('Unsupported HTTP method', {
+                        method: routeDef.method,
+                    });
+            }
+        }
+        return router;
+    }
+    /**
+     * Create Express router with static routes only (excludes API routes)
+     */
+    createStaticRouter() {
+        const router = Router();
+        // Get only static routes from TrokkyRoutes
+        const staticRoutes = this.routes.getStaticRoutes();
+        this.logger.info('Creating static router', {
+            routeCount: staticRoutes.length,
+        });
+        // Add each static route to Express router
+        for (const routeDef of staticRoutes) {
+            this.logger.debug('Registering static route', {
+                method: routeDef.method,
+                path: routeDef.path,
+            });
+            const expressHandler = this.adapter.handleRoute(routeDef.handler);
+            // Static routes are typically GET only
+            router.get(routeDef.path, expressHandler);
+        }
+        return router;
+    }
+    /**
+     * Create Studio router if Studio integration is enabled
+     */
+    async createStudioRouter() {
+        if (!this.config.studio) {
+            return undefined;
+        }
+        this.logger.info('Creating Studio router with dynamic config injection');
+        const router = Router();
+        try {
+            // Import Studio assets utilities (separate @trokky/studio package)
+            const { getStudioHTML, getStudioAsset } = await import(
+            // @ts-ignore - @trokky/studio is an optional peer dependency resolved at runtime
+            '@trokky/studio/dist/server/assets.js');
+            // Serve Studio HTML with dynamic config injection
+            router.get('/', (req, res) => {
+                try {
+                    const studioConfig = {
+                        mode: 'production',
+                        apiBasePath: this.getMountedApiPath(), // Use dynamic API path
+                        basePath: this.getMountedStudioPath(), // Set the base path for routing
+                        backendUrl: req.protocol + '://' + req.get('host') + this.getMountedApiPath(), // Full backend URL for integrated Studio
+                        schemas: this.config.core?.getAllSchemas() || [],
+                        branding: this.config.studio?.branding,
+                        structure: this.config.studio?.structure,
+                        config: this.config.studio?.config || {},
+                        customFields: this.config.studio?.customFields || [],
+                        mediaUrlGenerator: this.config.media?.mediaUrlGenerator,
+                        i18n: this.i18nConfig || undefined,
+                    };
+                    const html = getStudioHTML(studioConfig, this.getMountedStudioPath());
+                    res.setHeader('Content-Type', 'text/html');
+                    res.send(html);
+                }
+                catch (error) {
+                    this.logger.error('Failed to serve Studio HTML', error);
+                    res.status(500).send('Studio temporarily unavailable');
+                }
+            });
+            // Serve Studio assets
+            router.get('/assets/:filename', (req, res) => {
+                try {
+                    const asset = getStudioAsset(req.params.filename);
+                    if (!asset) {
+                        return res.status(404).send('Asset not found');
+                    }
+                    res.setHeader('Content-Type', asset.contentType);
+                    res.send(asset.content);
+                }
+                catch (error) {
+                    this.logger.error('Failed to serve Studio asset', error);
+                    res.status(500).send('Asset unavailable');
+                }
+            });
+            // SPA catch-all route - serve Studio HTML for any unmatched Studio routes
+            // This enables client-side routing to work on page refresh
+            router.get('*', (req, res) => {
+                try {
+                    const studioConfig = {
+                        mode: 'production',
+                        apiBasePath: this.getMountedApiPath(), // Use dynamic API path
+                        basePath: this.getMountedStudioPath(), // Set the base path for routing
+                        backendUrl: req.protocol + '://' + req.get('host') + this.getMountedApiPath(), // Full backend URL for integrated Studio
+                        schemas: this.config.core?.getAllSchemas() || [],
+                        branding: this.config.studio?.branding,
+                        structure: this.config.studio?.structure,
+                        config: this.config.studio?.config || {},
+                        customFields: this.config.studio?.customFields || [],
+                        mediaUrlGenerator: this.config.media?.mediaUrlGenerator,
+                        i18n: this.i18nConfig || undefined,
+                    };
+                    const html = getStudioHTML(studioConfig, this.getMountedStudioPath());
+                    res.setHeader('Content-Type', 'text/html');
+                    res.send(html);
+                }
+                catch (error) {
+                    this.logger.error('Failed to serve Studio HTML for SPA route', error);
+                    res.status(500).send('Studio temporarily unavailable');
+                }
+            });
+            return router;
+        }
+        catch (error) {
+            this.logger.error('Failed to create Studio router - Studio assets not available', error);
+            return undefined;
+        }
+    }
+    /**
+     * Get just the middleware array
+     */
+    getMiddleware() {
+        return this.middleware.getMiddleware();
+    }
+    /**
+     * Get the error handler middleware
+     */
+    static getErrorHandler() {
+        return TrokkyExpressMiddleware.createErrorHandler();
+    }
+    /**
+     * Get the currently mounted API path (useful for dynamic URL construction)
+     */
+    getMountedApiPath() {
+        return this.mountedApiPath || '/api';
+    }
+    /**
+     * Get the currently mounted Studio path
+     */
+    getMountedStudioPath() {
+        return this.mountedStudioPath || '/studio';
+    }
+    /**
+     * Get both mounted paths for easy access
+     */
+    getMountedPaths() {
+        return {
+            apiPath: this.getMountedApiPath(),
+            studioPath: this.getMountedStudioPath(),
+        };
+    }
+    /**
+     * PROFESSIONAL SETUP - Clean, type-safe configuration
+     *
+     * Uses the new professional configuration system with:
+     * - Organized config sections (storage, media, security, server, studio)
+     * - Environment-aware defaults
+     * - Better TypeScript auto-completion
+     * - Integration with trokky.config.ts
+     *
+     * @example
+     * ```typescript
+     * const trokky = await TrokkyExpress.create({
+     *   schemas: blogSchemas,
+     *   storage: {
+     *     data: { adapter: 'filesystem-data', options: { contentDir: './content' } },
+     *     media: { adapter: 'filesystem-media', options: { mediaDir: './media' } }
+     *   },
+     *   security: { adminUser: { username: 'admin', email: 'admin@demo.com', password: 'demo123' } }
+     * })
+     *
+     * trokky.mount(app)
+     * ```
+     */
+    static async create(config) {
+        const logger = createLogger('express', 'ProfessionalSetup');
+        logger.info('Starting professional Trokky setup');
+        try {
+            // Apply smart defaults based on environment
+            const fullConfig = withDefaults(config);
+            // 1. Create split storage adapters
+            const storageAdapters = await this.createStorageAdaptersFromConfig(fullConfig.storage);
+            // 2. Create TrokkyCore config (legacy format) - simplified since adapters are handled separately
+            const coreConfig = {
+                storage: {
+                    adapter: 'split',
+                    options: {},
+                },
+                schemas: fullConfig.schemas,
+                media: {
+                    imageProcessor: fullConfig.media.processor,
+                    imageVariants: fullConfig.media.variants || [],
+                    validation: {
+                        maxFileSize: fullConfig.media.upload?.maxFileSize,
+                        allowedTypes: fullConfig.media.upload?.allowedMimeTypes,
+                    },
+                },
+                security: {
+                    validateInput: fullConfig.security.validation?.input,
+                    rateLimitEnabled: fullConfig.security.rateLimit?.enabled,
+                    passkey: fullConfig.security.passkey,
+                },
+                // OAuth configuration (auto-enabled when credentials are set)
+                oauth: fullConfig.oauth,
+                // CAPTCHA configuration (auto-enabled when credentials are set)
+                captcha: fullConfig.captcha,
+                // Schema enhancement features (autoThumbnail, autoSlug)
+                features: fullConfig.features,
+            };
+            // 3. Create and initialize TrokkyCore with split adapters
+            const coreOptions = {
+                enableSecurity: fullConfig.security.enabled,
+                jwtSecret: fullConfig.security.jwtSecret,
+                cryptoOptions: fullConfig.security.cryptoOptions,
+                oauth2: fullConfig.oauth2,
+            };
+            const core = new TrokkyCore(coreConfig, storageAdapters, coreOptions);
+            await core.init();
+            logger.info('TrokkyCore initialized with professional config');
+            // Build studio, structure, and i18n configs for the instance
+            let resolvedStudioConfig = null;
+            let resolvedStructureConfig = null;
+            let resolvedI18nConfig = null;
+            if (fullConfig.studio) {
+                resolvedStudioConfig = {
+                    ...fullConfig.studio,
+                    mediaUrlGenerator: {
+                        options: {
+                            apiBasePath: fullConfig.server.basePath || '/api',
+                            mediaConfig: {
+                                serving: {
+                                    mode: fullConfig.media.serving?.mode || 'api',
+                                },
+                            },
+                        },
+                    },
+                    media: {
+                        variants: fullConfig.media.variants || [],
+                    },
+                };
+                if (fullConfig.studio.structure) {
+                    resolvedStructureConfig = fullConfig.studio.structure;
+                }
+                logger.debug('Studio configuration resolved');
+            }
+            if (fullConfig.i18n) {
+                resolvedI18nConfig = fullConfig.i18n;
+                logger.debug('i18n configuration resolved', {
+                    defaultLocale: fullConfig.i18n.defaultLocale,
+                    supportedLocales: fullConfig.i18n.supportedLocales,
+                });
+            }
+            // 4. Create admin user if specified
+            if (fullConfig.security.adminUser) {
+                try {
+                    await core.createUser({
+                        username: fullConfig.security.adminUser.username,
+                        email: fullConfig.security.adminUser.email,
+                        password: fullConfig.security.adminUser.password,
+                        firstName: fullConfig.security.adminUser.firstName,
+                        lastName: fullConfig.security.adminUser.lastName,
+                        role: fullConfig.security.adminUser.role || 'admin',
+                    });
+                    logger.info('Admin user created');
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    if (errorMessage.includes('already exists')) {
+                        logger.info('Admin user already exists');
+                    }
+                    else {
+                        logger.warn('Failed to create admin user', error);
+                    }
+                }
+            }
+            // 5. Map professional config to Express integration config
+            const expressConfig = {
+                core,
+                basePath: fullConfig.server.basePath,
+                server: fullConfig.server, // Pass the entire server config including CORS
+                staticRoutes: fullConfig.server.static.media || fullConfig.server.static.assets
+                    ? {
+                        ...(fullConfig.server.static.media && {
+                            media: {
+                                mountPath: fullConfig.server.static.media.path,
+                                directory: fullConfig.server.static.media.directory,
+                                maxAge: fullConfig.server.static.media.maxAge,
+                            },
+                        }),
+                        ...(fullConfig.server.static.assets && {
+                            assets: {
+                                mountPath: fullConfig.server.static.assets.path,
+                                directory: fullConfig.server.static.assets.directory,
+                                maxAge: fullConfig.server.static.assets.maxAge,
+                            },
+                        }),
+                    }
+                    : undefined,
+                fileUpload: {
+                    maxFileSize: fullConfig.media.upload?.maxFileSize,
+                    maxFiles: fullConfig.media.upload?.maxFiles,
+                    allowedMimeTypes: fullConfig.media.upload?.allowedMimeTypes,
+                },
+                bodyParser: fullConfig.server.parsing,
+                authentication: fullConfig.security.enabled
+                    ? {
+                        enabled: fullConfig.security.enabled,
+                        publicPaths: [],
+                        validateToken: async (token) => {
+                            try {
+                                // Use core's unified token verification which checks
+                                // JWT signature + expiration and API token hash
+                                const session = await core.verifyAnyToken(token);
+                                return session !== null;
+                            }
+                            catch (error) {
+                                return false;
+                            }
+                        },
+                    }
+                    : undefined,
+                rateLimiting: fullConfig.security.rateLimit?.enabled
+                    ? fullConfig.security.rateLimit
+                    : undefined,
+                studio: fullConfig.studio.enabled
+                    ? {
+                        enabled: fullConfig.studio.enabled,
+                        mount: fullConfig.studio.path,
+                        auth: fullConfig.studio.requireAuth,
+                        branding: fullConfig.studio.branding,
+                        structure: fullConfig.studio.structure,
+                        customFields: fullConfig.studio.fields,
+                        config: {
+                            pageSize: fullConfig.studio.settings?.pageSize,
+                            enableDrafts: fullConfig.studio.settings?.enableDrafts,
+                            enableVersioning: fullConfig.studio.settings?.enableVersioning,
+                            session: {
+                                refreshBufferMs: fullConfig.studio.session?.refreshBuffer,
+                                warningBufferMs: fullConfig.studio.session?.warningBuffer,
+                                checkIntervalMs: fullConfig.studio.session?.checkInterval,
+                                inactivityTimeoutMs: fullConfig.studio.session?.inactivityTimeout,
+                            },
+                        },
+                    }
+                    : undefined,
+            };
+            // 6. Create final integration
+            logger.debug('Creating integration with expressConfig', {
+                hasCore: !!expressConfig.core,
+                coreId: expressConfig.core ? 'present' : 'missing',
+            });
+            const integration = new TrokkyExpress(expressConfig);
+            // Store configs on instance (replaces global state pattern)
+            integration.studioConfig = resolvedStudioConfig;
+            integration.structureConfig = resolvedStructureConfig;
+            integration.i18nConfig = resolvedI18nConfig;
+            // Pass studio/structure config to routes via shared config reference
+            integration.config.studioConfig = resolvedStudioConfig;
+            integration.config.structureConfig = resolvedStructureConfig;
+            // Fail now if the structure presents collections as singletons that their schemas do
+            // not declare. Left alone the mismatch is invisible until a restore regenerates those
+            // documents' ids and the structure ends up pointing at documents that no longer exist.
+            await assertResolvedStructureConsistency(resolvedStructureConfig, core, fullConfig, logger);
+            const result = await integration.createIntegration();
+            // Debug: Check result.core before and after assignment
+            logger.debug('Integration result before core assignment', {
+                hasCore: !!result.core,
+                configCore: !!expressConfig.core,
+                localCore: !!core,
+            });
+            // Ensure core is accessible in the result
+            if (!result.core) {
+                logger.warn('result.core is undefined, assigning from local core variable');
+                result.core = core;
+            }
+            // Final verification
+            logger.debug('Integration result after core assignment', {
+                hasCore: !!result.core,
+                hasEvents: !!result.core?.events,
+            });
+            logger.info('Professional setup complete!');
+            return result;
+        }
+        catch (error) {
+            logger.error('Professional setup failed', error);
+            throw new Error(`Professional setup failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Helper method to extract route parameters for dynamic routing
+     */
+    findRouteForPath(method, path) {
+        return this.routes.findRoute(method, path);
+    }
+    /**
+     * Helper method to extract parameters from a path
+     */
+    extractParamsFromPath(routePattern, actualPath) {
+        return this.routes.extractParams(routePattern, actualPath);
+    }
+    /**
+     * Create split storage adapters from configuration
+     * Split-first architecture: always creates separate data and media adapters
+     */
+    static async createStorageAdaptersFromConfig(config) {
+        const logger = createLogger('express', 'StorageAdapter');
+        logger.info('🔄 Creating split storage adapters', {
+            dataAdapter: config.data.adapter,
+            mediaAdapter: config.media.adapter,
+        });
+        // Create data adapter
+        const dataAdapter = await this.createDataAdapter(config.data);
+        // Create media adapter
+        const mediaAdapter = await this.createMediaAdapter(config.media);
+        // Return split adapters object
+        const splitAdapters = {
+            data: dataAdapter,
+            media: mediaAdapter,
+        };
+        logger.info('Split storage adapters created successfully');
+        return splitAdapters;
+    }
+    /**
+     * Create data storage adapter using the registry system
+     */
+    static async createDataAdapter(config) {
+        const { createAdapter } = await import('../../core/index.js');
+        try {
+            return await createAdapter(config.adapter, 'data', {
+                // Filesystem data adapter options
+                ...(config.adapter === 'filesystem-data' && {
+                    contentDir: config.options?.contentDir || './content',
+                    usersDir: config.options?.usersDir || './users',
+                    tokensDir: config.options?.tokensDir || './tokens',
+                    webhooksDir: config.options?.webhooksDir || './webhooks',
+                    settingsDir: config.options?.settingsDir || './settings',
+                    auditLogsDir: config.options?.auditLogsDir || './audit-logs',
+                    createDirs: config.options?.createDirs ?? true,
+                    prettyJson: config.options?.prettyJson ?? true,
+                    jsonSpaces: config.options?.jsonSpaces ?? 2,
+                    silent: config.options?.silent ?? false,
+                }),
+                // Cloudflare D1 adapter options
+                ...(config.adapter === 'cloudflare-d1' && {
+                    database: config.options?.database,
+                    databaseName: config.options?.databaseName,
+                    tablePrefix: config.options?.tablePrefix,
+                    debug: config.options?.debug ?? false,
+                    enableFTS: config.options?.enableFTS ?? false,
+                    enableAuditLog: config.options?.enableAuditLog ?? false,
+                    migrations: config.options?.migrations,
+                }),
+                // Pass through any other options
+                ...config.options,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to create data adapter "${config.adapter}": ${error instanceof Error ? error.message : String(error)}\n\n` +
+                `Available data adapters depend on imported packages:\n` +
+                `- 'filesystem-data': Requires @trokky/adapter-filesystem-data (Node.js only)\n` +
+                `- 'cloudflare-d1': Requires @trokky/adapter-cloudflare-d1 (Edge runtime)\n` +
+                `- 'dynamodb': Requires @trokky/adapter-dynamodb\n\n` +
+                `Make sure the required adapter package is installed and imported.`);
+        }
+    }
+    /**
+     * Create media storage adapter using the registry system
+     */
+    static async createMediaAdapter(config) {
+        const { createAdapter } = await import('../../core/index.js');
+        try {
+            return await createAdapter(config.adapter, 'media', {
+                // Filesystem media adapter options
+                ...(config.adapter === 'filesystem-media' && {
+                    mediaDir: config.options?.mediaDir || './media',
+                    createDirs: config.options?.createDirs ?? true,
+                    prettyJson: config.options?.prettyJson ?? true,
+                    jsonSpaces: config.options?.jsonSpaces ?? 2,
+                    mediaBaseUrl: config.options?.mediaBaseUrl || '/media',
+                    silent: config.options?.silent ?? false,
+                }),
+                // Cloudflare R2 adapter options
+                ...(config.adapter === 'cloudflare-r2' && {
+                    bucket: config.options?.bucket,
+                    bucketName: config.options?.bucketName,
+                    keyPrefix: config.options?.keyPrefix,
+                    debug: config.options?.debug ?? false,
+                    cacheControl: config.options?.cacheControl,
+                    defaultMetadata: config.options?.defaultMetadata,
+                    autoContentType: config.options?.autoContentType ?? true,
+                    maxFileSize: config.options?.maxFileSize,
+                    allowPublicUrls: config.options?.allowPublicUrls ?? false,
+                    customDomain: config.options?.customDomain,
+                    defaultUrlExpiry: config.options?.defaultUrlExpiry ?? 3600,
+                    maxUrlExpiry: config.options?.maxUrlExpiry ?? 86400,
+                    accountId: config.options?.accountId,
+                    accessKeyId: config.options?.accessKeyId,
+                    secretAccessKey: config.options?.secretAccessKey,
+                    cspConfig: config.options?.cspConfig,
+                }),
+                // Pass through any other options
+                ...config.options,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to create media adapter "${config.adapter}": ${error instanceof Error ? error.message : String(error)}\n\n` +
+                `Available media adapters depend on imported packages:\n` +
+                `- 'filesystem-media': Requires @trokky/adapter-filesystem-media (Node.js only)\n` +
+                `- 'cloudflare-r2': Requires @trokky/adapter-cloudflare-r2 (Edge runtime)\n` +
+                `- 's3': Requires @trokky/adapter-s3\n\n` +
+                `Make sure the required adapter package is installed and imported.`);
+        }
+    }
+    /**
+     * Generate a secure JWT secret if none provided
+     */
+    static generateSecureSecret() {
+        // Simple secure secret generation for demo purposes
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < 64; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    }
+}
+/**
+ * Run the singleton consistency check against the structure a project actually configured.
+ *
+ * The structure may be a plain object or a function of the request context; at startup there
+ * is no user, so it is resolved the same way the create and read paths resolve it. A structure
+ * that cannot be resolved here is skipped rather than fatal — only a genuine disagreement
+ * between structure and schemas stops the server.
+ */
+async function assertResolvedStructureConsistency(structureConfig, core, config, logger) {
+    if (!structureConfig)
+        return;
+    const schemas = core.getAllSchemas();
+    let structure;
+    try {
+        structure =
+            typeof structureConfig === 'function'
+                ? await Promise.resolve(structureConfig({ user: null, schemas, core, config }))
+                : structureConfig;
+    }
+    catch (error) {
+        logger.warn('Could not resolve structure to check singleton consistency', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return;
+    }
+    try {
+        assertSingletonConsistency(structure, schemas, message => logger.warn(message));
+    }
+    catch (error) {
+        // The core is already initialised at this point, so tear it down before rethrowing:
+        // this stops the rate-limiter sweep and OAuth2 cleanup intervals and releases the
+        // storage adapters and event storage, leaving no handles behind for a host that catches
+        // this error rather than exiting. Awaiting would delay the throw for no benefit — the
+        // rethrow below is what the caller is waiting on — so failures are only logged.
+        void core.shutdown?.().catch(shutdownError => {
+            logger.warn('Error shutting down core after singleton consistency failure', {
+                error: shutdownError instanceof Error ? shutdownError.message : String(shutdownError),
+            });
+        });
+        throw error;
+    }
+    // Only once structure and schemas agree, compare what the structure names against what storage
+    // actually holds. This one reads data rather than source, so it warns and never stops the boot —
+    // see `checkSingletonStoredIds`. Its own failures are swallowed there, but the call is guarded
+    // anyway: nothing about a startup advisory should be able to take the server down.
+    try {
+        await checkSingletonStoredIds(structure, schemas, core, message => logger.warn(message));
+    }
+    catch (error) {
+        logger.warn('Could not check singleton stored document ids', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+//# sourceMappingURL=integration.js.map