auklet 0.0.29 → 0.1.1

package/dist/publish/inspectPack.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isArray, isPlainObject, isString } from 'aidly';
+import { createAukletLogger } from '#auklet/logger';
+import { resolvePublishPlan } from '#auklet/publish/targetResolver';
+export async function runInspectPackCli(args) {
+    const options = resolveInspectPackOptions(args);
+    const logger = createAukletLogger({ scope: 'inspect' });
+    const plan = await resolvePublishPlan({
+        cwd: options.cwd,
+        filters: options.filters,
+        dryRun: true,
+        version: undefined,
+    }, logger);
+    const checks = inspectPackageFiles(plan.targets);
+    new PackInspectReporter(options.cwd, plan.targets, checks).report();
+    return checks.some((check) => check.status === 'missing') ? 1 : 0;
+}
+const resolveInspectPackOptions = (args) => {
+    const filters = [];
+    const cliArgs = args.filter((arg) => arg !== '--');
+    for (let index = 0; index < cliArgs.length; index += 1) {
+        const arg = cliArgs[index];
+        if (arg === '--filter') {
+            const value = cliArgs[index + 1];
+            if (!value)
+                throw new Error('[inspect] --filter requires a value.');
+            filters.push(value);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--filter=')) {
+            filters.push(arg.slice('--filter='.length));
+            continue;
+        }
+        throw new Error(`[inspect] unknown inspect pack argument: ${arg}`);
+    }
+    return {
+        cwd: process.cwd(),
+        filters,
+    };
+};
+export function inspectPackageFiles(targets) {
+    return targets.flatMap((target) => inspectTargetPackage(target));
+}
+const inspectTargetPackage = (target) => {
+    return collectPackageFileReferences(target.packageJson).map((reference) => ({
+        target,
+        field: reference.field,
+        file: reference.file,
+        status: getFileStatus(target.packageRoot, reference.file),
+    }));
+};
+const collectPackageFileReferences = (packageJson) => {
+    const references = [];
+    addStringField(references, packageJson, 'main');
+    addStringField(references, packageJson, 'module');
+    addStringField(references, packageJson, 'types');
+    addStringField(references, packageJson, 'typings');
+    addStringField(references, packageJson, 'style');
+    addStringField(references, packageJson, 'stylesheet');
+    addBinFields(references, packageJson.bin);
+    addExportFields(references, packageJson.exports, 'exports');
+    addFilesFields(references, packageJson.files);
+    return references;
+};
+const addStringField = (references, packageJson, field) => {
+    const value = Reflect.get(packageJson, field);
+    if (isString(value))
+        references.push({ field, file: value });
+};
+const addBinFields = (references, value) => {
+    if (isString(value)) {
+        references.push({ field: 'bin', file: value });
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    for (const [name, file] of Object.entries(value)) {
+        if (isString(file))
+            references.push({ field: `bin.${name}`, file });
+    }
+};
+const addExportFields = (references, value, field) => {
+    if (isString(value)) {
+        references.push({ field, file: value });
+        return;
+    }
+    if (isArray(value)) {
+        value.forEach((item, index) => {
+            addExportFields(references, item, `${field}[${index}]`);
+        });
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    for (const [key, item] of Object.entries(value)) {
+        addExportFields(references, item, formatFieldKey(field, key));
+    }
+};
+const addFilesFields = (references, value) => {
+    if (!isArray(value))
+        return;
+    value.forEach((file, index) => {
+        if (isString(file))
+            references.push({ field: `files[${index}]`, file });
+    });
+};
+const getFileStatus = (packageRoot, file) => {
+    if (file.startsWith('!'))
+        return 'skipped';
+    if (file.startsWith('#') || file.includes('://'))
+        return 'skipped';
+    if (file.includes('*'))
+        return 'pattern';
+    const absolutePath = path.resolve(packageRoot, file);
+    const relativePath = path.relative(packageRoot, absolutePath);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        return 'skipped';
+    }
+    return fs.existsSync(absolutePath) ? 'exists' : 'missing';
+};
+const formatFieldKey = (field, key) => {
+    return /^[a-zA-Z_$][\w$-]*$/.test(key)
+        ? `${field}.${key}`
+        : `${field}[${JSON.stringify(key)}]`;
+};
+export class PackInspectReporter {
+    cwd;
+    targets;
+    checks;
+    title;
+    logger = createAukletLogger();
+    constructor(cwd, targets, checks, title = 'Pack inspect') {
+        this.cwd = cwd;
+        this.targets = targets;
+        this.checks = checks;
+        this.title = title;
+    }
+    report() {
+        const missingChecks = this.checks.filter((check) => check.status === 'missing');
+        this.logger.newline();
+        this.logger.result({
+            title: this.formatResultTitle(this.title, missingChecks.length > 0),
+            status: missingChecks.length ? 'error' : 'info',
+            body: ['Read-only package file checks. No files or packages changed.'],
+            details: {
+                packages: this.formatValue(this.targets.length),
+                checks: this.formatValue(this.checks.length),
+                missing: missingChecks.length
+                    ? this.logger.colors.bold(this.logger.colors.red(missingChecks.length))
+                    : this.formatValue(0),
+            },
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Package files');
+        this.logger.rows({
+            columns: ['package', 'field', 'file', 'status'],
+            rows: this.checks.map((check) => [
+                this.logger.package(check.target.packageName),
+                this.logger.colors.gray(check.field),
+                this.logger.path(check.file),
+                this.formatStatus(check.status),
+            ]),
+            empty: this.logger.colors.gray('No package file references found.'),
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Package roots');
+        this.logger.rows({
+            columns: ['package', 'root'],
+            rows: this.targets.map((target) => [
+                this.logger.package(target.packageName),
+                this.logger.path(path.relative(this.cwd, target.packageRoot) || '.'),
+            ]),
+        });
+        if (missingChecks.length) {
+            this.logger.newline();
+            this.writeSectionTitle('Missing files', 'error');
+            for (const [index, check] of missingChecks.entries()) {
+                if (index > 0)
+                    this.logger.newline();
+                this.logger.item(this.logger.package(check.target.packageName), ': ', this.logger.colors.red(check.field), ' -> ', this.logger.colors.red(check.file));
+            }
+        }
+        this.logger.newline();
+    }
+    writeSectionTitle(title, status = 'normal') {
+        const content = status === 'error' ? this.logger.colors.red(title) : title;
+        this.logger.raw(content);
+    }
+    formatStatus(status) {
+        if (status === 'exists')
+            return this.logger.colors.green('exists');
+        if (status === 'missing')
+            return this.logger.colors.red('missing');
+        if (status === 'pattern')
+            return this.logger.colors.yellow('pattern');
+        return this.logger.colors.gray('skipped');
+    }
+    formatValue(value) {
+        return this.logger.colors.bold(this.logger.colors.cyan(String(value)));
+    }
+    formatResultTitle(title, failed) {
+        return this.logger.colors.bold(failed ? this.logger.colors.red(title) : this.logger.colors.green(title));
+    }
+}

package/dist/publish/inspectRegistry.d.ts

@@ -0,0 +1,23 @@
+import type { PublishPlan } from '#auklet/publish/types';
+export type PublishRegistryCheckStatus = 'success' | 'error';
+export type PublishRegistryCheck = {
+    packageName: string;
+    registry: string;
+    auth: PublishRegistryCheckStatus;
+    version: PublishRegistryCheckStatus;
+    reason: string | null;
+};
+export type PublishRegistryRetryInfo = {
+    packageName: string;
+    registry: string;
+    check: 'auth' | 'version';
+    attempt: number;
+    maxAttempts: number;
+    error: Error;
+};
+export type PublishRegistryCheckInfo = Pick<PublishRegistryRetryInfo, 'packageName' | 'registry' | 'check'>;
+export type InspectPublishRegistryOptions = {
+    onCheck?: (info: PublishRegistryCheckInfo) => void;
+    onRetry?: (info: PublishRegistryRetryInfo) => void;
+};
+export declare function inspectPublishRegistry(plan: PublishPlan, options?: InspectPublishRegistryOptions): Promise<PublishRegistryCheck[]>;

package/dist/publish/inspectRegistry.js

@@ -0,0 +1,107 @@
+import { retry } from 'aidly';
+import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { hasPublishedPackageVersion, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
+const registryCheckTimeout = 5_000;
+const registryCheckRetryTimes = 2;
+export async function inspectPublishRegistry(plan, options = {}) {
+    const authResults = new Map();
+    const checks = [];
+    for (const target of plan.targets) {
+        const registry = getPublishRegistry(target.packageJson.publishConfig);
+        const registryLabel = registry ?? 'default';
+        const authKey = `${target.packageRoot}\n${registryLabel}`;
+        if (!authResults.has(authKey)) {
+            await checkAuth(authResults, authKey, target.packageRoot, target.packageName, registry, options);
+        }
+        const authError = authResults.get(authKey) ?? null;
+        const versionError = await checkVersion(target.packageRoot, target.packageName, target.publishVersion, registry, options);
+        checks.push({
+            packageName: target.packageName,
+            registry: registryLabel,
+            auth: authError ? 'error' : 'success',
+            version: versionError ? 'error' : 'success',
+            reason: getReason(authError, versionError),
+        });
+    }
+    return checks;
+}
+const checkAuth = async (authResults, authKey, packageRoot, packageName, registry, options) => {
+    try {
+        options.onCheck?.({
+            packageName,
+            registry: registry ?? 'default',
+            check: 'auth',
+        });
+        await retryWithLog(() => runPnpmWhoami(packageRoot, {
+            packageName,
+            registry,
+            timeout: registryCheckTimeout,
+        }), {
+            check: 'auth',
+            packageName,
+            registry,
+            onRetry: options.onRetry,
+        });
+        authResults.set(authKey, null);
+        return null;
+    }
+    catch (error) {
+        const authError = toError(error);
+        authResults.set(authKey, authError);
+        return authError;
+    }
+};
+const checkVersion = async (packageRoot, packageName, version, registry, options) => {
+    try {
+        options.onCheck?.({
+            packageName,
+            registry: registry ?? 'default',
+            check: 'version',
+        });
+        const exists = await retryWithLog(() => hasPublishedPackageVersion(packageRoot, packageName, version, {
+            registry,
+            timeout: registryCheckTimeout,
+        }), {
+            check: 'version',
+            packageName,
+            registry,
+            onRetry: options.onRetry,
+        });
+        return exists
+            ? new Error(`version already exists: ${packageName}@${version}`)
+            : null;
+    }
+    catch (error) {
+        return toError(error);
+    }
+};
+const getReason = (authError, versionError) => {
+    return authError?.message ?? versionError?.message ?? null;
+};
+const toError = (error) => {
+    return error instanceof Error ? error : new Error(String(error));
+};
+const retryWithLog = (fn, options) => {
+    let attempt = 0;
+    let previousError = null;
+    return retry(async () => {
+        attempt += 1;
+        if (attempt > 1) {
+            options.onRetry?.({
+                packageName: options.packageName,
+                registry: options.registry ?? 'default',
+                check: options.check,
+                attempt: attempt - 1,
+                maxAttempts: registryCheckRetryTimes,
+                error: previousError ?? new Error('publish registry check failed.'),
+            });
+        }
+        try {
+            return await fn();
+        }
+        catch (error) {
+            previousError = toError(error);
+            throw error;
+        }
+    }, registryCheckRetryTimes);
+};

package/dist/publish/runner/publishPreflight.js

@@ -1,6 +1,6 @@
-import { isPlainObject, isString } from 'aidly';
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
 import { hasPublishedPackageVersion, NpmPackageVersionExistsError, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
+import { getPublishRegistry } from '#auklet/publish/api/registry';
 import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
@@ -66,9 +66,3 @@ export class PublishPreflight {
         }
     }
 }
-const getPublishRegistry = (publishConfig) => {
-    if (!isPlainObject(publishConfig))
-        return undefined;
-    const registry = Reflect.get(publishConfig, 'registry');
-    return isString(registry) && registry.length > 0 ? registry : undefined;
-};

package/dist/publish/runner/releaseGitController.js

@@ -18,6 +18,10 @@ export class ReleaseGitController {
     }
     async commitAndTag(plan) {
         const git = await isGitRepository(plan.root);
+        if (git && this.options.git === false) {
+            this.warnOnce('--no-git enabled, skipping git commit and tag.');
+            return;
+        }
         if (git && this.options.allowDirty) {
             this.warnOnce('--allow-dirty enabled, skipping git commit and tag.');
             return;

package/dist/publish/types.d.ts

@@ -43,13 +43,14 @@ export type WorkspacePackage = {
 };
 export type PublishOptions = {
     cwd: string;
-    filters: Array<string>;
-    version?: string;
     dryRun: boolean;
     format: boolean;
-    otp?: string;
-    ignoreScripts: boolean;
     allowDirty: boolean;
+    ignoreScripts: boolean;
+    filters: Array<string>;
+    git?: boolean;
+    otp?: string;
+    version?: string;
 };
 export type OwnerOptions = {
     cwd: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.29",
+  "version": "0.1.1",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",
@@ -99,7 +99,7 @@
     "dev:registry-login": "npm adduser --registry http://127.0.0.1:4873 --auth-type=legacy",
     "dev:examples": "pnpm --filter './examples/*' --if-present dev",
     "build:examples": "pnpm --filter './examples/*' build",
-    "format:md": "prettier --write \"*.md\" \"examples/**/*.md\"",
-    "format": "prettier --write \"package.json\" \"pnpm-workspace.yaml\" \"(bin|src|dist|examples)/**/*.{js,mjs,cjs,ts,tsx,json,md,yaml,css}\""
+    "format:md": "prettier --write \"*.md\" \"docs/**/*.md\" \"examples/**/*.md\"",
+    "format": "prettier --write \"package.json\" \"pnpm-workspace.yaml\" \"*.md\" \"docs/**/*.md\" \"(bin|src|dist|examples)/**/*.{js,mjs,cjs,ts,tsx,json,md,yaml,css}\""
   }
 }