@xemahq/biomes-platform-gitlab 0.5.4 → 0.7.0

package/dist/connector-adapters/scm-actions.js

@@ -1,656 +0,0 @@
-import { adapterError, err, ok, } from '@xemahq/biome-sdk/adapter';
-import { createGitLabApi, encodePathSegment, GitLabApiError, } from './gitlab-client.factory.js';
-export const GITLAB_SCM_ACTION = {
-    GET_REPOSITORY: 'get-repository',
-    LIST_BRANCHES: 'list-branches',
-    CREATE_BRANCH: 'create-branch',
-    LIST_CHANGE_REQUESTS: 'list-change-requests',
-    GET_CHANGE_REQUEST: 'get-change-request',
-    CREATE_CHANGE_REQUEST: 'create-change-request',
-    UPDATE_CHANGE_REQUEST: 'update-change-request',
-    POST_COMMENT: 'post-comment',
-    LIST_COMMENTS: 'list-comments',
-    LIST_FILES: 'list-files',
-    GET_FILE: 'get-file',
-    GET_DIFF: 'get-diff',
-    LIST_COMMITS: 'list-commits',
-    GET_CHECKS: 'get-checks',
-};
-const CHANGE_REQUEST_STATUS = {
-    OPEN: 'open',
-    MERGED: 'merged',
-    CLOSED: 'closed',
-};
-const CHECK_STATUS = {
-    QUEUED: 'queued',
-    IN_PROGRESS: 'in_progress',
-    COMPLETED: 'completed',
-};
-const CHECK_CONCLUSION = {
-    SUCCESS: 'success',
-    FAILURE: 'failure',
-    PENDING: 'pending',
-    ERROR: 'error',
-};
-const DEFAULT_COMMIT_LIMIT = 30;
-function requireString(params, key, action) {
-    const value = params[key];
-    if (typeof value !== 'string' || value.length === 0) {
-        return err(adapterError('malformed-payload', `gitlab ${action}: missing required param "${key}"`));
-    }
-    return ok(value);
-}
-function optionalString(params, key, action) {
-    const value = params[key];
-    if (value === undefined || value === null) {
-        return ok(undefined);
-    }
-    if (typeof value !== 'string') {
-        return err(adapterError('malformed-payload', `gitlab ${action}: param "${key}" must be a string when present`));
-    }
-    return ok(value);
-}
-function optionalPositiveInt(params, key, action) {
-    const value = params[key];
-    if (value === undefined || value === null) {
-        return ok(undefined);
-    }
-    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0) {
-        return err(adapterError('malformed-payload', `gitlab ${action}: param "${key}" must be a positive integer when present`));
-    }
-    return ok(value);
-}
-function resolveTarget(input, action) {
-    const projectPath = requireString(input.params, 'projectPath', action);
-    if (!projectPath.ok) {
-        return projectPath;
-    }
-    const apiUrl = optionalString(input.params, 'apiUrl', action);
-    if (!apiUrl.ok) {
-        return apiUrl;
-    }
-    const token = input.credential.accessToken;
-    if (typeof token !== 'string' || token.length === 0) {
-        return err(adapterError('unauthorized', `gitlab ${action}: the resolved connection credential carries no access token`));
-    }
-    return ok({
-        encodedProjectPath: encodePathSegment(projectPath.value),
-        api: createGitLabApi(apiUrl.value ?? '', token, input.credential.tokenType),
-    });
-}
-function toAdapterError(cause) {
-    if (cause instanceof GitLabApiError) {
-        switch (cause.kind) {
-            case 'unauthorized':
-                return adapterError('unauthorized', cause.message);
-            case 'not-found':
-                return adapterError('not-found', cause.message);
-            case 'rate-limited':
-                return adapterError('rate-limited', cause.message, cause.retryAfterSec === undefined
-                    ? undefined
-                    : { retryAfterSec: cause.retryAfterSec });
-            case 'upstream':
-            default:
-                return adapterError('upstream-unavailable', cause.message);
-        }
-    }
-    return adapterError('internal', `gitlab action failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-}
-function mapMergeRequest(mr) {
-    const status = mr.state === 'merged'
-        ? CHANGE_REQUEST_STATUS.MERGED
-        : mr.state === 'closed'
-            ? CHANGE_REQUEST_STATUS.CLOSED
-            : CHANGE_REQUEST_STATUS.OPEN;
-    const changeRequest = {
-        id: String(mr.iid),
-        externalId: String(mr.id),
-        sourceBranch: mr.source_branch ?? '',
-        targetBranch: mr.target_branch ?? '',
-        title: mr.title ?? '',
-        status,
-        createdAt: mr.created_at ?? '',
-        updatedAt: mr.updated_at ?? '',
-    };
-    if (mr.description !== undefined) {
-        changeRequest.description = mr.description;
-    }
-    if (mr.author?.username !== undefined) {
-        changeRequest.authorId = mr.author.username;
-    }
-    if (mr.sha !== undefined) {
-        changeRequest.headCommit = mr.sha;
-    }
-    return changeRequest;
-}
-function mapNote(note, changeRequestId) {
-    return {
-        id: String(note.id),
-        changeRequestId,
-        body: note.body ?? '',
-        authorId: note.author?.username ?? 'unknown',
-        authorType: 'human',
-        createdAt: note.created_at ?? '',
-    };
-}
-function mapPipelineState(state) {
-    switch (state) {
-        case 'success':
-        case 'skipped':
-            return {
-                status: CHECK_STATUS.COMPLETED,
-                conclusion: CHECK_CONCLUSION.SUCCESS,
-            };
-        case 'failed':
-        case 'canceled':
-            return {
-                status: CHECK_STATUS.COMPLETED,
-                conclusion: CHECK_CONCLUSION.FAILURE,
-            };
-        case 'running':
-            return {
-                status: CHECK_STATUS.IN_PROGRESS,
-                conclusion: CHECK_CONCLUSION.PENDING,
-            };
-        default:
-            return {
-                status: CHECK_STATUS.QUEUED,
-                conclusion: CHECK_CONCLUSION.PENDING,
-            };
-    }
-}
-export function mapGitlabPipelines(pipelines) {
-    const latest = pipelines[0];
-    if (!latest) {
-        return [];
-    }
-    const { status, conclusion } = mapPipelineState(latest.status);
-    const check = {
-        name: latest.name ?? (latest.id ? `pipeline #${latest.id}` : 'pipeline'),
-        status,
-        conclusion,
-    };
-    if (latest.web_url) {
-        check.detailsUrl = latest.web_url;
-    }
-    return [check];
-}
-export function aggregateChecks(checks) {
-    if (checks.length === 0) {
-        return { conclusion: CHECK_CONCLUSION.SUCCESS, checks };
-    }
-    const conclusions = new Set(checks.map((c) => c.conclusion));
-    const conclusion = conclusions.has(CHECK_CONCLUSION.PENDING)
-        ? CHECK_CONCLUSION.PENDING
-        : conclusions.has(CHECK_CONCLUSION.FAILURE)
-            ? CHECK_CONCLUSION.FAILURE
-            : conclusions.has(CHECK_CONCLUSION.ERROR)
-                ? CHECK_CONCLUSION.ERROR
-                : CHECK_CONCLUSION.SUCCESS;
-    return { conclusion, checks };
-}
-const TARGET_PROPERTIES = {
-    projectPath: {
-        type: 'string',
-        description: 'GitLab project path, "group/project" (or "group/subgroup/project"). Encoded by the connector.',
-    },
-    apiUrl: {
-        type: 'string',
-        description: 'OPTIONAL base URL of a self-hosted GitLab instance. Defaults to https://gitlab.com.',
-    },
-};
-const TARGET_REQUIRED = ['projectPath'];
-function defineScmAction(action, properties, required, run) {
-    return {
-        action,
-        schema: {
-            type: 'object',
-            properties: { ...TARGET_PROPERTIES, ...properties },
-            required: [...TARGET_REQUIRED, ...required],
-        },
-        async execute(input) {
-            const target = resolveTarget(input, action);
-            if (!target.ok) {
-                return target;
-            }
-            try {
-                return await run(target.value, input.params);
-            }
-            catch (cause) {
-                return err(toAdapterError(cause));
-            }
-        },
-    };
-}
-const getRepository = defineScmAction(GITLAB_SCM_ACTION.GET_REPOSITORY, {}, [], async ({ api, encodedProjectPath }) => {
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}`,
-    });
-    const repository = {
-        id: String(data.id),
-        provider: 'gitlab',
-        defaultBranch: data.default_branch ?? 'main',
-        isActive: !data.archived,
-        contentBrowsingEnabled: true,
-    };
-    const remoteUrl = data.http_url_to_repo ?? data.web_url;
-    if (remoteUrl !== undefined) {
-        repository.remoteUrl = remoteUrl;
-    }
-    return ok({ externalId: String(data.id), outputs: { repository } });
-});
-const listBranches = defineScmAction(GITLAB_SCM_ACTION.LIST_BRANCHES, {}, [], async ({ api, encodedProjectPath }) => {
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/repository/branches`,
-        query: { per_page: '100' },
-    });
-    return ok({
-        outputs: {
-            branches: data.map((b) => ({
-                name: b.name,
-                commit: b.commit?.id ?? '',
-                isDefault: b.default === true,
-            })),
-        },
-    });
-});
-const createBranch = defineScmAction(GITLAB_SCM_ACTION.CREATE_BRANCH, {
-    name: { type: 'string', description: 'Name of the branch to create.' },
-    fromRef: {
-        type: 'string',
-        description: 'Ref the branch is cut from. Defaults to "main".',
-    },
-}, ['name'], async ({ api, encodedProjectPath }, params) => {
-    const name = requireString(params, 'name', GITLAB_SCM_ACTION.CREATE_BRANCH);
-    if (!name.ok) {
-        return name;
-    }
-    const fromRef = optionalString(params, 'fromRef', GITLAB_SCM_ACTION.CREATE_BRANCH);
-    if (!fromRef.ok) {
-        return fromRef;
-    }
-    const data = await api.request({
-        method: 'POST',
-        path: `/projects/${encodedProjectPath}/repository/branches`,
-        body: { branch: name.value, ref: fromRef.value ?? 'main' },
-    });
-    return ok({
-        externalId: data.name,
-        outputs: {
-            branch: {
-                name: data.name,
-                commit: data.commit?.id ?? '',
-                isDefault: false,
-            },
-        },
-    });
-});
-const listChangeRequests = defineScmAction(GITLAB_SCM_ACTION.LIST_CHANGE_REQUESTS, {}, [], async ({ api, encodedProjectPath }) => {
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/merge_requests`,
-        query: {
-            state: 'all',
-            per_page: '50',
-            order_by: 'updated_at',
-            sort: 'desc',
-        },
-    });
-    return ok({ outputs: { changeRequests: data.map(mapMergeRequest) } });
-});
-const getChangeRequest = defineScmAction(GITLAB_SCM_ACTION.GET_CHANGE_REQUEST, {
-    changeRequestId: {
-        type: 'string',
-        description: 'Merge-request IID within the project.',
-    },
-}, ['changeRequestId'], async ({ api, encodedProjectPath }, params) => {
-    const id = requireString(params, 'changeRequestId', GITLAB_SCM_ACTION.GET_CHANGE_REQUEST);
-    if (!id.ok) {
-        return id;
-    }
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/merge_requests/${encodePathSegment(id.value)}`,
-    });
-    return ok({
-        externalId: String(data.id),
-        outputs: { changeRequest: mapMergeRequest(data) },
-    });
-});
-const createChangeRequest = defineScmAction(GITLAB_SCM_ACTION.CREATE_CHANGE_REQUEST, {
-    sourceBranch: { type: 'string', description: 'Branch to merge FROM.' },
-    targetBranch: { type: 'string', description: 'Branch to merge INTO.' },
-    title: { type: 'string', description: 'Merge-request title.' },
-    description: {
-        type: 'string',
-        description: 'Merge-request description. Defaults to empty.',
-    },
-}, ['sourceBranch', 'targetBranch', 'title'], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.CREATE_CHANGE_REQUEST;
-    const sourceBranch = requireString(params, 'sourceBranch', action);
-    if (!sourceBranch.ok) {
-        return sourceBranch;
-    }
-    const targetBranch = requireString(params, 'targetBranch', action);
-    if (!targetBranch.ok) {
-        return targetBranch;
-    }
-    const title = requireString(params, 'title', action);
-    if (!title.ok) {
-        return title;
-    }
-    const description = optionalString(params, 'description', action);
-    if (!description.ok) {
-        return description;
-    }
-    const data = await api.request({
-        method: 'POST',
-        path: `/projects/${encodedProjectPath}/merge_requests`,
-        body: {
-            source_branch: sourceBranch.value,
-            target_branch: targetBranch.value,
-            title: title.value,
-            description: description.value ?? '',
-        },
-    });
-    return ok({
-        externalId: String(data.id),
-        outputs: { changeRequest: mapMergeRequest(data) },
-    });
-});
-const updateChangeRequest = defineScmAction(GITLAB_SCM_ACTION.UPDATE_CHANGE_REQUEST, {
-    changeRequestId: {
-        type: 'string',
-        description: 'Merge-request IID within the project.',
-    },
-    title: { type: 'string', description: 'New title.' },
-    status: {
-        type: 'string',
-        description: 'New status — "closed" closes the merge request, "open" reopens it. Any other value changes no state.',
-    },
-}, ['changeRequestId'], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.UPDATE_CHANGE_REQUEST;
-    const id = requireString(params, 'changeRequestId', action);
-    if (!id.ok) {
-        return id;
-    }
-    const title = optionalString(params, 'title', action);
-    if (!title.ok) {
-        return title;
-    }
-    const status = optionalString(params, 'status', action);
-    if (!status.ok) {
-        return status;
-    }
-    const body = {};
-    if (title.value !== undefined && title.value.length > 0) {
-        body.title = title.value;
-    }
-    if (status.value === CHANGE_REQUEST_STATUS.CLOSED) {
-        body.state_event = 'close';
-    }
-    if (status.value === CHANGE_REQUEST_STATUS.OPEN) {
-        body.state_event = 'reopen';
-    }
-    const data = await api.request({
-        method: 'PUT',
-        path: `/projects/${encodedProjectPath}/merge_requests/${encodePathSegment(id.value)}`,
-        body,
-    });
-    return ok({
-        externalId: String(data.id),
-        outputs: { changeRequest: mapMergeRequest(data) },
-    });
-});
-const postComment = defineScmAction(GITLAB_SCM_ACTION.POST_COMMENT, {
-    changeRequestId: {
-        type: 'string',
-        description: 'Merge-request IID to comment on.',
-    },
-    body: { type: 'string', description: 'Comment body (GitLab note).' },
-}, ['changeRequestId', 'body'], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.POST_COMMENT;
-    const id = requireString(params, 'changeRequestId', action);
-    if (!id.ok) {
-        return id;
-    }
-    const content = requireString(params, 'body', action);
-    if (!content.ok) {
-        return content;
-    }
-    const data = await api.request({
-        method: 'POST',
-        path: `/projects/${encodedProjectPath}/merge_requests/${encodePathSegment(id.value)}/notes`,
-        body: { body: content.value },
-    });
-    return ok({
-        externalId: String(data.id),
-        outputs: { comment: mapNote(data, id.value) },
-    });
-});
-const listComments = defineScmAction(GITLAB_SCM_ACTION.LIST_COMMENTS, {
-    changeRequestId: {
-        type: 'string',
-        description: 'Merge-request IID whose notes to list.',
-    },
-}, ['changeRequestId'], async ({ api, encodedProjectPath }, params) => {
-    const id = requireString(params, 'changeRequestId', GITLAB_SCM_ACTION.LIST_COMMENTS);
-    if (!id.ok) {
-        return id;
-    }
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/merge_requests/${encodePathSegment(id.value)}/notes`,
-        query: { per_page: '100', sort: 'asc' },
-    });
-    return ok({
-        outputs: {
-            comments: data
-                .filter((n) => !n.system)
-                .map((n) => mapNote(n, id.value)),
-        },
-    });
-});
-const listFiles = defineScmAction(GITLAB_SCM_ACTION.LIST_FILES, {
-    path: {
-        type: 'string',
-        description: 'Directory path to list. Empty string lists the root.',
-    },
-    ref: { type: 'string', description: 'Branch, tag or commit sha.' },
-}, ['path'], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.LIST_FILES;
-    const rawPath = optionalString(params, 'path', action);
-    if (!rawPath.ok) {
-        return rawPath;
-    }
-    const ref = optionalString(params, 'ref', action);
-    if (!ref.ok) {
-        return ref;
-    }
-    const safePath = (rawPath.value ?? '').replace(/^\/+/, '');
-    const query = { per_page: '100' };
-    if (ref.value) {
-        query.ref = ref.value;
-    }
-    if (safePath) {
-        query.path = safePath;
-    }
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/repository/tree`,
-        query,
-    });
-    return ok({
-        outputs: {
-            entries: data.map((e) => {
-                const entry = {
-                    name: e.name,
-                    path: e.path,
-                    type: e.type === 'tree' ? 'dir' : 'file',
-                };
-                if (e.id !== undefined) {
-                    entry.sha = e.id;
-                }
-                return entry;
-            }),
-        },
-    });
-});
-const getFile = defineScmAction(GITLAB_SCM_ACTION.GET_FILE, {
-    path: { type: 'string', description: 'File path within the repository.' },
-    ref: { type: 'string', description: 'Branch, tag or commit sha.' },
-}, ['path'], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.GET_FILE;
-    const rawPath = requireString(params, 'path', action);
-    if (!rawPath.ok) {
-        return rawPath;
-    }
-    const ref = optionalString(params, 'ref', action);
-    if (!ref.ok) {
-        return ref;
-    }
-    const safePath = rawPath.value.replace(/^\/+/, '');
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/repository/files/${encodePathSegment(safePath)}`,
-        ...(ref.value === undefined ? {} : { query: { ref: ref.value } }),
-    });
-    const content = data.content
-        ? Buffer.from(data.content, data.encoding === 'base64' ? 'base64' : 'utf-8').toString('utf-8')
-        : '';
-    const file = {
-        path: safePath,
-        content,
-        encoding: 'utf-8',
-        size: data.size ?? content.length,
-    };
-    const sha = data.blob_id ?? data.content_sha256;
-    if (sha !== undefined) {
-        file.sha = sha;
-    }
-    return ok({ outputs: { file } });
-});
-const getDiff = defineScmAction(GITLAB_SCM_ACTION.GET_DIFF, {
-    base: { type: 'string', description: 'Ref to compare FROM.' },
-    head: { type: 'string', description: 'Ref to compare TO.' },
-}, ['base', 'head'], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.GET_DIFF;
-    const base = requireString(params, 'base', action);
-    if (!base.ok) {
-        return base;
-    }
-    const head = requireString(params, 'head', action);
-    if (!head.ok) {
-        return head;
-    }
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/repository/compare`,
-        query: { from: base.value, to: head.value },
-    });
-    const diff = {
-        base: base.value,
-        head: head.value,
-        files: (data.diffs ?? []).map((d) => {
-            const file = {
-                filename: d.new_path,
-                status: d.new_file
-                    ? 'added'
-                    : d.deleted_file
-                        ? 'removed'
-                        : d.renamed_file
-                            ? 'renamed'
-                            : 'modified',
-                additions: 0,
-                deletions: 0,
-            };
-            if (d.diff !== undefined) {
-                file.patch = d.diff;
-            }
-            return file;
-        }),
-    };
-    if (data.commits) {
-        diff.stats = {
-            additions: 0,
-            deletions: 0,
-            changes: data.diffs?.length ?? 0,
-        };
-    }
-    return ok({ outputs: { diff } });
-});
-const listCommits = defineScmAction(GITLAB_SCM_ACTION.LIST_COMMITS, {
-    ref: { type: 'string', description: 'Branch, tag or commit sha.' },
-    limit: {
-        type: 'number',
-        description: `Maximum commits to return. Defaults to ${DEFAULT_COMMIT_LIMIT}.`,
-    },
-}, [], async ({ api, encodedProjectPath }, params) => {
-    const action = GITLAB_SCM_ACTION.LIST_COMMITS;
-    const ref = optionalString(params, 'ref', action);
-    if (!ref.ok) {
-        return ref;
-    }
-    const limit = optionalPositiveInt(params, 'limit', action);
-    if (!limit.ok) {
-        return limit;
-    }
-    const query = {
-        per_page: String(limit.value ?? DEFAULT_COMMIT_LIMIT),
-    };
-    if (ref.value) {
-        query.ref_name = ref.value;
-    }
-    const data = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/repository/commits`,
-        query,
-    });
-    return ok({
-        outputs: {
-            commits: data.map((c) => ({
-                sha: c.id,
-                message: c.message ?? '',
-                authorName: c.author_name ?? '',
-                authorEmail: c.author_email ?? '',
-                date: c.created_at ?? '',
-            })),
-        },
-    });
-});
-const getChecks = defineScmAction(GITLAB_SCM_ACTION.GET_CHECKS, {
-    headSha: {
-        type: 'string',
-        description: 'Commit sha whose CI pipelines to normalize.',
-    },
-}, ['headSha'], async ({ api, encodedProjectPath }, params) => {
-    const headSha = requireString(params, 'headSha', GITLAB_SCM_ACTION.GET_CHECKS);
-    if (!headSha.ok) {
-        return headSha;
-    }
-    const pipelines = await api.request({
-        method: 'GET',
-        path: `/projects/${encodedProjectPath}/pipelines`,
-        query: { sha: headSha.value },
-    });
-    return ok({ outputs: aggregateChecks(mapGitlabPipelines(pipelines)) });
-});
-export const gitlabScmActions = {
-    [GITLAB_SCM_ACTION.GET_REPOSITORY]: getRepository,
-    [GITLAB_SCM_ACTION.LIST_BRANCHES]: listBranches,
-    [GITLAB_SCM_ACTION.CREATE_BRANCH]: createBranch,
-    [GITLAB_SCM_ACTION.LIST_CHANGE_REQUESTS]: listChangeRequests,
-    [GITLAB_SCM_ACTION.GET_CHANGE_REQUEST]: getChangeRequest,
-    [GITLAB_SCM_ACTION.CREATE_CHANGE_REQUEST]: createChangeRequest,
-    [GITLAB_SCM_ACTION.UPDATE_CHANGE_REQUEST]: updateChangeRequest,
-    [GITLAB_SCM_ACTION.POST_COMMENT]: postComment,
-    [GITLAB_SCM_ACTION.LIST_COMMENTS]: listComments,
-    [GITLAB_SCM_ACTION.LIST_FILES]: listFiles,
-    [GITLAB_SCM_ACTION.GET_FILE]: getFile,
-    [GITLAB_SCM_ACTION.GET_DIFF]: getDiff,
-    [GITLAB_SCM_ACTION.LIST_COMMITS]: listCommits,
-    [GITLAB_SCM_ACTION.GET_CHECKS]: getChecks,
-};
-//# sourceMappingURL=scm-actions.js.map