@aspruyt/xfg 4.0.0 → 4.0.2

package/dist/config/validators/file-validator.d.ts

@@ -1,8 +1,6 @@
+import { isTextContent } from "../merge.js";
+export { isTextContent };
 declare const VALID_STRATEGIES: string[];
-/**
- * Check if content is text type (string or string[]).
- */
-export declare function isTextContent(content: unknown): boolean;
 /**
  * Check if content is object type (for JSON/YAML output).
  */
@@ -15,8 +13,4 @@ export declare function isStructuredFileExtension(fileName: string): boolean;
  * Validates a file name for security issues
  */
 export declare function validateFileName(fileName: string): void;
-/**
- * Validates that merge strategy is valid
- */
-export declare function isValidMergeStrategy(strategy: string): boolean;
 export { VALID_STRATEGIES };

package/dist/config/validators/file-validator.js

@@ -1,13 +1,8 @@
 import { extname, isAbsolute } from "node:path";
+import { isTextContent } from "../merge.js";
+import { ValidationError } from "../errors.js";
+export { isTextContent };
 const VALID_STRATEGIES = ["replace", "append", "prepend"];
-/**
- * Check if content is text type (string or string[]).
- */
-export function isTextContent(content) {
-    return (typeof content === "string" ||
-        (Array.isArray(content) &&
-            content.every((item) => typeof item === "string")));
-}
 /**
  * Check if content is object type (for JSON/YAML output).
  */
@@ -26,21 +21,15 @@ export function isStructuredFileExtension(fileName) {
  */
 export function validateFileName(fileName) {
     if (!fileName || typeof fileName !== "string") {
-        throw new Error("File name must be a non-empty string");
+        throw new ValidationError("File name must be a non-empty string");
     }
     // Validate fileName doesn't allow path traversal
     if (fileName.includes("..") || isAbsolute(fileName)) {
-        throw new Error(`Invalid fileName '${fileName}': must be a relative path without '..' components`);
+        throw new ValidationError(`Invalid fileName '${fileName}': must be a relative path without '..' components`);
     }
     // Validate fileName doesn't contain control characters that could bypass shell escaping
     if (/[\n\r\0]/.test(fileName)) {
-        throw new Error(`Invalid fileName '${fileName}': cannot contain newlines or null bytes`);
+        throw new ValidationError(`Invalid fileName '${fileName}': cannot contain newlines or null bytes`);
     }
 }
-/**
- * Validates that merge strategy is valid
- */
-export function isValidMergeStrategy(strategy) {
-    return VALID_STRATEGIES.includes(strategy);
-}
 export { VALID_STRATEGIES };

package/dist/config/validators/index.d.ts

@@ -1,3 +1,3 @@
-export { isTextContent, isObjectContent, isStructuredFileExtension, validateFileName, isValidMergeStrategy, VALID_STRATEGIES, } from "./file-validator.js";
-export { validateRepoSettings, VALID_VISIBILITY, VALID_SQUASH_MERGE_COMMIT_TITLE, VALID_SQUASH_MERGE_COMMIT_MESSAGE, VALID_MERGE_COMMIT_TITLE, VALID_MERGE_COMMIT_MESSAGE, } from "./repo-settings-validator.js";
-export { validateRule, validateRuleset, VALID_RULESET_TARGETS, VALID_ENFORCEMENT_LEVELS, VALID_ACTOR_TYPES, VALID_BYPASS_MODES, VALID_PATTERN_OPERATORS, VALID_MERGE_METHODS, VALID_ALERTS_THRESHOLDS, VALID_SECURITY_THRESHOLDS, VALID_RULE_TYPES, } from "./ruleset-validator.js";
+export { isTextContent, isObjectContent, isStructuredFileExtension, validateFileName, VALID_STRATEGIES, } from "./file-validator.js";
+export { validateRepoSettings } from "./repo-settings-validator.js";
+export { validateRuleset } from "./ruleset-validator.js";

package/dist/config/validators/index.js

@@ -1,6 +1,6 @@
 // File validation
-export { isTextContent, isObjectContent, isStructuredFileExtension, validateFileName, isValidMergeStrategy, VALID_STRATEGIES, } from "./file-validator.js";
+export { isTextContent, isObjectContent, isStructuredFileExtension, validateFileName, VALID_STRATEGIES, } from "./file-validator.js";
 // Repo settings validation
-export { validateRepoSettings, VALID_VISIBILITY, VALID_SQUASH_MERGE_COMMIT_TITLE, VALID_SQUASH_MERGE_COMMIT_MESSAGE, VALID_MERGE_COMMIT_TITLE, VALID_MERGE_COMMIT_MESSAGE, } from "./repo-settings-validator.js";
+export { validateRepoSettings } from "./repo-settings-validator.js";
 // Ruleset validation
-export { validateRule, validateRuleset, VALID_RULESET_TARGETS, VALID_ENFORCEMENT_LEVELS, VALID_ACTOR_TYPES, VALID_BYPASS_MODES, VALID_PATTERN_OPERATORS, VALID_MERGE_METHODS, VALID_ALERTS_THRESHOLDS, VALID_SECURITY_THRESHOLDS, VALID_RULE_TYPES, } from "./ruleset-validator.js";
+export { validateRuleset } from "./ruleset-validator.js";

package/dist/config/validators/repo-settings-validator.d.ts

@@ -1,10 +1,4 @@
-declare const VALID_VISIBILITY: string[];
-declare const VALID_SQUASH_MERGE_COMMIT_TITLE: string[];
-declare const VALID_SQUASH_MERGE_COMMIT_MESSAGE: string[];
-declare const VALID_MERGE_COMMIT_TITLE: string[];
-declare const VALID_MERGE_COMMIT_MESSAGE: string[];
 /**
  * Validates GitHub repository settings.
  */
 export declare function validateRepoSettings(repo: unknown, context: string): void;
-export { VALID_VISIBILITY, VALID_SQUASH_MERGE_COMMIT_TITLE, VALID_SQUASH_MERGE_COMMIT_MESSAGE, VALID_MERGE_COMMIT_TITLE, VALID_MERGE_COMMIT_MESSAGE, };

package/dist/config/validators/repo-settings-validator.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "../errors.js";
 const VALID_VISIBILITY = ["public", "private", "internal"];
 const VALID_SQUASH_MERGE_COMMIT_TITLE = ["PR_TITLE", "COMMIT_OR_PR_TITLE"];
 const VALID_SQUASH_MERGE_COMMIT_MESSAGE = [
@@ -12,7 +13,7 @@ const VALID_MERGE_COMMIT_MESSAGE = ["PR_BODY", "PR_TITLE", "BLANK"];
  */
 export function validateRepoSettings(repo, context) {
     if (typeof repo !== "object" || repo === null || Array.isArray(repo)) {
-        throw new Error(`${context}: repo must be an object`);
+        throw new ValidationError(`${context}: repo must be an object`);
     }
     const r = repo;
     // Validate boolean fields
@@ -39,33 +40,32 @@ export function validateRepoSettings(repo, context) {
     ];
     for (const field of booleanFields) {
         if (r[field] !== undefined && typeof r[field] !== "boolean") {
-            throw new Error(`${context}: ${field} must be a boolean`);
+            throw new ValidationError(`${context}: ${field} must be a boolean`);
         }
     }
     // Validate string fields
     if (r.defaultBranch !== undefined && typeof r.defaultBranch !== "string") {
-        throw new Error(`${context}: defaultBranch must be a string`);
+        throw new ValidationError(`${context}: defaultBranch must be a string`);
     }
     // Validate enum fields
     if (r.visibility !== undefined &&
         !VALID_VISIBILITY.includes(r.visibility)) {
-        throw new Error(`${context}: visibility must be one of: ${VALID_VISIBILITY.join(", ")}`);
+        throw new ValidationError(`${context}: visibility must be one of: ${VALID_VISIBILITY.join(", ")}`);
     }
     if (r.squashMergeCommitTitle !== undefined &&
         !VALID_SQUASH_MERGE_COMMIT_TITLE.includes(r.squashMergeCommitTitle)) {
-        throw new Error(`${context}: squashMergeCommitTitle must be one of: ${VALID_SQUASH_MERGE_COMMIT_TITLE.join(", ")}`);
+        throw new ValidationError(`${context}: squashMergeCommitTitle must be one of: ${VALID_SQUASH_MERGE_COMMIT_TITLE.join(", ")}`);
     }
     if (r.squashMergeCommitMessage !== undefined &&
         !VALID_SQUASH_MERGE_COMMIT_MESSAGE.includes(r.squashMergeCommitMessage)) {
-        throw new Error(`${context}: squashMergeCommitMessage must be one of: ${VALID_SQUASH_MERGE_COMMIT_MESSAGE.join(", ")}`);
+        throw new ValidationError(`${context}: squashMergeCommitMessage must be one of: ${VALID_SQUASH_MERGE_COMMIT_MESSAGE.join(", ")}`);
     }
     if (r.mergeCommitTitle !== undefined &&
         !VALID_MERGE_COMMIT_TITLE.includes(r.mergeCommitTitle)) {
-        throw new Error(`${context}: mergeCommitTitle must be one of: ${VALID_MERGE_COMMIT_TITLE.join(", ")}`);
+        throw new ValidationError(`${context}: mergeCommitTitle must be one of: ${VALID_MERGE_COMMIT_TITLE.join(", ")}`);
     }
     if (r.mergeCommitMessage !== undefined &&
         !VALID_MERGE_COMMIT_MESSAGE.includes(r.mergeCommitMessage)) {
-        throw new Error(`${context}: mergeCommitMessage must be one of: ${VALID_MERGE_COMMIT_MESSAGE.join(", ")}`);
+        throw new ValidationError(`${context}: mergeCommitMessage must be one of: ${VALID_MERGE_COMMIT_MESSAGE.join(", ")}`);
     }
 }
-export { VALID_VISIBILITY, VALID_SQUASH_MERGE_COMMIT_TITLE, VALID_SQUASH_MERGE_COMMIT_MESSAGE, VALID_MERGE_COMMIT_TITLE, VALID_MERGE_COMMIT_MESSAGE, };

package/dist/config/validators/ruleset-validator.d.ts

@@ -1,18 +1,4 @@
-declare const VALID_RULESET_TARGETS: string[];
-declare const VALID_ENFORCEMENT_LEVELS: string[];
-declare const VALID_ACTOR_TYPES: string[];
-declare const VALID_BYPASS_MODES: string[];
-declare const VALID_PATTERN_OPERATORS: string[];
-declare const VALID_MERGE_METHODS: string[];
-declare const VALID_ALERTS_THRESHOLDS: string[];
-declare const VALID_SECURITY_THRESHOLDS: string[];
-declare const VALID_RULE_TYPES: string[];
-/**
- * Validates a single ruleset rule.
- */
-export declare function validateRule(rule: unknown, context: string): void;
 /**
  * Validates a single ruleset.
  */
 export declare function validateRuleset(ruleset: unknown, name: string, context: string): void;
-export { VALID_RULESET_TARGETS, VALID_ENFORCEMENT_LEVELS, VALID_ACTOR_TYPES, VALID_BYPASS_MODES, VALID_PATTERN_OPERATORS, VALID_MERGE_METHODS, VALID_ALERTS_THRESHOLDS, VALID_SECURITY_THRESHOLDS, VALID_RULE_TYPES, };

package/dist/config/validators/ruleset-validator.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "../errors.js";
 const VALID_RULESET_TARGETS = ["branch", "tag"];
 const VALID_ENFORCEMENT_LEVELS = ["active", "disabled", "evaluate"];
 const VALID_ACTOR_TYPES = ["Team", "User", "Integration"];
@@ -48,33 +49,33 @@ const VALID_RULE_TYPES = [
 /**
  * Validates a single ruleset rule.
  */
-export function validateRule(rule, context) {
+function validateRule(rule, context) {
     if (typeof rule !== "object" || rule === null || Array.isArray(rule)) {
-        throw new Error(`${context}: rule must be an object`);
+        throw new ValidationError(`${context}: rule must be an object`);
     }
     const r = rule;
     if (!r.type || typeof r.type !== "string") {
-        throw new Error(`${context}: rule must have a 'type' string field`);
+        throw new ValidationError(`${context}: rule must have a 'type' string field`);
     }
     if (!VALID_RULE_TYPES.includes(r.type)) {
-        throw new Error(`${context}: invalid rule type '${r.type}'. Must be one of: ${VALID_RULE_TYPES.join(", ")}`);
+        throw new ValidationError(`${context}: invalid rule type '${r.type}'. Must be one of: ${VALID_RULE_TYPES.join(", ")}`);
     }
     // Validate parameters based on rule type
     if (r.parameters !== undefined) {
         if (typeof r.parameters !== "object" ||
             r.parameters === null ||
             Array.isArray(r.parameters)) {
-            throw new Error(`${context}: rule parameters must be an object`);
+            throw new ValidationError(`${context}: rule parameters must be an object`);
         }
         const params = r.parameters;
         // Validate pattern rule parameters
         if (r.type.toString().endsWith("_pattern")) {
             if (params.operator !== undefined &&
                 !VALID_PATTERN_OPERATORS.includes(params.operator)) {
-                throw new Error(`${context}: pattern rule operator must be one of: ${VALID_PATTERN_OPERATORS.join(", ")}`);
+                throw new ValidationError(`${context}: pattern rule operator must be one of: ${VALID_PATTERN_OPERATORS.join(", ")}`);
             }
             if (params.pattern !== undefined && typeof params.pattern !== "string") {
-                throw new Error(`${context}: pattern rule pattern must be a string`);
+                throw new ValidationError(`${context}: pattern rule pattern must be a string`);
             }
         }
         // Validate pull_request parameters
@@ -85,16 +86,16 @@ export function validateRule(rule, context) {
                     !Number.isInteger(count) ||
                     count < 0 ||
                     count > 10) {
-                    throw new Error(`${context}: requiredApprovingReviewCount must be an integer between 0 and 10`);
+                    throw new ValidationError(`${context}: requiredApprovingReviewCount must be an integer between 0 and 10`);
                 }
             }
             if (params.allowedMergeMethods !== undefined) {
                 if (!Array.isArray(params.allowedMergeMethods)) {
-                    throw new Error(`${context}: allowedMergeMethods must be an array`);
+                    throw new ValidationError(`${context}: allowedMergeMethods must be an array`);
                 }
                 for (const method of params.allowedMergeMethods) {
                     if (!VALID_MERGE_METHODS.includes(method)) {
-                        throw new Error(`${context}: allowedMergeMethods values must be one of: ${VALID_MERGE_METHODS.join(", ")}`);
+                        throw new ValidationError(`${context}: allowedMergeMethods values must be one of: ${VALID_MERGE_METHODS.join(", ")}`);
                     }
                 }
             }
@@ -102,20 +103,20 @@ export function validateRule(rule, context) {
         // Validate code_scanning parameters
         if (r.type === "code_scanning" && params.codeScanningTools !== undefined) {
             if (!Array.isArray(params.codeScanningTools)) {
-                throw new Error(`${context}: codeScanningTools must be an array`);
+                throw new ValidationError(`${context}: codeScanningTools must be an array`);
             }
             for (const tool of params.codeScanningTools) {
                 if (typeof tool !== "object" || tool === null) {
-                    throw new Error(`${context}: each codeScanningTool must be an object`);
+                    throw new ValidationError(`${context}: each codeScanningTool must be an object`);
                 }
                 const t = tool;
                 if (t.alertsThreshold !== undefined &&
                     !VALID_ALERTS_THRESHOLDS.includes(t.alertsThreshold)) {
-                    throw new Error(`${context}: alertsThreshold must be one of: ${VALID_ALERTS_THRESHOLDS.join(", ")}`);
+                    throw new ValidationError(`${context}: alertsThreshold must be one of: ${VALID_ALERTS_THRESHOLDS.join(", ")}`);
                 }
                 if (t.securityAlertsThreshold !== undefined &&
                     !VALID_SECURITY_THRESHOLDS.includes(t.securityAlertsThreshold)) {
-                    throw new Error(`${context}: securityAlertsThreshold must be one of: ${VALID_SECURITY_THRESHOLDS.join(", ")}`);
+                    throw new ValidationError(`${context}: securityAlertsThreshold must be one of: ${VALID_SECURITY_THRESHOLDS.join(", ")}`);
                 }
             }
         }
@@ -128,36 +129,36 @@ export function validateRuleset(ruleset, name, context) {
     if (typeof ruleset !== "object" ||
         ruleset === null ||
         Array.isArray(ruleset)) {
-        throw new Error(`${context}: ruleset '${name}' must be an object`);
+        throw new ValidationError(`${context}: ruleset '${name}' must be an object`);
     }
     const rs = ruleset;
     if (rs.target !== undefined &&
         !VALID_RULESET_TARGETS.includes(rs.target)) {
-        throw new Error(`${context}: ruleset '${name}' target must be one of: ${VALID_RULESET_TARGETS.join(", ")}`);
+        throw new ValidationError(`${context}: ruleset '${name}' target must be one of: ${VALID_RULESET_TARGETS.join(", ")}`);
     }
     if (rs.enforcement !== undefined &&
         !VALID_ENFORCEMENT_LEVELS.includes(rs.enforcement)) {
-        throw new Error(`${context}: ruleset '${name}' enforcement must be one of: ${VALID_ENFORCEMENT_LEVELS.join(", ")}`);
+        throw new ValidationError(`${context}: ruleset '${name}' enforcement must be one of: ${VALID_ENFORCEMENT_LEVELS.join(", ")}`);
     }
     // Validate bypassActors
     if (rs.bypassActors !== undefined) {
         if (!Array.isArray(rs.bypassActors)) {
-            throw new Error(`${context}: ruleset '${name}' bypassActors must be an array`);
+            throw new ValidationError(`${context}: ruleset '${name}' bypassActors must be an array`);
         }
         for (let i = 0; i < rs.bypassActors.length; i++) {
             const actor = rs.bypassActors[i];
             if (typeof actor !== "object" || actor === null) {
-                throw new Error(`${context}: ruleset '${name}' bypassActors[${i}] must be an object`);
+                throw new ValidationError(`${context}: ruleset '${name}' bypassActors[${i}] must be an object`);
             }
             if (typeof actor.actorId !== "number") {
-                throw new Error(`${context}: ruleset '${name}' bypassActors[${i}].actorId must be a number`);
+                throw new ValidationError(`${context}: ruleset '${name}' bypassActors[${i}].actorId must be a number`);
             }
             if (!VALID_ACTOR_TYPES.includes(actor.actorType)) {
-                throw new Error(`${context}: ruleset '${name}' bypassActors[${i}].actorType must be one of: ${VALID_ACTOR_TYPES.join(", ")}`);
+                throw new ValidationError(`${context}: ruleset '${name}' bypassActors[${i}].actorType must be one of: ${VALID_ACTOR_TYPES.join(", ")}`);
             }
             if (actor.bypassMode !== undefined &&
                 !VALID_BYPASS_MODES.includes(actor.bypassMode)) {
-                throw new Error(`${context}: ruleset '${name}' bypassActors[${i}].bypassMode must be one of: ${VALID_BYPASS_MODES.join(", ")}`);
+                throw new ValidationError(`${context}: ruleset '${name}' bypassActors[${i}].bypassMode must be one of: ${VALID_BYPASS_MODES.join(", ")}`);
             }
         }
     }
@@ -166,7 +167,7 @@ export function validateRuleset(ruleset, name, context) {
         if (typeof rs.conditions !== "object" ||
             rs.conditions === null ||
             Array.isArray(rs.conditions)) {
-            throw new Error(`${context}: ruleset '${name}' conditions must be an object`);
+            throw new ValidationError(`${context}: ruleset '${name}' conditions must be an object`);
         }
         const conditions = rs.conditions;
         if (conditions.refName !== undefined) {
@@ -174,28 +175,27 @@ export function validateRuleset(ruleset, name, context) {
             if (typeof refName !== "object" ||
                 refName === null ||
                 Array.isArray(refName)) {
-                throw new Error(`${context}: ruleset '${name}' conditions.refName must be an object`);
+                throw new ValidationError(`${context}: ruleset '${name}' conditions.refName must be an object`);
             }
             if (refName.include !== undefined &&
                 (!Array.isArray(refName.include) ||
                     !refName.include.every((s) => typeof s === "string"))) {
-                throw new Error(`${context}: ruleset '${name}' conditions.refName.include must be an array of strings`);
+                throw new ValidationError(`${context}: ruleset '${name}' conditions.refName.include must be an array of strings`);
             }
             if (refName.exclude !== undefined &&
                 (!Array.isArray(refName.exclude) ||
                     !refName.exclude.every((s) => typeof s === "string"))) {
-                throw new Error(`${context}: ruleset '${name}' conditions.refName.exclude must be an array of strings`);
+                throw new ValidationError(`${context}: ruleset '${name}' conditions.refName.exclude must be an array of strings`);
             }
         }
     }
     // Validate rules array
     if (rs.rules !== undefined) {
         if (!Array.isArray(rs.rules)) {
-            throw new Error(`${context}: ruleset '${name}' rules must be an array`);
+            throw new ValidationError(`${context}: ruleset '${name}' rules must be an array`);
         }
         for (let i = 0; i < rs.rules.length; i++) {
             validateRule(rs.rules[i], `${context}: ruleset '${name}' rules[${i}]`);
         }
     }
 }
-export { VALID_RULESET_TARGETS, VALID_ENFORCEMENT_LEVELS, VALID_ACTOR_TYPES, VALID_BYPASS_MODES, VALID_PATTERN_OPERATORS, VALID_MERGE_METHODS, VALID_ALERTS_THRESHOLDS, VALID_SECURITY_THRESHOLDS, VALID_RULE_TYPES, };

package/dist/lifecycle/ado-migration-source.js

@@ -1,6 +1,7 @@
 import { escapeShellArg } from "../shared/shell-utils.js";
 import { defaultExecutor, } from "../shared/command-executor.js";
 import { withRetry } from "../shared/retry-utils.js";
+import { toErrorMessage } from "../shared/type-guards.js";
 import { isAzureDevOpsRepo, } from "../shared/repo-detector.js";
 /**
  * Azure DevOps implementation of IMigrationSource.
@@ -28,7 +29,7 @@ export class AdoMigrationSource {
             });
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
+            const msg = toErrorMessage(error);
             throw new Error(`Failed to clone migration source ${repoInfo.gitUrl}: ${msg}. ` +
                 `Ensure you have authentication configured for Azure DevOps ` +
                 `(e.g., AZURE_DEVOPS_EXT_PAT or git credential helper).`);

package/dist/lifecycle/github-lifecycle-provider.d.ts

@@ -5,7 +5,7 @@ import type { IRepoLifecycleProvider, LifecyclePlatform, CreateRepoSettings } fr
  * GitHub implementation of IRepoLifecycleProvider.
  * Uses gh CLI for all operations.
  */
-export interface GitHubLifecycleProviderOptions {
+interface GitHubLifecycleProviderOptions {
     executor?: ICommandExecutor;
     retries?: number;
     cwd?: string;
@@ -29,11 +29,11 @@ export declare class GitHubLifecycleProvider implements IRepoLifecycleProvider {
     private isOrganization;
     private assertGitHub;
     /**
-     * Build GH_TOKEN prefix for gh CLI commands.
-     * Returns "GH_TOKEN=<escaped_token> " when token is provided, "" otherwise.
-     * Token is escaped via escapeShellArg to prevent injection.
+     * Builds the common gh API command prefix parts for a given repo.
+     * Returns tokenEnv for exec options, and the command prefix string
+     * (e.g., "gh api --hostname host repos/owner/repo").
      */
-    private buildTokenPrefix;
+    private buildGhApiPrefix;
     exists(repoInfo: RepoInfo, token?: string): Promise<boolean>;
     create(repoInfo: RepoInfo, settings?: CreateRepoSettings, token?: string): Promise<void>;
     fork(upstream: RepoInfo, target: RepoInfo, settings?: CreateRepoSettings, token?: string): Promise<void>;
@@ -68,3 +68,4 @@ export declare class GitHubLifecycleProvider implements IRepoLifecycleProvider {
      */
     private deleteReadme;
 }
+export {};