@wildo-ai/saas-backend-lib 1.0.1

package/package.json

@@ -0,0 +1,163 @@
+{
+  "name": "@wildo-ai/saas-backend-lib",
+  "version": "1.0.1",
+  "description": "Complete Express + Inversify backend SaaS infrastructure",
+  "license": "UNLICENSED",
+  "author": "Wildo AI",
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./testing": {
+      "source": "./src/testing.ts",
+      "types": "./dist/esm/testing.d.ts",
+      "import": "./dist/esm/testing.js",
+      "default": "./dist/esm/testing.js"
+    }
+  },
+  "main": "./dist/esm/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json && node ./scripts/run-tsc-alias-safe.mjs",
+    "dev": "npx tsc-watch -b tsconfig.build.json --preserveWatchOutput --onSuccess \"node ./scripts/run-tsc-alias-safe.mjs\"",
+    "rebuild": "pnpm clean && pnpm build",
+    "clean": "rimraf dist",
+    "watch": "npx tsc-watch -b tsconfig.build.json --preserveWatchOutput --onSuccess \"node ./scripts/run-tsc-alias-safe.mjs\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run src/__tests__/integration"
+  },
+  "dependencies": {
+    "@inversifyjs/container": "1.12.1",
+    "@authenio/samlify-xsd-schema-validator": "^1.0.5",
+    "@simplewebauthn/server": "^13.2.2",
+    "@wildo-ai/external-connectors": "1.0.1",
+    "@wildo-ai/external-connectors-models": "1.0.1",
+    "@wildo-ai/platform-config-lib": "1.0.1",
+    "@wildo-ai/platform-core-shared": "1.0.1",
+    "@wildo-ai/presets-components-models": "1.0.1",
+    "@wildo-ai/saas-models": "1.0.1",
+    "@wildo-ai/zod-decorators": "1.0.1",
+    "@xmldom/xmldom": "^0.8.11",
+    "expr-eval": "^2.0.2",
+    "inversify": "7.6.1",
+    "jose": "^6.1.3",
+    "kysely": "^0.28.11",
+    "minio": "^8.0.5",
+    "otpauth": "^9.4.0",
+    "pg": "^8.18.0",
+    "samlify": "^2.10.2"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.8",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.3",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^24.0.15",
+    "@types/node-cron": "^3.0.11",
+    "@types/passport": "^1.0.16",
+    "@types/passport-github2": "^1.2.9",
+    "@types/passport-google-oauth20": "^2.0.14",
+    "@types/passport-local": "^1.0.38",
+    "@types/pg": "^8.16.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitest/coverage-v8": "^1.6.1",
+    "@vitest/ui": "^1.6.1",
+    "chokidar": "^5.0.0",
+    "concurrently": "^9.1.0",
+    "oxc-transform": "^0.105.0",
+    "pg-mem": "^3.0.14",
+    "rimraf": "^6.0.1",
+    "tsc-alias": "^1.8.16",
+    "tsc-watch": "^6.2.4",
+    "typescript": "^5.8.3",
+    "vitest": "^1.6.1"
+  },
+  "peerDependencies": {
+    "@ai-sdk/anthropic": "3.0.0-beta.62",
+    "@ai-sdk/google": "3.0.0-beta.58",
+    "@ai-sdk/mistral": "3.0.0-beta.38",
+    "@ai-sdk/openai": "3.0.0-beta.68",
+    "@ai-sdk/perplexity": "3.0.0-beta.38",
+    "@ai-sdk/react": "3.0.0-beta.118",
+    "@ai-sdk/xai": "3.0.0-beta.44",
+    "@opentelemetry/api": "^1.7.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.62.0",
+    "@opentelemetry/exporter-jaeger": "^2.0.1",
+    "@opentelemetry/exporter-prometheus": "^0.203.0",
+    "@opentelemetry/instrumentation": "^0.203.0",
+    "@opentelemetry/instrumentation-express": "^0.52.0",
+    "@opentelemetry/instrumentation-http": "^0.203.0",
+    "@opentelemetry/instrumentation-mongoose": "^0.50.0",
+    "@opentelemetry/instrumentation-redis": "^0.51.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-metrics": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "@opentelemetry/sdk-trace-node": "^2.0.1",
+    "@opentelemetry/semantic-conventions": "^1.17.0",
+    "@react-email/components": "^1.0.8",
+    "@react-email/render": "^2.0.4",
+    "@socket.io/redis-adapter": "^8.3.0",
+    "ai": "6.0.0-beta.118",
+    "amqplib": "^0.10.9",
+    "argon2": "^0.44.0",
+    "axios": "^1.6.8",
+    "bcrypt": "^6.0.0",
+    "bcryptjs": "^3.0.2",
+    "big.js": "^6.2.2",
+    "body-parser": "^2.2.2",
+    "bottleneck": "^2.19.5",
+    "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
+    "commander": "^11.0.0",
+    "compression": "^1.8.1",
+    "connect-redis": "^9.0.0",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "culori": "^4.0.2",
+    "date-fns": "^4.1.0",
+    "dotenv": "^17.3.1",
+    "esbuild": "^0.27.3",
+    "execa": "^9.6.0",
+    "express": "^5.1.0",
+    "express-session": "^1.19.0",
+    "fs-extra": "^11.3.0",
+    "helmet": "^8.1.0",
+    "inquirer": "^9.2.0",
+    "inversify": "7.6.1",
+    "ioredis": "^5.9.3",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.23",
+    "mime": "^4.0.1",
+    "mongodb": "^6.0.0",
+    "mongoose": "^8.2.4",
+    "morgan": "^1.10.1",
+    "multer": "^2.0.1",
+    "mustache": "^4.2.0",
+    "ora": "^7.0.0",
+    "pino": "^9.7.0",
+    "pino-http": "^10.0.0",
+    "pino-pretty": "^10.3.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "redis": "^5.6.0",
+    "reflect-metadata": "0.2.2",
+    "safe-stable-stringify": "^2.5.0",
+    "socket.io": "^4.7.5",
+    "ufo": "^1.6.3",
+    "uuid": "^11.1.0",
+    "yaml": "^2.3.4",
+    "zod": "4.3.6"
+  }
+}

package/src/__tests__/integration/bulk-repository-write-contract.integration.test.ts

@@ -0,0 +1,373 @@
+import 'reflect-metadata';
+import { Container } from 'inversify';
+import { z } from 'zod';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';
+import { createTestContainer, getMocks, resetMocks } from '~wildo-backend-lib/__tests__/test-container';
+import { ResourcesRegistryBackendService } from '~wildo-backend-lib/resources/services/resources-registry.backend.service';
+import { RepositoriesRegistryHandlerBackendService } from '~wildo-backend-lib/base-classes/services/repositories/repositories-registry-handler.backend.service';
+import { RepositoryResourceBackendService } from '~wildo-backend-lib/base-classes/services/repositories/repository-resource.backend.service';
+import { PostgreSQLResourceRepositoryBackendService } from '~wildo-backend-lib/base-classes/services/repositories/postgresql-resource-repository.backend.service';
+import { ExecutionContext } from '~wildo-backend-lib/runtime/models/execution-context.backend.schemas';
+import {
+  CoreResourceOperation,
+  ExecutionContext_ExecutionType,
+  ResourceOperationRiskLevel,
+  ResourceOperationVariantType,
+  ResourcesConfig_OperationPathUtils,
+  createResourceConfiguration_Initialization,
+  type ResourceType,
+} from '@wildo-ai/saas-models';
+
+enum DemoCustomOperations {
+  ARCHIVE = 'archive',
+  RESTORE = 'restore',
+}
+
+describe('bulk repository write contract', () => {
+  let container: Container;
+  let resourceRegistry: ResourcesRegistryBackendService;
+  let repositoriesRegistry: RepositoriesRegistryHandlerBackendService;
+
+  const tasksResourceType = 'tasks' as ResourceType;
+  const taskId = '507f1f77bcf86cd799439011';
+
+  function createTasksFactory() {
+    return () => createResourceConfiguration_Initialization({
+      mainSchema: z.object({
+        _id: z.string().optional(),
+        title: z.string().min(1),
+        status: z.string().optional(),
+      }),
+      resourceIdentifier: tasksResourceType,
+      resourceFieldIdentifier: 'taskId',
+      resourceRelationships: [],
+      coreOperations: [CoreResourceOperation.CREATE, CoreResourceOperation.UPDATE],
+      operationsConfiguration: {
+        [CoreResourceOperation.CREATE]: {
+          variants: [
+            {
+              variantType: ResourceOperationVariantType.API_CALL,
+              isDefault: true,
+              roles: ['APP_USER'],
+              riskLevel: ResourceOperationRiskLevel.MEDIUM,
+              haveBulkOperation: true,
+            },
+          ],
+        },
+        [CoreResourceOperation.UPDATE]: {
+          variants: [
+            {
+              variantType: ResourceOperationVariantType.API_CALL,
+              isDefault: true,
+              roles: ['APP_USER'],
+              riskLevel: ResourceOperationRiskLevel.MEDIUM,
+              haveBulkOperation: true,
+            },
+          ],
+        },
+      },
+    });
+  }
+
+  function createCustomActionsFactory(resourceType: ResourceType) {
+    return () => createResourceConfiguration_Initialization({
+      mainSchema: z.object({
+        _id: z.string().optional(),
+        title: z.string().min(1),
+        status: z.string().optional(),
+      }),
+      resourceIdentifier: resourceType,
+      resourceFieldIdentifier: 'taskId',
+      resourceRelationships: [],
+      coreOperations: [CoreResourceOperation.READ, CoreResourceOperation.UPDATE],
+      customOperation: DemoCustomOperations,
+      operationsConfiguration: {
+        [CoreResourceOperation.READ]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.LOW,
+          }],
+        },
+        [CoreResourceOperation.UPDATE]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.LOW,
+          }],
+        },
+        [DemoCustomOperations.ARCHIVE]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.LOW,
+            resourceOperationLike: CoreResourceOperation.UPDATE,
+            requestDto: z.object({ archivedAt: z.date() }),
+          }],
+        },
+        [DemoCustomOperations.RESTORE]: {
+          variants: [{
+            variantType: ResourceOperationVariantType.API_CALL,
+            isDefault: true,
+            roles: ['APP_USER'],
+            riskLevel: ResourceOperationRiskLevel.LOW,
+            resourceOperationLike: CoreResourceOperation.UPDATE,
+            requestDto: z.object({ restoredBy: z.string() }),
+          }],
+        },
+      },
+    });
+  }
+
+  async function initializeTasksResource() {
+    await resourceRegistry.initialize(
+      { [tasksResourceType]: createTasksFactory() } as any,
+      { [tasksResourceType]: 'taskId' },
+      [],
+      {},
+      {},
+      []
+    );
+  }
+
+  function getOperation(operationIdentifier: CoreResourceOperation, isBulkOperation: boolean) {
+    const operation = resourceRegistry
+      .getResourceConfiguration(tasksResourceType)
+      .operations.find((candidate) =>
+        candidate.operationIdentifier === operationIdentifier
+        && candidate.isBulkOperation === isBulkOperation
+      );
+
+    expect(operation).toBeDefined();
+    return operation;
+  }
+
+  function createExecutionContext(operation: any) {
+    return new ExecutionContext(
+      operation,
+      ExecutionContext_ExecutionType.USER_REQUEST,
+      new Map(),
+      { userId: 'initiator-user-id' },
+      [],
+      [],
+      'request-1',
+      0,
+      new Set(),
+      'APP_USER'
+    );
+  }
+
+  function createRepositoryHelperStub() {
+    return {
+      cleanInputDataArray: vi.fn((data: any[]) => data),
+      cleanInputData: vi.fn((data: any) => data),
+      enrichDataWithContext: vi.fn((data: any) => data),
+      injectNonDiscriminatorLiteralValues: vi.fn((data: any) => data),
+    };
+  }
+
+  beforeEach(async () => {
+    container = createTestContainer();
+    resourceRegistry = container.get(SAAS_SERVICE_TYPES.ResourceRegistryService);
+    repositoriesRegistry = container.get(SAAS_SERVICE_TYPES.RepositoriesRegistryHandlerService);
+    await initializeTasksResource();
+  });
+
+  afterEach(() => {
+    resetMocks(container);
+  });
+
+  it('should validate bulk repository payloads against the non-bulk write slice', () => {
+    const bulkCreateOperation = getOperation(CoreResourceOperation.CREATE, true);
+    const bulkUpdateOperation = getOperation(CoreResourceOperation.UPDATE, true);
+
+    expect(() => bulkCreateOperation.requestDto.parse({ title: 'Created task' })).toThrow();
+    expect(() => bulkUpdateOperation.requestDto.parse({ title: 'Renamed task' })).toThrow();
+
+    expect(
+      repositoriesRegistry.validateRepositoryWriteData(
+        { title: 'Created task' },
+        tasksResourceType,
+        String(bulkCreateOperation.operationIdentifier),
+        true
+      )
+    ).toEqual({ title: 'Created task' });
+
+    expect(
+      repositoriesRegistry.validateRepositoryWriteData(
+        { title: 'Renamed task' },
+        tasksResourceType,
+        String(bulkUpdateOperation.operationIdentifier),
+        true
+      )
+    ).toEqual({ title: 'Renamed task' });
+  });
+
+  it('keeps custom UPDATE-like actions distinct in repository maps', async () => {
+    const customResourceType = 'custom_actions_resource' as ResourceType;
+    const localContainer = createTestContainer();
+    const localRegistry = localContainer.get(SAAS_SERVICE_TYPES.ResourceRegistryService);
+
+    await localRegistry.initialize(
+      { [customResourceType]: createCustomActionsFactory(customResourceType) } as any,
+      { [customResourceType]: 'taskId' },
+      [],
+      {},
+      {},
+      []
+    );
+
+    const customConfig = localRegistry.getResourceConfiguration(customResourceType);
+    const archiveOperation = customConfig.operations.find(op => op.operationIdentifier === DemoCustomOperations.ARCHIVE);
+    const restoreOperation = customConfig.operations.find(op => op.operationIdentifier === DemoCustomOperations.RESTORE);
+
+    expect(archiveOperation).toBeDefined();
+    expect(restoreOperation).toBeDefined();
+
+    const archiveKey = ResourcesConfig_OperationPathUtils.createOperationRepositoryPathKeyFromOperation(archiveOperation!);
+    const restoreKey = ResourcesConfig_OperationPathUtils.createOperationRepositoryPathKeyFromOperation(restoreOperation!);
+
+    expect(archiveKey).not.toBe(restoreKey);
+
+    const { logger, errorBuilder, zodConverter } = getMocks(localContainer);
+    const resourceOperationHelper = createRepositoryHelperStub();
+
+    const repository = new RepositoryResourceBackendService(
+      customResourceType,
+      zodConverter as any,
+      logger as any,
+      errorBuilder as any,
+      localRegistry,
+      resourceOperationHelper as any,
+      repositoriesRegistry,
+      undefined,
+      undefined
+    ) as any;
+
+    expect(repository.operationsMap.has(archiveKey)).toBe(true);
+    expect(repository.operationsMap.has(restoreKey)).toBe(true);
+    expect(repository.operationsMap.get(archiveKey)?.operationIdentifier).toBe(DemoCustomOperations.ARCHIVE);
+    expect(repository.operationsMap.get(restoreKey)?.operationIdentifier).toBe(DemoCustomOperations.RESTORE);
+
+    resetMocks(localContainer);
+  });
+
+  it('should increment the Mongo version token during UPDATE_MANY', async () => {
+    const { logger, errorBuilder, zodConverter } = getMocks(container);
+    const resourceOperationHelper = createRepositoryHelperStub();
+    const bulkUpdateOperation = getOperation(CoreResourceOperation.UPDATE, true);
+    const executionContext = createExecutionContext(bulkUpdateOperation);
+
+    const repository = new RepositoryResourceBackendService(
+      tasksResourceType,
+      zodConverter as any,
+      logger as any,
+      errorBuilder as any,
+      resourceRegistry,
+      resourceOperationHelper as any,
+      repositoriesRegistry,
+      undefined,
+      undefined
+    );
+
+    const model = zodConverter.getModel(tasksResourceType) as any;
+    model.find = vi.fn()
+      .mockResolvedValueOnce([{ _id: taskId }])
+      .mockResolvedValueOnce([{ _id: taskId, title: 'Retitled', _version_db_doc: 4 }]);
+    model.updateMany = vi.fn().mockResolvedValue({ matchedCount: 1, modifiedCount: 1 });
+
+    const result = await (repository as any)._doUpdateMany(
+      bulkUpdateOperation,
+      executionContext,
+      [taskId],
+      { title: 'Retitled', _version_db_doc: 99, _version: 99 }
+    );
+
+    expect(model.updateMany).toHaveBeenCalledWith(
+      expect.anything(),
+      {
+        $set: expect.objectContaining({ title: 'Retitled' }),
+        $inc: { _version_db_doc: 1 },
+      },
+      expect.any(Object)
+    );
+    expect((model.updateMany.mock.calls[0][1] as any).$set._version_db_doc).toBeUndefined();
+    expect((model.updateMany.mock.calls[0][1] as any).$set._version).toBeUndefined();
+    expect(result).toEqual([
+      expect.objectContaining({ _id: taskId, title: 'Retitled', _version: 4 }),
+    ]);
+  });
+
+  it('should route PostgreSQL bulk create and update through repository write payload validation', async () => {
+    const { logger, errorBuilder } = getMocks(container);
+    const resourceOperationHelper = createRepositoryHelperStub();
+    const dbService = container.get(SAAS_SERVICE_TYPES.PostgreSQLDatabaseService);
+    const sqlPlanner = container.get(SAAS_SERVICE_TYPES.ZodToSqlHybridSchemaPlannerService);
+    const bulkCreateOperation = getOperation(CoreResourceOperation.CREATE, true);
+    const bulkUpdateOperation = getOperation(CoreResourceOperation.UPDATE, true);
+
+    const repository = new PostgreSQLResourceRepositoryBackendService(
+      tasksResourceType,
+      dbService as any,
+      logger as any,
+      errorBuilder as any,
+      resourceRegistry,
+      resourceOperationHelper as any,
+      repositoriesRegistry as any,
+      sqlPlanner as any
+    );
+    const repositoryAny = repository as any;
+    const validateRepositoryWriteDataSpy = vi.spyOn(repositoriesRegistry, 'validateRepositoryWriteData');
+
+    const insertBuilder = {
+      values: vi.fn().mockReturnThis(),
+      returningAll: vi.fn().mockReturnThis(),
+      execute: vi.fn().mockResolvedValue([{ _id: 'task-1', title: 'Created task' }]),
+    };
+    const updateBuilder = {
+      set: vi.fn().mockReturnThis(),
+      $call: vi.fn(function (cb: (qb: any) => any) {
+        return cb(this);
+      }),
+      returningAll: vi.fn().mockReturnThis(),
+      execute: vi.fn().mockResolvedValue([{ _id: 'task-1', title: 'Retitled' }]),
+    };
+
+    repositoryAny.getDbOrTrx = vi.fn().mockResolvedValue({
+      insertInto: vi.fn().mockReturnValue(insertBuilder),
+      updateTable: vi.fn().mockReturnValue(updateBuilder),
+    });
+    repositoryAny.buildContextualFilter = vi.fn((_executionContext: any, filter: any) => filter);
+    repositoryAny.buildWhere = vi.fn().mockReturnValue(null);
+    repositoryAny.filterService.applyWhere = vi.fn((qb: any) => qb);
+
+    await repositoryAny._doCreateMany(
+      bulkCreateOperation,
+      createExecutionContext(bulkCreateOperation),
+      [{ title: 'Created task' }]
+    );
+    await repositoryAny._doUpdateMany(
+      bulkUpdateOperation,
+      createExecutionContext(bulkUpdateOperation),
+      [taskId],
+      { title: 'Retitled' }
+    );
+
+    expect(validateRepositoryWriteDataSpy).toHaveBeenCalledWith(
+      { title: 'Created task' },
+      tasksResourceType,
+      String(bulkCreateOperation.operationIdentifier),
+      true
+    );
+    expect(validateRepositoryWriteDataSpy).toHaveBeenCalledWith(
+      { title: 'Retitled' },
+      tasksResourceType,
+      String(bulkUpdateOperation.operationIdentifier),
+      true
+    );
+  });
+});

package/src/__tests__/integration/custom-batch-job-execution.integration.test.ts

@@ -0,0 +1,147 @@
+import 'reflect-metadata';
+
+import { Container } from 'inversify';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+
+import {
+  CoreResourceType,
+  JobPayloadSchema,
+  JobStatus,
+  JobType,
+  ResourceOperationVariantType,
+} from '@wildo-ai/saas-models';
+
+import { createTestContainer, getMocks, resetMocks } from '~wildo-backend-lib/__tests__/test-container';
+import { BatchesCronjobsExecutor_BackendService } from '~wildo-backend-lib/base-classes/services/batches/batches-cronjobs-executor.backend.service';
+import { createCustomBatchExecutionService } from '~wildo-backend-lib/base-classes/services/batches/batches-cronjobs-custom-execution.service';
+import { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';
+import { JobExecutorBackendService } from '~wildo-backend-lib/queue/job-executor.backend.service';
+import { ResourcesRegistryBackendService } from '~wildo-backend-lib/resources/services/resources-registry.backend.service';
+import { ExecutionContextCreatorBackendService } from '~wildo-backend-lib/runtime/services/execution-context-creator.backend.service';
+import { ExecutionContextHandlerBackendService } from '~wildo-backend-lib/runtime/services/execution-context-handler.backend.service';
+
+describe('custom batch execution integration', () => {
+  let container: Container;
+  let resourceRegistry: ResourcesRegistryBackendService;
+
+  beforeEach(async () => {
+    container = createTestContainer();
+    resourceRegistry = container.get(SAAS_SERVICE_TYPES.ResourceRegistryService);
+    await resourceRegistry.initialize({}, {}, [], {}, {}, []);
+  });
+
+  afterEach(() => {
+    resetMocks(container);
+  });
+
+  it('executes a custom batch through JobExecutor with a synthetic batch operation identity', async () => {
+    const { logger, errorBuilder, config } = getMocks(container);
+    const appRepositoryRead = vi.fn().mockResolvedValue({ _id: 'app-1' });
+    const repositoriesRegistry = {
+      getRepository: vi.fn((resourceType: string) => {
+        if (resourceType === CoreResourceType.APPLICATION) {
+          return { read: appRepositoryRead };
+        }
+        throw new Error(`Unexpected repository lookup for ${resourceType}`);
+      }),
+    };
+
+    const executionContextHandler = new ExecutionContextHandlerBackendService(
+      logger as any,
+      resourceRegistry,
+      errorBuilder as any,
+    );
+    const creator = new ExecutionContextCreatorBackendService(
+      logger as any,
+      config as any,
+      errorBuilder as any,
+      executionContextHandler,
+      {} as any,
+      resourceRegistry,
+      repositoriesRegistry as any,
+      {} as any,
+      {} as any,
+      container,
+    );
+    const errorHandler = {
+      handleBatchesCronjobsError: vi.fn((error: unknown) => {
+        throw error;
+      }),
+    };
+    const batchesExecutor = new BatchesCronjobsExecutor_BackendService(
+      logger as any,
+      errorBuilder as any,
+      errorHandler as any,
+      creator,
+      resourceRegistry,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+    );
+    const createForInternalCustomBatchSpy = vi.spyOn(creator, 'createForInternalCustomBatch');
+
+    const batch = createCustomBatchExecutionService({
+      input: z.object({ trigger: z.string() }),
+      output: z.object({
+        executionType: z.string(),
+        operationIdentifier: z.string(),
+        variantType: z.string(),
+        applicationId: z.string(),
+        roleCount: z.number(),
+      }),
+      batchCronjob_Context: {
+        resourceIdentifier: CoreResourceType.EMAIL_TEMPLATES,
+        operationIdentifier: 'batch-send' as any,
+      },
+      doHandle: async (_input, { executionContext }) => ({
+        executionType: executionContext.executionType,
+        operationIdentifier: String(executionContext.operation.operationIdentifier),
+        variantType: executionContext.operation.variantType,
+        applicationId: executionContext.initiatorIds?.applicationId ?? '',
+        roleCount: executionContext.initiatorRoles.length,
+      }),
+    });
+    await batchesExecutor.initialize(new Map([['email.batch-send', batch]]));
+
+    const jobExecutor = new JobExecutorBackendService(
+      {} as any,
+      creator,
+      batchesExecutor,
+      {} as any,
+      {} as any,
+      logger as any,
+      errorBuilder as any,
+    );
+
+    const job = JobPayloadSchema.parse({
+      jobId: '00000000-0000-4000-8000-000000000001',
+      jobType: JobType.CUSTOM_BATCH,
+      applicationId: 'app-routing-id',
+      batchRef: 'email.batch-send',
+      inputDataJson: JSON.stringify({ trigger: 'manual' }),
+      createdAt: new Date(),
+    });
+
+    const result = await jobExecutor.execute(job);
+
+    expect(result.status).toBe(JobStatus.COMPLETED);
+    expect(errorHandler.handleBatchesCronjobsError).not.toHaveBeenCalled();
+    expect(createForInternalCustomBatchSpy).toHaveBeenCalledWith({
+      batchOperationContext: {
+        operationIdentifier: 'batch-send',
+        resourceIdentifier: CoreResourceType.EMAIL_TEMPLATES,
+      },
+      contextResourcesFieldIdentifier: new Map(),
+    });
+    expect(JSON.parse(result.resultJson ?? '{}')).toEqual({
+      executionType: 'internally_initiated_request',
+      operationIdentifier: 'batch-send',
+      variantType: ResourceOperationVariantType.BATCH_JOB,
+      applicationId: '',
+      roleCount: 1,
+    });
+  });
+});