webspresso 0.0.106 → 0.0.107

package/core/auth/sessions.js

@@ -102,29 +102,65 @@ function createKnexSessionTracker(db, options = {}) {
         };
       }
 
-      const [id] = await knex(tableName).insert({
-        session_id: sessionId,
-        user_id: userId,
-        ip_address: ip,
-        user_agent: ua ? ua.slice(0, 1000) : null,
-        browser,
-        os,
-        device,
-        last_active_at: now,
-        created_at: now,
-      });
+      try {
+        const [id] = await knex(tableName).insert({
+          session_id: sessionId,
+          user_id: userId,
+          ip_address: ip,
+          user_agent: ua ? ua.slice(0, 1000) : null,
+          browser,
+          os,
+          device,
+          last_active_at: now,
+          created_at: now,
+        });
 
-      return {
-        id,
-        session_id: sessionId,
-        user_id: userId,
-        ip_address: ip,
-        browser,
-        os,
-        device,
-        last_active_at: now,
-        created_at: now,
-      };
+        return {
+          id,
+          session_id: sessionId,
+          user_id: userId,
+          ip_address: ip,
+          browser,
+          os,
+          device,
+          last_active_at: now,
+          created_at: now,
+        };
+      } catch (insertErr) {
+        // Handle concurrent insert race condition gracefully across database engines
+        const isUniqueConstraint =
+          insertErr.code === 'SQLITE_CONSTRAINT' ||
+          insertErr.code === '23505' || // PostgreSQL
+          insertErr.code === 'ER_DUP_ENTRY' || // MySQL
+          insertErr.errno === 19 || // SQLite
+          insertErr.errno === 1062 || // MySQL
+          (typeof insertErr.message === 'string' && /unique|duplicate|constraint/i.test(insertErr.message));
+
+        if (!isUniqueConstraint) {
+          throw insertErr;
+        }
+
+        await knex(tableName).where({ session_id: sessionId }).update({
+          user_id: userId,
+          ip_address: ip,
+          user_agent: ua ? ua.slice(0, 1000) : null,
+          browser,
+          os,
+          device,
+          last_active_at: now,
+        });
+
+        const record = await knex(tableName).where({ session_id: sessionId }).first();
+        return record || {
+          session_id: sessionId,
+          user_id: userId,
+          ip_address: ip,
+          browser,
+          os,
+          device,
+          last_active_at: now,
+        };
+      }
     },
 
     /**
@@ -415,24 +451,92 @@ function createKvSessionTracker(kv, options = {}) {
       return record;
     },
 
-    listUserSessions: async (userId) => {
-      // If list is supported by KV
-      if (typeof kv.list === 'function') {
-        const listRes = await kv.list({ prefix });
-        const keys = listRes.keys || [];
-        const results = [];
-        for (const k of keys) {
-          const item = await kvGet(k.name);
-          if (item && String(item.user_id) === String(userId)) {
-            results.push(item);
-          }
+    /**
+     * Touch session to update last_active_at and refresh expiration
+     * @param {string} sessionId
+     * @returns {Promise<boolean>}
+     */
+    touch: async (sessionId) => {
+      if (!sessionId) return false;
+      const record = await kvGet(`${prefix}${sessionId}`);
+      if (!record) return false;
+      record.last_active_at = new Date().toISOString();
+      await kvPut(`${prefix}${sessionId}`, record, defaultTtl);
+      return true;
+    },
+
+    /**
+     * Get session record by session_id
+     * @param {string} sessionId
+     * @returns {Promise<Object|null>}
+     */
+    get: async (sessionId) => {
+      if (!sessionId) return null;
+      return (await kvGet(`${prefix}${sessionId}`)) || null;
+    },
+
+    /**
+     * List all active sessions for a user, marking current session
+     * @param {string|number} userId
+     * @param {string} [currentSessionId]
+     * @returns {Promise<Array<Object>>}
+     */
+    list: async (userId, currentSessionId = null) => {
+      if (!userId) return [];
+      if (typeof kv.list !== 'function') return [];
+      const listRes = await kv.list({ prefix });
+      const keys = listRes.keys || [];
+      const items = await Promise.all(
+        keys.map((k) => kvGet(k.name).catch(() => null))
+      );
+      const results = [];
+      for (const item of items) {
+        if (item && String(item.user_id) === String(userId)) {
+          results.push({
+            ...item,
+            is_current: Boolean(currentSessionId && item.session_id === currentSessionId),
+          });
         }
-        return results;
       }
-      return [];
+      return results.sort((a, b) => new Date(b.last_active_at).getTime() - new Date(a.last_active_at).getTime());
+    },
+
+    /**
+     * Legacy alias for list()
+     * @param {string|number} userId
+     * @returns {Promise<Array<Object>>}
+     */
+    listUserSessions: async (userId) => {
+      if (!userId || typeof kv.list !== 'function') return [];
+      const listRes = await kv.list({ prefix });
+      const keys = listRes.keys || [];
+      const items = await Promise.all(
+        keys.map((k) => kvGet(k.name).catch(() => null))
+      );
+      return items.filter((item) => item && String(item.user_id) === String(userId));
+    },
+
+    /**
+     * Check if a session exists and belongs to the given user
+     * @param {string} sessionId
+     * @param {string|number} [userId]
+     * @returns {Promise<boolean>}
+     */
+    isSessionValid: async (sessionId, userId = null) => {
+      if (!sessionId) return false;
+      const record = await kvGet(`${prefix}${sessionId}`);
+      if (!record) return false;
+      if (userId && String(record.user_id) !== String(userId)) return false;
+      return true;
     },
 
-    validate: async (sessionId, userId) => {
+    /**
+     * Legacy alias for isSessionValid()
+     * @param {string} sessionId
+     * @param {string|number} [userId]
+     * @returns {Promise<boolean>}
+     */
+    validate: async (sessionId, userId = null) => {
       if (!sessionId) return false;
       const record = await kvGet(`${prefix}${sessionId}`);
       if (!record) return false;
@@ -440,38 +544,64 @@ function createKvSessionTracker(kv, options = {}) {
       return true;
     },
 
+    /**
+     * Revoke a single session
+     * @param {string} sessionId
+     * @returns {Promise<boolean>}
+     */
     revoke: async (sessionId) => {
       if (!sessionId) return false;
       await kvDelete(`${prefix}${sessionId}`);
       return true;
     },
 
+    /**
+     * Revoke all other sessions for user, keeping the current session active
+     * @param {string|number} userId
+     * @param {string} currentSessionId
+     * @returns {Promise<number>} Number of revoked sessions
+     */
     revokeOthers: async (userId, currentSessionId) => {
-      if (typeof kv.list !== 'function') return 0;
+      if (!userId || typeof kv.list !== 'function') return 0;
       const listRes = await kv.list({ prefix });
-      let count = 0;
-      for (const k of listRes.keys || []) {
-        const item = await kvGet(k.name);
-        if (item && String(item.user_id) === String(userId) && item.session_id !== currentSessionId) {
-          await kvDelete(k.name);
-          count++;
+      const keys = listRes.keys || [];
+      const items = await Promise.all(
+        keys.map((k) => kvGet(k.name).then((item) => ({ key: k.name, item })).catch(() => null))
+      );
+      const toDelete = [];
+      for (const entry of items) {
+        if (entry?.item && String(entry.item.user_id) === String(userId) && entry.item.session_id !== currentSessionId) {
+          toDelete.push(entry.key);
         }
       }
-      return count;
+      if (toDelete.length > 0) {
+        await Promise.all(toDelete.map((k) => kvDelete(k)));
+      }
+      return toDelete.length;
     },
 
+    /**
+     * Revoke all sessions for a user (force logout from all devices)
+     * @param {string|number} userId
+     * @returns {Promise<number>} Number of revoked sessions
+     */
     revokeAll: async (userId) => {
-      if (typeof kv.list !== 'function') return 0;
+      if (!userId || typeof kv.list !== 'function') return 0;
       const listRes = await kv.list({ prefix });
-      let count = 0;
-      for (const k of listRes.keys || []) {
-        const item = await kvGet(k.name);
-        if (item && String(item.user_id) === String(userId)) {
-          await kvDelete(k.name);
-          count++;
+      const keys = listRes.keys || [];
+      const items = await Promise.all(
+        keys.map((k) => kvGet(k.name).then((item) => ({ key: k.name, item })).catch(() => null))
+      );
+      const toDelete = [];
+      for (const entry of items) {
+        if (entry?.item && String(entry.item.user_id) === String(userId)) {
+          toDelete.push(entry.key);
         }
       }
-      return count;
+      if (toDelete.length > 0) {
+        await Promise.all(toDelete.map((k) => kvDelete(k)));
+      }
+      return toDelete.length;
     },
 
     purgeExpired: async () => {

package/core/console/eval.js

@@ -15,7 +15,10 @@ function wrapBlock(code) {
   const lastLine = lines[lines.length - 1].trim();
   const isStatementKeyword = /^(return|const|let|var|throw|if|while|for|function|class|try|switch|import|export)\b/.test(lastLine);
   if (!isStatementKeyword && lastLine.length > 0) {
-    const expr = lastLine.replace(/;+$/, '');
+    let expr = lastLine;
+    while (expr.endsWith(';')) {
+      expr = expr.slice(0, -1);
+    }
     lines[lines.length - 1] = `return (${expr});`;
   }
   return lines.join('\n');

package/core/content/service.js

@@ -400,6 +400,7 @@ function createContentService(db, options = {}) {
     createEntry,
     updateEntry,
     deleteEntry,
+    invalidateCache: () => cache.invalidateAll(),
   };
 }
 

package/core/errors/domain.js

@@ -17,20 +17,38 @@ class ValidationError extends HttpError {
    * @param {string} [message='Validation failed']
    * @param {Object} [options]
    * @param {Record<string, string[]|string>} [options.fields={}] - Field-specific validation error messages
+   * @param {Record<string, string[]>} [options.fieldErrors={}] - Detailed array of errors per field
    * @param {number} [options.status=422]
+   * @param {number} [options.statusCode]
    * @param {string} [options.code='VALIDATION_ERROR']
+   * @param {string} [options.service] - Service identifier if originating from services layer
    * @param {unknown} [options.details]
+   * @param {unknown} [options.issues]
    * @param {unknown} [options.cause]
    */
   constructor(message = 'Validation failed', options = {}) {
-    super(options.status || 422, message, {
+    const status = typeof options.status === 'number'
+      ? options.status
+      : (typeof options.statusCode === 'number' ? options.statusCode : 422);
+
+    super(status, message, {
       code: options.code || 'VALIDATION_ERROR',
       expose: true,
       ...options,
     });
 
+    this.statusCode = this.status;
     this.fields = options.fields || {};
-    this.issues = options.issues || options.details || [];
+    if (options.fieldErrors) {
+      this.fieldErrors = options.fieldErrors;
+    }
+    if (options.issues !== undefined || options.details !== undefined) {
+      this.issues = options.issues !== undefined ? options.issues : (options.details || []);
+      this.details = options.details !== undefined ? options.details : this.issues;
+    }
+    if (options.service) {
+      this.service = options.service;
+    }
   }
 }
 

package/core/errors/http.js

@@ -23,6 +23,7 @@ class HttpError extends WebspressoError {
     super(message, options);
 
     this.status = typeof status === 'number' ? status : 500;
+    this.statusCode = this.status;
     this.headers = options.headers || {};
     this.expose = options.expose !== undefined ? Boolean(options.expose) : this.status < 500;
   }

package/core/http/hono-adapter.js

@@ -341,7 +341,7 @@ class HonoHttpAdapter extends HttpAdapter {
   route(method, path, ...handlers) {
     const m = (method || '').toLowerCase();
     // Normalize Express bracket parameters: e.g. /api/notes/[id] -> /api/notes/:id
-    const honoPath = path.replace(/\[([^\]]+)\]/g, ':$1');
+    const honoPath = typeof path === 'string' ? path.replace(/\[([^\[\]]+)\]/g, ':$1') : path;
 
     for (const handler of handlers) {
       if (typeof handler !== 'function') continue;

package/core/http/pipeline.js

@@ -107,10 +107,32 @@ async function executeApiPipeline(params) {
   // 1. Injections
   if (db && !req.db) req.db = db;
   if (!req.service && serviceRegistry) {
+    const getCallContext = (explicitCtx) => {
+      if (explicitCtx) return explicitCtx;
+      const ctx = req.context ? { ...req.context } : { req, res, db: req.db || db };
+      if (!ctx.req) ctx.req = req;
+      if (!ctx.res) ctx.res = res;
+      if (!ctx.db) ctx.db = req.db || db;
+      if (req.user !== undefined) ctx.user = req.user;
+      if (req.auth !== undefined) ctx.auth = req.auth;
+      if (req.session !== undefined) ctx.session = req.session;
+      return ctx;
+    };
     req.service = (name, input, opts) => {
-      const baseContext = req.context || { req, res, db, user: req.user, session: req.session };
-      return serviceRegistry.call(name, input, baseContext, opts);
+      return serviceRegistry.call(name, input, getCallContext(opts?.ctx), opts);
     };
+    req.service.call = (name, input, opts) => req.service(name, input, opts);
+    req.service.execute = (name, input, opts) => req.service(name, input, opts);
+    req.service.invalidate = (name, input, ctx) =>
+      serviceRegistry.invalidate(name, input, getCallContext(ctx));
+    req.service.clearCache = (name) =>
+      serviceRegistry.clearCache(name);
+    req.service.invalidateByTag = (tag, serviceName) =>
+      serviceRegistry.invalidateByTag(tag, serviceName);
+    req.service.invalidateByTags = (tags, serviceName) =>
+      serviceRegistry.invalidateByTags(tags, serviceName);
+    req.service.invalidateTag = req.service.invalidateByTag;
+    req.service.invalidateTags = req.service.invalidateByTags;
   }
 
   // 2. Schema validation
@@ -261,6 +283,18 @@ async function executePagePipeline(params) {
     const baseContext = req.context || { req, res, db, user: req.user, session: req.session };
     req.service = (name, input, opts) =>
       serviceRegistry.call(name, input, baseContext, opts);
+    req.service.call = (name, input, opts) => req.service(name, input, opts);
+    req.service.execute = (name, input, opts) => req.service(name, input, opts);
+    req.service.invalidate = (name, input, ctx) =>
+      serviceRegistry.invalidate(name, input, ctx || baseContext);
+    req.service.clearCache = (name) =>
+      serviceRegistry.clearCache(name);
+    req.service.invalidateByTag = (tag, serviceName) =>
+      serviceRegistry.invalidateByTag(tag, serviceName);
+    req.service.invalidateByTags = (tags, serviceName) =>
+      serviceRegistry.invalidateByTags(tags, serviceName);
+    req.service.invalidateTag = req.service.invalidateByTag;
+    req.service.invalidateTags = req.service.invalidateByTags;
   }
 
   // 2. Middlewares

package/core/index.js

@@ -11,9 +11,11 @@
 const { CoreApp, createCoreApp } = require('./app');
 const {
   createServiceRegistry,
+  createServiceRegistryAsync,
   defineService,
   ServiceRegistry,
   executeService,
+  composeMiddleware,
   discoverServices,
   filePathToServiceName,
   toCamelCase,
@@ -23,7 +25,10 @@ const {
   stableCacheKey,
   sanitizeInput,
   maskSensitiveData,
-} = require('../src/services');
+  loadModuleSync,
+  loadModuleAsync,
+  extractModuleExport,
+} = require('./services');
 
 const { ShutdownManager } = require('./shutdown');
 const errors = require('./errors');
@@ -54,11 +59,14 @@ module.exports = {
   createCoreApp,
 
   // Services Layer
+  services: require('./services'),
   createServiceRegistry,
+  createServiceRegistryAsync,
   defineService,
   service: defineService,
   ServiceRegistry,
   executeService,
+  composeMiddleware,
   discoverServices,
   filePathToServiceName,
   toCamelCase,
@@ -68,6 +76,9 @@ module.exports = {
   stableCacheKey,
   sanitizeInput,
   maskSensitiveData,
+  loadModuleSync,
+  loadModuleAsync,
+  extractModuleExport,
 
   // Route & Endpoint Declarations
   defineApi: require('../src/api/define-api').defineApi,

package/core/mail/mailer.js

@@ -67,7 +67,7 @@ class Mailer {
 
     // Fallback simple text from HTML if text not provided
     if (!msg.text && typeof msg.html === 'string') {
-      msg.text = msg.html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+      msg.text = msg.html.replace(/<[^<>]*>/g, ' ').replace(/\s+/g, ' ').trim();
     }
 
     try {

package/core/orm/eager-loader.js

@@ -8,6 +8,60 @@ const { resolveRelationModel, getRelationKeys } = require('./model');
 const { applyScopes, createScopeContext } = require('./scopes');
 const { getJsonColumns, deserializeJsonFields } = require('./json-fields');
 
+const RELATION_TREE_CACHE_LIMIT = 512;
+const relationTreeCache = new Map();
+
+/**
+ * Generate a deterministic cache key for relation names specifications
+ * @param {string|Array|Object} relationNames
+ * @returns {string|null}
+ */
+function getRelationTreeCacheKey(relationNames) {
+  if (typeof relationNames === 'string') {
+    return 's:' + relationNames;
+  }
+  if (Array.isArray(relationNames)) {
+    for (let i = 0; i < relationNames.length; i++) {
+      if (typeof relationNames[i] !== 'string') {
+        try {
+          return 'o:' + JSON.stringify(relationNames);
+        } catch (_) {
+          return null;
+        }
+      }
+    }
+    return 'a:' + relationNames.join('|');
+  }
+  if (relationNames && typeof relationNames === 'object') {
+    try {
+      return 'o:' + JSON.stringify(relationNames);
+    } catch (_) {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Clone a relation tree Map to prevent external mutation from poisoning cache
+ * @param {Map<string, string[]>} tree
+ * @returns {Map<string, string[]>}
+ */
+function cloneRelationTree(tree) {
+  const copy = new Map();
+  for (const [k, v] of tree.entries()) {
+    copy.set(k, v.slice());
+  }
+  return copy;
+}
+
+/**
+ * Clear the internal relation tree cache
+ */
+function clearRelationTreeCache() {
+  relationTreeCache.clear();
+}
+
 /**
  * Parse relation specifications into a grouped structure: Map<topLevelRelation, string[]>
  * Supports dot notation ('author.profile'), arrays (['author', 'comments.author']),
@@ -17,6 +71,21 @@ const { getJsonColumns, deserializeJsonFields } = require('./json-fields');
  * @returns {Map<string, string[]>}
  */
 function parseRelationTree(relationNames) {
+  if (relationNames instanceof Map) {
+    return cloneRelationTree(relationNames);
+  }
+
+  const cacheKey = getRelationTreeCacheKey(relationNames);
+  if (cacheKey) {
+    const cached = relationTreeCache.get(cacheKey);
+    if (cached) {
+      // Refresh LRU order
+      relationTreeCache.delete(cacheKey);
+      relationTreeCache.set(cacheKey, cached);
+      return cloneRelationTree(cached);
+    }
+  }
+
   const tree = new Map();
 
   function addPath(top, nested) {
@@ -81,6 +150,15 @@ function parseRelationTree(relationNames) {
     processItem(item);
   }
 
+  if (cacheKey) {
+    if (relationTreeCache.size >= RELATION_TREE_CACHE_LIMIT) {
+      const firstKey = relationTreeCache.keys().next().value;
+      relationTreeCache.delete(firstKey);
+    }
+    relationTreeCache.set(cacheKey, tree);
+    return cloneRelationTree(tree);
+  }
+
   return tree;
 }
 
@@ -99,7 +177,7 @@ async function loadRelations(records, relationNames, model, knex, scopeContext)
   }
 
   const context = scopeContext || createScopeContext();
-  const tree = parseRelationTree(relationNames);
+  const tree = relationNames instanceof Map ? relationNames : parseRelationTree(relationNames);
 
   // Process each relation grouped by top-level
   for (const [relationName, nestedPaths] of tree.entries()) {
@@ -402,4 +480,6 @@ module.exports = {
   loadHasOne,
   queryInChunks,
   parseRelationTree,
+  clearRelationTreeCache,
+  getRelationTreeCacheKey,
 };

package/core/orm/index.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const { createSchemaHelpers, extractColumnsFromSchema, getColumnMeta } = require('./schema-helpers');
 const { defineModel, getModel, getAllModels, hasModel, clearRegistry, resolveModelName, isCascadeEnabled } = require('./model');
 const { createRepository } = require('./repository');
+const { createQueryBuilder, QueryBuilder } = require('./query-builder');
 const { createMigrationManager } = require('./migrations');
 const { createSeeder } = require('./seeder');
 const { createScopeContext } = require('./scopes');
@@ -278,9 +279,8 @@ function createDatabase(config) {
    */
   function query(modelName, scopeContext) {
     const model = getModelInstance(modelName);
-    const ctx = scopeContext || createScopeContext();
-    const repo = createRepository(model, knexInstance, ctx, ormCacheLayer);
-    return repo.query();
+    const ctx = scopeContext ? { ...scopeContext } : createScopeContext();
+    return createQueryBuilder(model, knexInstance, ctx, ormCacheLayer);
   }
 
   /**
@@ -325,6 +325,11 @@ function createDatabase(config) {
           const ctx = sContext || currentScope;
           return createRepository(model, trx, ctx, ormCacheLayer);
         },
+        query(modelName, sContext) {
+          const model = getModelInstance(modelName);
+          const ctx = sContext ? { ...sContext } : currentScope;
+          return createQueryBuilder(model, trx, ctx, ormCacheLayer);
+        },
         forTenant(tenantId) {
           currentScope = { ...currentScope, tenantId };
           return this;
@@ -472,6 +477,9 @@ const zdb = z ? createSchemaHelpers(z) : null;
 module.exports = {
   // Main factory
   createDatabase,
+  // Query builder
+  createQueryBuilder,
+  QueryBuilder,
   // ORM cache (provider + layer utilities)
   createMemoryCacheProvider: require('./cache/memory-provider').createMemoryCacheProvider,
   OrmCacheLayer: require('./cache/layer').OrmCacheLayer,
@@ -511,6 +519,7 @@ module.exports = {
   loadRelations: require('./eager-loader').loadRelations,
   loadRelation: require('./eager-loader').loadRelation,
   parseRelationTree: require('./eager-loader').parseRelationTree,
+  clearRelationTreeCache: require('./eager-loader').clearRelationTreeCache,
   // Query Complexity & DoS Protection
   QueryComplexityError: require('./complexity').QueryComplexityError,
   validateQueryComplexity: require('./complexity').validateQueryComplexity,
@@ -543,11 +552,16 @@ module.exports = {
   getUserId: require('./scopes').getUserId,
   getTenantId: require('./scopes').getTenantId,
   createScopeContext: require('./scopes').createScopeContext,
-  // Cloudflare D1 Native Edge Dialect
-  createD1Knex: require('./d1').createD1Knex,
-  Client_D1: require('./d1').Client_D1,
-  executeD1Batch: require('./d1').executeD1Batch,
-  normalizeD1Bindings: require('./d1').normalizeD1Bindings,
+  getSoftDeleteColumn: require('./scopes').getSoftDeleteColumn,
+  getCreatedAtColumn: require('./scopes').getCreatedAtColumn,
+  getUpdatedAtColumn: require('./scopes').getUpdatedAtColumn,
+  applyInsertTimestamps: require('./scopes').applyInsertTimestamps,
+  applyUpdateTimestamps: require('./scopes').applyUpdateTimestamps,
+  // Cloudflare D1 Native Edge Dialect (lazy getters to avoid eager dialect loading)
+  get createD1Knex() { return require('./d1').createD1Knex; },
+  get Client_D1() { return require('./d1').Client_D1; },
+  get executeD1Batch() { return require('./d1').executeD1Batch; },
+  get normalizeD1Bindings() { return require('./d1').normalizeD1Bindings; },
   // Serverless Connection Pool Management
   isServerlessEnvironment,
   normalizeServerlessPoolConfig,
@@ -555,9 +569,9 @@ module.exports = {
     isServerlessEnvironment,
     normalizeServerlessPoolConfig,
   },
-  // Cloud Database Migrations
-  waitForDatabaseConnection: require('./migrate-cloud').waitForDatabaseConnection,
-  freeStaleMigrationLock: require('./migrate-cloud').freeStaleMigrationLock,
-  getMigrationStatus: require('./migrate-cloud').getMigrationStatus,
-  runCloudMigration: require('./migrate-cloud').runCloudMigration,
+  // Cloud Database Migrations (lazy getters)
+  get waitForDatabaseConnection() { return require('./migrate-cloud').waitForDatabaseConnection; },
+  get freeStaleMigrationLock() { return require('./migrate-cloud').freeStaleMigrationLock; },
+  get getMigrationStatus() { return require('./migrate-cloud').getMigrationStatus; },
+  get runCloudMigration() { return require('./migrate-cloud').runCloudMigration; },
 };