@firestartr/cli 1.50.1-snapshot-26 → 1.50.1-snapshot-28

package/build/index.js

@@ -289786,12 +289786,18 @@ function fromYaml(data) {
 }
 function toYaml(data, opts = {}) {
     src_logger.debug('opts', opts);
-    const result = yaml_dist.stringify(data);
+    const result = yaml_dist.stringify(data, {
+        defaultKeyType: 'PLAIN',
+        defaultStringType: 'QUOTE_DOUBLE',
+    });
     return result;
 }
 function dumpYaml(data) {
     src_logger.debug('Dumping object data to YAML %O', data);
-    return yaml_dist.stringify(data);
+    return yaml_dist.stringify(data, {
+        defaultKeyType: 'PLAIN',
+        defaultStringType: 'QUOTE_DOUBLE',
+    });
 }
 
 // EXTERNAL MODULE: external "child_process"
@@ -295731,6 +295737,186 @@ function dist_bundle_paginateRest(octokit) {
 dist_bundle_paginateRest.VERSION = _octokit_plugin_paginate_rest_dist_bundle_VERSION;
 
 
+;// CONCATENATED MODULE: ../github/node_modules/@octokit/plugin-paginate-graphql/dist-bundle/index.js
+// pkg/dist-src/errors.js
+var generateMessage = (path, cursorValue) => `The cursor at "${path.join(
+  ","
+)}" did not change its value "${cursorValue}" after a page transition. Please make sure your that your query is set up correctly.`;
+var MissingCursorChange = class extends Error {
+  constructor(pageInfo, cursorValue) {
+    super(generateMessage(pageInfo.pathInQuery, cursorValue));
+    this.pageInfo = pageInfo;
+    this.cursorValue = cursorValue;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  name = "MissingCursorChangeError";
+};
+var MissingPageInfo = class extends Error {
+  constructor(response) {
+    super(
+      `No pageInfo property found in response. Please make sure to specify the pageInfo in your query. Response-Data: ${JSON.stringify(
+        response,
+        null,
+        2
+      )}`
+    );
+    this.response = response;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  name = "MissingPageInfo";
+};
+
+// pkg/dist-src/object-helpers.js
+var isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+function findPaginatedResourcePath(responseData) {
+  const paginatedResourcePath = deepFindPathToProperty(
+    responseData,
+    "pageInfo"
+  );
+  if (paginatedResourcePath.length === 0) {
+    throw new MissingPageInfo(responseData);
+  }
+  return paginatedResourcePath;
+}
+var deepFindPathToProperty = (object, searchProp, path = []) => {
+  for (const key of Object.keys(object)) {
+    const currentPath = [...path, key];
+    const currentValue = object[key];
+    if (isObject(currentValue)) {
+      if (currentValue.hasOwnProperty(searchProp)) {
+        return currentPath;
+      }
+      const result = deepFindPathToProperty(
+        currentValue,
+        searchProp,
+        currentPath
+      );
+      if (result.length > 0) {
+        return result;
+      }
+    }
+  }
+  return [];
+};
+var dist_bundle_get = (object, path) => {
+  return path.reduce((current, nextProperty) => current[nextProperty], object);
+};
+var set = (object, path, mutator) => {
+  const lastProperty = path[path.length - 1];
+  const parentPath = [...path].slice(0, -1);
+  const parent = dist_bundle_get(object, parentPath);
+  if (typeof mutator === "function") {
+    parent[lastProperty] = mutator(parent[lastProperty]);
+  } else {
+    parent[lastProperty] = mutator;
+  }
+};
+
+// pkg/dist-src/extract-page-info.js
+var extractPageInfos = (responseData) => {
+  const pageInfoPath = findPaginatedResourcePath(responseData);
+  return {
+    pathInQuery: pageInfoPath,
+    pageInfo: dist_bundle_get(responseData, [...pageInfoPath, "pageInfo"])
+  };
+};
+
+// pkg/dist-src/page-info.js
+var isForwardSearch = (givenPageInfo) => {
+  return givenPageInfo.hasOwnProperty("hasNextPage");
+};
+var getCursorFrom = (pageInfo) => isForwardSearch(pageInfo) ? pageInfo.endCursor : pageInfo.startCursor;
+var hasAnotherPage = (pageInfo) => isForwardSearch(pageInfo) ? pageInfo.hasNextPage : pageInfo.hasPreviousPage;
+
+// pkg/dist-src/iterator.js
+var createIterator = (octokit) => {
+  return (query, initialParameters = {}) => {
+    let nextPageExists = true;
+    let parameters = { ...initialParameters };
+    return {
+      [Symbol.asyncIterator]: () => ({
+        async next() {
+          if (!nextPageExists) return { done: true, value: {} };
+          const response = await octokit.graphql(
+            query,
+            parameters
+          );
+          const pageInfoContext = extractPageInfos(response);
+          const nextCursorValue = getCursorFrom(pageInfoContext.pageInfo);
+          nextPageExists = hasAnotherPage(pageInfoContext.pageInfo);
+          if (nextPageExists && nextCursorValue === parameters.cursor) {
+            throw new MissingCursorChange(pageInfoContext, nextCursorValue);
+          }
+          parameters = {
+            ...parameters,
+            cursor: nextCursorValue
+          };
+          return { done: false, value: response };
+        }
+      })
+    };
+  };
+};
+
+// pkg/dist-src/merge-responses.js
+var mergeResponses = (response1, response2) => {
+  if (Object.keys(response1).length === 0) {
+    return Object.assign(response1, response2);
+  }
+  const path = findPaginatedResourcePath(response1);
+  const nodesPath = [...path, "nodes"];
+  const newNodes = dist_bundle_get(response2, nodesPath);
+  if (newNodes) {
+    set(response1, nodesPath, (values) => {
+      return [...values, ...newNodes];
+    });
+  }
+  const edgesPath = [...path, "edges"];
+  const newEdges = dist_bundle_get(response2, edgesPath);
+  if (newEdges) {
+    set(response1, edgesPath, (values) => {
+      return [...values, ...newEdges];
+    });
+  }
+  const pageInfoPath = [...path, "pageInfo"];
+  set(response1, pageInfoPath, dist_bundle_get(response2, pageInfoPath));
+  return response1;
+};
+
+// pkg/dist-src/paginate.js
+var createPaginate = (octokit) => {
+  const iterator = createIterator(octokit);
+  return async (query, initialParameters = {}) => {
+    let mergedResponse = {};
+    for await (const response of iterator(
+      query,
+      initialParameters
+    )) {
+      mergedResponse = mergeResponses(mergedResponse, response);
+    }
+    return mergedResponse;
+  };
+};
+
+// pkg/dist-src/version.js
+var plugin_paginate_graphql_dist_bundle_VERSION = "0.0.0-development";
+
+// pkg/dist-src/index.js
+function paginateGraphQL(octokit) {
+  return {
+    graphql: Object.assign(octokit.graphql, {
+      paginate: Object.assign(createPaginate(octokit), {
+        iterator: createIterator(octokit)
+      })
+    })
+  };
+}
+
+
 ;// CONCATENATED MODULE: ../../node_modules/@octokit/oauth-methods/dist-bundle/index.js
 // pkg/dist-src/version.js
 var oauth_methods_dist_bundle_VERSION = "0.0.0-development";
@@ -297618,7 +297804,7 @@ async function dist_node_get(cache, options) {
     repositorySelection
   };
 }
-async function set(cache, options, data) {
+async function dist_node_set(cache, options, data) {
   const key = optionsToCacheKey(options);
   const permissionsString = options.permissions ? "" : Object.keys(data.permissions).map(
     (name) => `${name}${data.permissions[name] === "write" ? "!" : ""}`
@@ -297793,7 +297979,7 @@ async function getInstallationAuthenticationImpl(state, options, request) {
   if (singleFileName) {
     Object.assign(payload, { singleFileName });
   }
-  await set(state.cache, options, cacheOptions);
+  await dist_node_set(state.cache, options, cacheOptions);
   const cacheData = {
     installationId: options.installationId,
     token,
@@ -298057,6 +298243,7 @@ async function checkIfInstalledForOrg(org = 'default') {
 
 
 
+
 const generateGithubAppToken = async (config) => {
     try {
         const { appId, privateKey, installationOrgId } = config;
@@ -298102,7 +298289,7 @@ async function getOctokitForOrg(org, paginated = false, genGithubAppToken = gene
     });
     const options = { auth: auth };
     if (paginated) {
-        options.plugins = [dist_bundle_paginateRest];
+        options.plugins = [dist_bundle_paginateRest, paginateGraphQL];
     }
     return new dist_src_Octokit(options);
 }
@@ -298169,6 +298356,58 @@ async function getOrgInfo(org) {
     const orgInfo = await octokit.orgs.get({ org });
     return orgInfo.data;
 }
+async function getOrgTeamsDirectAccess(org) {
+    github_src_logger.info(`Getting teams for org ${org}`);
+    const octokit = await getOctokitForOrg(org);
+    const response = await octokit.graphql(`{
+    organization(login: "${org}") {
+      teams(first: 30) {
+        nodes {
+          id
+          name
+          repositories {
+            edges {
+              permission
+              node {
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }`);
+    console.dir("--- 🚀 GraphQL response:");
+    console.dir(response, { depth: null });
+    return transformGraphQLResponse(response);
+}
+;
+function transformGraphQLResponse(response) {
+    const teams = response?.organization?.teams?.nodes;
+    if (!teams)
+        return {};
+    let result = {
+        repositories: {},
+        teams: {},
+    };
+    teams.forEach((team) => {
+        const teamName = team.name;
+        const teamId = team.id;
+        result.teams[teamName] = { id: teamId };
+        const repositories = team.repositories.edges;
+        repositories.forEach((repoEdge) => {
+            const repoName = repoEdge.node.name;
+            const permission = repoEdge.permission;
+            if (!result.repositories[repoName]) {
+                result.repositories[repoName] = {};
+            }
+            result.repositories[repoName][teamName] = permission;
+        });
+    });
+    console.log("--- 🚀 Transformed GraphQL response:");
+    console.dir(result, { depth: null });
+    return result;
+}
 async function getOrgPlanName(org) {
     github_src_logger.info(`Getting plan for org ${org}`);
     const orgInfo = await getOrgInfo(org);
@@ -298187,6 +298426,7 @@ async function doPaginatedRequest(options) {
     validateMember,
     getUserRoleInOrg,
     getOrgInfo,
+    getOrgTeamsDirectAccess,
     getOrgPlanName,
 });
 
@@ -309585,10 +309825,19 @@ class GithubDecanter extends decanter_base {
     }
 }
 
+;// CONCATENATED MODULE: ../importer/src/logger.ts
+
+/* harmony default export */ const importer_src_logger = (catalog_common.logger);
+
 ;// CONCATENATED MODULE: ../importer/src/decanter/gh/github_group.ts
 
 
 
+
+
+
+
+
 class GroupGithubDecanter extends GithubDecanter {
     constructor() {
         super(...arguments);
@@ -309598,7 +309847,7 @@ class GroupGithubDecanter extends GithubDecanter {
         this.claim = {
             kind: this.claimKind,
             version: this.VERSION(),
-            name: this.data.groupDetails.name,
+            name: this.data.groupDetails.slug,
             description: this.data.groupDetails.description,
             type: 'business-unit',
         };
@@ -309622,7 +309871,9 @@ class GroupGithubDecanter extends GithubDecanter {
     __decantProviders() {
         this.__patchClaim({
             op: 'add',
-            value: { github: { name: this.data.groupDetails.name, org: this.org } },
+            value: {
+                github: { name: `${this.data.groupDetails.name}`, org: this.org },
+            },
             path: '/providers',
         });
     }
@@ -309630,13 +309881,13 @@ class GroupGithubDecanter extends GithubDecanter {
         if (this.data.groupDetails.parent) {
             this.__patchClaim({
                 op: 'add',
-                value: `group:${this.data.groupDetails.parent.name}`,
+                value: `group:${this.data.groupDetails.parent.slug}`,
                 path: '/parent',
             });
         }
     }
     async __gatherMembers() {
-        this.data['members'] = (await github_0.team.getTeamMembers(this.data.groupDetails.name, this.org)).map((member) => {
+        this.data['members'] = (await github_0.team.getTeamMembers(this.data.groupDetails.slug, this.org)).map((member) => {
             return { name: member.login, role: member.role };
         });
     }
@@ -309645,28 +309896,43 @@ class GroupGithubDecanter extends GithubDecanter {
         return this.__validateEqual(members, this.data.members);
     }
     async __adaptInitializerBase(_claim) {
-        const adapterBase = {
-            name: 'base',
-            apiVersion: 'firestartr.dev/v1',
-            kind: 'FirestartrGithubGroup',
-            defaultValues: {
-                context: {
-                    backend: {
-                        ref: {
-                            kind: 'FirestartrProviderConfig',
-                            name: 'firestartr-terraform-state',
+        let githubGroupDefaultsFilePath;
+        try {
+            githubGroupDefaultsFilePath = external_path_.join(getConfigPath(), 'resources', 'defaults_github_group.yaml');
+        }
+        catch (e) {
+            importer_src_logger.warn('No config path set, using built-in defaults');
+            githubGroupDefaultsFilePath = '';
+        }
+        let adapter;
+        if (githubGroupDefaultsFilePath &&
+            external_fs_.existsSync(githubGroupDefaultsFilePath)) {
+            adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(githubGroupDefaultsFilePath, 'utf-8'));
+        }
+        else {
+            adapter = {
+                name: 'base',
+                apiVersion: 'firestartr.dev/v1',
+                kind: 'FirestartrGithubGroup',
+                defaultValues: {
+                    context: {
+                        backend: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'firestartr-terraform-state',
+                            },
                         },
-                    },
-                    provider: {
-                        ref: {
-                            kind: 'FirestartrProviderConfig',
-                            name: 'github-app',
+                        provider: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'github-app',
+                            },
                         },
                     },
                 },
-            },
-        };
-        return new InitializerDefault(adapterBase);
+            };
+        }
+        return new InitializerDefault(adapter);
     }
     __validateKind(cr) {
         return true;
@@ -309746,9 +310012,9 @@ class GroupCollectionGithubDecanter extends GithubDecanter {
         const groups = [];
         const teamMaps = {};
         teamList.forEach((team) => {
-            teamMaps[team.name] = team;
+            teamMaps[team.slug] = team;
         });
-        const filteredGroups = await this.filter(GroupCollectionGithubDecanter.collectionKind, filters, teamList.map((team) => team.name));
+        const filteredGroups = await this.filter(GroupCollectionGithubDecanter.collectionKind, filters, teamList.map((team) => team.slug));
         for (const team of filteredGroups) {
             groups.push(new GroupGithubDecanter({ groupDetails: teamMaps[team] }, this.org));
         }
@@ -309763,6 +310029,11 @@ applyCollectionMixins(GroupCollectionGithubDecanter);
 
 
 
+
+
+
+
+
 class MemberGithubDecanter extends GithubDecanter {
     constructor() {
         super(...arguments);
@@ -309800,28 +310071,43 @@ class MemberGithubDecanter extends GithubDecanter {
         });
     }
     async __adaptInitializerBase(_claim) {
-        const adapterBase = {
-            name: 'base',
-            apiVersion: 'firestartr.dev/v1',
-            kind: 'FirestartrGithubMembership',
-            defaultValues: {
-                context: {
-                    backend: {
-                        ref: {
-                            kind: 'FirestartrProviderConfig',
-                            name: 'firestartr-terraform-state',
+        let githubMemberDefaultsFilePath;
+        try {
+            githubMemberDefaultsFilePath = external_path_.join(getConfigPath(), 'resources', 'defaults_github_membership.yaml');
+        }
+        catch (e) {
+            importer_src_logger.warn('No config path set, using built-in defaults');
+            githubMemberDefaultsFilePath = '';
+        }
+        let adapter;
+        if (githubMemberDefaultsFilePath &&
+            external_fs_.existsSync(githubMemberDefaultsFilePath)) {
+            adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(githubMemberDefaultsFilePath, 'utf-8'));
+        }
+        else {
+            adapter = {
+                name: 'base',
+                apiVersion: 'firestartr.dev/v1',
+                kind: 'FirestartrGithubMembership',
+                defaultValues: {
+                    context: {
+                        backend: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'firestartr-terraform-state',
+                            },
                         },
-                    },
-                    provider: {
-                        ref: {
-                            kind: 'FirestartrProviderConfig',
-                            name: 'github-app',
+                        provider: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'github-app',
+                            },
                         },
                     },
                 },
-            },
-        };
-        return new InitializerDefault(adapterBase);
+            };
+        }
+        return new InitializerDefault(adapter);
     }
 }
 
@@ -309854,15 +310140,21 @@ applyCollectionMixins(MemberCollectionGithubDecanter);
 
 
 
+
+
+
+
+
 const TYPE_MAP = {
     User: 'user',
     Team: 'group',
     Organization: 'org',
 };
 class RepoGithubDecanter extends GithubDecanter {
-    constructor() {
-        super(...arguments);
+    constructor(data, org, githubTeams = {}) {
+        super(data, org);
         this.claimKind = 'ComponentClaim';
+        this.githubTeams = githubTeams;
     }
     __decantStart() {
         this.claim = {
@@ -309870,7 +310162,6 @@ class RepoGithubDecanter extends GithubDecanter {
             version: this.VERSION(),
             type: 'service',
             lifecycle: 'production',
-            system: `system:${this.org}-system`,
             name: this.data.repoDetails.name,
         };
     }
@@ -309924,6 +310215,9 @@ class RepoGithubDecanter extends GithubDecanter {
         }
     }
     __decantRelations() {
+        importer_src_logger.debug("Decanting repo's relations...");
+        console.dir(this.data.teamsAndMembers, { depth: null });
+        importer_src_logger.debug("Decanting maintainers...");
         const directMaintainers = this.data.teamsAndMembers.directMembers
             .filter((member) => member.role === 'maintain')
             .map((member) => {
@@ -309949,6 +310243,7 @@ class RepoGithubDecanter extends GithubDecanter {
                 path: '/maintainedBy',
             });
         }
+        importer_src_logger.debug("Decanting admins...");
         const directAdmins = this.data.teamsAndMembers.directMembers
             .filter((member) => member.role === 'admin')
             .map((member) => {
@@ -309984,6 +310279,7 @@ class RepoGithubDecanter extends GithubDecanter {
                 path: '/providers/github/overrides',
             });
         }
+        importer_src_logger.debug("Decanting writers...");
         const directWriters = this.data.teamsAndMembers.directMembers
             .filter((member) => member.role === 'push')
             .map((member) => {
@@ -310008,6 +310304,7 @@ class RepoGithubDecanter extends GithubDecanter {
                 path: '/providers/github/overrides',
             });
         }
+        importer_src_logger.debug("Decanting readers...");
         const directReaders = this.data.teamsAndMembers.directMembers
             .filter((member) => member.role === 'pull')
             .map((member) => {
@@ -310036,13 +310333,18 @@ class RepoGithubDecanter extends GithubDecanter {
     async __gatherRepoTeamsAndMembers() {
         this.data['teamsAndMembers'] = {};
         const directMembers = (await github_0.repo.getCollaborators(this.data.repoDetails.owner.login, this.data.repoDetails.name, 'direct')).map((member) => {
-            return { name: member.login, role: member.role_name };
+            return { name: member.login, slug: member.slug, role: member.role_name };
         });
         const outsideMembers = (await github_0.repo.getCollaborators(this.data.repoDetails.owner.login, this.data.repoDetails.name, 'outside')).map((member) => {
             return { name: member.login, role: member.role_name };
         });
-        const teams = (await github_0.repo.getTeams(this.data.repoDetails.owner.login, this.data.repoDetails.name)).map((team) => {
-            return { name: team.name, role: team.permission, id: team.id };
+        console.debug("--- 🚀 Gathered repo's teams and members:");
+        console.dir(this.githubTeams, { depth: null });
+        const teams = Object.keys(this.githubTeams).map((teamName) => {
+            return {
+                name: teamName,
+                role: this.githubTeams[teamName].toLowerCase(),
+            };
         });
         this.data['teamsAndMembers']['teams'] = teams;
         this.data['teamsAndMembers']['directMembers'] = directMembers;
@@ -310108,59 +310410,74 @@ class RepoGithubDecanter extends GithubDecanter {
         return null;
     }
     async __adaptInitializerBase(_claim) {
-        const adapterBase = {
-            name: 'base',
-            apiVersion: 'firestartr.dev/v1',
-            kind: 'FirestartrGithubRepository',
-            defaultValues: {
-                context: {
-                    backend: {
-                        ref: {
-                            kind: 'FirestartrProviderConfig',
-                            name: 'firestartr-terraform-state',
+        let githubRepoDefaultsFilePath;
+        try {
+            githubRepoDefaultsFilePath = external_path_.join(getConfigPath(), 'resources', 'defaults_github_repository.yaml');
+        }
+        catch (e) {
+            importer_src_logger.warn('No config path set, using built-in defaults');
+            githubRepoDefaultsFilePath = '';
+        }
+        let adapter;
+        if (githubRepoDefaultsFilePath &&
+            external_fs_.existsSync(githubRepoDefaultsFilePath)) {
+            adapter = catalog_common.io.fromYaml(external_fs_.readFileSync(githubRepoDefaultsFilePath, 'utf-8'));
+        }
+        else {
+            adapter = {
+                name: 'base',
+                apiVersion: 'firestartr.dev/v1',
+                kind: 'FirestartrGithubRepository',
+                defaultValues: {
+                    context: {
+                        backend: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'firestartr-terraform-state',
+                            },
                         },
-                    },
-                    provider: {
-                        ref: {
-                            kind: 'FirestartrProviderConfig',
-                            name: 'github-app',
+                        provider: {
+                            ref: {
+                                kind: 'FirestartrProviderConfig',
+                                name: 'github-app',
+                            },
                         },
                     },
-                },
-                name: this.data.repoDetails.name,
-                description: this.data.repoDetails.description,
-                org: this.org,
-                firestartr: {
-                    technology: { stack: 'none', version: 'none' },
-                },
-                repo: {
+                    name: this.data.repoDetails.name,
                     description: this.data.repoDetails.description,
-                    allowMergeCommit: this.data.repoDetails.allow_merge_commit,
-                    allowSquashMerge: this.data.repoDetails.allow_squash_merge,
-                    allowRebaseMerge: this.data.repoDetails.allow_rebase_merge,
-                    allowAutoMerge: this.data.repoDetails.allow_auto_merge,
-                    deleteBranchOnMerge: this.data.repoDetails.delete_branch_on_merge,
-                    autoInit: true,
-                    archiveOnDestroy: true,
-                    allowUpdateBranch: this.data.repoDetails.allow_update_branch,
-                    hasIssues: this.data.repoDetails.has_issues,
-                    visibility: this.data.repoDetails.visibility,
-                    defaultBranch: this.data.repoDetails.default_branch,
-                },
-                permissions: [],
-                actions: {
-                    oidc: this.data.oidc.use_default
-                        ? undefined
-                        : {
-                            useDefault: this.data.oidc.use_default,
-                            includeClaimKeys: this.data.oidc.include_claim_keys
-                                ? this.data.oidc.include_claim_keys
-                                : [],
-                        },
+                    org: this.org,
+                    firestartr: {
+                        technology: { stack: 'none', version: 'none' },
+                    },
+                    repo: {
+                        description: this.data.repoDetails.description,
+                        allowMergeCommit: this.data.repoDetails.allow_merge_commit,
+                        allowSquashMerge: this.data.repoDetails.allow_squash_merge,
+                        allowRebaseMerge: this.data.repoDetails.allow_rebase_merge,
+                        allowAutoMerge: this.data.repoDetails.allow_auto_merge,
+                        deleteBranchOnMerge: this.data.repoDetails.delete_branch_on_merge,
+                        autoInit: true,
+                        archiveOnDestroy: true,
+                        allowUpdateBranch: this.data.repoDetails.allow_update_branch,
+                        hasIssues: this.data.repoDetails.has_issues,
+                        visibility: this.data.repoDetails.visibility,
+                        defaultBranch: this.data.repoDetails.default_branch,
+                    },
+                    permissions: [],
+                    actions: {
+                        oidc: this.data.oidc.use_default
+                            ? undefined
+                            : {
+                                useDefault: this.data.oidc.use_default,
+                                includeClaimKeys: this.data.oidc.include_claim_keys
+                                    ? this.data.oidc.include_claim_keys
+                                    : [],
+                            },
+                    },
                 },
-            },
-        };
-        return new InitializerDefault(adapterBase);
+            };
+        }
+        return new InitializerDefault(adapter);
     }
     async __adaptOverriderRepo(_claim) {
         return new GithubRepositoryOverrider();
@@ -310176,6 +310493,7 @@ class RepoCollectionGithubDecanter extends GithubDecanter {
         if (this.IS_SKIP_SET(filters, RepoCollectionGithubDecanter.collectionKind)) {
             return [];
         }
+        const { teams, repositories: directAccessRepos } = await this.github.org.getOrgTeamsDirectAccess(this.org);
         let repoList = await this.github.org.getRepositoryList(this.org);
         repoList = repoList.filter((el) => !el.archived);
         const repoMap = {};
@@ -310186,7 +310504,9 @@ class RepoCollectionGithubDecanter extends GithubDecanter {
         const filteredRepos = await this.filter(RepoCollectionGithubDecanter.collectionKind, filters, repoList.map((repo) => repo.name));
         for (const repoName of filteredRepos) {
             const repoInfo = await this.github.repo.getRepoInfo(this.org, repoName);
-            repos.push(new RepoGithubDecanter({ repoDetails: repoInfo }, this.org));
+            console.log(`--- 🚀 Processing repo: ${repoName}`);
+            console.dir(directAccessRepos, { depth: null });
+            repos.push(new RepoGithubDecanter({ repoDetails: repoInfo }, this.org, directAccessRepos?.[repoName]));
         }
         this.data['collection'] = repos;
         return repos;
@@ -310196,10 +310516,6 @@ RepoCollectionGithubDecanter.collectionKind = 'gh-repo';
 applyCollectionMixins(RepoCollectionGithubDecanter);
 /* harmony default export */ const github_repo_collection = (RepoCollectionGithubDecanter);
 
-;// CONCATENATED MODULE: ../importer/src/logger.ts
-
-/* harmony default export */ const importer_src_logger = (catalog_common.logger);
-
 ;// CONCATENATED MODULE: ../importer/src/decanter/index.ts
 
 
@@ -310292,7 +310608,7 @@ function getClaimPathFromCR(claimsBasePath, cr) {
         FirestartrGithubRepository: 'components',
         FirestartrGithubMembership: 'users',
     };
-    return external_path_.join(claimsBasePath, mapCrsToClaims[cr.kind], `${cr.metadata.annotations[catalog_common.generic.getFirestartrAnnotation('external-name')]}.yaml`.toLowerCase());
+    return external_path_.join(claimsBasePath, mapCrsToClaims[cr.kind], `${cr.metadata.labels['claim-ref']}.yaml`.toLowerCase());
 }
 function getCrPath(crsBasePath, cr) {
     return external_path_.join(crsBasePath, `${cr.kind}.${cr.metadata.name}.yaml`);

package/build/packages/github/index.d.ts

@@ -9,6 +9,7 @@ declare const _default: {
         validateMember: typeof import("./src/organization").validateMember;
         getUserRoleInOrg: typeof import("./src/organization").getUserRoleInOrg;
         getOrgInfo: typeof import("./src/organization").getOrgInfo;
+        getOrgTeamsDirectAccess: typeof import("./src/organization").getOrgTeamsDirectAccess;
         getOrgPlanName: typeof import("./src/organization").getOrgPlanName;
     };
     repo: {

package/build/packages/github/src/organization.d.ts

@@ -4,6 +4,8 @@ export declare function getUserList(org: string, perPageEntries?: number): Promi
 export declare function validateMember(username: string, org: string): Promise<any>;
 export declare function getUserRoleInOrg(username: string, org: string): Promise<"admin" | "member" | "billing_manager">;
 export declare function getOrgInfo(org: string): Promise<any>;
+export declare function getOrgTeamsDirectAccess(org: string): Promise<any>;
+export declare function transformGraphQLResponse(response: any): any;
 export declare function getOrgPlanName(org: string): Promise<any>;
 declare const _default: {
     getRepositoryList: typeof getRepositoryList;
@@ -12,6 +14,7 @@ declare const _default: {
     validateMember: typeof validateMember;
     getUserRoleInOrg: typeof getUserRoleInOrg;
     getOrgInfo: typeof getOrgInfo;
+    getOrgTeamsDirectAccess: typeof getOrgTeamsDirectAccess;
     getOrgPlanName: typeof getOrgPlanName;
 };
 export default _default;

package/build/packages/importer/src/decanter/gh/github_repo.d.ts

@@ -1,6 +1,8 @@
 import { BranchStrategiesInitializer, GithubRepositoryOverrider, InitializerDefault } from 'cdk8s_renderer';
 import { GithubDecanter } from './base';
 export default class RepoGithubDecanter extends GithubDecanter {
+    githubTeams: any;
+    constructor(data: any, org: string, githubTeams?: any);
     claimKind: string;
     __decantStart(): void;
     __decantProviders(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "1.50.1-snapshot-26",
+  "version": "1.50.1-snapshot-28",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",