Add cleanup logic, tests, and fix error handling for custom L1 parents

- Add cleanup logic to delete orphaned custom L1 parent if config creation fails
- Add tests for startCustomL1ParentSync job (10 test cases)
- Fix inconsistent error handling (res -> next) in Orbit config endpoint
- Add count method to OrbitChainConfig and OpChainConfig mocks

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: Antoine de Chevigné

run/api/explorers.js

@@ -328,6 +328,14 @@ router.post('/:id/orbitConfig', authMiddleware, async (req, res, next) => {
         try {
             config = await db.createOrbitConfig(userId, data.id, configParams);
         } catch(error) {
+            // Clean up orphaned custom L1 parent if config creation fails
+            if (hasNewCustomL1 && configParams.parentWorkspaceId) {
+                try {
+                    await db.deleteCustomL1Parent(userId, configParams.parentWorkspaceId);
+                } catch(cleanupError) {
+                    // Log but don't fail on cleanup error
+                }
+            }
             return managedError(error, req, res);
         }
 
@@ -343,7 +351,7 @@ router.post('/:id/orbitConfig', authMiddleware, async (req, res, next) => {
 
         res.status(200).json({ config });
     } catch (error) {
-        unmanagedError(error, req, res);
+        unmanagedError(error, req, next);
     }
 });
 
@@ -499,6 +507,14 @@ router.post('/:id/opConfig', authMiddleware, async (req, res, next) => {
         try {
             config = await db.createOpConfig(userId, data.id, configParams);
         } catch(error) {
+            // Clean up orphaned custom L1 parent if config creation fails
+            if (hasNewCustomL1 && configParams.parentWorkspaceId) {
+                try {
+                    await db.deleteCustomL1Parent(userId, configParams.parentWorkspaceId);
+                } catch(cleanupError) {
+                    // Log but don't fail on cleanup error
+                }
+            }
             return managedError(error, req, res);
         }
 

run/tests/jobs/startCustomL1ParentSync.test.js

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview Tests for startCustomL1ParentSync job.
+ */
+require('../mocks/lib/queue');
+require('../mocks/lib/logger');
+require('../mocks/models');
+
+const { Workspace, OrbitChainConfig, OpChainConfig } = require('../mocks/models');
+const startCustomL1ParentSync = require('../../jobs/startCustomL1ParentSync');
+
+jest.mock('../../lib/queue');
+jest.mock('../../lib/logger');
+jest.mock('../../lib/pm2');
+jest.mock('../../lib/env');
+
+const PM2 = require('../../lib/pm2');
+const { getPm2Host, getPm2Secret } = require('../../lib/env');
+
+beforeEach(() => jest.clearAllMocks());
+
+describe('startCustomL1ParentSync', () => {
+    let mockWorkspace;
+    let mockPm2Instance;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        getPm2Host.mockReturnValue('http://localhost:3000');
+        getPm2Secret.mockReturnValue('test-secret');
+
+        mockWorkspace = {
+            id: 113,
+            name: 'My Custom L1',
+            rpcServer: 'https://my-custom-l1.com/rpc',
+            isCustomL1Parent: true
+        };
+
+        mockPm2Instance = {
+            find: jest.fn(),
+            start: jest.fn()
+        };
+
+        PM2.mockImplementation(() => mockPm2Instance);
+    });
+
+    describe('when workspace is a valid custom L1 parent', () => {
+        it('should start sync when workspace has OP children', async () => {
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(0);
+            OpChainConfig.count.mockResolvedValue(1);
+            mockPm2Instance.find.mockResolvedValue({ data: null });
+            mockPm2Instance.start.mockResolvedValue({});
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(Workspace.findByPk).toHaveBeenCalledWith(113);
+            expect(OpChainConfig.count).toHaveBeenCalledWith({ where: { parentWorkspaceId: 113 } });
+            expect(mockPm2Instance.start).toHaveBeenCalledWith('custom-l1-113', 113);
+            expect(result).toBe('Started sync for workspace 113');
+        });
+
+        it('should start sync when workspace has Orbit children', async () => {
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(2);
+            OpChainConfig.count.mockResolvedValue(0);
+            mockPm2Instance.find.mockResolvedValue({ data: null });
+            mockPm2Instance.start.mockResolvedValue({});
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(OrbitChainConfig.count).toHaveBeenCalledWith({ where: { parentWorkspaceId: 113 } });
+            expect(mockPm2Instance.start).toHaveBeenCalledWith('custom-l1-113', 113);
+            expect(result).toBe('Started sync for workspace 113');
+        });
+
+        it('should skip if sync is already running', async () => {
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(1);
+            OpChainConfig.count.mockResolvedValue(0);
+            mockPm2Instance.find.mockResolvedValue({ data: { pm2_env: { status: 'online' } } });
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(mockPm2Instance.start).not.toHaveBeenCalled();
+            expect(result).toBe('Sync already running for workspace 113');
+        });
+    });
+
+    describe('when workspace should not be synced', () => {
+        it('should skip if workspace not found', async () => {
+            Workspace.findByPk.mockResolvedValue(null);
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 999 } });
+
+            expect(result).toBe('Workspace 999 not found');
+            expect(mockPm2Instance.start).not.toHaveBeenCalled();
+        });
+
+        it('should skip if workspace is not a custom L1 parent', async () => {
+            Workspace.findByPk.mockResolvedValue({ ...mockWorkspace, isCustomL1Parent: false });
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(result).toBe('Workspace 113 is not a custom L1 parent');
+            expect(mockPm2Instance.start).not.toHaveBeenCalled();
+        });
+
+        it('should skip if workspace has no L2 children', async () => {
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(0);
+            OpChainConfig.count.mockResolvedValue(0);
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(result).toBe('No L2 children for workspace 113');
+            expect(mockPm2Instance.start).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when PM2 is not configured', () => {
+        it('should skip if PM2 host is not set', async () => {
+            getPm2Host.mockReturnValue(null);
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(1);
+            OpChainConfig.count.mockResolvedValue(0);
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(result).toBe('PM2 not configured');
+            expect(mockPm2Instance.start).not.toHaveBeenCalled();
+        });
+
+        it('should skip if PM2 secret is not set', async () => {
+            getPm2Secret.mockReturnValue(null);
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(1);
+            OpChainConfig.count.mockResolvedValue(0);
+
+            const result = await startCustomL1ParentSync({ data: { workspaceId: 113 } });
+
+            expect(result).toBe('PM2 not configured');
+            expect(mockPm2Instance.start).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('error handling', () => {
+        it('should throw if workspaceId is missing', async () => {
+            await expect(startCustomL1ParentSync({ data: {} }))
+                .rejects.toThrow('Missing workspaceId parameter');
+        });
+
+        it('should throw if PM2 start fails', async () => {
+            Workspace.findByPk.mockResolvedValue(mockWorkspace);
+            OrbitChainConfig.count.mockResolvedValue(1);
+            OpChainConfig.count.mockResolvedValue(0);
+            mockPm2Instance.find.mockResolvedValue({ data: null });
+            mockPm2Instance.start.mockRejectedValue(new Error('PM2 connection failed'));
+
+            await expect(startCustomL1ParentSync({ data: { workspaceId: 113 } }))
+                .rejects.toThrow('PM2 connection failed');
+        });
+    });
+});

run/tests/mocks/models/OpChainConfig.js

@@ -3,7 +3,8 @@ const OpChainConfig = {
     create: jest.fn(),
     update: jest.fn(),
     findAll: jest.fn(),
-    destroy: jest.fn()
+    destroy: jest.fn(),
+    count: jest.fn()
 };
 
 module.exports = { OpChainConfig };

run/tests/mocks/models/OrbitChainConfig.js

@@ -4,7 +4,8 @@ const OrbitChainConfig = {
     create: jest.fn(),
     update: jest.fn(),
     findAll: jest.fn(),
-    destroy: jest.fn()
+    destroy: jest.fn(),
+    count: jest.fn()
 };
 
 module.exports = { OrbitChainConfig };