@owox/backend 0.38.0 → 0.39.0

package/dist/src/plugin-host/services/plugin-action-dispatcher.service.js

@@ -0,0 +1,140 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PluginActionDispatcherService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginActionDispatcherService = void 0;
+const common_1 = require("@nestjs/common");
+const internal_helpers_1 = require("@owox/internal-helpers");
+const guarded_dispatcher_1 = require("../../common/helpers/guarded-dispatcher");
+const read_bounded_body_helper_1 = require("../../common/helpers/read-bounded-body.helper");
+const safe_url_helper_1 = require("../../common/helpers/safe-url.helper");
+const graceful_shutdown_service_1 = require("../../common/scheduler/services/graceful-shutdown.service");
+const plugin_host_config_1 = require("../config/plugin-host.config");
+const plugin_action_limits_1 = require("../constants/plugin-action-limits");
+const plugin_action_execution_status_enum_1 = require("../enums/plugin-action-execution-status.enum");
+const plugin_action_outcome_util_1 = require("../utils/plugin-action-outcome.util");
+const plugin_action_execution_service_1 = require("./plugin-action-execution.service");
+const MAX_RESPONSE_BYTES = plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxResultBytes + 1024;
+const UNSTORABLE_RESULT = {
+    status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED,
+    errorCode: 'BACKEND_INVALID_RESPONSE',
+    errorMessage: 'The result could not be stored',
+};
+let PluginActionDispatcherService = PluginActionDispatcherService_1 = class PluginActionDispatcherService {
+    executions;
+    shutdown;
+    config;
+    logger = new common_1.Logger(PluginActionDispatcherService_1.name);
+    constructor(executions, shutdown, config) {
+        this.executions = executions;
+        this.shutdown = shutdown;
+        this.config = config;
+    }
+    async dispatch(execution, backendUrl, token, timeoutSeconds) {
+        const processId = this.shutdown.registerActiveProcess(`plugin-action-${execution.id}`);
+        const startedAt = Date.now();
+        const controller = new AbortController();
+        let stopReason;
+        const stop = (reason) => {
+            stopReason ??= reason;
+            controller.abort();
+        };
+        const deadline = setTimeout(() => stop('deadline'), Math.max(0, (execution.deadlineAt?.getTime() ?? startedAt) - startedAt));
+        const poll = setInterval(() => {
+            this.executions.findStatus(execution.id).then(status => {
+                if (status !== plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING)
+                    stop('ended');
+            }, () => undefined);
+        }, plugin_action_limits_1.PLUGIN_ACTION_LIMITS.cancelPollMs);
+        try {
+            let outcome;
+            try {
+                outcome = await this.call(execution.id, backendUrl, token, controller.signal);
+            }
+            catch (error) {
+                outcome =
+                    stopReason === 'deadline'
+                        ? timedOut(timeoutSeconds)
+                        : stopReason === 'ended'
+                            ? null
+                            : unreachable(error);
+            }
+            finally {
+                clearTimeout(deadline);
+                clearInterval(poll);
+            }
+            let recorded = false;
+            if (outcome) {
+                try {
+                    recorded = await this.executions.finish(execution.id, outcome);
+                }
+                catch (error) {
+                    if (outcome.status !== plugin_action_execution_status_enum_1.PluginActionExecutionStatus.SUCCEEDED)
+                        throw error;
+                    this.logger.error(`Plugin action ${execution.id} could not store its result`, (0, internal_helpers_1.castError)(error).stack);
+                    outcome = UNSTORABLE_RESULT;
+                    recorded = await this.executions.finish(execution.id, outcome);
+                }
+            }
+            const status = recorded && outcome ? outcome.status : await this.executions.findStatus(execution.id);
+            const errorCode = recorded && outcome?.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED
+                ? outcome.errorCode
+                : '-';
+            this.logger.log(`Plugin action finished executionId=${execution.id} action=${execution.action} status=${status} errorCode=${errorCode} durationMs=${Date.now() - startedAt}`);
+        }
+        catch (error) {
+            this.logger.error(`Plugin action ${execution.id} could not record its outcome`, (0, internal_helpers_1.castError)(error).stack);
+        }
+        finally {
+            this.shutdown.unregisterActiveProcess(processId);
+        }
+    }
+    async call(executionId, backendUrl, token, signal) {
+        await (0, safe_url_helper_1.assertPublicHttpUrl)(backendUrl, { allowedProtocols: ['https:'] });
+        const response = await fetch(backendUrl, (0, guarded_dispatcher_1.withGuardedDispatcher)({
+            method: 'POST',
+            redirect: 'manual',
+            signal,
+            headers: { 'content-type': 'application/json', 'x-owox-execution-token': token },
+            body: JSON.stringify({ owox: 1, host: this.config.publicOrigin, executionId }),
+        }));
+        const body = await (0, read_bounded_body_helper_1.readBoundedBody)(response, MAX_RESPONSE_BYTES);
+        return (0, plugin_action_outcome_util_1.classifyBackendResponse)(response.status, body?.toString('utf8') ?? null);
+    }
+};
+exports.PluginActionDispatcherService = PluginActionDispatcherService;
+exports.PluginActionDispatcherService = PluginActionDispatcherService = PluginActionDispatcherService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService,
+        graceful_shutdown_service_1.GracefulShutdownService,
+        plugin_host_config_1.PluginHostConfigService])
+], PluginActionDispatcherService);
+function timedOut(seconds) {
+    return {
+        status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.TIMED_OUT,
+        errorMessage: `The action did not finish within ${seconds} s`,
+    };
+}
+function unreachable(error) {
+    return {
+        status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED,
+        errorCode: 'BACKEND_UNREACHABLE',
+        errorMessage: `The backend could not be reached (${reasonOf(error)})`,
+    };
+}
+function reasonOf(error) {
+    if (error instanceof safe_url_helper_1.UnsafeUrlError)
+        return error.reason;
+    const { cause, name } = (0, internal_helpers_1.castError)(error);
+    const code = cause?.code;
+    return typeof code === 'string' ? code : name;
+}
+//# sourceMappingURL=plugin-action-dispatcher.service.js.map

package/dist/src/plugin-host/services/plugin-action-execution.service.d.ts

@@ -0,0 +1,69 @@
+import { Repository } from 'typeorm';
+import { PluginActionExecution } from '../entities/plugin-action-execution.entity';
+import { PluginInstallation } from '../entities/plugin-installation.entity';
+import { PluginActionExecutionStatus, type PluginActionTrigger } from '../enums/plugin-action-execution-status.enum';
+export interface InsertRunningExecutionInput {
+    pluginId: string;
+    pluginVersionId: string;
+    installationId: string;
+    projectId: string;
+    userId: string;
+    action: string;
+    input: unknown;
+    inputBytes: number;
+    role: string;
+    timeoutSeconds: number;
+    tokenHash: string;
+    trigger: PluginActionTrigger;
+}
+declare const TOKEN_OWNER_COLUMNS: {
+    readonly id: true;
+    readonly pluginId: true;
+    readonly installationId: true;
+    readonly projectId: true;
+    readonly userId: true;
+    readonly role: true;
+};
+export type ExecutionTokenOwner = Pick<PluginActionExecution, keyof typeof TOKEN_OWNER_COLUMNS>;
+declare const SUMMARY_COLUMNS: {
+    readonly id: true;
+    readonly installationId: true;
+    readonly action: true;
+    readonly status: true;
+    readonly trigger: true;
+    readonly startedAt: true;
+    readonly deadlineAt: true;
+    readonly finishedAt: true;
+    readonly errorCode: true;
+    readonly errorMessage: true;
+    readonly result: true;
+};
+export type PluginActionExecutionSummary = Pick<PluginActionExecution, keyof typeof SUMMARY_COLUMNS>;
+export type FinishExecutionInput = {
+    status: PluginActionExecutionStatus.SUCCEEDED;
+    result: unknown;
+} | {
+    status: PluginActionExecutionStatus.FAILED;
+    errorCode: string;
+    errorMessage: string;
+} | {
+    status: PluginActionExecutionStatus.TIMED_OUT;
+    errorMessage: string;
+};
+export declare class PluginActionExecutionService {
+    private readonly executions;
+    private readonly installations;
+    constructor(executions: Repository<PluginActionExecution>, installations: Repository<PluginInstallation>);
+    insertRunning(request: InsertRunningExecutionInput): Promise<PluginActionExecution>;
+    assertWithinStartLimits(installationId: string, now: number): Promise<void>;
+    findById(id: string): Promise<PluginActionExecutionSummary | null>;
+    findWithInput(id: string): Promise<PluginActionExecution | null>;
+    findStatus(id: string): Promise<PluginActionExecutionStatus | null>;
+    findRunningByTokenHash(tokenHash: string, now: Date): Promise<ExecutionTokenOwner | null>;
+    finish(id: string, outcome: FinishExecutionInput): Promise<boolean>;
+    cancel(id: string, installationId: string): Promise<boolean>;
+    timeOutOrphans(deadlineBefore: Date): Promise<number>;
+    clearPayloads(finishedBefore: Date, signal?: AbortSignal): Promise<number>;
+    deleteFinished(finishedBefore: Date, signal?: AbortSignal): Promise<number>;
+}
+export {};

package/dist/src/plugin-host/services/plugin-action-execution.service.js

@@ -0,0 +1,239 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginActionExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const plugin_action_limits_1 = require("../constants/plugin-action-limits");
+const plugin_action_execution_entity_1 = require("../entities/plugin-action-execution.entity");
+const plugin_installation_entity_1 = require("../entities/plugin-installation.entity");
+const plugin_action_execution_status_enum_1 = require("../enums/plugin-action-execution-status.enum");
+const plugin_action_errors_1 = require("../errors/plugin-action.errors");
+const HOUR_MS = 60 * 60 * 1000;
+const MINUTE_MS = 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+function byteLength(value) {
+    return value === null || value === undefined ? 0 : Buffer.byteLength(JSON.stringify(value) ?? '');
+}
+const TOKEN_OWNER_COLUMNS = {
+    id: true,
+    pluginId: true,
+    installationId: true,
+    projectId: true,
+    userId: true,
+    role: true,
+};
+const SUMMARY_COLUMNS = {
+    id: true,
+    installationId: true,
+    action: true,
+    status: true,
+    trigger: true,
+    startedAt: true,
+    deadlineAt: true,
+    finishedAt: true,
+    errorCode: true,
+    errorMessage: true,
+    result: true,
+};
+let PluginActionExecutionService = class PluginActionExecutionService {
+    executions;
+    installations;
+    constructor(executions, installations) {
+        this.executions = executions;
+        this.installations = installations;
+    }
+    async insertRunning(request) {
+        const lock = await this.installations
+            .createQueryBuilder()
+            .update(plugin_installation_entity_1.PluginInstallation)
+            .set({ modifiedAt: () => 'modifiedAt' })
+            .where('id = :id', { id: request.installationId })
+            .andWhere('uninstalledAt IS NULL')
+            .execute();
+        if (lock.affected !== 1) {
+            throw new plugin_action_errors_1.InstallationInactiveError();
+        }
+        const now = Date.now();
+        const running = await this.executions.countBy({
+            installationId: request.installationId,
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING,
+            deadlineAt: (0, typeorm_2.MoreThan)(new Date(now)),
+        });
+        if (running >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxRunningPerInstallation) {
+            throw new plugin_action_errors_1.TooManyExecutionsError();
+        }
+        await this.assertWithinStartLimits(request.installationId, now);
+        const startedAt = new Date(Math.floor(now / 1000) * 1000);
+        return this.executions.save(this.executions.create({
+            pluginId: request.pluginId,
+            pluginVersionId: request.pluginVersionId,
+            installationId: request.installationId,
+            projectId: request.projectId,
+            userId: request.userId,
+            action: request.action,
+            input: request.input,
+            trigger: request.trigger,
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING,
+            role: request.role,
+            tokenHash: request.tokenHash,
+            startedAt,
+            deadlineAt: new Date(Math.ceil((now + request.timeoutSeconds * 1000) / 1000) * 1000),
+            finishedAt: null,
+            errorCode: null,
+            errorMessage: null,
+            result: null,
+            payloadBytes: request.inputBytes,
+        }));
+    }
+    async assertWithinStartLimits(installationId, now) {
+        const raw = await this.executions
+            .createQueryBuilder('e')
+            .select('SUM(CASE WHEN e.startedAt > :minuteAgo THEN 1 ELSE 0 END)', 'perMinute')
+            .addSelect('SUM(CASE WHEN e.startedAt > :dayAgo THEN 1 ELSE 0 END)', 'perDay')
+            .addSelect('SUM(e.payloadBytes)', 'bytes')
+            .where('e.installationId = :installationId', { installationId })
+            .andWhere('e.startedAt > :bytesSince')
+            .setParameters({
+            minuteAgo: new Date(now - MINUTE_MS),
+            dayAgo: new Date(now - DAY_MS),
+            bytesSince: new Date(now - 2 * plugin_action_limits_1.PLUGIN_ACTION_LIMITS.payloadRetentionHours * HOUR_MS),
+        })
+            .getRawOne();
+        const perMinute = Number(raw?.perMinute ?? 0);
+        const perDay = Number(raw?.perDay ?? 0);
+        const bytes = Number(raw?.bytes ?? 0);
+        if (perMinute >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerMinute) {
+            throw new plugin_action_errors_1.TooManyExecutionsError(`${plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerMinute} starts per minute reached`);
+        }
+        if (perDay >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerDay) {
+            throw new plugin_action_errors_1.TooManyExecutionsError(`${plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerDay} starts per day reached`);
+        }
+        if (bytes >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxPayloadBytesPerInstallation) {
+            throw new plugin_action_errors_1.TooManyExecutionsError(`${plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxPayloadBytesPerInstallation / (1024 * 1024)} MiB of stored payloads reached`);
+        }
+    }
+    findById(id) {
+        return this.executions.findOne({ select: SUMMARY_COLUMNS, where: { id } });
+    }
+    findWithInput(id) {
+        return this.executions.findOneBy({ id });
+    }
+    async findStatus(id) {
+        const row = await this.executions.findOne({
+            select: { id: true, status: true },
+            where: { id },
+        });
+        return row?.status ?? null;
+    }
+    findRunningByTokenHash(tokenHash, now) {
+        return this.executions.findOne({
+            select: TOKEN_OWNER_COLUMNS,
+            where: { tokenHash, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING, deadlineAt: (0, typeorm_2.MoreThan)(now) },
+        });
+    }
+    async finish(id, outcome) {
+        const { affected } = await this.executions.update({ id, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING }, {
+            status: outcome.status,
+            finishedAt: new Date(),
+            errorCode: outcome.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED ? outcome.errorCode : null,
+            errorMessage: 'errorMessage' in outcome ? outcome.errorMessage : null,
+            result: (outcome.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.SUCCEEDED
+                ? outcome.result
+                : null),
+            ...(outcome.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.SUCCEEDED && {
+                payloadBytes: () => `payloadBytes + ${byteLength(outcome.result)}`,
+            }),
+        });
+        return affected === 1;
+    }
+    async cancel(id, installationId) {
+        const { affected } = await this.executions.update({ id, installationId, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING }, {
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.CANCELLED,
+            finishedAt: new Date(),
+            errorMessage: 'The execution was cancelled',
+        });
+        return affected === 1;
+    }
+    async timeOutOrphans(deadlineBefore) {
+        const { affected } = await this.executions.update({ status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING, deadlineAt: (0, typeorm_2.LessThan)(deadlineBefore) }, {
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.TIMED_OUT,
+            finishedAt: new Date(),
+            errorMessage: 'The execution outlived its replica',
+        });
+        return affected ?? 0;
+    }
+    clearPayloads(finishedBefore, signal) {
+        return inBatches(signal, async () => {
+            const rows = await this.executions.find({
+                select: { id: true, errorCode: true },
+                where: { payloadsClearedAt: (0, typeorm_2.IsNull)(), finishedAt: (0, typeorm_2.LessThan)(finishedBefore) },
+                take: plugin_action_limits_1.PLUGIN_ACTION_LIMITS.sweepBatchSize,
+            });
+            if (rows.length === 0)
+                return 0;
+            const pluginAuthored = rows.filter(row => (0, plugin_action_limits_1.isPluginOwnedErrorCode)(row.errorCode));
+            if (pluginAuthored.length > 0) {
+                await this.executions.update({ id: (0, typeorm_2.In)(pluginAuthored.map(row => row.id)) }, { errorMessage: null });
+            }
+            await this.executions.update({ id: (0, typeorm_2.In)(rows.map(row => row.id)) }, {
+                input: () => 'NULL',
+                result: () => 'NULL',
+                payloadsClearedAt: new Date(),
+                payloadBytes: 0,
+            });
+            return rows.length;
+        });
+    }
+    deleteFinished(finishedBefore, signal) {
+        return inBatches(signal, async () => {
+            const rows = await this.executions.find({
+                select: { id: true },
+                where: { finishedAt: (0, typeorm_2.LessThan)(finishedBefore) },
+                take: plugin_action_limits_1.PLUGIN_ACTION_LIMITS.sweepBatchSize,
+            });
+            if (rows.length > 0) {
+                await this.executions.delete({ id: (0, typeorm_2.In)(rows.map(row => row.id)) });
+            }
+            return rows.length;
+        });
+    }
+};
+exports.PluginActionExecutionService = PluginActionExecutionService;
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], PluginActionExecutionService.prototype, "insertRunning", null);
+exports.PluginActionExecutionService = PluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(plugin_action_execution_entity_1.PluginActionExecution)),
+    __param(1, (0, typeorm_1.InjectRepository)(plugin_installation_entity_1.PluginInstallation)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository])
+], PluginActionExecutionService);
+async function inBatches(signal, batch) {
+    let total = 0;
+    while (!signal?.aborted) {
+        const handled = await batch();
+        total += handled;
+        if (handled < plugin_action_limits_1.PLUGIN_ACTION_LIMITS.sweepBatchSize)
+            break;
+    }
+    return total;
+}
+//# sourceMappingURL=plugin-action-execution.service.js.map

package/dist/src/plugin-host/services/plugin-action-starter.service.d.ts

@@ -0,0 +1,22 @@
+import type { StartedPluginActionExecution } from '../dto/domain/plugin-action-execution.dto';
+import type { PluginInstallation } from '../entities/plugin-installation.entity';
+import type { PluginVersion } from '../entities/plugin-version.entity';
+import { type PluginActionTrigger } from '../enums/plugin-action-execution-status.enum';
+import { ActionInputValidatorService } from './action-input-validator.service';
+import { PluginActionDispatcherService } from './plugin-action-dispatcher.service';
+import { PluginActionExecutionService } from './plugin-action-execution.service';
+export interface PluginActionStart {
+    readonly installation: Pick<PluginInstallation, 'id' | 'projectId' | 'userId'>;
+    readonly version: PluginVersion;
+    readonly action: string;
+    readonly input: unknown;
+    readonly role: string;
+    readonly trigger: PluginActionTrigger;
+}
+export declare class PluginActionStarterService {
+    private readonly validator;
+    private readonly executions;
+    private readonly dispatcher;
+    constructor(validator: ActionInputValidatorService, executions: PluginActionExecutionService, dispatcher: PluginActionDispatcherService);
+    start(request: PluginActionStart): Promise<StartedPluginActionExecution>;
+}

package/dist/src/plugin-host/services/plugin-action-starter.service.js

@@ -0,0 +1,81 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginActionStarterService = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_action_limits_1 = require("../constants/plugin-action-limits");
+const plugin_action_execution_status_enum_1 = require("../enums/plugin-action-execution-status.enum");
+const plugin_action_errors_1 = require("../errors/plugin-action.errors");
+const execution_token_util_1 = require("../utils/execution-token.util");
+const json_shape_util_1 = require("../utils/json-shape.util");
+const plugin_manifest_util_1 = require("../utils/plugin-manifest.util");
+const action_input_validator_service_1 = require("./action-input-validator.service");
+const plugin_action_dispatcher_service_1 = require("./plugin-action-dispatcher.service");
+const plugin_action_execution_service_1 = require("./plugin-action-execution.service");
+let PluginActionStarterService = class PluginActionStarterService {
+    validator;
+    executions;
+    dispatcher;
+    constructor(validator, executions, dispatcher) {
+        this.validator = validator;
+        this.executions = executions;
+        this.dispatcher = dispatcher;
+    }
+    async start(request) {
+        const { installation, version, action } = request;
+        if (!version.backend || !Object.hasOwn(version.backend.actions, action)) {
+            throw new plugin_action_errors_1.ActionNotDeclaredError(action);
+        }
+        const declaration = version.backend.actions[action];
+        const input = request.input ?? null;
+        const shapeProblem = (0, json_shape_util_1.findJsonShapeProblem)(input);
+        if (shapeProblem) {
+            throw new plugin_action_errors_1.ActionInputInvalidError([{ instancePath: '', message: shapeProblem }]);
+        }
+        const inputBytes = input === null ? 0 : Buffer.byteLength(JSON.stringify(input));
+        if (inputBytes > plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxInputBytes) {
+            throw new plugin_action_errors_1.ActionInputTooLargeError();
+        }
+        await this.executions.assertWithinStartLimits(installation.id, Date.now());
+        if (declaration.input) {
+            const errors = await this.validator.validate(version.id, action, declaration.input, input);
+            if (errors.length > 0) {
+                throw new plugin_action_errors_1.ActionInputInvalidError(errors);
+            }
+        }
+        const backendUrl = (0, plugin_manifest_util_1.resolveBackendUrl)(version.backend, version.deliveryUrl);
+        const { token, tokenHash } = (0, execution_token_util_1.createExecutionToken)();
+        const execution = await this.executions.insertRunning({
+            pluginId: version.pluginId,
+            pluginVersionId: version.id,
+            installationId: installation.id,
+            projectId: installation.projectId,
+            userId: installation.userId,
+            action,
+            input,
+            inputBytes,
+            role: request.role,
+            timeoutSeconds: declaration.timeoutSeconds,
+            tokenHash,
+            trigger: request.trigger,
+        });
+        void this.dispatcher.dispatch(execution, backendUrl, token, declaration.timeoutSeconds);
+        return { id: execution.id, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING };
+    }
+};
+exports.PluginActionStarterService = PluginActionStarterService;
+exports.PluginActionStarterService = PluginActionStarterService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [action_input_validator_service_1.ActionInputValidatorService,
+        plugin_action_execution_service_1.PluginActionExecutionService,
+        plugin_action_dispatcher_service_1.PluginActionDispatcherService])
+], PluginActionStarterService);
+//# sourceMappingURL=plugin-action-starter.service.js.map

package/dist/src/plugin-host/services/plugin-audit.service.d.ts

@@ -3,6 +3,17 @@ import { OwoxEventDispatcher } from '../../common/event-dispatcher/owox-event-di
 import { PluginAuditEvent } from '../entities/plugin-audit-event.entity';
 import { PluginAuditAction } from '../enums/plugin-audit-action.enum';
 import { PluginPublicationScope } from '../enums/plugin-publication-scope.enum';
+export interface PluginHistoryQuery {
+    readonly projectId: string;
+    readonly userId: string;
+    readonly installations: boolean;
+    readonly publications: boolean;
+    readonly changes: boolean;
+    readonly deploymentPluginIds: readonly string[];
+    readonly relevantPluginIds: readonly string[];
+    readonly afterId: string | null;
+    readonly take: number;
+}
 export interface PluginAuditRecord {
     readonly pluginId: string;
     readonly action: PluginAuditAction;
@@ -19,4 +30,6 @@ export declare class PluginAuditService {
     private readonly logger;
     constructor(repository: Repository<PluginAuditEvent>, eventDispatcher: OwoxEventDispatcher);
     record(entry: PluginAuditRecord): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    findHistory(query: PluginHistoryQuery): Promise<PluginAuditEvent[]>;
 }

package/dist/src/plugin-host/services/plugin-audit.service.js

@@ -19,7 +19,20 @@ const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const owox_event_dispatcher_1 = require("../../common/event-dispatcher/owox-event-dispatcher");
 const plugin_audit_event_entity_1 = require("../entities/plugin-audit-event.entity");
+const plugin_audit_action_enum_1 = require("../enums/plugin-audit-action.enum");
+const plugin_publication_scope_enum_1 = require("../enums/plugin-publication-scope.enum");
 const plugin_lifecycle_event_1 = require("../events/plugin-lifecycle.event");
+const INSTALLATION_ACTIONS = [
+    plugin_audit_action_enum_1.PluginAuditAction.INSTALL,
+    plugin_audit_action_enum_1.PluginAuditAction.RESTORE,
+    plugin_audit_action_enum_1.PluginAuditAction.UNINSTALL,
+];
+const PUBLICATION_ACTIONS = [plugin_audit_action_enum_1.PluginAuditAction.PUBLISH, plugin_audit_action_enum_1.PluginAuditAction.UNPUBLISH];
+const CHANGE_ACTIONS = [
+    plugin_audit_action_enum_1.PluginAuditAction.UPDATE,
+    plugin_audit_action_enum_1.PluginAuditAction.SUSPEND,
+    plugin_audit_action_enum_1.PluginAuditAction.RESUME,
+];
 let PluginAuditService = PluginAuditService_1 = class PluginAuditService {
     repository;
     eventDispatcher;
@@ -53,6 +66,71 @@ let PluginAuditService = PluginAuditService_1 = class PluginAuditService {
             this.logger.warn(`Audit event for plugin ${entry.pluginId} was not published: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    exists(id) {
+        return this.repository.existsBy({ id });
+    }
+    findHistory(query) {
+        const builder = this.repository
+            .createQueryBuilder('event')
+            .where(new typeorm_2.Brackets(visible => {
+            if (query.installations) {
+                visible.orWhere(new typeorm_2.Brackets(own => own
+                    .where('event.action IN (:...installationActions)', {
+                    installationActions: INSTALLATION_ACTIONS,
+                })
+                    .andWhere('event.projectId = :projectId')
+                    .andWhere('event.userId = :userId')));
+            }
+            if (query.publications) {
+                visible.orWhere(new typeorm_2.Brackets(project => project
+                    .where('event.action IN (:...publicationActions)')
+                    .andWhere('event.authorityScope = :projectScope', {
+                    projectScope: plugin_publication_scope_enum_1.PluginPublicationScope.PROJECT,
+                })
+                    .andWhere('event.projectId = :projectId')));
+                visible.orWhere(new typeorm_2.Brackets(member => member
+                    .where('event.action IN (:...publicationActions)')
+                    .andWhere('event.authorityScope = :memberScope', {
+                    memberScope: plugin_publication_scope_enum_1.PluginPublicationScope.MEMBER,
+                })
+                    .andWhere('event.projectId = :projectId')
+                    .andWhere('event.userId = :userId')));
+                if (query.deploymentPluginIds.length > 0) {
+                    visible.orWhere(new typeorm_2.Brackets(deployment => deployment
+                        .where('event.action IN (:...publicationActions)')
+                        .andWhere('event.authorityScope = :deploymentScope', {
+                        deploymentScope: plugin_publication_scope_enum_1.PluginPublicationScope.DEPLOYMENT,
+                    })
+                        .andWhere('event.pluginId IN (:...deploymentPluginIds)', {
+                        deploymentPluginIds: query.deploymentPluginIds,
+                    })));
+                }
+            }
+            if (query.changes && query.relevantPluginIds.length > 0) {
+                visible.orWhere(new typeorm_2.Brackets(change => change
+                    .where('event.action IN (:...changeActions)', { changeActions: CHANGE_ACTIONS })
+                    .andWhere('event.pluginId IN (:...relevantPluginIds)', {
+                    relevantPluginIds: query.relevantPluginIds,
+                })));
+            }
+        }))
+            .setParameters({
+            projectId: query.projectId,
+            userId: query.userId,
+            publicationActions: PUBLICATION_ACTIONS,
+        });
+        if (query.afterId) {
+            const anchor = '(SELECT anchor.createdAt FROM plugin_audit_event anchor WHERE anchor.id = :afterId)';
+            builder.andWhere(new typeorm_2.Brackets(after => after
+                .where(`event.createdAt < ${anchor}`)
+                .orWhere(new typeorm_2.Brackets(tie => tie.where(`event.createdAt = ${anchor}`).andWhere('event.id < :afterId')))), { afterId: query.afterId });
+        }
+        return builder
+            .orderBy('event.createdAt', 'DESC')
+            .addOrderBy('event.id', 'DESC')
+            .limit(query.take)
+            .getMany();
+    }
 };
 exports.PluginAuditService = PluginAuditService;
 exports.PluginAuditService = PluginAuditService = PluginAuditService_1 = __decorate([