auklet 0.0.19 → 0.0.21

package/dist/publish/publishRunner.js

@@ -0,0 +1,108 @@
+import { createAukletLogger, createScopedAukletLogger } from '#auklet/logger';
+import { runPublishHook } from '#auklet/publish/api/publishHookApi';
+import { runPackageBuilds, validateBuildScript, } from '#auklet/publish/runner/packageBuilder';
+import { formatPublishOutputs } from '#auklet/publish/runner/publishOutputFormatter';
+import { resolvePublishPlan } from '#auklet/publish/targetResolver';
+import { PackagePublisher } from '#auklet/publish/runner/packagePublisher';
+import { reportPublishFailure } from '#auklet/publish/runner/publishFailureReporter';
+import { reportPublishSummary } from '#auklet/publish/runner/publishSummaryReporter';
+import { PublishPreflight } from '#auklet/publish/runner/publishPreflight';
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+import { ReleaseGitController } from '#auklet/publish/runner/releaseGitController';
+import { VersionWriter } from '#auklet/publish/runner/versionWriter';
+export class PublishRunner {
+    git;
+    publisher;
+    preflight;
+    versions;
+    logger;
+    summaryLogger;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.logger = createScopedAukletLogger('publish');
+        this.summaryLogger = createAukletLogger();
+        this.git = new ReleaseGitController(this.options, this.logger);
+        this.publisher = new PackagePublisher(this.options);
+        this.preflight = new PublishPreflight(this.options);
+        this.versions = new VersionWriter(this.options, this.logger);
+    }
+    async run() {
+        const plan = await this.preparePlan();
+        let failureHookEnabled = false;
+        try {
+            await runPublishHook({ status: 'beforeBuild', plan });
+            failureHookEnabled = true;
+            this.versions.writeBeforeBuild(plan);
+            await runPackageBuilds(plan.targets, this.logger);
+            await runPublishHook({ status: 'afterBuild', plan });
+            await formatPublishOutputs(plan.targets, this.options.format);
+            await runPublishHook({ status: 'beforePublish', plan });
+            await this.publishWithPlan(plan);
+        }
+        catch (error) {
+            if (!failureHookEnabled) {
+                reportPublishSummary(this.summaryLogger, {
+                    plan,
+                    status: 'failure',
+                    error,
+                });
+                throw error;
+            }
+            await this.handleFailure(plan, error);
+        }
+        await this.runAfterPublishSuccess(plan);
+    }
+    async preparePlan() {
+        const plan = await resolvePublishPlan(this.options, this.logger);
+        validateBuildScript(plan.targets);
+        await this.git.checkBeforePublish(plan);
+        this.versions.logDryRunPlan(plan);
+        return plan;
+    }
+    async publishWithPlan(plan) {
+        if (plan.dryRun) {
+            await this.preflight.run(plan);
+            return;
+        }
+        await this.preflight.run(plan);
+        await this.git.commitAndTag(plan);
+        await this.publisher.run(plan);
+    }
+    async handleFailure(plan, error) {
+        const failedTarget = error instanceof PublishTargetError ? error.target : undefined;
+        try {
+            await runPublishHook({
+                status: 'afterPublish',
+                plan,
+                result: 'failure',
+                failedTarget,
+                error: error instanceof PublishTargetError ? error.originalError : error,
+            });
+        }
+        catch (hookError) {
+            this.logger.error?.(hookError);
+        }
+        if (error instanceof PublishTargetError) {
+            reportPublishFailure(error, plan.version, this.logger);
+        }
+        reportPublishSummary(this.summaryLogger, {
+            plan,
+            status: 'failure',
+            error,
+        });
+        this.versions.logWrittenVersionFailure(plan);
+        throw error;
+    }
+    async runAfterPublishSuccess(plan) {
+        await runPublishHook({
+            status: 'afterPublish',
+            plan,
+            result: 'success',
+        });
+        reportPublishSummary(this.summaryLogger, {
+            plan,
+            status: 'success',
+        });
+    }
+}

package/dist/publish/runner/packageBuilder.d.ts

@@ -0,0 +1,4 @@
+import type { PublishTarget } from '#auklet/publish/types';
+import type { AukletLogger } from '#auklet/logger';
+export declare function validateBuildScript(targets: Array<PublishTarget>): void;
+export declare function runPackageBuilds(targets: Array<PublishTarget>, logger: AukletLogger): Promise<void>;

package/dist/publish/runner/packageBuilder.js

@@ -0,0 +1,16 @@
+import { isString } from 'aidly';
+import { runPnpmBuild } from '#auklet/publish/api/pnpmApi';
+export function validateBuildScript(targets) {
+    for (const target of targets) {
+        const buildScript = target.packageJson.scripts?.build;
+        if (!isString(buildScript) || !buildScript) {
+            throw new Error(`[auklet:publish] package ${target.packageName} must define package.json#scripts.build before publishing.`);
+        }
+    }
+}
+export async function runPackageBuilds(targets, logger) {
+    for (const target of targets) {
+        logger.step('build ', logger.package(target.packageName));
+        await runPnpmBuild(target.packageRoot);
+    }
+}

package/dist/publish/runner/packagePublisher.d.ts

@@ -0,0 +1,7 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export declare class PackagePublisher {
+    private readonly options;
+    private readonly pnpm;
+    constructor(options: PublishOptions);
+    run(plan: PublishPlan): Promise<void>;
+}

package/dist/publish/runner/packagePublisher.js

@@ -0,0 +1,21 @@
+import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+export class PackagePublisher {
+    options;
+    pnpm = new PnpmPublishApi();
+    constructor(options) {
+        this.options = options;
+    }
+    async run(plan) {
+        const publishedTargets = [];
+        for (const target of plan.targets) {
+            try {
+                await this.pnpm.publish(target, this.options);
+                publishedTargets.push(target);
+            }
+            catch (error) {
+                throw new PublishTargetError(target, 'publish', error, publishedTargets);
+            }
+        }
+    }
+}

package/dist/publish/runner/publishFailureReporter.d.ts

@@ -0,0 +1,3 @@
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+import type { AukletLogger } from '#auklet/logger';
+export declare function reportPublishFailure(error: PublishTargetError, version: string, logger: AukletLogger): void;

package/dist/publish/runner/publishFailureReporter.js

@@ -0,0 +1,14 @@
+export function reportPublishFailure(error, version, logger) {
+    if (error.phase === 'publish' && error.publishedTargets.length) {
+        logger.error('partial publish detected');
+        logger.error('published packages:');
+        for (const target of error.publishedTargets) {
+            logger.error(formatPublishedTarget(logger, target.packageName, version));
+        }
+    }
+    logger.error('failed package:');
+    logger.error(formatPublishedTarget(logger, error.target.packageName, version));
+}
+const formatPublishedTarget = (logger, packageName, version) => {
+    return ['- ', logger.package(packageName), '@', logger.version(version)];
+};

package/dist/publish/runner/publishOutputFormatter.d.ts

@@ -0,0 +1,2 @@
+import type { PublishTarget } from '#auklet/publish/types';
+export declare function formatPublishOutputs(targets: Array<PublishTarget>, enabled: boolean): Promise<void>;

package/dist/publish/runner/publishOutputFormatter.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import prettier from 'prettier';
+const supportedExtensions = new Set([
+    '.js',
+    '.ts',
+    '.tsx',
+    '.css',
+    '.json',
+    '.yaml',
+    '.yml',
+]);
+export async function formatPublishOutputs(targets, enabled) {
+    if (!enabled)
+        return;
+    for (const target of targets) {
+        const files = collectPublishFiles(target);
+        for (const file of files) {
+            await formatFile(file);
+        }
+    }
+}
+const collectPublishFiles = (target) => {
+    const patterns = target.packageJson.files ?? [];
+    const includes = patterns.filter((item) => !item.startsWith('!'));
+    const excludes = patterns
+        .filter((item) => item.startsWith('!'))
+        .map((item) => item.slice(1));
+    const files = new Set();
+    for (const include of includes) {
+        const absolutePath = path.resolve(target.packageRoot, include);
+        if (!fs.existsSync(absolutePath))
+            continue;
+        for (const file of walkFiles(absolutePath)) {
+            if (isExcluded(target.packageRoot, file, excludes))
+                continue;
+            if (!isSupportedStyleFile(file))
+                continue;
+            files.add(file);
+        }
+    }
+    return [...files].sort();
+};
+const walkFiles = (absolutePath) => {
+    const stat = fs.statSync(absolutePath);
+    if (stat.isFile())
+        return [absolutePath];
+    if (!stat.isDirectory())
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(absolutePath)) {
+        files.push(...walkFiles(path.join(absolutePath, entry)));
+    }
+    return files;
+};
+const isExcluded = (packageRoot, file, excludes) => {
+    const relativePath = path
+        .relative(packageRoot, file)
+        .split(path.sep)
+        .join('/');
+    return excludes.some((exclude) => {
+        const normalized = exclude.replace(/\\/g, '/').replace(/\/$/, '');
+        return (relativePath === normalized || relativePath.startsWith(`${normalized}/`));
+    });
+};
+const isSupportedStyleFile = (file) => {
+    if (file.endsWith('.d.ts'))
+        return true;
+    return supportedExtensions.has(path.extname(file));
+};
+const formatFile = async (file) => {
+    const source = fs.readFileSync(file, 'utf8');
+    let formatted;
+    try {
+        formatted = await prettier.format(source, { filepath: file });
+    }
+    catch {
+        return;
+    }
+    if (formatted !== source) {
+        fs.writeFileSync(file, formatted);
+    }
+};

package/dist/publish/runner/publishPreflight.d.ts

@@ -0,0 +1,8 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+export declare class PublishPreflight {
+    private readonly options;
+    private readonly pnpm;
+    constructor(options: PublishOptions);
+    run(plan: PublishPlan): Promise<void>;
+    private verifyPnpmPublishDryRun;
+}

package/dist/publish/runner/publishPreflight.js

@@ -0,0 +1,26 @@
+import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+export class PublishPreflight {
+    options;
+    pnpm = new PnpmPublishApi();
+    constructor(options) {
+        this.options = options;
+    }
+    async run(plan) {
+        await this.verifyPnpmPublishDryRun(plan);
+    }
+    async verifyPnpmPublishDryRun(plan) {
+        const options = {
+            ...this.options,
+            dryRun: true,
+        };
+        for (const target of plan.targets) {
+            try {
+                await this.pnpm.publish(target, options);
+            }
+            catch (error) {
+                throw new PublishTargetError(target, 'preflight', error, []);
+            }
+        }
+    }
+}

package/dist/publish/runner/publishSummaryReporter.d.ts

@@ -0,0 +1,10 @@
+import type { AukletLogger } from '#auklet/logger';
+import type { PublishPlan } from '#auklet/publish/types';
+type PublishSummaryStatus = 'success' | 'failure';
+type PublishSummaryOptions = {
+    plan: PublishPlan;
+    status: PublishSummaryStatus;
+    error?: unknown;
+};
+export declare function reportPublishSummary(logger: AukletLogger, options: PublishSummaryOptions): void;
+export {};

package/dist/publish/runner/publishSummaryReporter.js

@@ -0,0 +1,81 @@
+import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
+export function reportPublishSummary(logger, options) {
+    const publishError = options.error instanceof PublishTargetError ? options.error : undefined;
+    const failedTarget = publishError?.target;
+    const publishedTargets = publishError?.publishedTargets ?? [];
+    const publishedTargetRoots = new Set(publishedTargets.map((target) => getTargetKey(target)));
+    const publishedCount = options.status === 'success' && !options.plan.dryRun
+        ? options.plan.targets.length
+        : publishedTargets.length;
+    logger.newline();
+    logger.raw(logger.colors.gray('-'.repeat(56)));
+    logger.newline();
+    logger.result({
+        title: logger.colors.bold(getSummaryTitle(options.status, options.plan)),
+        status: options.status === 'success' ? 'success' : 'error',
+        body: getSummaryBody(options.status, options.plan, failedTarget),
+        details: {
+            mode: options.plan.dryRun ? 'dry-run' : 'publish',
+            packages: String(options.plan.targets.length),
+            version: logger.version(options.plan.version),
+            published: String(publishedCount),
+        },
+    });
+    logger.tasks({
+        tasks: getVersionChangeTasks(logger, {
+            targets: options.plan.targets,
+            status: options.status,
+            dryRun: options.plan.dryRun,
+            failedTarget,
+            publishedTargetRoots,
+        }),
+    });
+    logger.newline();
+}
+const getSummaryTitle = (status, plan) => {
+    if (status === 'failure')
+        return 'Publish failed';
+    return plan.dryRun ? 'Publish dry-run complete' : 'Publish complete';
+};
+const getSummaryBody = (status, plan, failedTarget) => {
+    if (status === 'success') {
+        return [
+            plan.dryRun
+                ? 'Preflight completed without publishing packages.'
+                : 'All selected packages were published.',
+        ];
+    }
+    if (failedTarget) {
+        return [['Failed at ', failedTarget.packageName, '. Check logs above.']];
+    }
+    return ['Publish stopped before package publishing completed.'];
+};
+const getVersionChangeTasks = (logger, options) => {
+    return options.targets.map((target) => ({
+        title: [
+            logger.package(target.packageName),
+            ' ',
+            ...formatVersionChange(logger, target.version, target.publishVersion),
+        ],
+        status: getVersionChangeTaskStatus(target, options),
+    }));
+};
+const getVersionChangeTaskStatus = (target, options) => {
+    if (options.dryRun)
+        return 'skipped';
+    if (options.status === 'success')
+        return 'success';
+    if (options.failedTarget &&
+        getTargetKey(target) === getTargetKey(options.failedTarget)) {
+        return 'error';
+    }
+    if (options.publishedTargetRoots.has(getTargetKey(target)))
+        return 'success';
+    return 'skipped';
+};
+const getTargetKey = (target) => {
+    return `${target.packageRoot}:${target.packageName}`;
+};
+const formatVersionChange = (logger, from, to) => {
+    return [logger.version(from), logger.colors.gray(' -> '), logger.version(to)];
+};

package/dist/publish/runner/publishTargetError.d.ts

@@ -0,0 +1,9 @@
+import type { PublishTarget } from '#auklet/publish/types';
+export type PublishPhase = 'preflight' | 'publish';
+export declare class PublishTargetError extends Error {
+    readonly target: PublishTarget;
+    readonly phase: PublishPhase;
+    readonly originalError: unknown;
+    readonly publishedTargets: Array<PublishTarget>;
+    constructor(target: PublishTarget, phase: PublishPhase, originalError: unknown, publishedTargets: Array<PublishTarget>);
+}

package/dist/publish/runner/publishTargetError.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+export class PublishTargetError extends Error {
+    target;
+    phase;
+    originalError;
+    publishedTargets;
+    constructor(target, phase, originalError, publishedTargets) {
+        super(`[auklet:publish] ${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
+        this.target = target;
+        this.phase = phase;
+        this.originalError = originalError;
+        this.publishedTargets = publishedTargets;
+    }
+}

package/dist/publish/runner/releaseGitController.d.ts

@@ -0,0 +1,10 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { AukletLogger } from '#auklet/logger';
+export declare class ReleaseGitController {
+    private readonly options;
+    private readonly logger;
+    constructor(options: PublishOptions, logger: AukletLogger);
+    checkBeforePublish(plan: PublishPlan): Promise<void>;
+    commitAndTag(plan: PublishPlan): Promise<void>;
+    private warnOnce;
+}

package/dist/publish/runner/releaseGitController.js

@@ -0,0 +1,41 @@
+import { commitRelease, createVersionTag, ensureGitClean, hasGitChanges, isGitRepository, } from '#auklet/publish/api/gitApi';
+export class ReleaseGitController {
+    options;
+    logger;
+    constructor(options, logger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    async checkBeforePublish(plan) {
+        const git = await isGitRepository(plan.root);
+        if (plan.dryRun || !git)
+            return;
+        if (this.options.allowDirty) {
+            this.warnOnce('--allow-dirty enabled, skipping git clean check, commit, and tag.');
+            return;
+        }
+        await ensureGitClean(plan.root);
+    }
+    async commitAndTag(plan) {
+        const git = await isGitRepository(plan.root);
+        if (git && this.options.allowDirty) {
+            this.warnOnce('--allow-dirty enabled, skipping git commit and tag.');
+            return;
+        }
+        if (!git) {
+            this.warnOnce('git repository not found, skipping commit and tag.');
+            return;
+        }
+        const changed = await hasGitChanges(plan.root);
+        if (changed) {
+            if (!this.options.version) {
+                throw new Error('[auklet:publish] build or format changed files. Commit changes before publishing without --version.');
+            }
+            await commitRelease(plan.root, plan.version);
+        }
+        await createVersionTag(plan.root, plan.version, this.logger);
+    }
+    warnOnce(content) {
+        this.logger.warnOnce(content);
+    }
+}

package/dist/publish/runner/versionWriter.d.ts

@@ -0,0 +1,13 @@
+import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { AukletLogger } from '#auklet/logger';
+export declare class VersionWriter {
+    private readonly options;
+    private readonly logger;
+    constructor(options: PublishOptions, logger: AukletLogger);
+    writeBeforeBuild(plan: PublishPlan): void;
+    logDryRunPlan(plan: PublishPlan): void;
+    logWrittenVersionFailure(plan: PublishPlan): void;
+    private writeVersions;
+    private formatPackage;
+    private formatVersionChange;
+}

package/dist/publish/runner/versionWriter.js

@@ -0,0 +1,78 @@
+import { readPackageJson, writePackageJson, } from '#auklet/publish/api/packageJsonApi';
+export class VersionWriter {
+    options;
+    logger;
+    constructor(options, logger) {
+        this.options = options;
+        this.logger = logger;
+    }
+    writeBeforeBuild(plan) {
+        if (!plan.dryRun && this.options.version) {
+            this.writeVersions(plan);
+        }
+    }
+    logDryRunPlan(plan) {
+        if (!plan.dryRun || !this.options.version)
+            return;
+        const logger = this.logger;
+        logger.info('dry-run mode: package.json files will not be changed');
+        if (plan.workspaceMode === 'monorepo') {
+            const rootPackageJson = readPackageJson(plan.root);
+            logger.summary({
+                title: 'Publish dry-run plan',
+                values: {
+                    mode: plan.workspaceMode,
+                    sharedVersion: this.formatVersionChange(rootPackageJson.version, plan.version),
+                    targets: plan.targets.length,
+                },
+            });
+            for (const target of plan.targets) {
+                logger.info('planned package ', this.formatPackage(target.packageName), ': ', ...this.formatVersionChange(target.version, target.publishVersion));
+            }
+            logger.info('builds will still read each package.json#version');
+            logger.info('pnpm publish --dry-run will still read each package.json#version');
+            return;
+        }
+        const [target] = plan.targets;
+        if (target) {
+            logger.summary({
+                title: 'Publish dry-run plan',
+                values: {
+                    package: this.formatPackage(target.packageName),
+                    version: this.formatVersionChange(target.version, target.publishVersion),
+                },
+            });
+            logger.info(`build will still read package.json#version: ${target.version}`);
+            logger.info(`pnpm publish --dry-run will still read package.json#version: ${target.version}`);
+        }
+    }
+    logWrittenVersionFailure(plan) {
+        if (!plan.dryRun && this.options.version) {
+            this.logger.error('package.json versions may have been written. Auklet will not roll them back; check publish output before retrying.');
+        }
+    }
+    writeVersions(plan) {
+        const packageRoots = new Set([
+            plan.root,
+            ...plan.targets.map((target) => target.packageRoot),
+        ]);
+        for (const packageRoot of packageRoots) {
+            const packageJson = readPackageJson(packageRoot);
+            const packageName = plan.targets.find((target) => target.packageRoot === packageRoot)
+                ?.packageName ?? (packageRoot === plan.root ? 'root' : packageRoot);
+            if (packageJson.version !== plan.version) {
+                this.logger.info('writing version ', this.formatPackage(packageName), ': ', ...this.formatVersionChange(packageJson.version, plan.version));
+            }
+            packageJson.version = plan.version;
+            writePackageJson(packageRoot, packageJson);
+        }
+    }
+    formatPackage(packageName) {
+        return this.logger.package(packageName);
+    }
+    formatVersionChange(from, to) {
+        const logger = this.logger;
+        const fromVersion = String(from);
+        return [logger.version(fromVersion), ' -> ', logger.version(to)];
+    }
+}

package/dist/publish/targetResolver.d.ts

@@ -0,0 +1,7 @@
+import { type AukletLogger } from '#auklet/logger';
+import type { OwnerOptions, PublishOptions, PublishPlan } from '#auklet/publish/types';
+type ResolvePublishTargetsOptions = Pick<PublishOptions, 'cwd' | 'filters' | 'version' | 'dryRun'>;
+type ResolveOwnerTargetsOptions = Pick<OwnerOptions, 'cwd' | 'filters' | 'packages'>;
+export declare function resolvePublishPlan(options: ResolvePublishTargetsOptions, logger?: AukletLogger): Promise<PublishPlan>;
+export declare function resolveOwnerPackageNames(options: ResolveOwnerTargetsOptions): Promise<string[]>;
+export {};