@owox/backend 0.38.0 → 0.39.0

package/dist/src/plugin-host/use-cases/check-plugin-release.service.js

@@ -0,0 +1,152 @@
+"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.CheckPluginReleaseService = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_host_config_1 = require("../config/plugin-host.config");
+const github_access_mode_enum_1 = require("../enums/github-access-mode.enum");
+const release_rejection_code_enum_1 = require("../enums/release-rejection-code.enum");
+const plugin_host_errors_1 = require("../errors/plugin-host.errors");
+const github_api_service_1 = require("../services/github-api.service");
+const plugin_publication_service_1 = require("../services/plugin-publication.service");
+const plugin_version_service_1 = require("../services/plugin-version.service");
+const plugin_service_1 = require("../services/plugin.service");
+const publication_authorization_service_1 = require("../services/publication-authorization.service");
+const release_candidate_rules_service_1 = require("../services/release-candidate-rules.service");
+const github_repo_locator_util_1 = require("../utils/github-repo-locator.util");
+const semver_util_1 = require("../utils/semver.util");
+const plugin_publisher_access_1 = require("./plugin-publisher-access");
+let CheckPluginReleaseService = class CheckPluginReleaseService {
+    pluginService;
+    authorization;
+    publications;
+    versionService;
+    githubApi;
+    candidateRules;
+    config;
+    lastCheckAt = new Map();
+    constructor(pluginService, authorization, publications, versionService, githubApi, candidateRules, config) {
+        this.pluginService = pluginService;
+        this.authorization = authorization;
+        this.publications = publications;
+        this.versionService = versionService;
+        this.githubApi = githubApi;
+        this.candidateRules = candidateRules;
+        this.config = config;
+    }
+    async run(command) {
+        const namedSemver = command.version === undefined ? null : eligibleSemver(command.version);
+        const locator = (0, github_repo_locator_util_1.parseGithubRepoLocator)(command.repoLocator);
+        const plugin = await this.pluginService.findByRepoName(locator.owner, locator.name);
+        const isPublisher = this.authorization.isDeploymentPublisher(command.context);
+        const notFound = () => new common_1.NotFoundException(`Plugin ${locator.owner}/${locator.name} was not found on this deployment`);
+        if (!plugin ||
+            !(isPublisher || (await (0, plugin_publisher_access_1.managesPublicationOf)(this.publications, plugin.id, command.context)))) {
+            throw notFound();
+        }
+        this.claimSlot(`${plugin.id}:${command.context.userId || command.context.apiKeyId}`);
+        const ref = { owner: plugin.repoOwner, name: plugin.repoName };
+        if ((await this.githubApi.getRepo(ref)).githubRepoId !== plugin.githubRepoId) {
+            throw notFound();
+        }
+        const current = plugin.currentVersionId
+            ? await this.versionService.findById(plugin.currentVersionId)
+            : null;
+        const semver = namedSemver ?? (current ? nextVersionOf(current.semver) : null);
+        const identity = {
+            pluginId: plugin.id,
+            repository: `${ref.owner}/${ref.name}`,
+            candidateVersion: semver,
+        };
+        const commitSha = await this.githubApi.resolveCommitSha(ref, command.ref);
+        if (!commitSha) {
+            return {
+                ...identity,
+                commitSha: null,
+                baselineVersion: null,
+                collectionsEvaluated: false,
+                issues: [
+                    {
+                        code: release_rejection_code_enum_1.ReleaseRejectionCode.COMMIT_UNRESOLVABLE,
+                        detail: `Ref ${command.ref} does not resolve to a commit`,
+                    },
+                ],
+            };
+        }
+        const versionIssue = semver ? await this.versionConflict(plugin.id, semver, current) : null;
+        const report = await this.candidateRules.collectAll({
+            pluginId: plugin.id,
+            ref,
+            commitSha,
+            semver,
+        });
+        return {
+            ...identity,
+            commitSha,
+            baselineVersion: report.baselineSemver,
+            collectionsEvaluated: report.collectionsEvaluated,
+            issues: [...(versionIssue ? [versionIssue] : []), ...report.issues],
+        };
+    }
+    async versionConflict(pluginId, semver, current) {
+        const recorded = await this.versionService.findBySemver(pluginId, semver);
+        if (recorded) {
+            return {
+                code: release_rejection_code_enum_1.ReleaseRejectionCode.VERSION_CONFLICT,
+                detail: `Version ${semver} is already recorded from commit ${recorded.commitSha}`,
+            };
+        }
+        if (current && (0, semver_util_1.compareSemver)(semver, current.semver) < 0) {
+            return {
+                code: release_rejection_code_enum_1.ReleaseRejectionCode.VERSION_CONFLICT,
+                detail: `Version ${semver} is lower than the current version ${current.semver}; release sync stops at the current version, so it would never become current`,
+            };
+        }
+        return null;
+    }
+    claimSlot(key) {
+        const mode = this.config.isAppModeConfigured
+            ? github_access_mode_enum_1.GithubAccessMode.APP
+            : this.config.githubToken
+                ? github_access_mode_enum_1.GithubAccessMode.SERVER_TOKEN
+                : github_access_mode_enum_1.GithubAccessMode.ANONYMOUS;
+        const intervalMs = this.config.getSyncMinIntervalMs(mode);
+        const now = Date.now();
+        const last = this.lastCheckAt.get(key);
+        if (last !== undefined && now - last < intervalMs) {
+            throw new plugin_host_errors_1.PluginCheckRateLimitedError(Math.ceil((last + intervalMs - now) / 1000));
+        }
+        this.lastCheckAt.set(key, now);
+    }
+};
+exports.CheckPluginReleaseService = CheckPluginReleaseService;
+exports.CheckPluginReleaseService = CheckPluginReleaseService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_service_1.PluginService,
+        publication_authorization_service_1.PublicationAuthorizationService,
+        plugin_publication_service_1.PluginPublicationService,
+        plugin_version_service_1.PluginVersionService,
+        github_api_service_1.GithubApiService,
+        release_candidate_rules_service_1.ReleaseCandidateRulesService,
+        plugin_host_config_1.PluginHostConfigService])
+], CheckPluginReleaseService);
+function nextVersionOf(current) {
+    const [major, minor, patch] = current.split('.').map(Number);
+    return major === 0 ? `0.${minor}.${patch + 1}` : `${major}.${minor + 1}.0`;
+}
+function eligibleSemver(version) {
+    const parsed = (0, semver_util_1.parseReleaseTag)(version);
+    if (!parsed.ok) {
+        throw new common_1.BadRequestException(`Version ${version} is not eligible: use X.Y.Z, optionally prefixed with v, without prerelease or build metadata`);
+    }
+    return (0, semver_util_1.formatSemver)(parsed.parts);
+}
+//# sourceMappingURL=check-plugin-release.service.js.map

package/dist/src/plugin-host/use-cases/get-current-plugin-action-execution.service.d.ts

@@ -0,0 +1,14 @@
+import { type CredentialConsumerBindingFacade } from '../../data-marts/credentials/facades/credential-consumer-binding.facade';
+import { GetCurrentPluginActionExecutionCommand } from '../dto/domain/plugin-action-execution.command';
+import type { PluginActionWorkerContext } from '../dto/domain/plugin-action-execution.dto';
+import { PluginActionExecutionService } from '../services/plugin-action-execution.service';
+import { PluginVersionService } from '../services/plugin-version.service';
+import { PluginService } from '../services/plugin.service';
+export declare class GetCurrentPluginActionExecutionService {
+    private readonly executions;
+    private readonly plugins;
+    private readonly versions;
+    private readonly credentialBindings;
+    constructor(executions: PluginActionExecutionService, plugins: PluginService, versions: PluginVersionService, credentialBindings: CredentialConsumerBindingFacade);
+    run(command: GetCurrentPluginActionExecutionCommand): Promise<PluginActionWorkerContext>;
+}

package/dist/src/plugin-host/use-cases/get-current-plugin-action-execution.service.js

@@ -0,0 +1,85 @@
+"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.GetCurrentPluginActionExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const credential_consumer_binding_facade_1 = require("../../data-marts/credentials/facades/credential-consumer-binding.facade");
+const credential_types_1 = require("../../data-marts/credentials/credential.types");
+const plugin_action_errors_1 = require("../errors/plugin-action.errors");
+const plugin_action_execution_service_1 = require("../services/plugin-action-execution.service");
+const plugin_version_service_1 = require("../services/plugin-version.service");
+const plugin_service_1 = require("../services/plugin.service");
+const credential_handles_util_1 = require("../utils/credential-handles.util");
+let GetCurrentPluginActionExecutionService = class GetCurrentPluginActionExecutionService {
+    executions;
+    plugins;
+    versions;
+    credentialBindings;
+    constructor(executions, plugins, versions, credentialBindings) {
+        this.executions = executions;
+        this.plugins = plugins;
+        this.versions = versions;
+        this.credentialBindings = credentialBindings;
+    }
+    async run(command) {
+        const { context } = command;
+        if (!context.executionId) {
+            throw new plugin_action_errors_1.ExecutionTokenRequiredError();
+        }
+        const execution = await this.executions.findWithInput(context.executionId);
+        if (!execution?.deadlineAt || execution.installationId !== context.installationId) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        const plugin = await this.plugins.findById(execution.pluginId);
+        const current = plugin?.currentVersionId
+            ? await this.versions.findById(plugin.currentVersionId)
+            : null;
+        const started = current?.id === execution.pluginVersionId
+            ? current
+            : await this.versions.findById(execution.pluginVersionId);
+        if (!plugin || !current || !started) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        const ready = await this.credentialBindings.assertConsumerReady({
+            projectId: context.projectId,
+            userId: context.userId,
+            roles: context.roles ?? [],
+            consumerType: 'plugin-installation',
+            consumerId: execution.installationId,
+            requirements: (current.credentialRequirements ?? []).filter(requirement => (0, credential_types_1.normalizeCredentialRequirement)(requirement).definitionId !== null),
+        });
+        return {
+            executionId: execution.id,
+            action: execution.action,
+            input: execution.input,
+            trigger: execution.trigger,
+            deadlineAt: execution.deadlineAt,
+            plugin: { id: plugin.id, repositoryId: plugin.githubRepoId },
+            pluginVersion: started.semver,
+            installationId: execution.installationId,
+            projectId: execution.projectId,
+            userId: execution.userId,
+            credentialHandles: (0, credential_handles_util_1.toCredentialHandles)(ready),
+        };
+    }
+};
+exports.GetCurrentPluginActionExecutionService = GetCurrentPluginActionExecutionService;
+exports.GetCurrentPluginActionExecutionService = GetCurrentPluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Inject)(credential_consumer_binding_facade_1.CREDENTIAL_CONSUMER_BINDING_FACADE)),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService,
+        plugin_service_1.PluginService,
+        plugin_version_service_1.PluginVersionService, Object])
+], GetCurrentPluginActionExecutionService);
+//# sourceMappingURL=get-current-plugin-action-execution.service.js.map

package/dist/src/plugin-host/use-cases/get-plugin-action-execution.service.d.ts

@@ -0,0 +1,9 @@
+import { GetPluginActionExecutionCommand } from '../dto/domain/plugin-action-execution.command';
+import type { PluginActionExecutionView } from '../dto/domain/plugin-action-execution.dto';
+import { PluginActionExecutionService } from '../services/plugin-action-execution.service';
+export declare class GetPluginActionExecutionService {
+    private readonly executions;
+    constructor(executions: PluginActionExecutionService);
+    run(command: GetPluginActionExecutionCommand): Promise<PluginActionExecutionView>;
+    private find;
+}

package/dist/src/plugin-host/use-cases/get-plugin-action-execution.service.js

@@ -0,0 +1,67 @@
+"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.GetPluginActionExecutionService = 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 plugin_action_execution_mapper_1 = require("../mappers/plugin-action-execution.mapper");
+const plugin_action_execution_service_1 = require("../services/plugin-action-execution.service");
+let GetPluginActionExecutionService = class GetPluginActionExecutionService {
+    executions;
+    constructor(executions) {
+        this.executions = executions;
+    }
+    async run(command) {
+        const waitUntil = Date.now() + command.waitSeconds * 1000;
+        const execution = await this.find(command);
+        let status = execution.status;
+        let polled = false;
+        while (status !== null && !(0, plugin_action_execution_status_enum_1.isFinalPluginActionStatus)(status)) {
+            const remaining = waitUntil - Date.now();
+            if (remaining <= 0 || command.signal.aborted)
+                break;
+            await pause(Math.min(plugin_action_limits_1.PLUGIN_ACTION_LIMITS.waitPollMs, remaining), command.signal);
+            if (command.signal.aborted)
+                break;
+            status = await this.executions.findStatus(command.id);
+            polled = true;
+        }
+        return (0, plugin_action_execution_mapper_1.toPluginActionExecutionView)(polled ? await this.find(command) : execution);
+    }
+    async find(command) {
+        const execution = await this.executions.findById(command.id);
+        if (!execution || execution.installationId !== command.context.installationId) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        return execution;
+    }
+};
+exports.GetPluginActionExecutionService = GetPluginActionExecutionService;
+exports.GetPluginActionExecutionService = GetPluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService])
+], GetPluginActionExecutionService);
+function pause(ms, signal) {
+    return new Promise(resolve => {
+        const elapsed = new AbortController();
+        const timer = setTimeout(() => {
+            elapsed.abort();
+            resolve();
+        }, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true, signal: elapsed.signal });
+    });
+}
+//# sourceMappingURL=get-plugin-action-execution.service.js.map

package/dist/src/plugin-host/use-cases/get-plugin-installation-entry.service.js

@@ -18,6 +18,7 @@ const plugin_host_errors_1 = require("../errors/plugin-host.errors");
 const plugin_installation_service_1 = require("../services/plugin-installation.service");
 const plugin_version_service_1 = require("../services/plugin-version.service");
 const plugin_service_1 = require("../services/plugin.service");
+const credential_handles_util_1 = require("../utils/credential-handles.util");
 const credential_consumer_binding_facade_1 = require("../../data-marts/credentials/facades/credential-consumer-binding.facade");
 let GetPluginInstallationEntryService = class GetPluginInstallationEntryService {
     installations;
@@ -62,13 +63,7 @@ let GetPluginInstallationEntryService = class GetPluginInstallationEntryService
             displayName: version.displayName,
             pluginId: plugin.id,
             versionId: version.id,
-            credentialHandles: readyRequirements.map(requirement => requirement.definitionId === null
-                ? {
-                    name: requirement.key,
-                    kind: 'ai',
-                    models: requirement.models,
-                }
-                : { name: requirement.key, kind: 'exact' }),
+            credentialHandles: (0, credential_handles_util_1.toCredentialHandles)(readyRequirements),
         };
     }
 };

package/dist/src/plugin-host/use-cases/install-plugin.service.js

@@ -69,13 +69,16 @@ let InstallPluginService = class InstallPluginService {
         }
         const existing = await this.installations.findOne(plugin.id, command.context.projectId, command.context.userId);
         let firstInstall = false;
+        let wasUninstalled = false;
         let installation;
         if (existing) {
+            wasUninstalled = existing.uninstalledAt !== null;
             installation = await this.restore(existing);
         }
         else {
             const claimed = await this.installations.installOrFind(plugin.id, command.context.projectId, command.context.userId);
             firstInstall = claimed.wonRace;
+            wasUninstalled = claimed.installation.uninstalledAt !== null;
             installation = claimed.wonRace
                 ? claimed.installation
                 : await this.restore(claimed.installation);
@@ -99,6 +102,7 @@ let InstallPluginService = class InstallPluginService {
             authorityScope: plugin_publication_scope_enum_1.PluginPublicationScope.MEMBER,
             projectId: command.context.projectId,
             userId: command.context.userId,
+            ...(firstInstall ? {} : { beforeState: { uninstalled: wasUninstalled } }),
             afterState: { versionId: plugin.currentVersionId },
         });
         return {

package/dist/src/plugin-host/use-cases/list-plugin-history.service.d.ts

@@ -0,0 +1,25 @@
+import { IdpProjectionsFacade } from '../../idp/facades/idp-projections.facade';
+import { ListPluginHistoryCommand } from '../dto/domain/list-plugin-history.command';
+import { PluginHistoryPageDto } from '../dto/domain/plugin-history.dto';
+import { PluginPresentationMapper } from '../mappers/plugin-presentation.mapper';
+import { PluginAuditService } from '../services/plugin-audit.service';
+import { PluginInstallationService } from '../services/plugin-installation.service';
+import { PluginPublicationService } from '../services/plugin-publication.service';
+import { PluginVersionService } from '../services/plugin-version.service';
+import { PluginService } from '../services/plugin.service';
+export declare class ListPluginHistoryService {
+    private readonly audit;
+    private readonly publications;
+    private readonly installations;
+    private readonly pluginService;
+    private readonly versionService;
+    private readonly mapper;
+    private readonly idpProjections;
+    constructor(audit: PluginAuditService, publications: PluginPublicationService, installations: PluginInstallationService, pluginService: PluginService, versionService: PluginVersionService, mapper: PluginPresentationMapper, idpProjections: IdpProjectionsFacade);
+    run(command: ListPluginHistoryCommand): Promise<PluginHistoryPageDto>;
+    private toItems;
+    private actorOf;
+    private isNameable;
+    private isNoOp;
+    private versionIdAfter;
+}

package/dist/src/plugin-host/use-cases/list-plugin-history.service.js

@@ -0,0 +1,147 @@
+"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.ListPluginHistoryService = void 0;
+const common_1 = require("@nestjs/common");
+const idp_projections_facade_1 = require("../../idp/facades/idp-projections.facade");
+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_presentation_mapper_1 = require("../mappers/plugin-presentation.mapper");
+const plugin_audit_service_1 = require("../services/plugin-audit.service");
+const plugin_installation_service_1 = require("../services/plugin-installation.service");
+const plugin_publication_service_1 = require("../services/plugin-publication.service");
+const plugin_version_service_1 = require("../services/plugin-version.service");
+const plugin_service_1 = require("../services/plugin.service");
+const unique = (ids) => [...new Set(ids)];
+const isPublication = (row) => row.action === plugin_audit_action_enum_1.PluginAuditAction.PUBLISH || row.action === plugin_audit_action_enum_1.PluginAuditAction.UNPUBLISH;
+let ListPluginHistoryService = class ListPluginHistoryService {
+    audit;
+    publications;
+    installations;
+    pluginService;
+    versionService;
+    mapper;
+    idpProjections;
+    constructor(audit, publications, installations, pluginService, versionService, mapper, idpProjections) {
+        this.audit = audit;
+        this.publications = publications;
+        this.installations = installations;
+        this.pluginService = pluginService;
+        this.versionService = versionService;
+        this.mapper = mapper;
+        this.idpProjections = idpProjections;
+    }
+    async run(command) {
+        const { projectId, userId } = command.context;
+        if (command.cursor && !(await this.audit.exists(command.cursor))) {
+            throw new common_1.BadRequestException('cursor does not point to a plugin history entry');
+        }
+        const [listed, installed] = await Promise.all([
+            this.publications.findEverVisibleTo(projectId, userId),
+            this.installations.findByMember(projectId, userId),
+        ]);
+        const rows = await this.audit.findHistory({
+            projectId,
+            userId,
+            installations: command.type !== 'publications',
+            publications: command.type !== 'installations',
+            changes: command.type === 'all',
+            deploymentPluginIds: unique(listed
+                .filter(publication => publication.scope === plugin_publication_scope_enum_1.PluginPublicationScope.DEPLOYMENT)
+                .map(publication => publication.pluginId)),
+            relevantPluginIds: unique([...listed, ...installed].map(row => row.pluginId)),
+            afterId: command.cursor,
+            take: command.limit + 1,
+        });
+        const page = rows.slice(0, command.limit);
+        const items = await this.toItems(page, projectId, userId);
+        return {
+            items,
+            nextCursor: rows.length > command.limit ? page[page.length - 1].id : null,
+        };
+    }
+    async toItems(page, projectId, userId) {
+        const plugins = await this.pluginService.findByIds(unique(page.map(row => row.pluginId)));
+        const pluginById = new Map(plugins.map(plugin => [plugin.id, plugin]));
+        const versions = await this.versionService.findByIds(unique([
+            ...plugins.map(plugin => plugin.currentVersionId),
+            ...page.map(row => this.versionIdAfter(row)),
+        ].filter((id) => typeof id === 'string')));
+        const versionById = new Map(versions.map(version => [version.id, version]));
+        const namedIds = unique(page.filter(row => this.isNameable(row, projectId, userId)).map(row => row.userId));
+        const names = await this.idpProjections.getUserProjectionList(namedIds);
+        return page.flatMap(row => {
+            const plugin = pluginById.get(row.pluginId);
+            if (!plugin || this.isNoOp(row)) {
+                return [];
+            }
+            const versionId = this.versionIdAfter(row);
+            return [
+                {
+                    id: row.id,
+                    occurredAt: row.createdAt,
+                    action: row.action,
+                    scope: isPublication(row) ? row.authorityScope : null,
+                    plugin: this.mapper.toHistoryPlugin(plugin, plugin.currentVersionId ? (versionById.get(plugin.currentVersionId) ?? null) : null),
+                    actor: this.actorOf(row, projectId, userId, names),
+                    version: row.action === plugin_audit_action_enum_1.PluginAuditAction.UPDATE && versionId
+                        ? (versionById.get(versionId)?.semver ?? null)
+                        : null,
+                },
+            ];
+        });
+    }
+    actorOf(row, projectId, userId, names) {
+        if (row.action === plugin_audit_action_enum_1.PluginAuditAction.SUSPEND ||
+            row.action === plugin_audit_action_enum_1.PluginAuditAction.RESUME ||
+            (isPublication(row) && row.authorityScope === plugin_publication_scope_enum_1.PluginPublicationScope.DEPLOYMENT)) {
+            return { kind: 'deployment' };
+        }
+        if (row.userId === userId) {
+            return { kind: 'you' };
+        }
+        if (!this.isNameable(row, projectId, userId)) {
+            return null;
+        }
+        const projection = names.getByUserId(row.userId);
+        const name = projection?.fullName || projection?.email;
+        return name ? { kind: 'member', name } : null;
+    }
+    isNameable(row, projectId, userId) {
+        return (row.userId !== null &&
+            row.userId !== userId &&
+            row.projectId === projectId &&
+            row.authorityScope !== plugin_publication_scope_enum_1.PluginPublicationScope.DEPLOYMENT &&
+            row.action !== plugin_audit_action_enum_1.PluginAuditAction.SUSPEND &&
+            row.action !== plugin_audit_action_enum_1.PluginAuditAction.RESUME);
+    }
+    isNoOp(row) {
+        const uninstalled = row.beforeState?.uninstalled;
+        return ((row.action === plugin_audit_action_enum_1.PluginAuditAction.RESTORE && uninstalled === false) ||
+            (row.action === plugin_audit_action_enum_1.PluginAuditAction.UNINSTALL && uninstalled === true));
+    }
+    versionIdAfter(row) {
+        const id = row.afterState?.currentVersionId;
+        return typeof id === 'string' ? id : null;
+    }
+};
+exports.ListPluginHistoryService = ListPluginHistoryService;
+exports.ListPluginHistoryService = ListPluginHistoryService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_audit_service_1.PluginAuditService,
+        plugin_publication_service_1.PluginPublicationService,
+        plugin_installation_service_1.PluginInstallationService,
+        plugin_service_1.PluginService,
+        plugin_version_service_1.PluginVersionService,
+        plugin_presentation_mapper_1.PluginPresentationMapper,
+        idp_projections_facade_1.IdpProjectionsFacade])
+], ListPluginHistoryService);
+//# sourceMappingURL=list-plugin-history.service.js.map

package/dist/src/plugin-host/use-cases/plugin-publisher-access.d.ts

@@ -0,0 +1,5 @@
+import { AuthorizationContext } from '../../idp/types/auth.types';
+import { Plugin } from '../entities/plugin.entity';
+import { PluginPublicationService } from '../services/plugin-publication.service';
+export declare function managesPublicationOf(publications: PluginPublicationService, pluginId: string, context: AuthorizationContext): Promise<boolean>;
+export declare function visibleRepository(plugin: Plugin, repository: string, isPublisher: boolean): string;

package/dist/src/plugin-host/use-cases/plugin-publisher-access.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.managesPublicationOf = managesPublicationOf;
+exports.visibleRepository = visibleRepository;
+const plugin_publication_scope_enum_1 = require("../enums/plugin-publication-scope.enum");
+async function managesPublicationOf(publications, pluginId, context) {
+    const scopes = [];
+    if (context.roles?.includes('admin')) {
+        scopes.push(plugin_publication_scope_enum_1.PluginPublicationScope.PROJECT);
+    }
+    if (context.userId) {
+        scopes.push(plugin_publication_scope_enum_1.PluginPublicationScope.MEMBER);
+    }
+    for (const scope of scopes) {
+        const rows = await publications.listManageable(scope, {
+            projectId: context.projectId,
+            userId: scope === plugin_publication_scope_enum_1.PluginPublicationScope.MEMBER ? (context.userId ?? undefined) : undefined,
+        });
+        if (rows.some(row => row.pluginId === pluginId)) {
+            return true;
+        }
+    }
+    return false;
+}
+function visibleRepository(plugin, repository, isPublisher) {
+    return plugin.isPrivateRepo && !isPublisher ? `${plugin.repoOwner}/***` : repository;
+}
+//# sourceMappingURL=plugin-publisher-access.js.map

package/dist/src/plugin-host/use-cases/start-plugin-action-execution.service.d.ts

@@ -0,0 +1,12 @@
+import { StartPluginActionExecutionCommand } from '../dto/domain/plugin-action-execution.command';
+import type { StartedPluginActionExecution } from '../dto/domain/plugin-action-execution.dto';
+import { PluginActionStarterService } from '../services/plugin-action-starter.service';
+import { PluginVersionService } from '../services/plugin-version.service';
+import { PluginService } from '../services/plugin.service';
+export declare class StartPluginActionExecutionService {
+    private readonly plugins;
+    private readonly versions;
+    private readonly starter;
+    constructor(plugins: PluginService, versions: PluginVersionService, starter: PluginActionStarterService);
+    run(command: StartPluginActionExecutionCommand): Promise<StartedPluginActionExecution>;
+}