@firestartr/cli 2.5.0-snapshot-1 → 2.5.0-snapshot-2

package/README.md

@@ -9,7 +9,6 @@
 # requirements
 
 - terraform 1.6.2
-- cdktf-cli@0.19.0
 - lerna@7.4.1
 
 To install it, run the next commands:
@@ -21,7 +20,6 @@ mv terraform /usr/local/bin/;  \
 chmod a+x /usr/local/bin/terraform;  \
 rm -f terraform_1.6.2_linux_amd64.zip;  \
 terraform --version;  \
-npm install -g cdktf-cli@0.19.0; \
 npm install -g lerna@7.4.1; 
 ```
 

package/build/index.js

@@ -268553,12 +268553,7 @@ var envVars;
     envVars["s3Bucket"] = "S3_BUCKET";
     envVars["s3Lock"] = "S3_LOCK";
     envVars["s3Region"] = "S3_REGION";
-    // ---- CDKTF/LOCAL VARIABLES -----------------------------------------------
-    envVars["cdktfConfigFiles"] = "CDKTF_CONFIG_FILES";
     envVars["exclusionsYamlPath"] = "EXCLUSIONS_PATH";
-    envVars["cdktfEntityPath"] = "FIRESTARTR_CDKTF_ENTITY_PATH";
-    envVars["cdktfDepsPath"] = "FIRESTARTR_CDKTF_DEPS_PATH";
-    envVars["cdktfIsImport"] = "FIRESTARTR_CDKTF_IS_IMPORT";
     // ---- GITHUB APP VARIABLES -----------------------------------------------
     envVars["githubAppId"] = "GITHUB_APP_ID";
     envVars["githubAppInstallationId"] = "GITHUB_APP_INSTALLATION_ID";
@@ -268980,6 +268975,128 @@ class SimpleTokenizer {
     SimpleTokenizer,
 });
 
+;// CONCATENATED MODULE: ../catalog_common/src/codeowners/index.ts
+// Common CODEOWNERS machinery (pure TypeScript/data; NO IO, NO classes)
+// Strictly follows GitHub CODEOWNERS syntax.
+// Spec: see specs/common/001-common-codeowners-machinery/spec.md
+
+const OWNER_RE = /^@[\w.-]+(\/[\w.-]+)?$/;
+function codeowners_parse(raw) {
+    if (typeof raw !== 'string' || raw === '')
+        return [];
+    return raw.split(/\r?\n/).map((line) => {
+        const trimmed = line.trim();
+        if (trimmed === '') {
+            return { type: 'blank', raw: line };
+        }
+        if (/^#/.test(trimmed)) {
+            return { type: 'comment', raw: line };
+        }
+        // Rule line: parse pattern & owners structurally, no ref resolution
+        const tokens = trimmed.split(/\s+/);
+        const pattern = tokens[0];
+        const owners = tokens.slice(1);
+        return { type: 'rule', pattern, owners, raw: line };
+    });
+}
+function format(entries) {
+    let end = entries.length;
+    while (end > 0 && entries[end - 1].type === 'blank') {
+        end -= 1;
+    }
+    const lines = entries.slice(0, end).map((entry) => {
+        switch (entry.type) {
+            case 'blank':
+                return '';
+            case 'comment':
+                return entry.raw.trimEnd();
+            case 'rule': {
+                const owners = entry.owners ?? [];
+                return owners.length > 0
+                    ? `${entry.pattern} ${owners.join(' ')}`
+                    : `${entry.pattern}`;
+            }
+        }
+    });
+    return lines.join('\n') + '\n';
+}
+function codeowners_validate(raw) {
+    const errors = [];
+    const lines = raw.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^\s*$/.test(line))
+            continue;
+        if (/^\s*#/.test(line))
+            continue;
+        const tokens = line.trim().split(/\s+/);
+        const pattern = tokens[0];
+        const owners = tokens.slice(1);
+        if (!pattern) {
+            errors.push(`Line ${i + 1}: empty pattern`);
+            continue;
+        }
+        if (owners.length === 0) {
+            errors.push(`Line ${i + 1}: rule must have at least one owner`);
+            continue;
+        }
+        for (const owner of owners) {
+            if (!OWNER_RE.test(owner)) {
+                errors.push(`Line ${i + 1}: invalid owner '${owner}' (must be @username or @org/team-slug)`);
+            }
+        }
+        if (line.includes('#')) {
+            errors.push(`Line ${i + 1}: inline comments are not allowed`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+function updateRule(entries, pattern, owners) {
+    const idx = entries.findIndex((e) => e.type === 'rule' && e.pattern === pattern);
+    const newEntry = {
+        type: 'rule',
+        pattern,
+        owners,
+        raw: `${pattern} ${owners.join(' ')}`,
+    };
+    if (idx >= 0) {
+        const result = [...entries];
+        result[idx] = newEntry;
+        return result;
+    }
+    return [...entries, newEntry];
+}
+function remove(entries, pattern) {
+    return entries.filter((e) => !(e.type === 'rule' && e.pattern === pattern));
+}
+function getOwners(entries) {
+    const owners = new Set();
+    for (const entry of entries) {
+        if (entry.type === 'rule' && entry.owners) {
+            for (const owner of entry.owners) {
+                owners.add(owner);
+            }
+        }
+    }
+    return [...owners];
+}
+function resolveRefs(raw, replacements) {
+    const tokenizer = new SimpleTokenizer(/\{\{\s*([\w./-]+)\s*\}\}/);
+    return tokenizer.replace(raw, (token) => {
+        const key = token.groups?.[0] ?? '';
+        return key in replacements ? replacements[key] : token.value;
+    });
+}
+/* harmony default export */ const codeowners = ({
+    parse: codeowners_parse,
+    format,
+    validate: codeowners_validate,
+    updateRule,
+    remove,
+    getOwners,
+    resolveRefs,
+});
+
 // EXTERNAL MODULE: ../../node_modules/cron-parser/dist/index.js
 var cron_parser_dist = __nccwpck_require__(98370);
 ;// CONCATENATED MODULE: ../catalog_common/src/cron.ts
@@ -269023,6 +269140,7 @@ function getCronNextInterval(cronLine, tz) {
 
 
 
+
 /* harmony default export */ const catalog_common = ({
     io: io,
     generic: generic,
@@ -269033,6 +269151,7 @@ function getCronNextInterval(cronLine, tz) {
     policies: policies,
     logger: logger_logger,
     tokenizer: tokenizer,
+    codeowners: codeowners,
     cron: {
         validateCron: validateCron,
         isValidCron: isValidCron,
@@ -290043,7 +290162,7 @@ class RepoGithubDecanter extends GithubDecanter {
         if (this.data.isEmpty) {
             const repoFullName = `${this.org}/${this.data.repoDetails.name}`;
             throw new Error(`The repo ${repoFullName} is empty - no commits, therefore CAN NOT be imported. ` +
-                'Create it with firestartr or fill it with some README.md or another initial file or code');
+                'Create it with Firestartr or fill it with some README.md or another initial file or code');
         }
     }
     constructor(data, org, githubTeams = {}) {
@@ -293242,7 +293361,7 @@ async function* markedToDeletion(item, op, handler) {
             reason: op,
             type: 'PROVISIONED',
             status: 'False',
-            message: 'Synth CDKTF',
+            message: 'Synth',
         };
         yield {
             item,
@@ -296792,7 +296911,7 @@ async function* process_operation_markedToDeletion(item, op, handler) {
             reason: op,
             type: 'PROVISIONED',
             status: 'False',
-            message: 'Synth CDKTF',
+            message: 'Synth',
         };
         yield {
             item,
@@ -296914,7 +297033,7 @@ async function* doApply(item, op, handler) {
             reason: op,
             type: 'PROVISIONED',
             status: 'False',
-            message: 'Synth CDKTF',
+            message: 'Synth',
         };
         let output = '';
         const type = 'PROVISIONING';
@@ -298683,16 +298802,67 @@ function provisionDefaultBranch(fsGithubRepository) {
 ;// CONCATENATED MODULE: ../gh_provisioner/src/entities/ghrepo/helpers/codeowners.ts
 
 
+// Helper: Escape RegExp special characters in owner strings
+function codeowners_escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 async function provisionCodeowners(fsGithubRepository) {
     const cr = fsGithubRepository.cr;
+    let codeownersText = cr.spec.repo.codeowners;
+    const org = cr.spec.org;
+    if (typeof codeownersText !== 'string') {
+        gh_provisioner_src_logger.debug('[provisionCodeowners] No CODEOWNERS content configured; skipping provisioning.');
+        return;
+    }
+    // 1. Gather all group refs present in cr.spec.permissions (if any)
+    const allRefs = [];
+    if (cr.spec.permissions && Array.isArray(cr.spec.permissions)) {
+        for (const perm of cr.spec.permissions) {
+            if (perm.ref && perm.ref.kind === 'FirestartrGithubGroup') {
+                allRefs.push(perm.ref);
+            }
+        }
+    }
+    // (Extend here if group refs appear in other fields in future specs)
+    // 2. For each group dependency: get external name & slug
+    const replacements = [];
+    for (const ref of allRefs) {
+        let dep;
+        try {
+            dep = base_Entity.refResolver(ref);
+        }
+        catch (e) {
+            gh_provisioner_src_logger.error(`[provisionCodeowners] Failed to resolve group ref ${ref.name}: ${String(e)}`);
+            continue;
+        }
+        const extName = dep?.cr?.metadata?.annotations?.['firestartr.dev/external-name'];
+        const slug = dep?.getOutput && dep.getOutput('slug');
+        if (!extName) {
+            gh_provisioner_src_logger.error(`[provisionCodeowners] Missing external-name annotation for group ref ${ref.name}`);
+            continue;
+        }
+        if (!slug) {
+            gh_provisioner_src_logger.error(`[provisionCodeowners] Missing slug output for group '${extName}' (${ref.name}) - will preserve as-is.`);
+            continue;
+        }
+        const from = `@${org}/${extName}`;
+        const to = `@${org}/${slug}`;
+        replacements.push({ from, to });
+    }
+    // 3. Replace all exact occurrences of each external name owner with slug owner
+    for (const { from, to } of replacements) {
+        // Needs literal match, even if source owner has spaces/punctuation
+        codeownersText = codeownersText.replace(new RegExp(codeowners_escapeRegExp(from), 'g'), to);
+    }
+    // Do not reformat, parse, or canonicalize further (per spec: preserve layout except for replacements)
     const config = {
         branch: cr.spec.repo.defaultBranch,
         commitMessage: 'ci: provision CODEOWNERS file',
-        content: cr.spec.repo.codeowners,
+        content: codeownersText,
         file: '.github/CODEOWNERS',
         overwriteOnCreate: true,
     };
-    gh_provisioner_src_logger.debug(`Content of the codeowners:  ${cr.spec.repo.codeowners}`);
+    gh_provisioner_src_logger.debug(`[provisionCodeowners] Final CODEOWNERS content: ${codeownersText}`);
     fsGithubRepository.patchData({
         path: '/config/files/-',
         op: PatchOperations.add,
@@ -301739,7 +301909,7 @@ const crs_analyzerSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = JSON.parse('{"i8":"2.5.0-snapshot-1"}');
+const package_namespaceObject = JSON.parse('{"i8":"2.5.0-snapshot-2"}');
 ;// CONCATENATED MODULE: ../../package.json
 const package_namespaceObject_1 = {"i8":"2.4.0"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts

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

@@ -104,6 +104,15 @@ declare const _default: {
     tokenizer: {
         SimpleTokenizer: typeof import("./src/tokenizer").SimpleTokenizer;
     };
+    codeowners: {
+        parse: typeof import("./src/codeowners").parse;
+        format: typeof import("./src/codeowners").format;
+        validate: typeof import("./src/codeowners").validate;
+        updateRule: typeof import("./src/codeowners").updateRule;
+        remove: typeof import("./src/codeowners").remove;
+        getOwners: typeof import("./src/codeowners").getOwners;
+        resolveRefs: typeof import("./src/codeowners").resolveRefs;
+    };
     cron: {
         validateCron: typeof validateCron;
         isValidCron: typeof isValidCron;

package/build/packages/catalog_common/src/codeowners/index.d.ts

@@ -0,0 +1,26 @@
+export interface CodeownersEntry {
+    type: 'rule' | 'comment' | 'blank';
+    pattern?: string;
+    owners?: string[];
+    raw: string;
+}
+export declare function parse(raw: string): CodeownersEntry[];
+export declare function format(entries: CodeownersEntry[]): string;
+export declare function validate(raw: string): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function updateRule(entries: CodeownersEntry[], pattern: string, owners: string[]): CodeownersEntry[];
+export declare function remove(entries: CodeownersEntry[], pattern: string): CodeownersEntry[];
+export declare function getOwners(entries: CodeownersEntry[]): string[];
+export declare function resolveRefs(raw: string, replacements: Record<string, string>): string;
+declare const _default: {
+    parse: typeof parse;
+    format: typeof format;
+    validate: typeof validate;
+    updateRule: typeof updateRule;
+    remove: typeof remove;
+    getOwners: typeof getOwners;
+    resolveRefs: typeof resolveRefs;
+};
+export default _default;

package/build/packages/catalog_common/src/types/envvars.d.ts

@@ -25,11 +25,7 @@ export declare enum envVars {
     s3Bucket = "S3_BUCKET",
     s3Lock = "S3_LOCK",
     s3Region = "S3_REGION",
-    cdktfConfigFiles = "CDKTF_CONFIG_FILES",
     exclusionsYamlPath = "EXCLUSIONS_PATH",
-    cdktfEntityPath = "FIRESTARTR_CDKTF_ENTITY_PATH",
-    cdktfDepsPath = "FIRESTARTR_CDKTF_DEPS_PATH",
-    cdktfIsImport = "FIRESTARTR_CDKTF_IS_IMPORT",
     githubAppId = "GITHUB_APP_ID",
     githubAppInstallationId = "GITHUB_APP_INSTALLATION_ID",
     githubAppInstallationIdPrefapp = "GITHUB_APP_INSTALLATION_ID_PREFAPP",

package/package.json

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