auklet 0.1.2 → 0.1.4

package/dist/publish/runner/packageBuilder.js

@@ -1,5 +1,6 @@
 import { isString } from 'aidly';
 import { runPnpmBuild } from '#auklet/publish/api/pnpmApi';
+import { createPublishTargetEnv } from '#auklet/publish/publishEnv';
 export function validateBuildScript(targets) {
     for (const target of targets) {
         const buildScript = target.packageJson.scripts?.build;
@@ -8,9 +9,14 @@ export function validateBuildScript(targets) {
         }
     }
 }
-export async function runPackageBuilds(targets, logger) {
+export async function runPackageBuilds(targets, logger, options, runtime) {
     for (const target of targets) {
         logger.step('build ', logger.package(target.packageName));
+        const { env } = createPublishTargetEnv(options, runtime, target);
+        if (env) {
+            await runPnpmBuild(target.packageRoot, { env });
+            continue;
+        }
         await runPnpmBuild(target.packageRoot);
     }
 }

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

@@ -1,10 +1,11 @@
 import type { AukletLogger } from '#auklet/logger';
-import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { PublishOptions, PublishPlan, PublishRuntime } from '#auklet/publish/types';
 export declare class PackagePublisher {
     private readonly options;
+    private readonly runtime;
     private readonly logger;
     private readonly pnpm;
-    constructor(options: PublishOptions, logger: AukletLogger);
+    constructor(options: PublishOptions, runtime: PublishRuntime, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
 }
 export declare function logAuthenticationError(logger: AukletLogger, error: unknown): void;

package/dist/publish/runner/packagePublisher.js

@@ -3,17 +3,19 @@ import { NpmPublishAuthenticationError } from '#auklet/publish/api/pnpmApi';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PackagePublisher {
     options;
+    runtime;
     logger;
     pnpm = new PnpmPublishApi();
-    constructor(options, logger) {
+    constructor(options, runtime, logger) {
         this.options = options;
+        this.runtime = runtime;
         this.logger = logger;
     }
     async run(plan) {
         const publishedTargets = [];
         for (const target of plan.targets) {
             try {
-                await this.pnpm.publish(target, this.options);
+                await this.pnpm.publish(target, this.options, this.runtime);
                 publishedTargets.push(target);
             }
             catch (error) {

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

@@ -1,12 +1,14 @@
 import type { AukletLogger } from '#auklet/logger';
-import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
+import type { PublishOptions, PublishPlan, PublishRuntime } from '#auklet/publish/types';
 export declare class PublishPreflight {
     private readonly options;
+    private readonly runtime;
     private readonly logger;
     private readonly pnpm;
-    constructor(options: PublishOptions, logger: AukletLogger);
+    constructor(options: PublishOptions, runtime: PublishRuntime, 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,27 +1,39 @@
 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 { runPnpmWhoami, hasPublishedPackageVersion, NpmPackageVersionExistsError, } from '#auklet/publish/api/pnpmApi';
+import { findNpmrcFiles, findNpmrcWithAuthToken, toNpmrcRegistryKey, validateNpmrcAuthEnv, } from '#auklet/publish/api/npmrc';
 import { getPublishRegistry } from '#auklet/publish/api/registry';
+import { createPublishTargetEnv } from '#auklet/publish/publishEnv';
 import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
     options;
+    runtime;
     logger;
     pnpm = new PnpmPublishApi();
-    constructor(options, logger) {
+    constructor(options, runtime, logger) {
         this.options = options;
+        this.runtime = runtime;
         this.logger = logger;
     }
     async run(plan) {
         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) {
+            const { env } = createPublishTargetEnv(this.options, this.runtime, target);
+            validateNpmrcAuthEnv(target.packageRoot, plan.root, {
+                env,
+            });
+        }
+    }
     verifyTokenConfig(plan) {
         if (!this.options.token)
             return;
@@ -43,7 +55,7 @@ export class PublishPreflight {
             await runPnpmWhoami(target.packageRoot, {
                 packageName: target.packageName,
                 registry,
-                token: this.options.token,
+                ...createPublishTargetEnv(this.options, this.runtime, target),
             });
             checked.add(key);
         }
@@ -55,7 +67,7 @@ export class PublishPreflight {
         };
         for (const target of plan.targets) {
             try {
-                await this.pnpm.publish(target, options);
+                await this.pnpm.publish(target, options, this.runtime);
             }
             catch (error) {
                 logAuthenticationError(this.logger, error);
@@ -66,7 +78,10 @@ export class PublishPreflight {
     async verifyPackageVersions(plan) {
         for (const target of plan.targets) {
             const registry = getPublishRegistry(target.packageJson.publishConfig);
-            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, { registry, token: this.options.token });
+            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, {
+                registry,
+                ...createPublishTargetEnv(this.options, this.runtime, target),
+            });
             if (!exists)
                 continue;
             this.logExistingVersion(target, registry);

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

@@ -1,5 +1,5 @@
+import { type AukletLogger } from '#auklet/logger';
 import type { PublishOptions, PublishPlan } from '#auklet/publish/types';
-import type { AukletLogger } from '#auklet/logger';
 export declare class VersionWriter {
     private readonly options;
     private readonly logger;

package/dist/publish/targetResolver.d.ts

@@ -1,7 +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'>;
+import type { OwnerOptions, PublishOptions, PublishPlan, PublishRuntime } from '#auklet/publish/types';
+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 resolvePublishPlan(options: ResolvePublishTargetsOptions, runtime: PublishRuntime, logger?: AukletLogger): Promise<PublishPlan>;
 export declare function resolveOwnerPackageNames(options: ResolveOwnerTargetsOptions): Promise<string[]>;
 export {};

package/dist/publish/targetResolver.js

@@ -1,13 +1,14 @@
 import path from 'node:path';
 import semver from 'semver';
-import { createScopedAukletLogger } from '#auklet/logger';
 import { findWorkspaceRoot } from '#auklet/workspace/root';
+import { createPublishRootEnv } from '#auklet/publish/publishEnv';
+import { createAukletLogger } from '#auklet/logger';
 import { getPublishConfig, readPackageJson, requirePackageName, requirePackageVersion, } from '#auklet/publish/api/packageJsonApi';
 import { readPnpmWorkspacePackages } from '#auklet/publish/api/pnpmApi';
 import { resolvePublishVersion, validateVersionConsistency, } from '#auklet/publish/version';
-export async function resolvePublishPlan(options, logger = createScopedAukletLogger('publish')) {
+export async function resolvePublishPlan(options, runtime, logger = createAukletLogger({ scope: 'publish' })) {
     if (options.filters.length) {
-        return resolveMonorepoPublishPlan(options, logger);
+        return resolveMonorepoPublishPlan(options, runtime, logger);
     }
     return resolveCurrentPackagePublishPlan(options);
 }
@@ -55,11 +56,16 @@ const resolveCurrentPackagePublishPlan = async (options) => {
         workspaceMode: 'single',
     };
 };
-const resolveMonorepoPublishPlan = async (options, logger) => {
+const resolveMonorepoPublishPlan = async (options, runtime, logger) => {
     const root = requireWorkspaceRoot(options.cwd);
     const rootPackageJson = readPackageJson(root);
     const rootVersion = requirePackageVersion(root, rootPackageJson);
-    const workspacePackages = await readPnpmWorkspacePackages(root);
+    const { env } = createPublishRootEnv({
+        token: options.token,
+    }, runtime);
+    const workspacePackages = await readPnpmWorkspacePackages(root, {
+        env,
+    });
     const selectedPackages = filterWorkspacePackages(workspacePackages, options.filters);
     const targets = selectedPackages
         .filter((item) => {

package/dist/publish/types.d.ts

@@ -1,3 +1,5 @@
+import type { AukletEnvContext } from '#auklet/env';
+import type { DeferredCliValue } from '#auklet/cli/values';
 export type PackageJson = {
     name?: string;
     version?: string;
@@ -50,9 +52,12 @@ export type PublishOptions = {
     filters: Array<string>;
     git?: boolean;
     otp?: string;
-    token?: string;
+    token?: DeferredCliValue;
     version?: string;
 };
+export type PublishRuntime = {
+    envContext: AukletEnvContext;
+};
 export type OwnerOptions = {
     cwd: string;
     users: Array<string>;

package/package.json

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