auklet 0.1.2 → 0.1.3

package/dist/publish/api/npmrc.d.ts

@@ -1,4 +1,8 @@
+export type NpmrcAuthEnvOptions = {
+    token?: string;
+};
 export declare function findNpmrcWithAuthToken(packageRoot: string, root: string, registry?: string): string | undefined;
 export declare function findNpmrcFiles(packageRoot: string, root: string): string[];
+export declare function validateNpmrcAuthEnv(packageRoot: string, root: string, options?: NpmrcAuthEnvOptions): void;
 export declare function hasAuthToken(content: string, registry?: string): boolean;
 export declare function toNpmrcRegistryKey(registry: string): string;

package/dist/publish/api/npmrc.js

@@ -23,6 +23,19 @@ export function findNpmrcFiles(packageRoot, root) {
     }
     return files;
 }
+export function validateNpmrcAuthEnv(packageRoot, root, options = {}) {
+    const env = createAvailableAuthEnv(options);
+    for (const file of findNpmrcFiles(packageRoot, root)) {
+        const missing = findMissingNpmrcEnvVars(fs.readFileSync(file, 'utf8'), env);
+        if (!missing.length)
+            continue;
+        const variable = missing[0];
+        throw new Error(`[publish] npmrc auth environment is missing: ${variable}\n` +
+            `[publish] file: ${file}\n` +
+            `[publish] Set ${variable} before retrying, or use --token with an npmrc entry such as:\n` +
+            '  //registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}');
+    }
+}
 export function hasAuthToken(content, registry) {
     const lines = content
         .split(/\r?\n/)
@@ -50,3 +63,27 @@ const parseRegistryUrl = (registry) => {
         });
     }
 };
+const findMissingNpmrcEnvVars = (content, env) => {
+    return getNpmrcAuthLines(content)
+        .flatMap((line) => [...line.matchAll(/\$\{([^}]+)\}/g)])
+        .map((match) => match[1])
+        .filter((name) => name && !env[name]);
+};
+const getNpmrcAuthLines = (content) => {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line &&
+        !line.startsWith('#') &&
+        !line.startsWith(';') &&
+        line.includes('_authToken'));
+};
+const createAvailableAuthEnv = (options) => {
+    if (!options.token)
+        return process.env;
+    return {
+        ...process.env,
+        NODE_AUTH_TOKEN: options.token,
+        NPM_TOKEN: options.token,
+    };
+};

package/dist/publish/api/pnpmApi.d.ts

@@ -8,9 +8,15 @@ export declare class NpmPackageVersionExistsError extends Error {
     constructor(packageName: string, version: string, registry?: string);
 }
 export declare function withPnpmTimeout(subprocess: ReturnType<typeof execa>, timeout: number): Promise<import("node_modules/execa/types/return/result").CommonResult<false, Options> & import("node_modules/execa/types/return/result").OmitErrorIfReject<boolean | undefined>>;
-export declare function ensurePnpm(): Promise<string>;
-export declare function readPnpmWorkspacePackages(root: string): Promise<WorkspacePackage[]>;
-export declare function runPnpmBuild(packageRoot: string): Promise<void>;
+export declare function ensurePnpm(options?: {
+    token?: string;
+}): Promise<string>;
+export declare function readPnpmWorkspacePackages(root: string, options?: {
+    token?: string;
+}): Promise<WorkspacePackage[]>;
+export declare function runPnpmBuild(packageRoot: string, options?: {
+    token?: string;
+}): Promise<void>;
 export declare function runPnpmPublish(packageRoot: string, args: Array<string>, options?: {
     token?: string;
 }): Promise<void>;

package/dist/publish/api/pnpmApi.js

@@ -50,8 +50,10 @@ export async function withPnpmTimeout(subprocess, timeout) {
     subprocess.catch(() => { });
     return result;
 }
-export async function ensurePnpm() {
-    const result = await runPnpm(['--version']);
+export async function ensurePnpm(options = {}) {
+    const result = await runPnpm(['--version'], {
+        env: createPnpmAuthEnv(options.token),
+    });
     const stdout = String(result.stdout ?? '');
     if (hasFailedPnpmResult(result) || !stdout) {
         throw new Error('[publish] pnpm is required for publishing.\n' +
@@ -66,9 +68,11 @@ export async function ensurePnpm() {
     }
     return version;
 }
-export async function readPnpmWorkspacePackages(root) {
+export async function readPnpmWorkspacePackages(root, options = {}) {
     try {
-        return (await readPnpmWorkspacePackageInfo(root)).map((item) => {
+        return (await readPnpmWorkspacePackageInfo(root, {
+            env: createPnpmAuthEnv(options.token),
+        })).map((item) => {
             if (!isWorkspacePackage(item))
                 throwInvalidWorkspacePackages();
             return item;
@@ -80,9 +84,10 @@ export async function readPnpmWorkspacePackages(root) {
         });
     }
 }
-export async function runPnpmBuild(packageRoot) {
+export async function runPnpmBuild(packageRoot, options = {}) {
     const result = await runPnpm(['run', 'build'], {
         cwd: packageRoot,
+        env: createPnpmAuthEnv(options.token),
         stdio: 'inherit',
     });
     if (hasFailedPnpmResult(result)) {

package/dist/publish/cli.js

@@ -2,7 +2,9 @@ import minimist from 'minimist';
 import { isArray } from 'aidly';
 import { OwnerRunner } from '#auklet/publish/ownerRunner';
 import { PublishRunner } from '#auklet/publish/publishRunner';
+import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
 import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 const publishFlags = new Set([
     '_',
     'filter',
@@ -17,8 +19,10 @@ const publishFlags = new Set([
 ]);
 const ownerFlags = new Set(['_', 'filter', 'package', 'otp']);
 export async function runPublishCli(args) {
-    await ensurePnpm();
-    await new PublishRunner(resolvePublishCliOptions(args)).run();
+    const options = resolvePublishCliOptions(args);
+    validatePublishCliNpmrcAuthEnv(options.cwd, options.token);
+    await ensurePnpm({ token: options.token });
+    await new PublishRunner(options).run();
 }
 export function resolvePublishCliOptions(args, cwd = process.cwd()) {
     const argv = parsePublishArgs(args);
@@ -66,9 +70,11 @@ export async function runOwnerCli(args) {
     if (!users.length) {
         throw new Error('[publish] owner add requires at least one user.');
     }
+    const cwd = process.cwd();
+    validatePublishCliNpmrcAuthEnv(cwd);
     await ensurePnpm();
     await new OwnerRunner({
-        cwd: process.cwd(),
+        cwd,
         users,
         filters: toArray(argv.filter),
         packages: toArray(argv.package),
@@ -105,3 +111,6 @@ const stringOption = (value) => {
         return String(value.at(-1));
     return String(value);
 };
+const validatePublishCliNpmrcAuthEnv = (cwd, token) => {
+    validateNpmrcAuthEnv(cwd, findWorkspaceRoot(cwd) ?? cwd, { token });
+};

package/dist/publish/inspect.js

@@ -4,13 +4,18 @@ import { createAukletLogger } from '#auklet/logger';
 import { resolvePublishTag } from '#auklet/publish/api/publishArgs';
 import { getPublishRegistry } from '#auklet/publish/api/registry';
 import { ensurePnpm } from '#auklet/publish/api/pnpmApi';
+import { validateNpmrcAuthEnv } from '#auklet/publish/api/npmrc';
 import { resolvePublishCliOptions } from '#auklet/publish/cli';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
 import { inspectPublishRegistry, } from '#auklet/publish/inspectRegistry';
 import { inspectPackageFiles, PackInspectReporter, } from '#auklet/publish/inspectPack';
 import { resolvePublishPlan } from '#auklet/publish/targetResolver';
 export async function runInspectPublishCli(args) {
-    await ensurePnpm();
     const options = resolvePublishCliOptions(args);
+    validateNpmrcAuthEnv(options.cwd, findWorkspaceRoot(options.cwd) ?? options.cwd, {
+        token: options.token,
+    });
+    await ensurePnpm({ token: options.token });
     const logger = createAukletLogger({ scope: 'inspect' });
     const plan = await resolvePublishPlan(options, logger);
     const packageFileChecks = inspectPackageFiles(plan.targets);

package/dist/publish/publishRunner.js

@@ -36,7 +36,7 @@ export class PublishRunner {
             await runPublishHook({ status: 'beforeBuild', plan });
             failureHookEnabled = true;
             this.versions.writeBeforeBuild(plan);
-            await runPackageBuilds(plan.targets, this.logger);
+            await runPackageBuilds(plan.targets, this.logger, this.options);
             await runPublishHook({ status: 'afterBuild', plan });
             await formatPublishOutputs(plan.targets, this.options.format);
             await runPublishHook({ status: 'beforePublish', plan });

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

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

package/dist/publish/runner/packageBuilder.js

@@ -8,9 +8,13 @@ export function validateBuildScript(targets) {
         }
     }
 }
-export async function runPackageBuilds(targets, logger) {
+export async function runPackageBuilds(targets, logger, options = {}) {
     for (const target of targets) {
         logger.step('build ', logger.package(target.packageName));
+        if (options.token) {
+            await runPnpmBuild(target.packageRoot, { token: options.token });
+            continue;
+        }
         await runPnpmBuild(target.packageRoot);
     }
 }

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

@@ -7,6 +7,7 @@ export declare class PublishPreflight {
     constructor(options: PublishOptions, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
     verifyBeforeBuild(plan: PublishPlan): Promise<void>;
+    private verifyNpmrcAuthEnv;
     private verifyTokenConfig;
     private verifyAuthentication;
     private verifyPnpmPublishDryRun;

package/dist/publish/runner/publishPreflight.js

@@ -1,6 +1,6 @@
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
 import { hasPublishedPackageVersion, NpmPackageVersionExistsError, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
-import { findNpmrcFiles, findNpmrcWithAuthToken, toNpmrcRegistryKey, } from '#auklet/publish/api/npmrc';
+import { findNpmrcFiles, findNpmrcWithAuthToken, toNpmrcRegistryKey, validateNpmrcAuthEnv, } from '#auklet/publish/api/npmrc';
 import { getPublishRegistry } from '#auklet/publish/api/registry';
 import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
@@ -16,12 +16,20 @@ export class PublishPreflight {
         await this.verifyPnpmPublishDryRun(plan);
     }
     async verifyBeforeBuild(plan) {
+        this.verifyNpmrcAuthEnv(plan);
         this.verifyTokenConfig(plan);
         if (plan.dryRun)
             return;
         await this.verifyAuthentication(plan);
         await this.verifyPackageVersions(plan);
     }
+    verifyNpmrcAuthEnv(plan) {
+        for (const target of plan.targets) {
+            validateNpmrcAuthEnv(target.packageRoot, plan.root, {
+                token: this.options.token,
+            });
+        }
+    }
     verifyTokenConfig(plan) {
         if (!this.options.token)
             return;

package/dist/publish/targetResolver.d.ts

@@ -1,6 +1,6 @@
 import { type AukletLogger } from '#auklet/logger';
 import type { OwnerOptions, PublishOptions, PublishPlan } from '#auklet/publish/types';
-type ResolvePublishTargetsOptions = Pick<PublishOptions, 'cwd' | 'filters' | 'version' | 'dryRun'>;
+type ResolvePublishTargetsOptions = Pick<PublishOptions, 'cwd' | 'filters' | 'version' | 'dryRun' | 'token'>;
 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[]>;

package/dist/publish/targetResolver.js

@@ -59,7 +59,9 @@ const resolveMonorepoPublishPlan = async (options, logger) => {
     const root = requireWorkspaceRoot(options.cwd);
     const rootPackageJson = readPackageJson(root);
     const rootVersion = requirePackageVersion(root, rootPackageJson);
-    const workspacePackages = await readPnpmWorkspacePackages(root);
+    const workspacePackages = await readPnpmWorkspacePackages(root, {
+        token: options.token,
+    });
     const selectedPackages = filterWorkspacePackages(workspacePackages, options.filters);
     const targets = selectedPackages
         .filter((item) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",