@enrichlayer/el-linear 1.2.0

package/dist/utils/graphql-documents-service.js

@@ -0,0 +1,97 @@
+import { CREATE_DOCUMENT_MUTATION, DELETE_DOCUMENT_MUTATION, GET_DOCUMENT_QUERY, LIST_DOCUMENTS_QUERY, UPDATE_DOCUMENT_MUTATION, } from "../queries/documents.js";
+import { createGraphQLService, } from "./graphql-service.js";
+function transformDocument(doc) {
+    const creator = doc.creator;
+    const project = doc.project;
+    const issue = doc.issue;
+    return {
+        id: doc.id,
+        title: doc.title,
+        content: doc.content || undefined,
+        color: doc.color || undefined,
+        icon: doc.icon || undefined,
+        slugId: doc.slugId || undefined,
+        url: doc.url || undefined,
+        creator: creator
+            ? { id: creator.id, name: creator.name }
+            : undefined,
+        project: project
+            ? { id: project.id, name: project.name }
+            : undefined,
+        issue: issue
+            ? {
+                id: issue.id,
+                identifier: issue.identifier,
+                title: issue.title,
+            }
+            : undefined,
+        createdAt: doc.createdAt || undefined,
+        updatedAt: doc.updatedAt || undefined,
+    };
+}
+class GraphQLDocumentsService {
+    graphqlService;
+    constructor(graphqlService) {
+        this.graphqlService = graphqlService;
+    }
+    async createDocument(input) {
+        const result = await this.graphqlService.rawRequest(CREATE_DOCUMENT_MUTATION, { input });
+        const createData = result.documentCreate;
+        if (!createData.success) {
+            throw new Error(`Failed to create document "${input.title}"${input.projectId ? ` in project ${input.projectId}` : ""}${input.teamId ? ` for team ${input.teamId}` : ""}`);
+        }
+        return transformDocument(createData.document);
+    }
+    async updateDocument(id, input) {
+        const result = await this.graphqlService.rawRequest(UPDATE_DOCUMENT_MUTATION, { id, input });
+        const updateData = result.documentUpdate;
+        if (!updateData.success) {
+            throw new Error(`Failed to update document: ${id}`);
+        }
+        return transformDocument(updateData.document);
+    }
+    async getDocument(id) {
+        const result = await this.graphqlService.rawRequest(GET_DOCUMENT_QUERY, {
+            id,
+        });
+        if (!result.document) {
+            throw new Error(`Document not found: ${id}`);
+        }
+        return transformDocument(result.document);
+    }
+    async listDocuments(options) {
+        const filter = options?.projectId
+            ? { project: { id: { eq: options.projectId } } }
+            : undefined;
+        const result = await this.graphqlService.rawRequest(LIST_DOCUMENTS_QUERY, {
+            first: options?.first ?? 50,
+            filter,
+        });
+        return result.documents.nodes.map(transformDocument);
+    }
+    async deleteDocument(id) {
+        const result = await this.graphqlService.rawRequest(DELETE_DOCUMENT_MUTATION, { id });
+        const deleteData = result.documentDelete;
+        if (!deleteData.success) {
+            throw new Error(`Failed to delete document: ${id}`);
+        }
+        return true;
+    }
+    async listDocumentsBySlugIds(slugIds, limit) {
+        if (slugIds.length === 0) {
+            return [];
+        }
+        const filter = {
+            or: slugIds.map((slugId) => ({ slugId: { eq: slugId } })),
+        };
+        const result = await this.graphqlService.rawRequest(LIST_DOCUMENTS_QUERY, {
+            first: limit ?? slugIds.length,
+            filter,
+        });
+        return result.documents.nodes.map(transformDocument);
+    }
+}
+export function createGraphQLDocumentsService(options) {
+    const graphqlService = createGraphQLService(options);
+    return new GraphQLDocumentsService(graphqlService);
+}

package/dist/utils/graphql-issues-service.d.ts

@@ -0,0 +1,49 @@
+import type { GraphQLResponseData, LinearIssue } from "../types/linear.js";
+import type { GraphQLService } from "./graphql-service.js";
+import type { LinearService } from "./linear-service.js";
+export declare class GraphQLIssuesService {
+    private readonly graphQLService;
+    private readonly linearService;
+    constructor(graphQLService: GraphQLService, linearService: LinearService);
+    getIssues(limit?: number): Promise<LinearIssue[]>;
+    getIssueById(issueId: string): Promise<LinearIssue>;
+    updateIssue(args: Record<string, unknown>, labelMode?: string): Promise<LinearIssue>;
+    private extractMilestoneNodes;
+    private executeUpdateMutation;
+    createIssue(args: Record<string, unknown>): Promise<LinearIssue>;
+    private resolveCreateFields;
+    private executeCreateMutation;
+    searchIssues(args: Record<string, unknown>): Promise<LinearIssue[]>;
+    private resolveTeamId;
+    private resolveProjectId;
+    /**
+     * Check that the resolved team is associated with the project.
+     * If not, auto-switch when the project belongs to exactly one team.
+     */
+    private validateProjectTeam;
+    private resolveLabels;
+    private resolveLabelsWithMode;
+    /** Auto-create a missing label on the team. Returns the new label ID or null on failure. */
+    private autoCreateLabel;
+    private resolveTeamKeyFromResult;
+    private collectTeamNodes;
+    private resolveMilestoneId;
+    private resolveMilestoneIdForCreate;
+    private fetchIssueTeamId;
+    private buildCreateInput;
+    private buildUpdateInput;
+    private buildResolveVariablesForTeam;
+    private applySearchFilters;
+    private buildSearchFilter;
+    private resolveAssigneeId;
+    private resolveUpdateContext;
+    private resolveCycleIdForUpdate;
+    private resolveStatusIdForUpdate;
+    private buildCreateResolveVariables;
+    private resolveParentId;
+    transformIssueData(issue: GraphQLResponseData): LinearIssue;
+    private transformIssueCoreFields;
+    private transformIssueRelations;
+    private transformIssueHierarchy;
+    private transformIssueComments;
+}