KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use repositoryStillExists method in argos

Best JavaScript code snippet using argos

synchronizer.js

Source:synchronizer.js

1/* eslint-disable no-await-in-loop */2import {3  getOAuthOctokit,4  getTokenOctokit,5  getInstallationOctokit,6} from "@argos-ci/github";7import {8  Installation,9  Organization,10  Repository,11  User,12  UserOrganizationRight,13  UserRepositoryRight,14  UserInstallationRight,15  InstallationRepositoryRight,16} from "@argos-ci/database/models";17import config from "@argos-ci/config";18export async function getOrCreateInstallation(payload) {19  const installation = await Installation.query()20    .where({ githubId: payload.githubId })21    .first();22  if (installation) return installation;23  return Installation.query().insertAndFetch(payload);24}25async function checkAccessTokenValidity(accessToken) {26  const oauthOctokit = getOAuthOctokit();27  try {28    await oauthOctokit.apps.checkToken({29      access_token: accessToken,30      client_id: config.get("github.clientId"),31    });32  } catch (error) {33    if (error.status === 404) {34      return false;35    }36    throw error;37  }38  return true;39}40const OWNER_ORGANIZATION = "Organization";41const OWNER_USER = "User";42export class GitHubSynchronizer {43  constructor(synchronization) {44    this.synchronization = synchronization;45    this.repositories = [];46    this.organizationIds = [];47  }48  async synchronizeAppRepositories(installationId) {49    const options =50      this.octokit.apps.listReposAccessibleToInstallation.endpoint.DEFAULTS;51    const githubRepositories = await this.octokit.paginate(options);52    const { repositories, organizations } = await this.synchronizeRepositories(53      githubRepositories54    );55    await this.synchronizeInstallationRepositoryRights(56      repositories,57      installationId58    );59    return { repositories, organizations };60  }61  async getInstallationRepositories(options) {62    try {63      return await this.octokit.paginate(options);64    } catch (error) {65      if (error.response.status === 404) return [];66      throw error;67    }68  }69  async synchronizeUserInstallationRepositories(installation) {70    const options =71      this.octokit.apps.listInstallationReposForAuthenticatedUser.endpoint.merge(72        { installation_id: installation.githubId }73      );74    const githubRepositories = await this.getInstallationRepositories(options);75    const { repositories, organizations } = await this.synchronizeRepositories(76      githubRepositories77    );78    await this.synchronizeInstallationRepositoryRights(79      repositories,80      installation.id81    );82    return { repositories, organizations };83  }84  async synchronizeRepositories(githubRepositories) {85    const [86      {87        owners: organizations,88        ownerIdByRepositoryId: organizationIdByRepositoryId,89      },90      { ownerIdByRepositoryId: userIdByRepositoryId },91    ] = await Promise.all([92      this.synchronizeOwners(githubRepositories, OWNER_ORGANIZATION),93      this.synchronizeOwners(githubRepositories, OWNER_USER),94    ]);95    const repositories = await Promise.all(96      githubRepositories.map(async (githubRepository) => {97        const data = {98          githubId: githubRepository.id,99          name: githubRepository.name,100          organizationId:101            organizationIdByRepositoryId[githubRepository.id] || null,102          userId: userIdByRepositoryId[githubRepository.id] || null,103          private: githubRepository.private,104          defaultBranch: githubRepository.default_branch,105        };106        let [repository] = await Repository.query().where({107          githubId: githubRepository.id,108        });109        if (repository) {110          return repository.$query().patchAndFetch(data);111        }112        return Repository.query().insertAndFetch({ ...data, enabled: false });113      })114    );115    return { repositories, organizations };116  }117  async synchronizeOwners(githubRepositories, type) {118    const githubOwners = githubRepositories.reduce(119      (githubOwners, githubRepository) => {120        if (githubRepository.owner.type !== type) {121          return githubOwners;122        }123        let githubOwner = githubOwners.find(124          ({ id }) => id === githubRepository.owner.id125        );126        if (!githubOwner) {127          githubOwner = githubRepository.owner;128          githubOwners.push(githubRepository.owner);129        }130        return githubOwners;131      },132      []133    );134    let owners;135    switch (type) {136      case OWNER_ORGANIZATION:137        owners = await Promise.all(138          githubOwners.map((githubOwner) =>139            this.synchronizeOrganization(githubOwner)140          )141        );142        break;143      case OWNER_USER:144        owners = await Promise.all(145          githubOwners.map((githubOwner) => this.synchronizeUser(githubOwner))146        );147        break;148      default:149        throw new Error(`Unsupported type ${type}`);150    }151    return {152      owners,153      ownerIdByRepositoryId: githubRepositories.reduce(154        (ownerIdByRepositoryId, githubRepository) => {155          if (githubRepository.owner.type === type) {156            ownerIdByRepositoryId[githubRepository.id] = owners.find(157              (owner) => owner.githubId === githubRepository.owner.id158            ).id;159          }160          return ownerIdByRepositoryId;161        },162        {}163      ),164    };165  }166  // eslint-disable-next-line class-methods-use-this167  async synchronizeOrganization(githubOrganization) {168    const organizationData = await this.octokit.orgs.get({169      org: githubOrganization.login,170    });171    githubOrganization = organizationData.data;172    let [organization] = await Organization.query().where({173      githubId: githubOrganization.id,174    });175    const data = {176      githubId: githubOrganization.id,177      name: githubOrganization.name,178      login: githubOrganization.login,179    };180    if (organization) {181      await organization.$query().patchAndFetch(data);182    } else {183      organization = await Organization.query().insert(data);184    }185    return organization;186  }187  // eslint-disable-next-line class-methods-use-this188  async synchronizeUser(githubUser) {189    const data = { githubId: githubUser.id, login: githubUser.login };190    let user = await User.query().where({ githubId: githubUser.id }).first();191    if (user) {192      await user.$query().patchAndFetch(data);193    } else {194      user = await User.query().insert(data);195    }196    return user;197  }198  async synchronizeInstallationRepositoryRights(repositories, installationId) {199    const installationRepositoryRights =200      await InstallationRepositoryRight.query().where({201        installationId,202      });203    await Promise.all(204      repositories.map(async (repository) => {205        const hasRights = installationRepositoryRights.some(206          ({ repositoryId }) => repositoryId === repository.id207        );208        if (!hasRights) {209          await InstallationRepositoryRight.query().insert({210            installationId,211            repositoryId: repository.id,212          });213        }214      })215    );216    await Promise.all(217      installationRepositoryRights.map(async (installationRepositoryRight) => {218        const repositoryStillExists = repositories.find(219          ({ id }) => id === installationRepositoryRight.repositoryId220        );221        if (!repositoryStillExists) {222          await installationRepositoryRight.$query().delete();223        }224      })225    );226  }227  async synchronizeRepositoryRights(repositories, userId) {228    const userRepositoryRights = await UserRepositoryRight.query().where({229      userId,230    });231    await Promise.all(232      repositories.map(async (repository) => {233        const hasRights = userRepositoryRights.some(234          ({ repositoryId }) => repositoryId === repository.id235        );236        if (!hasRights) {237          await UserRepositoryRight.query().insert({238            userId,239            repositoryId: repository.id,240          });241        }242      })243    );244    await Promise.all(245      userRepositoryRights.map(async (userRepositoryRight) => {246        const repositoryStillExists = repositories.find(247          ({ id }) => id === userRepositoryRight.repositoryId248        );249        if (!repositoryStillExists) {250          await userRepositoryRight.$query().delete();251        }252      })253    );254  }255  async synchronizeOrganizationRights(organizations, userId) {256    const userOrganizationRights = await UserOrganizationRight.query().where({257      userId,258    });259    await Promise.all(260      organizations.map(async (organization) => {261        const hasRights = userOrganizationRights.some(262          ({ organizationId }) => organizationId === organization.id263        );264        if (!hasRights) {265          await UserOrganizationRight.query().insert({266            userId,267            organizationId: organization.id,268          });269        }270      })271    );272    await Promise.all(273      userOrganizationRights.map(async (userOrganizationRight) => {274        const organizationStillExists = organizations.find(275          ({ id }) => id === userOrganizationRight.organizationId276        );277        if (!organizationStillExists) {278          await userOrganizationRight.$query().delete();279        }280      })281    );282  }283  async synchronizeUserInstallations() {284    const options =285      this.octokit.apps.listInstallationsForAuthenticatedUser.endpoint.DEFAULTS;286    const githubInstallations = await this.octokit.paginate(options);287    return Promise.all(288      githubInstallations.map(async (githubInstallation) => {289        return getOrCreateInstallation({290          githubId: githubInstallation.id,291          deleted: false,292        });293      })294    );295  }296  async synchronizeUserInstallationRights(installations, userId) {297    const userInstallationRights = await UserInstallationRight.query().where({298      userId,299    });300    await Promise.all(301      installations.map(async (installation) => {302        const exists = userInstallationRights.some(303          ({ installationId }) => installationId === installation.id304        );305        if (!exists) {306          await UserInstallationRight.query().insertAndFetch({307            userId,308            installationId: installation.id,309          });310        }311      })312    );313    await Promise.all(314      userInstallationRights.map(async (userInstallationRight) => {315        const installationStillExists = installations.find(316          ({ id }) => id === userInstallationRight.installationId317        );318        if (!installationStillExists) {319          await userInstallationRight.$query().delete();320        }321      })322    );323    return installations;324  }325  async synchronize() {326    this.synchronization = await this.synchronization.$query();327    switch (this.synchronization.type) {328      case "installation":329        return this.synchronizeFromInstallation(330          this.synchronization.installationId331        );332      case "user":333        return this.synchronizeFromUser(this.synchronization.userId);334      default:335        throw new Error(336          `Unknown synchronization type "${this.synchronization.type}"`337        );338    }339  }340  async synchronizeFromInstallation(installationId) {341    const installation = await Installation.query()342      .findById(installationId)343      .withGraphFetched("users");344    if (installation.deleted) {345      await Promise.all(346        installation.users.map(async (user) =>347          this.synchronizeFromUser(user.id)348        )349      );350      await this.synchronizeInstallationRepositoryRights([], installationId);351      return;352    }353    const octokit = await getInstallationOctokit(installation.githubId);354    // If we don't get an octokit, then the installation has been removed355    // we deleted the installation356    if (!octokit) {357      await installation.$query().patch({ deleted: true });358      return;359    }360    this.octokit = octokit;361    await this.synchronizeAppRepositories(installationId);362    await Promise.all(363      installation.users.map(async (user) => this.synchronizeFromUser(user.id))364    );365  }366  async synchronizeFromUser(userId) {367    const user = await User.query().findById(userId);368    const tokenValid = await checkAccessTokenValidity(user.accessToken);369    if (!tokenValid) {370      await this.synchronizeUserInstallationRights([], userId);371      await Promise.all([372        this.synchronizeRepositoryRights([], userId),373        this.synchronizeOrganizationRights([], userId),374      ]);375      return;376    }377    this.octokit = getTokenOctokit(user.accessToken);378    const installations = await this.synchronizeUserInstallations(userId);379    await this.synchronizeUserInstallationRights(installations, userId);380    const results = await Promise.all(381      installations.map((installation) =>382        this.synchronizeUserInstallationRepositories(installation)383      )384    );385    const { repositories, organizations } = results.reduce(386      (all, result) => {387        all.repositories = [...all.repositories, ...result.repositories];388        all.organizations = [...all.organizations, ...result.organizations];389        return all;390      },391      { repositories: [], organizations: [] }392    );393    await Promise.all([394      this.synchronizeRepositoryRights(repositories, userId),395      this.synchronizeOrganizationRights(organizations, userId),396    ]);397  }...

github.js

Source:github.js

1/* eslint-disable no-await-in-loop */2import {3  getAuthorizationOctokit,4  getUserOctokit,5  getInstallationOctokit,6} from 'modules/github/client'7import {8  Installation,9  Organization,10  Repository,11  User,12  UserOrganizationRight,13  UserRepositoryRight,14  UserInstallationRight,15  InstallationRepositoryRight,16} from 'models'17import config from 'config'18export async function getOrCreateInstallation(payload) {19  const installation = await Installation.query()20    .where({ githubId: payload.githubId })21    .first()22  if (installation) return installation23  return Installation.query().insertAndFetch(payload)24}25async function checkAccessTokenValidity(accessToken) {26  try {27    await getAuthorizationOctokit().oauthAuthorizations.checkAuthorization({28      access_token: accessToken,29      client_id: config.get('github.clientId'),30    })31  } catch (error) {32    if (error.status === 404) {33      return false34    }35    throw error36  }37  return true38}39const OWNER_ORGANIZATION = 'Organization'40const OWNER_USER = 'User'41export class GitHubSynchronizer {42  constructor(synchronization) {43    this.synchronization = synchronization44    this.repositories = []45    this.organizationIds = []46  }47  async synchronizeAppRepositories(installationId) {48    const options = this.octokit.apps.listRepos.endpoint.DEFAULTS49    const githubRepositories = await this.octokit.paginate(options)50    const { repositories, organizations } = await this.synchronizeRepositories(51      githubRepositories,52    )53    await this.synchronizeInstallationRepositoryRights(54      repositories,55      installationId,56    )57    return { repositories, organizations }58  }59  async synchronizeUserInstallationRepositories(installation) {60    const options = this.octokit.apps.listInstallationReposForAuthenticatedUser.endpoint.merge(61      { installation_id: installation.githubId },62    )63    const githubRepositories = await this.octokit.paginate(options)64    const { repositories, organizations } = await this.synchronizeRepositories(65      githubRepositories,66    )67    await this.synchronizeInstallationRepositoryRights(68      repositories,69      installation.id,70    )71    return { repositories, organizations }72  }73  async synchronizeRepositories(githubRepositories) {74    const [75      {76        owners: organizations,77        ownerIdByRepositoryId: organizationIdByRepositoryId,78      },79      { ownerIdByRepositoryId: userIdByRepositoryId },80    ] = await Promise.all([81      this.synchronizeOwners(githubRepositories, OWNER_ORGANIZATION),82      this.synchronizeOwners(githubRepositories, OWNER_USER),83    ])84    const repositories = await Promise.all(85      githubRepositories.map(async githubRepository => {86        const data = {87          githubId: githubRepository.id,88          name: githubRepository.name,89          organizationId: organizationIdByRepositoryId[githubRepository.id],90          userId: userIdByRepositoryId[githubRepository.id],91          private: githubRepository.private,92        }93        let [repository] = await Repository.query().where({94          githubId: githubRepository.id,95        })96        if (githubRepository.archived) {97          data.archived = true98        }99        if (repository) {100          await repository.$query().patchAndFetch(data)101        } else {102          repository = await Repository.query().insert({103            ...data,104            baselineBranch: githubRepository.default_branch,105            config: {106              files: [{ test: '*.js', maxSize: '10 mB' }],107            },108          })109        }110        return repository111      }),112    )113    return { repositories, organizations }114  }115  async synchronizeOwners(githubRepositories, type) {116    const githubOwners = githubRepositories.reduce(117      (githubOwners, githubRepository) => {118        if (githubRepository.owner.type !== type) {119          return githubOwners120        }121        let githubOwner = githubOwners.find(122          ({ id }) => id === githubRepository.owner.id,123        )124        if (!githubOwner) {125          githubOwner = githubRepository.owner126          githubOwners.push(githubRepository.owner)127        }128        return githubOwners129      },130      [],131    )132    let owners133    switch (type) {134      case OWNER_ORGANIZATION:135        owners = await Promise.all(136          githubOwners.map(githubOwner =>137            this.synchronizeOrganization(githubOwner),138          ),139        )140        break141      case OWNER_USER:142        owners = await Promise.all(143          githubOwners.map(githubOwner => this.synchronizeUser(githubOwner)),144        )145        break146      default:147        throw new Error(`Unsupported type ${type}`)148    }149    return {150      owners,151      ownerIdByRepositoryId: githubRepositories.reduce(152        (ownerIdByRepositoryId, githubRepository) => {153          if (githubRepository.owner.type === type) {154            ownerIdByRepositoryId[githubRepository.id] = owners.find(155              owner => owner.githubId === githubRepository.owner.id,156            ).id157          }158          return ownerIdByRepositoryId159        },160        {},161      ),162    }163  }164  // eslint-disable-next-line class-methods-use-this165  async synchronizeOrganization(githubOrganization) {166    const organizationData = await this.octokit.orgs.get({167      org: githubOrganization.login,168    })169    githubOrganization = organizationData.data170    let [organization] = await Organization.query().where({171      githubId: githubOrganization.id,172    })173    const data = {174      githubId: githubOrganization.id,175      name: githubOrganization.name,176      login: githubOrganization.login,177    }178    if (organization) {179      await organization.$query().patchAndFetch(data)180    } else {181      organization = await Organization.query().insert(data)182    }183    return organization184  }185  // eslint-disable-next-line class-methods-use-this186  async synchronizeUser(githubUser) {187    const data = { githubId: githubUser.id, login: githubUser.login }188    let user = await User.query()189      .where({ githubId: githubUser.id })190      .first()191    if (user) {192      await user.$query().patchAndFetch(data)193    } else {194      user = await User.query().insert(data)195    }196    return user197  }198  async synchronizeInstallationRepositoryRights(repositories, installationId) {199    const installationRepositoryRights = await InstallationRepositoryRight.query().where(200      {201        installationId,202      },203    )204    await Promise.all(205      repositories.map(async repository => {206        const hasRights = installationRepositoryRights.some(207          ({ repositoryId }) => repositoryId === repository.id,208        )209        if (!hasRights) {210          await InstallationRepositoryRight.query().insert({211            installationId,212            repositoryId: repository.id,213          })214        }215      }),216    )217    await Promise.all(218      installationRepositoryRights.map(async installationRepositoryRight => {219        const repositoryStillExists = repositories.find(220          ({ id }) => id === installationRepositoryRight.repositoryId,221        )222        if (!repositoryStillExists) {223          await installationRepositoryRight.$query().delete()224        }225      }),226    )227  }228  async synchronizeRepositoryRights(repositories, userId) {229    const userRepositoryRights = await UserRepositoryRight.query().where({230      userId,231    })232    await Promise.all(233      repositories.map(async repository => {234        const hasRights = userRepositoryRights.some(235          ({ repositoryId }) => repositoryId === repository.id,236        )237        if (!hasRights) {238          await UserRepositoryRight.query().insert({239            userId,240            repositoryId: repository.id,241          })242        }243      }),244    )245    await Promise.all(246      userRepositoryRights.map(async userRepositoryRight => {247        const repositoryStillExists = repositories.find(248          ({ id }) => id === userRepositoryRight.repositoryId,249        )250        if (!repositoryStillExists) {251          await userRepositoryRight.$query().delete()252        }253      }),254    )255  }256  async synchronizeOrganizationRights(organizations, userId) {257    const userOrganizationRights = await UserOrganizationRight.query().where({258      userId,259    })260    await Promise.all(261      organizations.map(async organization => {262        const hasRights = userOrganizationRights.some(263          ({ organizationId }) => organizationId === organization.id,264        )265        if (!hasRights) {266          await UserOrganizationRight.query().insert({267            userId,268            organizationId: organization.id,269          })270        }271      }),272    )273    await Promise.all(274      userOrganizationRights.map(async userOrganizationRight => {275        const organizationStillExists = organizations.find(276          ({ id }) => id === userOrganizationRight.organizationId,277        )278        if (!organizationStillExists) {279          await userOrganizationRight.$query().delete()280        }281      }),282    )283  }284  async synchronizeUserInstallations() {285    const options = this.octokit.apps.listInstallationsForAuthenticatedUser286      .endpoint.DEFAULTS287    const githubInstallations = await this.octokit.paginate(options)288    return Promise.all(289      githubInstallations.map(async githubInstallation => {290        return getOrCreateInstallation({291          githubId: githubInstallation.id,292          deleted: false,293        })294      }),295    )296  }297  async synchronizeUserInstallationRights(installations, userId) {298    const userInstallationRights = await UserInstallationRight.query().where({299      userId,300    })301    await Promise.all(302      installations.map(async installation => {303        const exists = userInstallationRights.some(304          ({ installationId }) => installationId === installation.id,305        )306        if (!exists) {307          await UserInstallationRight.query().insertAndFetch({308            userId,309            installationId: installation.id,310          })311        }312      }),313    )314    await Promise.all(315      userInstallationRights.map(async userInstallationRight => {316        const installationStillExists = installations.find(317          ({ id }) => id === userInstallationRight.installationId,318        )319        if (!installationStillExists) {320          await userInstallationRight.$query().delete()321        }322      }),323    )324    return installations325  }326  async synchronize() {327    this.synchronization = await this.synchronization.$query()328    switch (this.synchronization.type) {329      case 'installation':330        return this.synchronizeFromInstallation(331          this.synchronization.installationId,332        )333      case 'user':334        return this.synchronizeFromUser(this.synchronization.userId)335      default:336        throw new Error(337          `Unknown synchronization type "${this.synchronization.type}"`,338        )339    }340  }341  async synchronizeFromInstallation(installationId) {342    const installation = await Installation.query()343      .findById(installationId)344      .eager('users')345    if (installation.deleted) {346      await Promise.all(347        installation.users.map(async user => this.synchronizeFromUser(user.id)),348      )349      await this.synchronizeInstallationRepositoryRights([], installationId)350      return351    }352    this.octokit = getInstallationOctokit(installation)353    await this.synchronizeAppRepositories(installationId)354    await Promise.all(355      installation.users.map(async user => this.synchronizeFromUser(user.id)),356    )357  }358  async synchronizeFromUser(userId) {359    const user = await User.query().findById(userId)360    const tokenValid = await checkAccessTokenValidity(user.accessToken)361    if (!tokenValid) {362      await this.synchronizeUserInstallationRights([], userId)363      await Promise.all([364        this.synchronizeRepositoryRights([], userId),365        this.synchronizeOrganizationRights([], userId),366      ])367      return368    }369    this.octokit = getUserOctokit(user)370    const installations = await this.synchronizeUserInstallations(userId)371    await this.synchronizeUserInstallationRights(installations, userId)372    const results = await Promise.all(373      installations.map(installation =>374        this.synchronizeUserInstallationRepositories(installation),375      ),376    )377    const { repositories, organizations } = results.reduce(378      (all, result) => {379        all.repositories = [...all.repositories, ...result.repositories]380        all.organizations = [...all.organizations, ...result.organizations]381        return all382      },383      { repositories: [], organizations: [] },384    )385    await Promise.all([386      this.synchronizeRepositoryRights(repositories, userId),387      this.synchronizeOrganizationRights(organizations, userId),388    ])389  }...

GitHubSynchronizer.js

Source:GitHubSynchronizer.js

1import GitHubAPI from 'github'2import config from 'config'3import Organization from 'server/models/Organization'4import Repository from 'server/models/Repository'5import User from 'server/models/User'6import UserOrganizationRight from 'server/models/UserOrganizationRight'7import UserRepositoryRight from 'server/models/UserRepositoryRight'8const OWNER_ORGANIZATION = 'Organization'9const OWNER_USER = 'User'10class GitHubSynchronizer {11  constructor(synchronization) {12    this.synchronization = synchronization13    this.github = new GitHubAPI({ debug: config.get('env') === 'development' })14    this.repositories = []15    this.organizationIds = []16  }17  async synchronizeRepositories({ page = 1 } = {}) {18    const githubRepositories = await this.github.repos.getAll({ page, per_page: 100 })19    const [20      { owners: organizations, ownerIdByRepositoryId: organizationIdByRepositoryId },21      { ownerIdByRepositoryId: userIdByRepositoryId },22    ] = await Promise.all([23      this.synchronizeOwners(githubRepositories, OWNER_ORGANIZATION),24      this.synchronizeOwners(githubRepositories, OWNER_USER),25    ])26    const repositories = await Promise.all(27      githubRepositories.data.map(async githubRepository => {28        const data = {29          githubId: githubRepository.id,30          name: githubRepository.name,31          organizationId: organizationIdByRepositoryId[githubRepository.id],32          userId: userIdByRepositoryId[githubRepository.id],33          private: githubRepository.private,34        }35        let [repository] = await Repository.query().where({ githubId: githubRepository.id })36        if (repository) {37          await repository.$query().patchAndFetch(data)38        } else {39          repository = await Repository.query().insert({40            ...data,41            baselineBranch: 'master',42            enabled: false,43          })44        }45        return repository46      })47    )48    if (this.github.hasNextPage(githubRepositories)) {49      const nextPageData = await this.synchronizeRepositories({ page: page + 1 })50      nextPageData.repositories.forEach(repository => {51        if (!repositories.find(({ id }) => id === repository.id)) {52          repositories.push(repository)53        }54      })55      nextPageData.organizations.forEach(organization => {56        if (!organizations.find(({ id }) => id === organization.id)) {57          organizations.push(organization)58        }59      })60    }61    return { repositories, organizations }62  }63  async synchronizeOwners(githubRepositories, type) {64    const githubOwners = githubRepositories.data.reduce((githubOwners, githubRepository) => {65      if (githubRepository.owner.type !== type) {66        return githubOwners67      }68      let githubOwner = githubOwners.find(({ id }) => id === githubRepository.owner.id)69      if (!githubOwner) {70        githubOwner = githubRepository.owner71        githubOwners.push(githubRepository.owner)72      }73      return githubOwners74    }, [])75    let owners76    switch (type) {77      case OWNER_ORGANIZATION:78        owners = await Promise.all(79          githubOwners.map(githubOwner => this.synchronizeOrganization(githubOwner))80        )81        break82      case OWNER_USER:83        owners = await Promise.all(84          githubOwners.map(githubOwner => this.synchronizeUser(githubOwner))85        )86        break87      default:88        throw new Error(`Unsupported type ${type}`)89    }90    return {91      owners,92      ownerIdByRepositoryId: githubRepositories.data.reduce(93        (ownerIdByRepositoryId, githubRepository) => {94          if (githubRepository.owner.type === type) {95            ownerIdByRepositoryId[githubRepository.id] = owners.find(96              owner => owner.githubId === githubRepository.owner.id97            ).id98          }99          return ownerIdByRepositoryId100        },101        {}102      ),103    }104  }105  // eslint-disable-next-line class-methods-use-this106  async synchronizeOrganization(githubOrganization) {107    const organizationData = await this.github.orgs.get({ org: githubOrganization.login })108    githubOrganization = organizationData.data109    let [organization] = await Organization.query().where({ githubId: githubOrganization.id })110    const data = {111      githubId: githubOrganization.id,112      name: githubOrganization.name,113      login: githubOrganization.login,114    }115    if (organization) {116      await organization.$query().patchAndFetch(data)117    } else {118      organization = await Organization.query().insert(data)119    }120    return organization121  }122  // eslint-disable-next-line class-methods-use-this123  async synchronizeUser(githubUser) {124    const data = { githubId: githubUser.id, login: githubUser.login }125    let user = await User.query()126      .where({ githubId: githubUser.id })127      .limit(1)128      .first()129    if (user) {130      await user.$query().patchAndFetch(data)131    } else {132      user = await User.query().insert(data)133    }134    return user135  }136  async synchronizeRepositoryRights(repositories) {137    const userRepositoryRights = await UserRepositoryRight.query().where({138      userId: this.synchronization.user.id,139    })140    await Promise.all(141      repositories.map(async repository => {142        const hasRights = userRepositoryRights.some(143          ({ repositoryId }) => repositoryId === repository.id144        )145        if (!hasRights) {146          await UserRepositoryRight.query().insert({147            userId: this.synchronization.user.id,148            repositoryId: repository.id,149          })150        }151      })152    )153    await Promise.all(154      userRepositoryRights.map(async userRepositoryRight => {155        const repositoryStillExists = repositories.find(156          ({ id }) => id === userRepositoryRight.repositoryId157        )158        if (!repositoryStillExists) {159          await userRepositoryRight.$query().delete()160        }161      })162    )163  }164  async synchronizeOrganizationRights(organizations) {165    const userOrganizationRights = await UserOrganizationRight.query().where({166      userId: this.synchronization.user.id,167    })168    await Promise.all(169      organizations.map(async organization => {170        const hasRights = userOrganizationRights.some(171          ({ organizationId }) => organizationId === organization.id172        )173        if (!hasRights) {174          await UserOrganizationRight.query().insert({175            userId: this.synchronization.user.id,176            organizationId: organization.id,177          })178        }179      })180    )181    await Promise.all(182      userOrganizationRights.map(async userOrganizationRight => {183        const organizationStillExists = organizations.find(184          ({ id }) => id === userOrganizationRight.organizationId185        )186        if (!organizationStillExists) {187          await userOrganizationRight.$query().delete()188        }189      })190    )191  }192  async synchronize() {193    this.synchronization = await this.synchronization.$query().eager('user')194    this.github.authenticate({195      type: 'oauth',196      token: this.synchronization.user.accessToken,197    })198    await this.synchronization.$relatedQuery('user')199    const { repositories, organizations } = await this.synchronizeRepositories()200    await this.synchronizeRepositoryRights(repositories)201    await this.synchronizeOrganizationRights(organizations)202  }203}...

Using AI Code Generation

1var repositoryStillExists = require('argos-repository').repositoryStillExists;2var repositoryStillExists = require('argos-repository').repositoryStillExists;3repositoryStillExists().then(function (exists) {4    console.log('Repository still exists: ' + exists);5});6var repositoryStillExists = require('argos-repository').repositoryStillExists;7repositoryStillExists().then(function (exists) {8    console.log('Repository still exists: ' + exists);9});10var repositoryStillExists = require('argos-repository').repositoryStillExists;11repositoryStillExists().then(function (exists) {12    console.log('Repository still exists: ' + exists);13});14var repositoryStillExists = require('argos-repository').repositoryStillExists;15repositoryStillExists().then(function (exists) {16    console.log('Repository still exists: ' + exists);17});18var repositoryStillExists = require('argos-repository').repositoryStillExists;19repositoryStillExists().then(function (exists) {20    console.log('Repository still exists: ' + exists);21});22var repositoryStillExists = require('argos-repository').repositoryStillExists;23repositoryStillExists().then(function (exists) {24    console.log('Repository still exists: ' + exists);25});26var repositoryStillExists = require('argos-repository').repositoryStillExists;27repositoryStillExists().then(function (exists) {28    console.log('Repository still exists: ' + exists);29});30var repositoryStillExists = require('argos-repository').repositoryStillExists;31repositoryStillExists().then(function (exists) {32    console.log('Repository still exists: ' + exists);33});34var repositoryStillExists = require('argos-repository').repositoryStillExists;35repositoryStillExists().then(function (exists) {36    console.log('Repository still exists: ' + exists);37});

Using AI Code Generation

1var repo = require('argos-repo');2repo.repositoryStillExists('argos-repo', 'master', function (err, exists) {3    if (err) {4        console.log(err);5    } else {6        console.log(exists);7    }8});9repo.repositoryStillExists('argos-repo', 'master', function (err, exists) {10    if (err) {11        console.log(err);12    } else {13        console.log(exists);14    }15});

Using AI Code Generation

1var repositoryStillExists = require('argos-repo').repositoryStillExists;2repositoryStillExists('argos-repo', function (err, exists) {3    if (err) {4        console.log(err);5    }6    console.log('Repository still exists: ' + exists);7});8var repositoryStillExists = require('argos-repo').repositoryStillExists;9repositoryStillExists('argos-repo', function (err, exists) {10    if (err) {11        console.log(err);12    }13    console.log('Repository still exists: ' + exists);14});15var repositoryStillExists = require('argos-repo').repositoryStillExists;16repositoryStillExists('argos-repo', function (err, exists) {17    if (err) {18        console.log(err);19    }20    console.log('Repository still exists: ' + exists);21});22var repositoryStillExists = require('argos-repo').repositoryStillExists;23repositoryStillExists('argos-repo', function (err, exists) {24    if (err) {25        console.log(err);26    }27    console.log('Repository still exists: ' + exists);28});29var repositoryStillExists = require('argos-repo').repositoryStillExists;30repositoryStillExists('argos-repo', function (err, exists) {31    if (err) {32        console.log(err);33    }34    console.log('Repository still exists: ' + exists);35});36var repositoryStillExists = require('argos-repo').repositoryStillExists;37repositoryStillExists('argos

Using AI Code Generation

1var repo = require('argos-repo');2var path = require('path');3var repoPath = path.join(__dirname, 'repo');4repo.repositoryStillExists(repoPath, function (err, exists) {5    if (err) {6        console.log(err);7    } else {8        console.log(exists);9    }10});11var repo = require('argos-repo');12var path = require('path');13var repoPath = path.join(__dirname, 'repo');14var exists = repo.repositoryStillExistsSync(repoPath);15console.log(exists);16var repo = require('argos-repo');17var path = require('path');18var repoPath = path.join(__dirname, 'repo');19repo.deleteRepository(repoPath, function (err) {20    if (err) {21        console.log(err);22    } else {23        console.log('Repository deleted successfully');24    }25});26var repo = require('argos-repo');27var path = require('path');28var repoPath = path.join(__dirname, 'repo');29repo.deleteRepositorySync(repoPath);30console.log('Repository deleted successfully');31var repo = require('argos-repo');32var path = require('path');33var repoPath = path.join(__dirname, 'repo');34repo.createRepository(repoPath, function (err) {35    if (err) {36        console.log(err);37    } else {38        console.log('Repository created successfully');39    }40});41var repo = require('argos-repo');42var path = require('path');43var repoPath = path.join(__dirname, 'repo');44repo.createRepositorySync(repoPath);45console.log('Repository created successfully');46var repo = require('argos-repo');47var path = require('path');48var repoPath = path.join(__dirname, 'repo');49repo.getRepositoryInfo(repoPath, function (err, info) {50    if (err

Using AI Code Generation

1var repositoryStillExists = require('argos-repository').repositoryStillExists;2repositoryStillExists('repositoryName', function (err, exists) {3    if (err) {4        console.log(err);5    } else {6        console.log(exists);7    }8});9var repositoryStillExists = require('argos-repository').repositoryStillExists;10repositoryStillExists('test', function (err, exists) {11    if (err) {12        console.log(err);13    } else {14        console.log(exists);15    }16});17var repositoryStillExists = require('argos-repository').repositoryStillExists;18repositoryStillExists('test', function (err, exists) {19    if (err) {20        console.log(err);21    } else {22        console.log(exists);23    }24});25var repositoryStillExists = require('argos-repository').repositoryStillExists;26repositoryStillExists('repositoryName', function (err, exists) {27    if (err) {28        console.log(err);29    } else {30        console.log(exists);31    }32});

Using AI Code Generation

1var repositoryStillExists = require('argos-repository').repositoryStillExists;2repositoryStillExists('argos-repository', 'master', function(err, exists) {3    if (err) {4        console.log(err);5    } else {6        console.log(exists);7    }8});

Using AI Code Generation

1var argosRepo = require('argos-repo');2var repo = argosRepo.getRepository('testrepo');3repo.repositoryStillExists(function (err, exists) {4    if (err) {5        console.log('error: ' + err);6    } else {7        console.log('exists: ' + exists);8    }9});10var argosRepo = require('argos-repo');11argosRepo.deleteRepository('testrepo', function (err) {12    if (err) {13        console.log('error: ' + err);14    } else {15        console.log('repository deleted');16    }17});18var argosRepo = require('argos-repo');19var repo = argosRepo.getRepository('testrepo');20console.log('repo: ' + repo);21var argosRepo = require('argos-repo');22var repo = argosRepo.getRepository('testrepo');23repo.addFile('testFile', 'test content', function (err) {24    if (err) {25        console.log('error: ' + err);26    } else {27        console.log('file added');28    }29});30var argosRepo = require('argos-repo');31var repo = argosRepo.getRepository('testrepo');32repo.addFile('testFile', 'test content', function (err) {33    if (err) {34        console.log('error: ' + err);35    } else {36        console.log('file added');37        repo.removeFile('testFile', function (err) {38            if (err) {39                console.log('error: ' + err);40            } else {41                console.log('file removed');42            }43        });44    }45});46var argosRepo = require('argos-repo');47var repo = argosRepo.getRepository('testrepo');48repo.addFile('testFile', 'test content', function (err) {49    if (err) {50        console.log('error: ' + err);51    } else {

Using AI Code Generation

1var repo = require('argos-repo');2repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {3  console.log('Repository still exists: ' + exists);4});5var repo = require('argos-repo');6repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {7  console.log('Repository still exists: ' + exists);8});9var repo = require('argos-repo');10repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {11  console.log('Repository still exists: ' + exists);12});13var repo = require('argos-repo');14repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {15  console.log('Repository still exists: ' + exists);16});17var repo = require('argos-repo');18repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {19  console.log('Repository still exists: ' + exists);20});21var repo = require('argos-repo');22repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {23  console.log('Repository still exists: ' + exists);24});25var repo = require('argos-repo');26repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {27  console.log('Repository still exists: ' + exists);28});29var repo = require('argos-repo');30repo.repositoryStillExists('argos-repo', 'master', function(err, exists) {31  console.log('Repository still exists: ' + exists);32});

Using AI Code Generation

1var repository = require('argos-repository');2var repo = new repository();3repo.repositoryStillExists('myRepo', function(err, data){4  if(err){5    console.log(err);6  }else{7    console.log(data);8  }9});

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.