@breadstone-infrastructure/nx-tasks 0.0.256 → 0.0.258

package/src/executors/svelte-proxy-transform/executor.ts

@@ -0,0 +1,45 @@
+// #region Imports
+
+import { Path } from '@breadstone-infrastructure/utilities';
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
+import { isVerbose } from '../../utils/isVerbose';
+import type { SvelteProxyTransformTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type SvelteProxyTransformExecutorOptions = Omit<SvelteProxyTransformTask.ISvelteProxyTransformOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: SvelteProxyTransformExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).SvelteProxyTransformTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            packageJson: getProjectPackageJson(context),
+            tsConfigJson: getProjectTsConfigJson(context),
+            out: options.out,
+            path: options.path,
+            verbose: isVerbose(context, options),
+            aliases: options.aliases,
+            cleanOut: options.cleanOut,
+            ignore: options.ignore,
+            cache: {
+                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
+                dirPath: Path.combine(getProjectRoot(context), '.cache')
+            }
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/svelte-proxy-transform/schema.json

@@ -0,0 +1 @@
+{}

package/src/executors/token-linter/executor.options.ts

@@ -0,0 +1,23 @@
+// #region Imports
+
+import type { RuleSeverity } from '@breadstone-infrastructure/token-linter';
+
+// #endregion
+
+/**
+ * @description Options for the token-linter executor as declared in project.json.
+ * All fields are optional - the primary config comes from `tokenlinter.config.mjs`.
+ * Any options specified here override the config file values.
+ * @public
+ */
+export interface TokenLinterExecutorOptions {
+    tokensDir?: string;
+    themes?: string[];
+    mixinsDir?: string;
+    fix?: boolean;
+    interactive?: boolean;
+    verbose?: boolean;
+    reporter?: 'console' | 'json' | 'summary';
+    rules?: Record<string, RuleSeverity | 'off'>;
+    ruleOptions?: Record<string, Record<string, unknown>>;
+}

package/src/executors/token-linter/executor.task.ts

@@ -0,0 +1,66 @@
+// #region Imports
+
+import { TokenLinterOrchestrator, type RuleSeverity } from '@breadstone-infrastructure/token-linter';
+
+// #endregion
+
+/**
+ * @description Task to validate and lint Style Dictionary token JSON files across themes.
+ * Discovers `tokenlinter.config.mjs` in the project root automatically.
+ * Executor options from project.json override the config file values.
+ * @public
+ */
+export namespace TokenLinterTask {
+
+    // #region Interfaces
+
+    /**
+     * @description All fields are optional - the primary configuration comes from
+     * the `tokenlinter.config.mjs` config file. Any values provided here override
+     * the config file values.
+     * @public
+     */
+    export interface ITokenLinterTaskOptions {
+        cwd: string;
+        tokensDir?: string;
+        mixinsDir?: string;
+        themes?: string[];
+        fix?: boolean;
+        interactive?: boolean;
+        verbose?: boolean;
+        reporter?: 'console' | 'json' | 'summary';
+        rules?: Record<string, RuleSeverity | 'off'>;
+        ruleOptions?: Record<string, Record<string, unknown>>;
+    }
+
+    // #endregion
+
+    // #region Functions
+
+    /**
+     * @description Discovers the config file and executes the token linter.
+     * Executor options override config file values.
+     */
+    export async function run(options: ITokenLinterTaskOptions): Promise<void> {
+        const orchestrator = new TokenLinterOrchestrator();
+        const overrides: Record<string, unknown> = {};
+
+        if (options.tokensDir !== undefined) { overrides['tokensDir'] = options.tokensDir; }
+        if (options.mixinsDir !== undefined) { overrides['mixinsDir'] = options.mixinsDir; }
+        if (options.themes !== undefined) { overrides['themes'] = options.themes; }
+        if (options.fix !== undefined) { overrides['fix'] = options.fix; }
+        if (options.interactive !== undefined) { overrides['interactive'] = options.interactive; }
+        if (options.verbose !== undefined) { overrides['verbose'] = options.verbose; }
+        if (options.reporter !== undefined) { overrides['reporter'] = options.reporter; }
+        if (options.rules !== undefined) { overrides['rules'] = options.rules; }
+        if (options.ruleOptions !== undefined) { overrides['ruleOptions'] = options.ruleOptions; }
+
+        const result = await orchestrator.executeWithOverrides(options.cwd, overrides);
+
+        if (result.totalErrors > 0) {
+            throw new Error(`Token Linter found ${result.totalErrors} error(s).`);
+        }
+    }
+
+    // #endregion
+}

package/src/executors/token-linter/executor.ts

@@ -0,0 +1,37 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { isVerbose } from '../../utils/isVerbose';
+import type { TokenLinterExecutorOptions } from './executor.options';
+
+// #endregion
+
+/**
+ * @description Nx executor entry point for the token linter.
+ * @public
+ */
+export default async function runExecutor(options: TokenLinterExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).TokenLinterTask;
+        const verbose = isVerbose(context, options);
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            tokensDir: options.tokensDir,
+            mixinsDir: options.mixinsDir,
+            themes: options.themes,
+            fix: options.fix,
+            verbose,
+            reporter: options.reporter,
+            rules: options.rules,
+            ruleOptions: options.ruleOptions,
+        });
+
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+
+        return { success: false };
+    }
+}

package/src/executors/token-linter/schema.json

@@ -0,0 +1,63 @@
+{
+  "type": "object",
+  "description": "Token linter executor options. All fields are optional - the primary config comes from `tokenlinter.config.mjs` in the project root. Options specified here override the config file values.",
+  "properties": {
+    "tokensDir": {
+      "type": "string",
+      "description": "Relative path to the tokens/themes directory. Overrides config file."
+    },
+    "mixinsDir": {
+      "type": "string",
+      "description": "Relative path to the tokens/mixins directory. Overrides config file."
+    },
+    "themes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Theme names to validate. Overrides config file."
+    },
+    "fix": {
+      "type": "boolean",
+      "description": "Auto-fix fixable rule violations. Overrides config file."
+    },
+    "interactive": {
+      "type": "boolean",
+      "description": "Enable interactive mode for user-prompted resolution. Overrides config file."
+    },
+    "verbose": {
+      "type": "boolean",
+      "description": "Enable verbose logging. Overrides config file."
+    },
+    "reporter": {
+      "type": "string",
+      "enum": [
+        "console",
+        "json",
+        "summary"
+      ],
+      "description": "Output reporter format. Overrides config file."
+    },
+    "rules": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "enum": [
+          "error",
+          "warning",
+          "info",
+          "off"
+        ]
+      },
+      "description": "Rule severity overrides. Merged with config file rules."
+    },
+    "ruleOptions": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object"
+      },
+      "description": "Per-rule configuration options. Merged with config file ruleOptions."
+    }
+  },
+  "required": []
+}

package/src/executors/unrelease-package/executor.task.ts

@@ -0,0 +1,138 @@
+// #region Imports
+
+import { ConsoleLogger, logSeparator, logTree, magenta, red, Path, bold, File } from '@breadstone-infrastructure/utilities';
+import { execSync } from 'child_process';
+import type { PackageJson, TsConfigJson } from 'type-fest';
+
+// #endregion
+
+export namespace UnpublishPackageTask {
+
+    export interface IUnpublishPackageTaskOptions {
+        cwd: string;
+        tsConfigJson: TsConfigJson;
+        packageJson: PackageJson;
+        dryRun?: boolean;
+        verbose?: boolean;
+        versionOnly?: boolean; // Wenn true, wird nur eine bestimmte Version entfernt
+    }
+
+    interface INpmPackageInfo {
+        name: string;
+        version: string;
+        description?: string;
+        homepage?: string;
+        license?: string;
+        maintainers?: Array<{
+            name: string;
+            email?: string;
+        }>;
+        time?: Record<string, string>;
+        unpublished?: boolean;
+    }
+
+    export async function run(options: IUnpublishPackageTaskOptions): Promise<boolean> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Unpublish Package');
+
+        logger.info(`    ${magenta('Reading local package info...')}`);
+
+        const outPath = Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.outDir ?? '');
+        const packageJsonPath = Path.combine(outPath, 'package.json');
+
+        if (!File.exists(packageJsonPath)) {
+            logger.error(red(`Package.json not found at ${packageJsonPath}`));
+            return false;
+        }
+
+        if (!options.packageJson.name || !options.packageJson.version) {
+            logger.error(red('Missing "name" or "version" field in package.json.'));
+            return false;
+        }
+
+        if (!options.verbose) {
+            logTree(logger, 'Local Package Info', [
+                { label: `Name ${options.packageJson.name}` },
+                { label: `Version ${options.packageJson.version}` },
+                { label: `Description ${options.packageJson.description}` },
+                { label: `Homepage ${options.packageJson.homepage}` },
+                { label: `License ${options.packageJson.license}` }
+            ], { prefixSpaceLength: 4 });
+        }
+
+        logger.info(`    ${magenta('Checking remote registry...')}`);
+
+        try {
+            const remotePackageInfo = await fetchRemotePackageInfo(options.packageJson.name);
+
+            if (remotePackageInfo) {
+                logTree(logger, 'Remote Package Info', [
+                    { label: `Name ${remotePackageInfo.name}` },
+                    { label: `Version ${remotePackageInfo.version}` },
+                    { label: `Description ${remotePackageInfo.description}` },
+                    { label: `Homepage ${remotePackageInfo.homepage}` },
+                    { label: `License ${remotePackageInfo.license}` },
+                    { label: `Maintainers ${remotePackageInfo.maintainers?.map((m) => m.name).join(', ')}` }
+                ], { prefixSpaceLength: 4 });
+            } else {
+                logger.error(red(`Remote package '${options.packageJson.name}' not found.`));
+                return false;
+            }
+
+            logger.info(`    ${magenta('Unpublishing...')}`);
+
+            const unpublishCmd = options.versionOnly
+                ? `npm unpublish ${remotePackageInfo.name}@${remotePackageInfo.version} --force`
+                : `npm unpublish ${remotePackageInfo.name} --force`;
+
+            if (options.dryRun) {
+                logger.info(bold(`Dry run: would execute → ${unpublishCmd}`));
+            } else {
+                try {
+                    execSync(unpublishCmd, {
+                        cwd: options.cwd,
+                        stdio: 'inherit'
+                    });
+                } catch (error) {
+                    logger.error(red(error instanceof Error ? error.message : String(error)));
+                    return false;
+                }
+            }
+        } catch (error) {
+            logger.error(red(error.message));
+            return false;
+        }
+
+        return true;
+    }
+
+    async function fetchRemotePackageInfo(packageName: string): Promise<INpmPackageInfo | null> {
+        const encoded = encodeURIComponent(packageName);
+        const url = `https://registry.npmjs.org/${encoded}`;
+
+        const res = await fetch(url);
+        if (!res.ok) {
+            if (res.status === 404) {
+                // throw new Error(`Remote (npm) package '${bold(packageName)}' not found.`);
+                return null;
+            }
+
+            throw new Error(`Failed to fetch package info for '${bold(packageName)}': ${res.statusText}`);
+        }
+
+        const data = await res.json();
+
+        return {
+            name: data.name,
+            version: data.version,
+            description: data.description,
+            homepage: data.homepage,
+            license: data.license,
+            maintainers: data.maintainers,
+            time: data.time,
+            unpublished: data.time.unpublished
+        };
+    }
+
+}

package/src/executors/unrelease-package/executor.ts

@@ -0,0 +1,33 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
+import { isVerbose } from '../../utils/isVerbose';
+import type { UnpublishPackageTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type UnpublishPackageExecutorOptions = Omit<UnpublishPackageTask.IUnpublishPackageTaskOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: UnpublishPackageExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    const task = (await import('./executor.task')).UnpublishPackageTask;
+
+    return task.run({
+        cwd: getProjectRoot(context),
+        tsConfigJson: getProjectTsConfigJson(context),
+        packageJson: getProjectPackageJson(context),
+        versionOnly: options.versionOnly,
+        dryRun: options.dryRun,
+        verbose: isVerbose(context, options),
+    }).then((result) => ({ success: result }));
+}
+
+// #endregion

package/src/executors/unrelease-package/schema.json

@@ -0,0 +1 @@
+{}

package/src/executors/vercel-edge-config-sync/executor.task.ts

@@ -0,0 +1,30 @@
+// #region Imports
+
+import { ConsoleLogger, File, logSeparator, Path } from '@breadstone-infrastructure/utilities';
+import * as dotenv from 'dotenv';
+
+// #endregion
+
+export namespace VercelEdgeConfigSyncTask {
+    export interface IVercelEdgeConfigSyncTaskOptions {
+        cwd: string;
+    }
+
+    export async function run(options: IVercelEdgeConfigSyncTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Vercel Edge Config Sync');
+
+        const envPath = Path.combine(options.cwd, '.env');
+        const env = dotenv.config({ path: envPath });
+        const url = env.parsed?.EDGE_CONFIG ?? '';
+
+        logger.log(`Fetching edge config from ${url}`);
+
+        const body = await (await fetch(url)).json();
+
+        logger.log('Writing edge config to app.json');
+
+        File.writeAllJson(Path.combine(options.cwd, 'src/app.json'), body.items);
+    }
+}

package/src/executors/vercel-edge-config-sync/executor.ts

@@ -0,0 +1,25 @@
+
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import type { VercelEdgeConfigSyncTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: VercelEdgeConfigSyncTask.IVercelEdgeConfigSyncTaskOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).VercelEdgeConfigSyncTask;
+
+        await task.run({
+            cwd: getProjectRoot(context)
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/vercel-edge-config-sync/schema.json

@@ -0,0 +1 @@
+{}