From 787c59744be8305b362ce5de04dc590315c9c178 Mon Sep 17 00:00:00 2001 From: Austin McKinley Date: Mon, 18 Jun 2018 15:08:27 -0700 Subject: [PATCH 01/10] Correctly attach users to identities Summary: This never worked. Test Plan: Ran `bin/repository rebuild-identities` and viewed identity objects with `currentEffectiveUserID`s and no longer got errors about attempting to attach `null` objects instead of `PhabricatorUser` objects. Reviewers: epriestley Reviewed By: epriestley Subscribers: Korvin Differential Revision: https://secure.phabricator.com/D19495 --- .../PhabricatorRepositoryIdentityQuery.php | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php b/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php index c64b1a296b..b816a967db 100644 --- a/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php +++ b/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php @@ -124,6 +124,27 @@ final class PhabricatorRepositoryIdentityQuery return $where; } + protected function didFilterPage(array $identities) { + $user_ids = array_filter( + mpull($identities, 'getCurrentEffectiveUserPHID', 'getID')); + if (!$user_ids) { + return $identities; + } + + $users = id(new PhabricatorUser())->loadAllWhere( + 'phid IN (%Ls)', $user_ids); + $users = mpull($users, null, 'getPHID'); + + foreach ($identities as $identity) { + if ($identity->hasEffectiveUser()) { + $user = idx($users, $identity->getCurrentEffectiveUserPHID()); + $identity->attachEffectiveUser($user); + } + } + + return $identities; + } + public function getQueryApplicationClass() { return 'PhabricatorDiffusionApplication'; } From 05f333dfba0ad17fecab36c5bd8dce215e9f221f Mon Sep 17 00:00:00 2001 From: Austin McKinley Date: Tue, 12 Jun 2018 14:07:41 -0700 Subject: [PATCH 02/10] Attach identities to commits and users to identities Summary: Ref T12164. Make it easier to work with identity objects by attaching them to commits and attaching users to identities. Test Plan: Loaded some commits with `->needIdentities(true)` and checked the resulting objects. Reviewers: epriestley Reviewed By: epriestley Subscribers: Korvin Maniphest Tasks: T12164 Differential Revision: https://secure.phabricator.com/D19491 --- .../diffusion/query/DiffusionCommitQuery.php | 24 +++++++++++++++++++ .../PhabricatorRepositoryIdentityPHIDType.php | 14 ++++++++++- .../PhabricatorRepositoryIdentityQuery.php | 6 +++-- .../storage/PhabricatorRepositoryCommit.php | 18 ++++++++++++++ .../storage/PhabricatorRepositoryIdentity.php | 15 ++++++++++++ 5 files changed, 74 insertions(+), 3 deletions(-) diff --git a/src/applications/diffusion/query/DiffusionCommitQuery.php b/src/applications/diffusion/query/DiffusionCommitQuery.php index 53e8d51bf9..0ca9cd97d4 100644 --- a/src/applications/diffusion/query/DiffusionCommitQuery.php +++ b/src/applications/diffusion/query/DiffusionCommitQuery.php @@ -26,6 +26,7 @@ final class DiffusionCommitQuery private $needCommitData; private $needDrafts; + private $needIdentities; private $mustFilterRefs = false; private $refRepository; @@ -110,6 +111,11 @@ final class DiffusionCommitQuery return $this; } + public function needIdentities($need) { + $this->needIdentities = $need; + return $this; + } + public function needAuditRequests($need) { $this->needAuditRequests = $need; return $this; @@ -393,6 +399,24 @@ final class DiffusionCommitQuery } } + if ($this->needIdentities) { + $identity_phids = array_merge( + mpull($commits, 'getAuthorIdentityPHID'), + mpull($commits, 'getCommitterIdentityPHID')); + + $data = id(new PhabricatorRepositoryIdentityQuery()) + ->withPHIDs($identity_phids) + ->setViewer($this->getViewer()) + ->execute(); + $data = mpull($data, null, 'getPHID'); + + foreach ($commits as $commit) { + $author_identity = idx($data, $commit->getAuthorIdentityPHID()); + $committer_identity = idx($data, $commit->getCommitterIdentityPHID()); + $commit->attachIdentities($author_identity, $committer_identity); + } + } + if ($this->needDrafts) { PhabricatorDraftEngine::attachDrafts( $viewer, diff --git a/src/applications/repository/phid/PhabricatorRepositoryIdentityPHIDType.php b/src/applications/repository/phid/PhabricatorRepositoryIdentityPHIDType.php index 4572e7b005..5bb4d5b907 100644 --- a/src/applications/repository/phid/PhabricatorRepositoryIdentityPHIDType.php +++ b/src/applications/repository/phid/PhabricatorRepositoryIdentityPHIDType.php @@ -28,6 +28,18 @@ final class PhabricatorRepositoryIdentityPHIDType public function loadHandles( PhabricatorHandleQuery $query, array $handles, - array $objects) {} + array $objects) { + + foreach ($handles as $phid => $handle) { + $identity = $objects[$phid]; + + $id = $identity->getID(); + $name = $identity->getIdentityNameRaw(); + + $handle->setObjectName(pht('Identity %d', $id)); + $handle->setName($name); + $handle->setURI($identity->getURI()); + } + } } diff --git a/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php b/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php index b816a967db..ef038f045f 100644 --- a/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php +++ b/src/applications/repository/query/PhabricatorRepositoryIdentityQuery.php @@ -131,8 +131,10 @@ final class PhabricatorRepositoryIdentityQuery return $identities; } - $users = id(new PhabricatorUser())->loadAllWhere( - 'phid IN (%Ls)', $user_ids); + $users = id(new PhabricatorPeopleQuery()) + ->withPHIDs($user_ids) + ->setViewer($this->getViewer()) + ->execute(); $users = mpull($users, null, 'getPHID'); foreach ($identities as $identity) { diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php index 347f9afcde..7cad448e7d 100644 --- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php +++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php @@ -44,6 +44,9 @@ final class PhabricatorRepositoryCommit private $audits = self::ATTACHABLE; private $repository = self::ATTACHABLE; private $customFields = self::ATTACHABLE; + private $authorIdentity = self::ATTACHABLE; + private $committerIdentity = self::ATTACHABLE; + private $drafts = array(); private $auditAuthorityPHIDs = array(); @@ -191,6 +194,21 @@ final class PhabricatorRepositoryCommit return ($this->audits !== self::ATTACHABLE); } + public function attachIdentities( + PhabricatorRepositoryIdentity $author, + $committer = null) { + $this->authorIdentity = $author; + $this->committerIdentity = $committer; + } + + public function getAuthorIdentity() { + return $this->assertAttached($this->authorIdentity); + } + + public function getCommiterIdentity() { + return $this->assertAttached($this->committerIdentity); + } + public function loadAndAttachAuditAuthority( PhabricatorUser $viewer, $actor_phid = null) { diff --git a/src/applications/repository/storage/PhabricatorRepositoryIdentity.php b/src/applications/repository/storage/PhabricatorRepositoryIdentity.php index 60d4ccb148..bf421692a0 100644 --- a/src/applications/repository/storage/PhabricatorRepositoryIdentity.php +++ b/src/applications/repository/storage/PhabricatorRepositoryIdentity.php @@ -14,6 +14,17 @@ final class PhabricatorRepositoryIdentity protected $manuallySetUserPHID; protected $currentEffectiveUserPHID; + private $effectiveUser = self::ATTACHABLE; + + public function attachEffectiveUser(PhabricatorUser $user) { + $this->effectiveUser = $user; + return $this; + } + + public function getEffectiveUser() { + return $this->assertAttached($this->effectiveUser); + } + protected function getConfiguration() { return array( self::CONFIG_AUX_PHID => true, @@ -63,6 +74,10 @@ final class PhabricatorRepositoryIdentity return '/diffusion/identity/view/'.$this->getID().'/'; } + public function hasEffectiveUser() { + return ($this->currentEffectiveUserPHID != null); + } + public function save() { if ($this->manuallySetUserPHID) { $this->currentEffectiveUserPHID = $this->manuallySetUserPHID; From 9db5ad3476a959f57a900e7f925f813d0405555e Mon Sep 17 00:00:00 2001 From: Austin McKinley Date: Mon, 18 Jun 2018 15:33:08 -0700 Subject: [PATCH 03/10] Allow null identities to be attached to commit objects Summary: I landed D19491 a little aggressively, so allow this field to be null until after the migration goes out. Test Plan: Loaded commits without identity objects; did not get any errors. Reviewers: epriestley Reviewed By: epriestley Subscribers: Korvin Differential Revision: https://secure.phabricator.com/D19496 --- .../repository/storage/PhabricatorRepositoryCommit.php | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php index 7cad448e7d..abcf862b40 100644 --- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php +++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php @@ -195,8 +195,9 @@ final class PhabricatorRepositoryCommit } public function attachIdentities( - PhabricatorRepositoryIdentity $author, - $committer = null) { + PhabricatorRepositoryIdentity $author = null, + PhabricatorRepositoryIdentity $committer = null) { + $this->authorIdentity = $author; $this->committerIdentity = $committer; } From 6136b8327575c8d1fab7f21ef916e94f39f9aaf7 Mon Sep 17 00:00:00 2001 From: epriestley Date: Thu, 21 Jun 2018 15:53:57 -0700 Subject: [PATCH 04/10] Fix changeset construction special case for empty commits in pre-commit hooks Summary: Fixes T13155. Ref T13151. A recent change (D19455) changed the return format here, but I missed this special case for empty commits. Test Plan: - T13155 has a good set of reproduction instructions. - Pushed an empty commit. - Before: bunch of warning log spew. - After: clean logs. Reviewers: amckinley, avivey Reviewed By: avivey Maniphest Tasks: T13155, T13151 Differential Revision: https://secure.phabricator.com/D19500 --- src/applications/diffusion/engine/DiffusionCommitHookEngine.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/applications/diffusion/engine/DiffusionCommitHookEngine.php b/src/applications/diffusion/engine/DiffusionCommitHookEngine.php index 857c939a23..59fb4b5e12 100644 --- a/src/applications/diffusion/engine/DiffusionCommitHookEngine.php +++ b/src/applications/diffusion/engine/DiffusionCommitHookEngine.php @@ -1212,7 +1212,7 @@ final class DiffusionCommitHookEngine extends Phobject { if (!strlen($raw_diff)) { // If the commit is actually empty, just return no changesets. - return array(); + return array(array(), 0); } $parser = new ArcanistDiffParser(); From 8ab8c390b785f30013efcdc70f176ec6dc201423 Mon Sep 17 00:00:00 2001 From: epriestley Date: Thu, 21 Jun 2018 15:24:43 -0700 Subject: [PATCH 05/10] If "branch" is provided to "diffusion.branchquery", use it as the "" argument to "git branch --contains ..." Summary: Ref T13151. See PHI720. If you want to test if commit X appears on specific branch Y, `git branch --contains X -- Y` is faster than (effectively) `git branch --contains X | grep Y`. Since this call has a "branch" parameter anyway, use it as the pattern argument if provided. Test Plan: - Called the API method with no parameters, got all branches. - Called the API method with `master`, got just master. - Called the API method with `maste*`, got master. This behavior is not officially supported and may change in the future. - Viewed a commit, still saw all branches. - Grepped for `diffusion.branchquery` and verified that no remaining callsites pass a default "branch" parameter. Reviewers: amckinley Reviewed By: amckinley Maniphest Tasks: T13151 Differential Revision: https://secure.phabricator.com/D19499 --- .../DiffusionBranchQueryConduitAPIMethod.php | 21 +++++++++++++++---- .../DiffusionCommitBranchesController.php | 1 + 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/src/applications/diffusion/conduit/DiffusionBranchQueryConduitAPIMethod.php b/src/applications/diffusion/conduit/DiffusionBranchQueryConduitAPIMethod.php index d42c45a96b..62878c0291 100644 --- a/src/applications/diffusion/conduit/DiffusionBranchQueryConduitAPIMethod.php +++ b/src/applications/diffusion/conduit/DiffusionBranchQueryConduitAPIMethod.php @@ -30,18 +30,31 @@ final class DiffusionBranchQueryConduitAPIMethod $contains = $request->getValue('contains'); if (strlen($contains)) { + + // See PHI720. If the standard "branch" field is provided, use it + // as the "pattern" argument to "git branch ..." to let callers test + // for reachability from a particular branch head. + $pattern = $request->getValue('branch'); + if (strlen($pattern)) { + $pattern_argv = array($pattern); + } else { + $pattern_argv = array(); + } + // NOTE: We can't use DiffusionLowLevelGitRefQuery here because // `git for-each-ref` does not support `--contains`. if ($repository->isWorkingCopyBare()) { list($stdout) = $repository->execxLocalCommand( - 'branch --verbose --no-abbrev --contains %s --', - $contains); + 'branch --verbose --no-abbrev --contains %s -- %Ls', + $contains, + $pattern_argv); $ref_map = DiffusionGitBranch::parseLocalBranchOutput( $stdout); } else { list($stdout) = $repository->execxLocalCommand( - 'branch -r --verbose --no-abbrev --contains %s --', - $contains); + 'branch -r --verbose --no-abbrev --contains %s -- %Ls', + $contains, + $pattern_argv); $ref_map = DiffusionGitBranch::parseRemoteBranchOutput( $stdout, DiffusionGitBranch::DEFAULT_GIT_REMOTE); diff --git a/src/applications/diffusion/controller/DiffusionCommitBranchesController.php b/src/applications/diffusion/controller/DiffusionCommitBranchesController.php index e698ff6fc7..633c3b9174 100644 --- a/src/applications/diffusion/controller/DiffusionCommitBranchesController.php +++ b/src/applications/diffusion/controller/DiffusionCommitBranchesController.php @@ -22,6 +22,7 @@ final class DiffusionCommitBranchesController extends DiffusionController { array( 'contains' => $drequest->getCommit(), 'limit' => $branch_limit + 1, + 'branch' => null, ))); $has_more_branches = (count($branches) > $branch_limit); From b1f4a974fe035915cc26041077578d11515ed714 Mon Sep 17 00:00:00 2001 From: epriestley Date: Fri, 22 Jun 2018 04:57:51 -0700 Subject: [PATCH 06/10] Fix two minor breadcrumb issues in Config Summary: Fixes T13159. Two issues here: - When viewing a particular config setting, there's an extra "Config" crumb. - On the page for a config group, the link to the parent group has an extra "/config/" in it. Test Plan: - Viewed a page for a particular setting, no longer saw an extra "Config" crumb. - Viewed a page for a setting group, clicked parent crumb, got taken to a real page. Reviewers: amckinley Reviewed By: amckinley Maniphest Tasks: T13159 Differential Revision: https://secure.phabricator.com/D19501 --- .../config/controller/PhabricatorConfigEditController.php | 1 - .../config/controller/PhabricatorConfigGroupController.php | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/applications/config/controller/PhabricatorConfigEditController.php b/src/applications/config/controller/PhabricatorConfigEditController.php index 06df0de889..37f7db6c7c 100644 --- a/src/applications/config/controller/PhabricatorConfigEditController.php +++ b/src/applications/config/controller/PhabricatorConfigEditController.php @@ -231,7 +231,6 @@ final class PhabricatorConfigEditController $box_header[] = $key; $crumbs = $this->buildApplicationCrumbs(); - $crumbs->addTextCrumb(pht('Config'), $this->getApplicationURI()); if ($group) { $crumbs->addTextCrumb($group->getName(), $group_uri); } diff --git a/src/applications/config/controller/PhabricatorConfigGroupController.php b/src/applications/config/controller/PhabricatorConfigGroupController.php index 920b2092ac..7068ddaecc 100644 --- a/src/applications/config/controller/PhabricatorConfigGroupController.php +++ b/src/applications/config/controller/PhabricatorConfigGroupController.php @@ -30,7 +30,7 @@ final class PhabricatorConfigGroupController $view = $this->buildConfigBoxView($box_header, $list); $crumbs = $this->buildApplicationCrumbs() - ->addTextCrumb($group_name, $this->getApplicationURI($group_uri)) + ->addTextCrumb($group_name, $group_uri) ->addTextCrumb($options->getName()) ->setBorder(true); From cbc71e75fae3e527bc7cd18c735bc62922322787 Mon Sep 17 00:00:00 2001 From: epriestley Date: Fri, 22 Jun 2018 05:36:21 -0700 Subject: [PATCH 07/10] When queueing search index tasks, include the "objectPHID" in the task metadata Summary: Ref T13151. See PHI719. One minor hiccup in debugging the issue (which ended up being "revision has 100K comments") was that the `SearchWorker` did not show which object it was indexing. Add `'objectPHID'` to the queue call so you can see which object is affected from the web UI. Test Plan: - Stopped daemons. - Used `bin/search index D123 --background` to queue a search task. - Viewed task details in web UI from `/daemon/`. - Before change: no indication of which object was being indexed. - After change: page helpfully shows that the task is indexing D123. Reviewers: amckinley Reviewed By: amckinley Maniphest Tasks: T13151 Differential Revision: https://secure.phabricator.com/D19502 --- src/applications/search/worker/PhabricatorSearchWorker.php | 1 + 1 file changed, 1 insertion(+) diff --git a/src/applications/search/worker/PhabricatorSearchWorker.php b/src/applications/search/worker/PhabricatorSearchWorker.php index 607baed69a..6cebb64da4 100644 --- a/src/applications/search/worker/PhabricatorSearchWorker.php +++ b/src/applications/search/worker/PhabricatorSearchWorker.php @@ -15,6 +15,7 @@ final class PhabricatorSearchWorker extends PhabricatorWorker { ), array( 'priority' => parent::PRIORITY_IMPORT, + 'objectPHID' => $phid, )); } From 14e911a0d8c06956b869a6a6c2afa6cfaadf9edd Mon Sep 17 00:00:00 2001 From: epriestley Date: Fri, 22 Jun 2018 07:21:24 -0700 Subject: [PATCH 08/10] Index only the first 1,000 comments on any object Summary: Depends on D19502. Ref T13151. See PHI719. An install ended up with an object with 111,000+ comments on it because someone wrote a script to treat it like a logfile. Although we seem to do mostly okay with this (locally, it only takes about 30s to index a similar object) we'll hit a wall somewhere (since we need to hold everything in memory), and it's hard to imagine a legitimate object with more than 1,000 comments. Just ignore comments past the first thousand. (Conpherence threads may legitimately have more than 1,000 comments, but go through a different indexer.) Test Plan: - Piped some comments into `maniphest.edit` in a loop to create a task with 100K comments. - Ran `bin/search index Txxx --force` to reindex it, with `--trace`. - Before: task indexed in about 30s. - After: script loaded comments with LIMIT 1000 and indexed in a couple seconds. Reviewers: amckinley Reviewed By: amckinley Maniphest Tasks: T13151 Differential Revision: https://secure.phabricator.com/D19503 --- ...torTransactionsFulltextEngineExtension.php | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/src/applications/transactions/engineextension/PhabricatorTransactionsFulltextEngineExtension.php b/src/applications/transactions/engineextension/PhabricatorTransactionsFulltextEngineExtension.php index c9f43f49b2..4eeda3251c 100644 --- a/src/applications/transactions/engineextension/PhabricatorTransactionsFulltextEngineExtension.php +++ b/src/applications/transactions/engineextension/PhabricatorTransactionsFulltextEngineExtension.php @@ -22,12 +22,28 @@ final class PhabricatorTransactionsFulltextEngineExtension return; } - $xactions = $query + $query ->setViewer($this->getViewer()) ->withObjectPHIDs(array($object->getPHID())) ->withComments(true) - ->needComments(true) - ->execute(); + ->needComments(true); + + // See PHI719. Users occasionally create objects with huge numbers of + // comments, which can be slow to index. We handle this with reasonable + // grace: at time of writing, we can index a task with 100K comments in + // about 30 seconds. However, we do need to hold all the comments in + // memory in the AbstractDocument, so there's some practical limit to what + // we can realistically index. + + // Since objects with more than 1,000 comments are not likely to be + // legitimate objects with actual discussion, index only the first + // thousand comments. + + $query + ->setOrderVector(array('-id')) + ->setLimit(1000); + + $xactions = $query->execute(); foreach ($xactions as $xaction) { if (!$xaction->hasComment()) { From d84f866ca06127a9e322383f4efdfe4f82ab15cd Mon Sep 17 00:00:00 2001 From: epriestley Date: Fri, 22 Jun 2018 10:01:44 -0700 Subject: [PATCH 09/10] When search indexers contend for a lock, just yield Summary: Depends on D19503. Ref T13151. See PHI719. If you have something like a script which updates an object in a loop, we can end up queueing many search reindex tasks. These tasks may reasonably contend for the lock, especially if the object is larger (lots of text and/or lots of comments) and indexing takes a few seconds. This isn't concerning, and the indexers should converge to good behavior quickly once the updates stop. Today, they'll spew a bunch of serious-looking lock exceptions into the log. Instead, just yield so it's more clear that there's (normally) no cause for concern here. Test Plan: Ran `bin/search index Txxx --force` on a large object in multiple windows with a 0 second lock, saw an explicit yield instead of a lock exception. Reviewers: amckinley Reviewed By: amckinley Maniphest Tasks: T13151 Differential Revision: https://secure.phabricator.com/D19504 --- .../search/worker/PhabricatorSearchWorker.php | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/applications/search/worker/PhabricatorSearchWorker.php b/src/applications/search/worker/PhabricatorSearchWorker.php index 6cebb64da4..f93df63981 100644 --- a/src/applications/search/worker/PhabricatorSearchWorker.php +++ b/src/applications/search/worker/PhabricatorSearchWorker.php @@ -38,7 +38,15 @@ final class PhabricatorSearchWorker extends PhabricatorWorker { $key = "index.{$object_phid}"; $lock = PhabricatorGlobalLock::newLock($key); - $lock->lock(1); + try { + $lock->lock(1); + } catch (PhutilLockException $ex) { + // If we fail to acquire the lock, just yield. It's expected that we may + // contend on this lock occasionally if a large object receives many + // updates in a short period of time, and it's appropriate to just retry + // rebuilding the index later. + throw new PhabricatorWorkerYieldException(15); + } try { // Reload the object now that we have a lock, to make sure we have the From cac3dc4983c3671ba4ec841aac8efac10744a80c Mon Sep 17 00:00:00 2001 From: epriestley Date: Fri, 22 Jun 2018 10:36:37 -0700 Subject: [PATCH 10/10] Give "create" transactions a readable type in "transaction.search" Summary: Ref T13151. See PHI725. By default, "transaction.search" doesn't provide details about transactions because many have bad/weird/policy-violating internal types or fields. The "create" transaction is simple and straightforward, so label it to allow callers to distinguish it. Test Plan: - Created a new task. - Called `transaction.search` on it. - Saw the labelled "create" transaction. Reviewers: amckinley Reviewed By: amckinley Subscribers: swisspol Maniphest Tasks: T13151 Differential Revision: https://secure.phabricator.com/D19505 --- .../transactions/conduit/TransactionSearchConduitAPIMethod.php | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php b/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php index 66285547b3..17f53cfeee 100644 --- a/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php +++ b/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php @@ -205,6 +205,9 @@ final class TransactionSearchConduitAPIMethod case PhabricatorTransactions::TYPE_COMMENT: $type = 'comment'; break; + case PhabricatorTransactions::TYPE_CREATE: + $type = 'create'; + break; } }