@gitkraken/core-gitlens 0.22.1 → 0.24.0

package/dist/plus/integrations/manager.d.ts

@@ -5,7 +5,7 @@ import { PullRequestFilter, PullRequestSearchCriteria, PullRequestShape, PullReq
 import { ConfiguredIntegrationDescriptor } from "./authentication/models.js";
 import { IntegrationIds, IssuesCloudHostIntegrationId, IssuesSelfManagedHostIntegrationId } from "./constants.js";
 import { ConfiguredIntegrationsChangeEvent } from "./authentication/configuredIntegrationService.js";
-import { ConnectionStateChangeEvent, ProviderBroadenResult, ProviderOrganization, ProviderPagedResult, ProviderRepositoryShape, ProviderResult, ProviderSweepResult, ResolveRepositoryResult } from "./results.js";
+import { ConnectionStateChangeEvent, ProviderBroadenResult, ProviderLinearProjectShape, ProviderOrganization, ProviderPagedResult, ProviderRepositoryShape, ProviderResult, ProviderSweepResult, ResolveRepositoryResult } from "./results.js";
 import { IssueFilter } from "./providerFilters.js";
 import { IssueEtagInclude, PullRequestEtagInclude } from "./models/integration.js";
 import { IssueCountResult, IssueCountScope, PullRequestCountResult, PullRequestCountScope } from "./reads/counts.js";
@@ -223,6 +223,12 @@ export type GetAutolinkReferencesOptions = {
   /** Drops discovery and awaits a fresh build; retires builds started before the refresh. */
   forceSync?: boolean;
 };
+/** Linear Project discovery reads one Linear connection: the primary, or the one `connectionId` names. */
+export type ListLinearProjectsOptions = {
+  connectionId?: string;
+  /** Drops the cached Project list and re-syncs the connection before reading, as the other reads' `forceSync`. */
+  forceSync?: boolean;
+};
 /**
  * Public, provider-neutral integration facade. Provider clients and integration model instances remain private
  * implementation details so SDK changes don't expand this contract.
@@ -298,6 +304,16 @@ export interface IntegrationManager {
    * references can contain compiled regular expressions and are not a wire format.
    */
   getAutolinkReferences(options: GetAutolinkReferencesOptions): Promise<RefSet | undefined>;
+  /**
+   * The Linear workspace's Projects: Linear's own `Project` entity, which can span several teams. Not what
+   * {@link listProjects} returns for Linear, which is its teams (the tier a Linear issue read is windowed by).
+   * Pass a Project's `id` to {@link listIssueTrackerIssuesPage}'s `linearProjects` to narrow an issue read to it.
+   *
+   * Drained across Linear's pages (100 Projects each, up to 2,000) and cached per connection like the team list,
+   * for five minutes or until `forceSync`. A list the drain could not finish comes back with what it read, a
+   * warning and `fetchFailed`, and is not cached.
+   */
+  listLinearProjects(options?: ListLinearProjectsOptions): Promise<ProviderResult<ProviderLinearProjectShape>>;
   listRepos(options: {
     providerId: IntegrationIds;
     org?: string;
@@ -824,6 +840,14 @@ export interface IntegrationManager {
      * `getSupportedFilters().issueStates` and are refused otherwise (warning + `fetchFailed`).
      */
     state?: IssueStateFilter;
+    /**
+     * Linear only: narrows the read to issues in any of these Linear Projects, by the `id`
+     * {@link listLinearProjects} lists. Combines with `org`/`project` (a team), `includeAllAssignees`, `state`
+     * and `sort`: the read stays windowed by team, and each team's issues are those in the Projects. Omitted or
+     * empty narrows nothing; any other tracker refuses it (warning + `fetchFailed`). Part of a cursor's
+     * fingerprint, so drop the cursor when you change it.
+     */
+    linearProjects?: string[];
     forceSync?: boolean;
     page?: number;
     /**

package/dist/plus/integrations/models/issueReads.d.ts

@@ -99,6 +99,11 @@ export type IssuesForProjectOptions = {
    * (Trello) refuses anything but `'open'` rather than serving its open cards as if they were the closed ones.
    */
   state?: IssueStateFilter;
+  /**
+   * Linear only: narrows the read to issues in any of these Linear Projects (Linear's `Project` entity, by id),
+   * server-side. Validated by the facade, which refuses it for any other tracker; omitted or empty adds nothing.
+   */
+  linearProjects?: readonly string[];
 };
 /** One project of a batched tracker read (`IssuesIntegration.getIssuesForProjectsWithTruncationResult`). */
 export type ProjectIssuesRequest<T> = {

package/dist/plus/integrations/providers/linear.d.ts

@@ -5,10 +5,10 @@ import { Issue, IssueShape } from "../../../git/models/issue.js";
 import { Account } from "../../../git/models/author.js";
 import { ConnectionResource, ProviderAuthenticationSession } from "../authentication/models.js";
 import { IssuesCloudHostIntegrationId } from "../constants.js";
-import { ProviderApiCollectionResult } from "./models.js";
+import { ProviderApiCollectionResult, ProviderHierarchyResult, ProviderLinearProject } from "./models.js";
 import { AccountWideIssuesResult, IssuesForProjectOptions, ProjectIssuesDrain, ProjectIssuesRequest, SearchMyIssuesOptions } from "../models/issueReads.js";
 import { IssuesIntegration } from "../models/issuesIntegration.js";
-import { IssueEtagFields } from "../models/integration.js";
+import { IntegrationResult, IssueEtagFields } from "../models/integration.js";
 import { IntegrationAuthenticationProviderDescriptor } from "../authentication/integrationAuthenticationProvider.js";
 //#region ../plus/integrations/src/providers/linear.d.ts
 export interface LinearTeamDescriptor extends IssueResourceDescriptor {
@@ -45,6 +45,34 @@ export declare class LinearIntegration extends IssuesIntegration<IssuesCloudHost
   private getTeams;
   private getTeamsWithMetadata;
   private readTeams;
+  /**
+   * The workspace's Linear Projects (Linear's `Project` entity), drained across their pages. Separate from the
+   * teams this integration lists as its projects: a Linear Project can span several teams, and selecting one
+   * narrows an issue read (`IssuesForProjectOptions.linearProjects`) rather than naming what is read.
+   *
+   * Cached like the teams, and only when complete: a drain cut short by its backstop or a failed page is returned
+   * with its `truncated`/`metadata` so the facade can say so, and read again next time. A first-page failure
+   * rejects, which the result wrapper turns into `{ error }`. `fresh` reads past the cache and any read in flight,
+   * for a caller that must not take a list from before what it needs to see (a Project created since).
+   */
+  getWorkspaceProjectsResult(connectionId?: string, options?: {
+    fresh?: boolean;
+  }): Promise<IntegrationResult<ProviderHierarchyResult<ProviderLinearProject>>>;
+  /** Expires, and is dropped on a re-sync, so a Project created or archived mid-session is picked up. */
+  private readonly _workspaceProjects;
+  /**
+   * In flight by token, with the cache generation it started under: concurrent cold reads share one drain, but a
+   * read after the cache was dropped (a `forceSync`) never joins one started before, which could miss what it asks
+   * to see.
+   */
+  private readonly _workspaceProjectsReads;
+  private getWorkspaceProjects;
+  /**
+   * Drains the Projects cursor up to {@link maxWorkspaceProjectPages}. A first-page failure rejects, so the read
+   * fails as the team read does rather than reading as a workspace with no Projects; a later one keeps the prefix
+   * and records the failure, as do a stalled cursor and the backstop with pages left.
+   */
+  private readWorkspaceProjects;
   protected getProviderResourcesForUser(session: ProviderAuthenticationSession): Promise<ResourceDescriptor[] | undefined>;
   protected getProviderUncachedResourcesForUser(session: ProviderAuthenticationSession): Promise<ResourceDescriptor[] | undefined>;
   protected getProviderProjectsForResources(session: ProviderAuthenticationSession, _resources: ResourceDescriptor[]): Promise<ResourceDescriptor[] | undefined>;
@@ -64,9 +92,14 @@ export declare class LinearIntegration extends IssuesIntegration<IssuesCloudHost
   protected getProviderIssuesForProject(session: ProviderAuthenticationSession, project: ResourceDescriptor, options?: IssuesForProjectOptions): Promise<IssueShape[] | undefined>;
   protected getProviderIssuesForProjectWithTruncation(session: ProviderAuthenticationSession, project: ResourceDescriptor, options?: IssuesForProjectOptions): Promise<ProjectIssuesDrain | undefined>;
   /**
-   * Searches every team of a user-scoped read together: one `getIssues` names all of them and the viewer as
-   * assignee, so a team with none of the user's issues costs no request of its own. Linear's filter is a GraphQL
-   * body, not a query string, so there is no key bound to chunk at.
+   * Searches every team of a user-scoped read together: one `getIssues` names all of them and the viewer's scope
+   * (see {@link viewerScope}), so a team with none of the user's issues costs no request of its own. Linear's filter
+   * is a GraphQL body, not a query string, so there is no key bound to chunk at.
+   *
+   * A read narrowed to Linear Projects is searched together even across every assignee: the Projects already bound
+   * it to a few teams' worth of issues, so a team holding none of them costs no request either. An unnarrowed read
+   * of every assignee is still read team by team, since a search over all of them would just spend one team's page
+   * budget before falling back.
    */
   protected getProjectIssuesSearches(requests: readonly ProjectIssuesRequest<ResourceDescriptor>[]): number[][] | undefined;
   protected searchProviderProjectIssues(session: ProviderAuthenticationSession, requests: readonly ProjectIssuesRequest<ResourceDescriptor>[]): Promise<IssueShape[][] | undefined>;
@@ -81,7 +114,7 @@ export declare class LinearIntegration extends IssuesIntegration<IssuesCloudHost
    * Follows `getIssues`' cursor up to {@link maxPagesPerRequest}. `truncated` is set when that backstop stopped
    * the drain with more pages still available, when the provider stalled its cursor or flagged its paging as
    * truncated, or when a page after the first failed, which is recorded at `failureScope` while the prefix is
-   * kept. A first-page failure throws, so the caller sees a hard error rather than an empty success.
+   * kept. A failure before any issue was kept throws, so the caller sees a hard error rather than an empty success.
    */
   private drainIssues;
   get id(): IssuesCloudHostIntegrationId.Linear;

package/dist/plus/integrations/providers/linear.js

@@ -1,14 +1,19 @@
 import { chunk } from "../../../utils/array.js";
 import { Logger as _logger } from "../../../utils/logger.js";
+import { getScopedLogger } from "../../../utils/logger.scoped.js";
 import { mapSettledBounded } from "../../../utils/promise.js";
+import { trace } from "../../../utils/decorators/log.js";
 import { PromiseCache } from "../../../utils/promiseCache.js";
+import __decorate from "../../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
 import { isIssueResourceDescriptor } from "../../../git/utils/resourceDescriptor.utils.js";
-import { IntegrationReadUnavailableError } from "../errors.js";
+import { IntegrationReadUnavailableError, toError } from "../errors.js";
 import "../constants.js";
 import { toCollectionScopeFailure } from "../collectionMetadata.js";
 import { toTokenWithInfo } from "../authentication/models.js";
-import { mergeCollectionMetadata } from "./utils/providerPaging.js";
+import "../providerFilters.js";
+import { collectProviderPagedResult, mergeCollectionMetadata } from "./utils/providerPaging.js";
 import { fromProviderIssue, providersMetadata, toIssueShape, toProviderIssueStates } from "./models.js";
+import { isReadSessionFailure } from "../models/integration.js";
 import { IssuesIntegration, groupProjectIssuesSearches, splitProjectIssuesSearch } from "../models/issuesIntegration.js";
 import { createIssueAutolinkReferences } from "./utils/issueAutolinks.js";
 import { DiscoveryCache } from "./utils/discoveryCache.js";
@@ -36,10 +41,26 @@ const maxPagesPerRequest = 10;
 */
 const maxAccountWidePagesPerRequest = 50;
 const linearImplicitTeamsPageSize = 50;
+/** The workspace Projects read's backstop: provider-apis pages them 100 at a time, so 2,000 Projects. */
+const maxWorkspaceProjectPages = 20;
 /** Long enough to span one tracker read, short enough that a profile change shows on the next. */
 const recentAccountTTL = 6e4;
 /** A team key and issue number, as Linear writes an issue's identifier (`ENG-123`). */
 const linearIdentifier = /^([A-Za-z0-9]+)-(\d+)$/;
+/**
+* How a user-scoped team read narrows to the viewer: the issues assigned to them, plus, unless the caller asked for
+* assigned issues by name, the GitHub-synced issues they created. Linear's GitHub Issues sync makes the GitHub author
+* of an issue (one who linked their GitHub account) the creator of its Linear copy but assigns no one GitHub doesn't,
+* so an assignee-only read never returns the copy of a GitHub issue the user filed (gitkraken/kepler#4480). Only
+* synced issues widen, and only those the viewer created on either side: the rest of what the user created in Linear
+* stays out of "my issues", as does a synced issue they merely follow.
+*/
+function viewerScope(viewerId, filters) {
+	return filters?.includes("assignee") ? { assignees: [viewerId] } : {
+		assignees: [viewerId],
+		githubSyncedCreators: [viewerId]
+	};
+}
 var LinearIntegration = class extends IssuesIntegration {
 	/**
 	* Built from the teams, so it follows them: rebuilt when the team list changes or the caches are dropped, and once
@@ -148,6 +169,84 @@ var LinearIntegration = class extends IssuesIntegration {
 		};
 		return { values: descriptors };
 	}
+	/**
+	* The workspace's Linear Projects (Linear's `Project` entity), drained across their pages. Separate from the
+	* teams this integration lists as its projects: a Linear Project can span several teams, and selecting one
+	* narrows an issue read (`IssuesForProjectOptions.linearProjects`) rather than naming what is read.
+	*
+	* Cached like the teams, and only when complete: a drain cut short by its backstop or a failed page is returned
+	* with its `truncated`/`metadata` so the facade can say so, and read again next time. A first-page failure
+	* rejects, which the result wrapper turns into `{ error }`. `fresh` reads past the cache and any read in flight,
+	* for a caller that must not take a list from before what it needs to see (a Project created since).
+	*/
+	async getWorkspaceProjectsResult(connectionId, options) {
+		const scope = getScopedLogger();
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null || isReadSessionFailure(session)) return session && { error: session.error };
+		try {
+			const projects = await this.getWorkspaceProjects(session, options?.fresh === true);
+			await this.confirmScopedAuthFailures(session, projects.metadata);
+			this.resetRequestExceptionCount("getProjectsForResources");
+			return { value: projects };
+		} catch (ex) {
+			this.handleProviderException("getProjectsForResources", ex, { connectionId });
+			return { error: toError(ex) };
+		}
+	}
+	/** Expires, and is dropped on a re-sync, so a Project created or archived mid-session is picked up. */
+	_workspaceProjects = new DiscoveryCache();
+	/**
+	* In flight by token, with the cache generation it started under: concurrent cold reads share one drain, but a
+	* read after the cache was dropped (a `forceSync`) never joins one started before, which could miss what it asks
+	* to see.
+	*/
+	_workspaceProjectsReads = /* @__PURE__ */ new Map();
+	getWorkspaceProjects(session, fresh) {
+		const { accessToken } = session;
+		const generation = this._workspaceProjects.generation;
+		if (!fresh) {
+			const cached = this._workspaceProjects.get(accessToken);
+			if (cached != null) return Promise.resolve({ values: cached });
+			const inFlight = this._workspaceProjectsReads.get(accessToken);
+			if (inFlight?.generation === generation) return inFlight.read;
+		}
+		const entry = {
+			generation,
+			read: this.readWorkspaceProjects(session)
+		};
+		entry.read = entry.read.then((result) => {
+			if (this._workspaceProjectsReads.get(accessToken) === entry && result.truncated !== true && (result.metadata == null || result.metadata.completeness === "complete")) this._workspaceProjects.set(accessToken, result.values, { generation });
+			return result;
+		});
+		this._workspaceProjectsReads.set(accessToken, entry);
+		entry.read.finally(() => {
+			if (this._workspaceProjectsReads.get(accessToken) === entry) this._workspaceProjectsReads.delete(accessToken);
+		}).catch(() => {});
+		return entry.read;
+	}
+	/**
+	* Drains the Projects cursor up to {@link maxWorkspaceProjectPages}. A first-page failure rejects, so the read
+	* fails as the team read does rather than reading as a workspace with no Projects; a later one keeps the prefix
+	* and records the failure, as do a stalled cursor and the backstop with pages left.
+	*/
+	async readWorkspaceProjects(session) {
+		const api = await this.getProvidersApi();
+		const tokenWithInfo = toTokenWithInfo(this.id, session);
+		let pagesRead = 0;
+		let firstPageError;
+		const read = await collectProviderPagedResult(async (cursor) => {
+			try {
+				const page = await api.getLinearProjects(tokenWithInfo, { cursor });
+				pagesRead++;
+				return page;
+			} catch (ex) {
+				if (pagesRead === 0) firstPageError = toError(ex);
+				throw ex;
+			}
+		}, maxWorkspaceProjectPages, { providerId: this.id });
+		if (firstPageError != null) throw firstPageError;
+		return read;
+	}
 	async getProviderResourcesForUser(session) {
 		const organization = await this.getOrganization(session);
 		return organization != null ? [organization] : void 0;
@@ -174,6 +273,8 @@ var LinearIntegration = class extends IssuesIntegration {
 	clearDiscoveryCaches() {
 		this._organizations = void 0;
 		this._teams.clear();
+		this._workspaceProjects.clear();
+		this._workspaceProjectsReads.clear();
 		this._autolinks.clear();
 		this._recentAccounts.clear();
 	}
@@ -221,7 +322,8 @@ var LinearIntegration = class extends IssuesIntegration {
 		}
 		const drain = await this.drainIssues(session, {
 			teams: [project.id],
-			...viewerId != null ? { assignees: [viewerId] } : {},
+			...options?.linearProjects?.length ? { projects: [...options.linearProjects] } : {},
+			...viewerId != null ? viewerScope(viewerId, options?.filters) : {},
 			states: toProviderIssueStates(options?.state)
 		}, options?.sort, {
 			providerId: this.id,
@@ -239,28 +341,38 @@ var LinearIntegration = class extends IssuesIntegration {
 		};
 	}
 	/**
-	* Searches every team of a user-scoped read together: one `getIssues` names all of them and the viewer as
-	* assignee, so a team with none of the user's issues costs no request of its own. Linear's filter is a GraphQL
-	* body, not a query string, so there is no key bound to chunk at.
+	* Searches every team of a user-scoped read together: one `getIssues` names all of them and the viewer's scope
+	* (see {@link viewerScope}), so a team with none of the user's issues costs no request of its own. Linear's filter
+	* is a GraphQL body, not a query string, so there is no key bound to chunk at.
+	*
+	* A read narrowed to Linear Projects is searched together even across every assignee: the Projects already bound
+	* it to a few teams' worth of issues, so a team holding none of them costs no request either. An unnarrowed read
+	* of every assignee is still read team by team, since a search over all of them would just spend one team's page
+	* budget before falling back.
 	*/
 	getProjectIssuesSearches(requests) {
-		return groupProjectIssuesSearches(requests, ({ project, options }) => options.user != null && isIssueResourceDescriptor(project) ? [
-			options.user,
+		return groupProjectIssuesSearches(requests, ({ project, options }) => (options.user != null || options.linearProjects?.length) && isIssueResourceDescriptor(project) ? [
+			options.user ?? "",
 			options.userId ?? "",
 			options.sort ?? "",
-			options.state ?? ""
+			options.state ?? "",
+			options.filters?.join(",") ?? "",
+			...options.linearProjects ?? []
 		].join("\0") : void 0);
 	}
 	async searchProviderProjectIssues(session, requests) {
 		const { options } = requests[0];
-		if (options.user == null) return void 0;
-		const viewerId = await this.getViewerId(session, options);
-		if (viewerId == null) return void 0;
+		let viewerId;
+		if (options.user != null) {
+			viewerId = await this.getViewerId(session, options);
+			if (viewerId == null) return void 0;
+		} else if (!options.linearProjects?.length) return;
 		const teams = requests.map((request) => request.project).filter(isIssueResourceDescriptor);
 		if (teams.length !== requests.length) return void 0;
 		const drain = await this.drainIssues(session, {
 			teams: teams.map((team) => team.id),
-			assignees: [viewerId],
+			...options.linearProjects?.length ? { projects: [...options.linearProjects] } : {},
+			...viewerId != null ? viewerScope(viewerId, options.filters) : {},
 			states: toProviderIssueStates(options.state)
 		}, options.sort, { providerId: this.id });
 		if (drain.truncated || drain.metadata != null && drain.metadata.completeness !== "complete") return;
@@ -285,11 +397,12 @@ var LinearIntegration = class extends IssuesIntegration {
 	* Follows `getIssues`' cursor up to {@link maxPagesPerRequest}. `truncated` is set when that backstop stopped
 	* the drain with more pages still available, when the provider stalled its cursor or flagged its paging as
 	* truncated, or when a page after the first failed, which is recorded at `failureScope` while the prefix is
-	* kept. A first-page failure throws, so the caller sees a hard error rather than an empty success.
+	* kept. A failure before any issue was kept throws, so the caller sees a hard error rather than an empty success.
 	*/
 	async drainIssues(session, filter, sort, failureScope) {
 		const api = await this.getProvidersApi();
 		const assignees = filter.assignees?.length ? filter.assignees : void 0;
+		const syncedCreators = filter.githubSyncedCreators?.length ? filter.githubSyncedCreators : void 0;
 		let cursor;
 		let hasMore;
 		let requestCount = 0;
@@ -319,7 +432,7 @@ var LinearIntegration = class extends IssuesIntegration {
 			collectionMetadata = mergeCollectionMetadata(collectionMetadata, result.metadata);
 			for (const issue of result.values) {
 				const shape = toIssueShape(issue, this, { projection: "project" });
-				if (shape != null && (assignees == null || shape.assignees?.some((a) => assignees.includes(a.id)))) issues.push(shape);
+				if (shape != null && (assignees == null || shape.assignees?.some((a) => assignees.includes(a.id)) || syncedCreators != null && shape.author != null && syncedCreators.includes(shape.author.id) && shape.syncedWith?.length !== 0)) issues.push(shape);
 			}
 			if (hasMore && (nextCursor == null || nextCursor === cursor)) {
 				truncated = true;
@@ -532,6 +645,7 @@ var LinearIntegration = class extends IssuesIntegration {
 		return url.substring(0, url.length - lastSegment.length - 1);
 	}
 };
+__decorate([trace()], LinearIntegration.prototype, "getWorkspaceProjectsResult", null);
 //#endregion
 export { LinearIntegration };