apify-test-tools 0.10.1-beta.6 → 0.10.1-beta.7

package/bin/build-from-local.ts

@@ -7,12 +7,13 @@ import type * as ApifyClientTypes from 'apify-client';
 import { ActorSourceType } from 'apify-client';
 
 import { dryRunBuildData, LOCAL_SOURCE_VERSION_NUMBER, runAndSummarizeBuilds } from './build.js';
-import { buildDockerIgnoreMatcher } from './dockerignore.js';
+import { loadDockerIgnore } from './dockerignore.js';
 import { logger } from './logger.js';
 import { isPathWithinScope } from './path-utils.js';
 import type { ActorConfig, BuildData } from './types.js';
 import type { SourceFile } from './utils.js';
 import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, readSourceFile } from './utils.js';
+import type { RelativeDir } from './utils/path/repo-relative.js';
 
 // JUST IN CASE. File patterns that commonly hold credentials — never ship these into a build, regardless
 // of sourceType or of whether the repo's .gitignore happens to list them. Everything else that should be
@@ -21,30 +22,27 @@ import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, readSourceFile } f
 const SKIP_FILE_PATTERNS = [/^\.env(\..+)?$/, /\.pem$/, /\.key$/, /\.pfx$/, /\.p12$/];
 const isSecretFile = (fileName: string): boolean => SKIP_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
 
-export const collectSourceFiles = async (actorName: string, actorDir: string): Promise<SourceFile[]> => {
+export const collectSourceFiles = async (actorConfig: ActorConfig): Promise<SourceFile[]> => {
     const repoRoot = process.cwd();
-    const absActorDir = path.resolve(actorDir);
+    const absActorDir = path.resolve(actorConfig.folder.path);
 
-    // Read actor.json to check if this is a monorepo actor with an external dockerContextDir.
-    // Monorepo actors point their dockerContextDir to a parent directory (e.g. "../../.."),
-    // which means the Docker build context is the repo root, not the actor directory itself.
-    const actorJsonPath = path.join(absActorDir, '.actor', 'actor.json');
-    const actorJson = JSON.parse(await fs.readFile(actorJsonPath, 'utf8')) as Record<string, unknown>;
-    const rawContextDir = actorJson.dockerContextDir as string | undefined;
-    const contextAbsDir = rawContextDir ? path.resolve(absActorDir, '.actor', rawContextDir) : undefined;
-    const isMonorepoActor = !!contextAbsDir && isOutsideDir(contextAbsDir, absActorDir);
+    // Config loading has already resolved dockerContextDir. Keep the raw actor.json contents
+    // for rewriting its path fields if this actor needs a flattened build context.
+    const actorJson = JSON.parse(await fs.readFile(actorConfig.actorJson.file.path, 'utf8')) as Record<string, unknown>;
+    const isMonorepoActor = !actorConfig.folder.contains(actorConfig.dockerContextDir);
 
-    const dockerContextDirAbs = isMonorepoActor ? contextAbsDir! : absActorDir;
-    const keptFilePaths = await collectNonIgnoredFiles(dockerContextDirAbs, repoRoot);
+    const sourceRoot = isMonorepoActor ? actorConfig.dockerContextDir : actorConfig.folder;
+    const sourceRootAbs = path.resolve(sourceRoot.path);
+    const keptFilePaths = await collectNonIgnoredFiles(sourceRoot, repoRoot);
 
     if (!isMonorepoActor) {
-        return Promise.all(keptFilePaths.map(async (filePath) => readSourceFile(filePath, dockerContextDirAbs)));
+        return Promise.all(keptFilePaths.map(async (filePath) => readSourceFile(filePath, sourceRootAbs)));
     }
 
     const { tempDir, filePaths } = await flattenMonorepoContext(
-        actorName,
+        actorConfig.actorFullName,
         absActorDir,
-        contextAbsDir!,
+        sourceRootAbs,
         actorJson,
         keptFilePaths,
     );
@@ -65,16 +63,10 @@ export const collectSourceFiles = async (actorName: string, actorDir: string): P
 // regardless of .gitignore/.dockerignore, matching Apify CLI's own behavior. Files matching the
 // hardcoded secret-pattern backstop (keys, certs, .env variants) are dropped unconditionally,
 // .actor/ included, since those should never ship regardless of what the ignore files say.
-export const collectNonIgnoredFiles = async (dockerContextDir: string, repoRoot: string): Promise<string[]> => {
-    const relativePaths = await listRepoFilePaths(repoRoot, dockerContextDir);
+export const collectNonIgnoredFiles = async (dockerContextDir: RelativeDir, repoRoot: string): Promise<string[]> => {
+    const relativePaths = await listRepoFilePaths(repoRoot, path.resolve(repoRoot, dockerContextDir.path));
     const ignoredPaths = await getGitignoredPaths(relativePaths, repoRoot);
-    const rootRelativePaths = new Map(
-        relativePaths.map((relPath) => [
-            relPath,
-            path.relative(dockerContextDir, path.join(repoRoot, relPath)).split(path.sep).join('/'),
-        ]),
-    );
-    const isDockerIgnored = buildDockerIgnoreMatcher(dockerContextDir);
+    const isDockerIgnored = loadDockerIgnore(dockerContextDir);
 
     return relativePaths
         .filter((relPath) => {
@@ -82,7 +74,7 @@ export const collectNonIgnoredFiles = async (dockerContextDir: string, repoRoot:
             const isUnderActorDir = relPath.split('/').includes('.actor');
             if (isUnderActorDir) return true;
             if (ignoredPaths.has(relPath)) return false;
-            return !isDockerIgnored(rootRelativePaths.get(relPath)!);
+            return !isDockerIgnored(relPath);
         })
         .map((relPath) => path.join(repoRoot, relPath));
 };
@@ -205,7 +197,7 @@ export const runBuildsFromLocal = async ({
     return runAndSummarizeBuilds(actorConfigs, 'LOCAL BUILDS', async (actorConfig, builder) => {
         // Zipped and uploaded like `apify push` does, since inline SOURCE_FILES are capped at ~9 MB.
         const zip = new AdmZip();
-        for (const { name, content } of await collectSourceFiles(actorConfig.actorFullName, actorConfig.folder)) {
+        for (const { name, content } of await collectSourceFiles(actorConfig)) {
             zip.addFile(name, content);
         }
         const actorVersion: ApifyClientTypes.ActorVersion = {

package/bin/build.ts

@@ -352,7 +352,7 @@ export const runBuilds = async ({
 
             // Depending on if these are miniactors or standaloneActors
             let gitRepoUrl = `${repoUrl}#${branch}`;
-            if (actorConfig.folder) {
+            if (!actorConfig.folder.isRoot()) {
                 gitRepoUrl = `${gitRepoUrl}:${actorConfig.folder}`;
             }
             return {

package/bin/diff-changes.ts

@@ -1,8 +1,8 @@
 import { isCosmeticOnlyJsonSchemaChange } from './diff-json-schema.js';
 import { type DockerIgnoreMatcher, loadDockerIgnore } from './dockerignore.js';
 import { logger } from './logger.js';
-import { findContainingScope, hoistPath, isPathWithinScope } from './path-utils.js';
 import type { ActorConfig, Commit } from './types.js';
+import { type RelativeDir, RelativeFile } from './utils/path/repo-relative.js';
 
 interface ShouldBuildAndTestOptions {
     filepathsChanged: string[];
@@ -21,9 +21,10 @@ const IGNORED_TOP_LEVEL_FILES = [
     '.editorconfig',
 ];
 
-// Expects an already-hoisted path (relative to the matched context entry, see findContainingScope).
-const isIgnoredTopLevelFile = (hoistedLowercaseFilePath: string): boolean =>
-    IGNORED_TOP_LEVEL_FILES.some((pattern) => hoistedLowercaseFilePath.startsWith(pattern));
+const isIgnoredTopLevelFile = (filePath: RelativeFile, contextPath: RelativeDir): boolean => {
+    const pathWithinContext = contextPath.relativePathTo(filePath.path).toLowerCase();
+    return IGNORED_TOP_LEVEL_FILES.some((pattern) => pathWithinContext.startsWith(pattern));
+};
 
 type FileChangeForActor =
     | { impact: 'ignored' }
@@ -46,12 +47,12 @@ type FileChangeForActor =
  * 7. Everything else → functional
  */
 const classifyFileChange = async (
-    originalFilePath: string,
+    changedFile: RelativeFile,
     actorConfig: ActorConfig,
     commits: Commit[],
     dockerIgnoreMatcher: DockerIgnoreMatcher,
 ): Promise<FileChangeForActor> => {
-    const lowercaseFilePath = originalFilePath.toLowerCase();
+    const lowercaseFilePath = changedFile.path.toLowerCase();
 
     // TODO: hardcodes that there's a single repo-wide changelog belonging to every actor. Should instead
     // be derived from parsing actor.json (readme, changelog, schema paths), see
@@ -60,56 +61,46 @@ const classifyFileChange = async (
         return { impact: 'cosmetic', semanticallyVerified: false };
     }
 
-    const lowercaseContextPaths = actorConfig.contextPaths.map((contextPath) => contextPath.toLowerCase());
-
-    const matchedContext = findContainingScope(lowercaseFilePath, lowercaseContextPaths);
-    if (matchedContext === undefined) {
+    const matchedContext = actorConfig.contextPaths.find((contextPath) => contextPath.contains(changedFile));
+    if (!matchedContext) {
         return { impact: 'outside-context' };
     }
 
-    const hoistedFilePath = hoistPath(lowercaseFilePath, matchedContext);
-    if (isIgnoredTopLevelFile(hoistedFilePath)) {
+    if (isIgnoredTopLevelFile(changedFile, matchedContext)) {
         return { impact: 'ignored' };
     }
 
-    const lowercaseFolder = actorConfig.folder.toLowerCase();
-    const actorDotDir = lowercaseFolder ? `${lowercaseFolder}/.actor` : '.actor';
-    const isUnderActorDotDir = isPathWithinScope(lowercaseFilePath, actorDotDir);
+    const isUnderActorDotDir = actorConfig.actorJson.file.parent.contains(changedFile);
 
     // .actor/ can legitimately be listed in .dockerignore (the Apify platform evaluates it before
     // the Docker build, so excluding it from the build context is a valid caching optimization) —
     // that shouldn't cause changes to .actor/ itself to be ignored here.
-    if (!isUnderActorDotDir && dockerIgnoreMatcher(originalFilePath)) {
+    if (!isUnderActorDotDir && dockerIgnoreMatcher(changedFile.path)) {
         return { impact: 'ignored' };
     }
 
-    const isInActorFolder = isPathWithinScope(lowercaseFilePath, lowercaseFolder);
+    const isInActorFolder = changedFile.isWithin(actorConfig.folder);
 
     if (lowercaseFilePath.endsWith('readme.md')) {
         return isInActorFolder ? { impact: 'cosmetic', semanticallyVerified: false } : { impact: 'ignored' };
     }
 
     if (lowercaseFilePath.endsWith('.json') && isUnderActorDotDir) {
-        const isCosmetic = await isCosmeticOnlyJsonSchemaChange(commits, originalFilePath);
-        if (isCosmetic) {
-            return { impact: 'cosmetic', semanticallyVerified: true };
-        }
+        const isCosmetic = await isCosmeticOnlyJsonSchemaChange(commits, changedFile.path);
+        if (isCosmetic) return { impact: 'cosmetic', semanticallyVerified: true };
     }
 
     return { impact: 'functional' };
 };
 
 /**
- * Check if a file falls inside another actor's folder.
- * Root actors (folder === "") never exclude files from siblings.
+ * Exclude files inside another actor's non-root folder, including for an actor at the repo root.
  */
-const isExcludedBySibling = (lowercaseFilePath: string, actor: ActorConfig, allActors: ActorConfig[]): boolean => {
-    return allActors.some(
-        (other) =>
-            other.folder !== actor.folder &&
-            other.folder !== '' &&
-            isPathWithinScope(lowercaseFilePath, other.folder.toLowerCase()),
-    );
+const isExcludedBySibling = (filePath: RelativeFile, actor: ActorConfig, allActors: ActorConfig[]): boolean => {
+    const isSibling = (other: ActorConfig) => !other.folder.isEqualTo(actor.folder);
+    const isNonRoot = (other: ActorConfig) => !other.folder.isRoot();
+    const nonRootSiblings = allActors.filter(isSibling).filter(isNonRoot);
+    return nonRootSiblings.some((other) => filePath.isWithin(other.folder));
 };
 
 type ActorChangeEntry = {
@@ -179,20 +170,20 @@ export const getChangedActors = async ({
         const dockerIgnoreMatcher = loadDockerIgnore(actorConfig.dockerContextDir);
 
         for (const originalFilePath of filepathsChanged) {
-            const lowercaseFilePath = originalFilePath.toLowerCase();
+            const filePath = new RelativeFile(originalFilePath);
 
-            if (isExcludedBySibling(lowercaseFilePath, actorConfig, actorConfigs)) {
+            if (isExcludedBySibling(filePath, actorConfig, actorConfigs)) {
                 continue;
             }
 
-            const change = await classifyFileChange(originalFilePath, actorConfig, commits, dockerIgnoreMatcher);
+            const change = await classifyFileChange(filePath, actorConfig, commits, dockerIgnoreMatcher);
 
             if (change.impact === 'ignored' || change.impact === 'outside-context') continue;
             if (change.impact === 'cosmetic' && !isLatest) continue;
 
-            const entry = actorsChangedMap.get(actorConfig.folder) ?? { actorConfig, files: [] };
+            const entry = actorsChangedMap.get(actorConfig.folder.path) ?? { actorConfig, files: [] };
             entry.files.push(originalFilePath);
-            actorsChangedMap.set(actorConfig.folder, entry);
+            actorsChangedMap.set(actorConfig.folder.path, entry);
         }
     }
 

package/bin/dockerignore.ts

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
-import path from 'node:path';
 
 import ignore from 'ignore';
 
-import { hoistPath, isPathWithinScope } from './path-utils.js';
+import { logger } from './logger.js';
+import type { RelativeDir, RelativeFile } from './utils/path/repo-relative.js';
 
 export type DockerIgnoreMatcher = (repoRelativePath: string) => boolean;
 
@@ -15,36 +15,43 @@ export type DockerIgnoreMatcher = (repoRelativePath: string) => boolean;
 const normalizeDockerignorePattern = (line: string): string => line.replace(/^(!?)(?:\.\/)+/, '$1');
 
 /**
- * Reads `.dockerignore` from `absoluteRootDir` and returns a matcher for paths relative to
- * `hoistFrom`. `hoistFrom` defaults to '', meaning callers already pass paths relative to
- * `absoluteRootDir` directly — isPathWithinScope/hoistPath both treat '' as "matches everything" /
- * identity, so the scope-check and hoist collapse to a no-op in that case, not via a branch.
+ * Reads a `.dockerignore` file and returns a matcher for repo-relative paths within its parent
+ * directory. Paths outside that directory never match. Matching is performed on paths relative to
+ * the `.dockerignore` file's parent, and leading `./` prefixes are removed from patterns to match
+ * Docker's normalization behavior.
  *
- * Returns a no-op matcher (always returns false) when the file is absent.
+ * Returns a matcher that always returns `false` if the file cannot be read.
  */
-export const buildDockerIgnoreMatcher = (absoluteRootDir: string, hoistFrom = ''): DockerIgnoreMatcher => {
+export const buildDockerIgnoreMatcher = (dockerIgnore: RelativeFile): DockerIgnoreMatcher => {
     let content: string;
     try {
-        content = fs.readFileSync(path.join(absoluteRootDir, '.dockerignore'), 'utf-8');
+        content = fs.readFileSync(dockerIgnore.path, 'utf-8');
     } catch {
         return () => false;
     }
 
     const matcher = ignore().add(content.split('\n').map(normalizeDockerignorePattern).join('\n'));
-
+    const rootDir = dockerIgnore.parent;
     return (filePath: string): boolean => {
-        if (!isPathWithinScope(filePath.toLowerCase(), hoistFrom.toLowerCase())) {
+        if (!rootDir.containsPath(filePath)) {
             return false;
         }
 
-        return matcher.ignores(hoistPath(filePath, hoistFrom));
+        return matcher.ignores(rootDir.relativePathTo(filePath));
     };
 };
 
 /**
- * Load .dockerignore from the root of an actor's dockerContextDir and return a matcher
- * that accepts repo-root-relative file paths. Patterns are resolved relative to
- * dockerContextDir, matching Docker's own behavior.
+ * Loads `.dockerignore` from the root of `dockerContextDir` and returns a matcher that accepts
+ * repo-relative file paths. Patterns are matched relative to `dockerContextDir`, consistent with
+ * Docker's build-context behavior. If the file cannot be read, the matcher always returns `false`.
  */
-export const loadDockerIgnore = (dockerContextDir: string): DockerIgnoreMatcher =>
-    buildDockerIgnoreMatcher(path.resolve(dockerContextDir), dockerContextDir);
+export const loadDockerIgnore = (dockerContextDir: RelativeDir): DockerIgnoreMatcher => {
+    try {
+        const dockerIgnorePath = dockerContextDir.joinFile('.dockerignore');
+        return buildDockerIgnoreMatcher(dockerIgnorePath);
+    } catch {
+        logger.warn(`[.dockerignore] not found in "${dockerContextDir}".`);
+        return () => false;
+    }
+};

package/bin/types.ts

@@ -1,3 +1,6 @@
+import type { ActorJsonPaths } from './utils/config/actor-json.js';
+import type { ExistingDir, RelativeDir } from './utils/path/repo-relative.js';
+
 export interface Config {
     targetBranch: string;
     sourceBranch: string;
@@ -22,8 +25,9 @@ export interface BuildData {
 
 export interface ActorConfig {
     actorFullName: string;
-    folder: string;
+    folder: ExistingDir;
     tokenEnvVar: string;
-    dockerContextDir: string;
-    contextPaths: string[];
+    actorJson: ActorJsonPaths;
+    dockerContextDir: RelativeDir;
+    contextPaths: RelativeDir[];
 }

package/bin/utils/config/actor-json.ts

@@ -1,3 +1,6 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+
 import z from 'zod';
 
 import { safeReadJsonObjectFile } from '../json-file.js';
@@ -38,6 +41,31 @@ const resolveFile = (actorJsonFile: ExistingFile, field: string, value: unknown)
     }
 };
 
+/**
+ * Looks for fallback locations of config files in the provided order, matches insensitively.
+ *
+ * Pretty inefficient way to do it, but it was either this bs or adding a matching library just for the insensitive matching of fallback files.
+ * So if this ever becomes a performance problem for anyone, they can explicitly state their files in the config and live happily ever after.
+ */
+const resolveDefaultFileLocations = (
+    actorJsonFile: ExistingFile,
+    fallbackPaths: readonly string[],
+): RelativeFile | undefined => {
+    for (const fallbackCandidate of fallbackPaths) {
+        const file = actorJsonFile.joinFile(fallbackCandidate);
+        const expectedName = path.posix.basename(file.path);
+        const entries = readdirSync(file.parent.path);
+        const actualName =
+            entries.find((entry) => entry === expectedName) ??
+            entries.find((entry) => entry.toLowerCase() === expectedName.toLowerCase());
+        if (actualName) {
+            const actualFile = file.parent.joinFile(actualName);
+            if (actualFile.exists()) return actualFile;
+        }
+    }
+    return undefined;
+};
+
 export function readActorJson(config: ValidatedActorConfig): ActorJsonPaths {
     const actorJsonPath = config.folder.joinFile('.actor/actor.json');
     let actorJsonFile: ExistingFile;
@@ -66,14 +94,27 @@ export function readActorJson(config: ValidatedActorConfig): ActorJsonPaths {
     return {
         file: actorJsonFile,
         dockerContextDir,
-        dockerfile: resolveFile(actorJsonFile, 'dockerfile', fields.dockerfile),
-        readme: resolveFile(actorJsonFile, 'readme', fields.readme),
-        changelog: resolveFile(actorJsonFile, 'changelog', fields.changelog),
-        inputSchema: resolveFile(
-            actorJsonFile,
-            fields.input != null ? 'input' : 'inputSchema',
-            fields.input ?? fields.inputSchema,
-        ),
+        // all these with `resolveDefaultFileLocations` is because the platform has lookup locations as fallback
+        // if not present in actor.json, this is behavior from before .actor folder was a thing
+        // with this we replicate exactly what the platform does for resolution of these files
+        // so we resolve the same way the platform does during builds.
+        dockerfile:
+            resolveFile(actorJsonFile, 'dockerfile', fields.dockerfile) ??
+            resolveDefaultFileLocations(actorJsonFile, ['./Dockerfile', '../Dockerfile']),
+        readme:
+            resolveFile(actorJsonFile, 'readme', fields.readme) ??
+            resolveDefaultFileLocations(actorJsonFile, ['./README.md', '../README.md']),
+        changelog:
+            resolveFile(actorJsonFile, 'changelog', fields.changelog) ??
+            resolveDefaultFileLocations(actorJsonFile, ['./CHANGELOG.md', '../CHANGELOG.md']),
+        inputSchema:
+            resolveFile(
+                actorJsonFile,
+                fields.input != null ? 'input' : 'inputSchema',
+                fields.input ?? fields.inputSchema,
+            ) ?? resolveDefaultFileLocations(actorJsonFile, ['./INPUT_SCHEMA.json', '../INPUT_SCHEMA.json']),
+
+        // these other schemas came after .actor was invented, so they have no fallbacks in platform
         outputSchema: resolveFile(
             actorJsonFile,
             fields.output != null ? 'output' : 'outputSchema',

package/bin/utils/config/load-config.ts

@@ -1,8 +1,8 @@
 import { selectActors } from '../../actor-filtering.js';
 import type { ActorConfig } from '../../types.js';
 import { safeReadJsonObjectFile } from '../json-file.js';
-import { type ExistingDir, ExistingFile, type RelativeDir } from '../path/repo-relative.js';
-import { type ActorJsonPaths, readActorJson } from './actor-json.js';
+import { ExistingFile, type RelativeDir } from '../path/repo-relative.js';
+import { readActorJson } from './actor-json.js';
 import { parseConfigFile } from './parser.js';
 import type { ValidatedActorConfig } from './structures/base.js';
 
@@ -28,18 +28,6 @@ const findOverlappingContextPaths = (contextPaths: RelativeDir[]): [RelativeDir,
     return undefined;
 };
 
-// Downstream ActorConfig consumers still use "" for the repo root.
-const legacyPath = (dir: RelativeDir): string => (dir.path === '.' ? '' : dir.path);
-
-export interface LoadedActorConfig {
-    actorFullName: string;
-    folder: ExistingDir;
-    tokenEnvVar: string;
-    actorJson: ActorJsonPaths;
-    dockerContextDir: RelativeDir;
-    contextPaths: RelativeDir[];
-}
-
 // #endregion
 
 // #region stages
@@ -79,7 +67,7 @@ const readConfigFileContents = async (): Promise<Record<string, unknown>> => {
  * Stage 3 — resolves one normalized entry against the repo, reading the actor's `.actor/actor.json`
  * for its `dockerContextDir` and deciding which paths count as the actor's context.
  */
-export const loadActorConfig = (entry: ValidatedActorConfig): LoadedActorConfig => {
+export const loadActorConfig = (entry: ValidatedActorConfig): ActorConfig => {
     const { folder } = entry;
     const actorJson = readActorJson(entry);
     const { dockerContextDir } = actorJson;
@@ -109,14 +97,6 @@ export const loadActorConfig = (entry: ValidatedActorConfig): LoadedActorConfig
     };
 };
 
-const toLegacyActorConfig = (entry: LoadedActorConfig): ActorConfig => ({
-    actorFullName: entry.actorFullName,
-    folder: legacyPath(entry.folder),
-    tokenEnvVar: entry.tokenEnvVar,
-    dockerContextDir: legacyPath(entry.dockerContextDir),
-    contextPaths: entry.contextPaths.map(legacyPath),
-});
-
 // #endregion
 
 export const readConfigFile = async (selection: { actors: string[]; ignore: string[] }): Promise<ActorConfig[]> => {
@@ -126,7 +106,7 @@ export const readConfigFile = async (selection: { actors: string[]; ignore: stri
     const actorConfigs: ActorConfig[] = [];
     for (const parsed of parsedConfigs) {
         // Sequential on purpose: the first actor with a problem should be the one reported.
-        actorConfigs.push(toLegacyActorConfig(loadActorConfig(parsed)));
+        actorConfigs.push(loadActorConfig(parsed));
     }
 
     return selectActors(selection, actorConfigs);

package/bin/utils/path/repo-relative.ts

@@ -55,6 +55,10 @@ export abstract class AbstractPath {
 export class RelativeDir extends AbstractPath {
     static readonly ROOT = new RelativeDir('.');
 
+    isRoot(): boolean {
+        return this.path === RelativeDir.ROOT.path;
+    }
+
     joinDir(relativePath: string): RelativeDir {
         return new RelativeDir(this.join(relativePath));
     }
@@ -65,10 +69,24 @@ export class RelativeDir extends AbstractPath {
         return new RelativeFile(this.join(relativePath));
     }
 
+    relativePathTo(filePath: string): string {
+        // mainly for matching against .dockerignore since paths consumed by it are relative to the docker context dir
+        return posix.relative(this.path, filePath);
+    }
+
+    containsPath(filePath: string): boolean {
+        try {
+            // should be OK even if not a directory (e.g. a file)
+            return this.contains(new RelativeDir(filePath));
+        } catch {
+            return false;
+        }
+    }
+
     // True when `other` is this directory itself or lies inside it.
     contains(other: AbstractPath): boolean {
         // the root contains every path
-        if (this.path === '.') return true;
+        if (this.isRoot()) return true;
         return this.isEqualTo(other) || other.path.startsWith(`${this.path}/`);
     }
 
@@ -133,14 +151,19 @@ export class RelativeFile extends AbstractPath {
         return scope.contains(this);
     }
 
+    exists(): boolean {
+        // `stat`, not `lstat`: a symlink must resolve to its target, matching what reading it does.
+        return statSync(this.path, { throwIfNoEntry: false })?.isFile() ?? false;
+    }
+
     // Throws unless this path exists and is a file. Paths resolve against the process working
     // directory, which is the repo root.
     assertIsFile(): this {
-        // `stat`, not `lstat`: a symlink must resolve to its target, matching what reading it does.
+        if (this.exists()) return this;
+
         const stats = statSync(this.path, { throwIfNoEntry: false });
         if (!stats) throw new Error(`Expected file "${this}" to exist.`);
-        if (!stats.isFile()) throw new Error(`Expected "${this}" to be a file.`);
-        return this;
+        throw new Error(`Expected "${this}" to be a file.`);
     }
 }
 

package/dist/bin/build-from-local.d.ts

@@ -1,7 +1,8 @@
 import type { ActorConfig, BuildData } from './types.js';
 import type { SourceFile } from './utils.js';
-export declare const collectSourceFiles: (actorName: string, actorDir: string) => Promise<SourceFile[]>;
-export declare const collectNonIgnoredFiles: (dockerContextDir: string, repoRoot: string) => Promise<string[]>;
+import type { RelativeDir } from './utils/path/repo-relative.js';
+export declare const collectSourceFiles: (actorConfig: ActorConfig) => Promise<SourceFile[]>;
+export declare const collectNonIgnoredFiles: (dockerContextDir: RelativeDir, repoRoot: string) => Promise<string[]>;
 export declare const flattenMonorepoContext: (actorName: string, absActorDir: string, contextAbsDir: string, actorJson: Record<string, unknown>, keptContextFiles: string[]) => Promise<{
     tempDir: string;
     filePaths: string[];

package/dist/bin/build-from-local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-from-local.d.ts","sourceRoot":"","sources":["../../bin/build-from-local.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAU7C,eAAO,MAAM,kBAAkB,GAAU,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,UAAU,EAAE,CAiClG,CAAC;AAWF,eAAO,MAAM,sBAAsB,GAAU,kBAAkB,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAoBzG,CAAC;AAaF,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,kBAAkB,MAAM,EAAE,KAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAyClD,CAAC;AAcF,eAAO,MAAM,qBAAqB,GAC9B,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,SAAS,MAAM,EACf,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACnC,OAAO,CAAC,IAAI,CAqBd,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,2BAGtC;IACC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;CACnB,KAAG,OAAO,CAAC,SAAS,EAAE,CAsBtB,CAAC"}
+{"version":3,"file":"build-from-local.d.ts","sourceRoot":"","sources":["../../bin/build-from-local.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AASjE,eAAO,MAAM,kBAAkB,GAAU,aAAa,WAAW,KAAG,OAAO,CAAC,UAAU,EAAE,CA8BvF,CAAC;AAWF,eAAO,MAAM,sBAAsB,GAAU,kBAAkB,WAAW,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAc9G,CAAC;AAaF,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,kBAAkB,MAAM,EAAE,KAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAyClD,CAAC;AAcF,eAAO,MAAM,qBAAqB,GAC9B,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,SAAS,MAAM,EACf,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACnC,OAAO,CAAC,IAAI,CAqBd,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,2BAGtC;IACC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;CACnB,KAAG,OAAO,CAAC,SAAS,EAAE,CAsBtB,CAAC"}

package/dist/bin/build-from-local.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import AdmZip from 'adm-zip';
 import { ActorSourceType } from 'apify-client';
 import { dryRunBuildData, LOCAL_SOURCE_VERSION_NUMBER, runAndSummarizeBuilds } from './build.js';
-import { buildDockerIgnoreMatcher } from './dockerignore.js';
+import { loadDockerIgnore } from './dockerignore.js';
 import { logger } from './logger.js';
 import { isPathWithinScope } from './path-utils.js';
 import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, readSourceFile } from './utils.js';
@@ -14,23 +14,20 @@ import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, readSourceFile } f
 // in the repo's .gitignore — see collectNonIgnoredFiles.
 const SKIP_FILE_PATTERNS = [/^\.env(\..+)?$/, /\.pem$/, /\.key$/, /\.pfx$/, /\.p12$/];
 const isSecretFile = (fileName) => SKIP_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
-export const collectSourceFiles = async (actorName, actorDir) => {
+export const collectSourceFiles = async (actorConfig) => {
     const repoRoot = process.cwd();
-    const absActorDir = path.resolve(actorDir);
-    // Read actor.json to check if this is a monorepo actor with an external dockerContextDir.
-    // Monorepo actors point their dockerContextDir to a parent directory (e.g. "../../.."),
-    // which means the Docker build context is the repo root, not the actor directory itself.
-    const actorJsonPath = path.join(absActorDir, '.actor', 'actor.json');
-    const actorJson = JSON.parse(await fs.readFile(actorJsonPath, 'utf8'));
-    const rawContextDir = actorJson.dockerContextDir;
-    const contextAbsDir = rawContextDir ? path.resolve(absActorDir, '.actor', rawContextDir) : undefined;
-    const isMonorepoActor = !!contextAbsDir && isOutsideDir(contextAbsDir, absActorDir);
-    const dockerContextDirAbs = isMonorepoActor ? contextAbsDir : absActorDir;
-    const keptFilePaths = await collectNonIgnoredFiles(dockerContextDirAbs, repoRoot);
+    const absActorDir = path.resolve(actorConfig.folder.path);
+    // Config loading has already resolved dockerContextDir. Keep the raw actor.json contents
+    // for rewriting its path fields if this actor needs a flattened build context.
+    const actorJson = JSON.parse(await fs.readFile(actorConfig.actorJson.file.path, 'utf8'));
+    const isMonorepoActor = !actorConfig.folder.contains(actorConfig.dockerContextDir);
+    const sourceRoot = isMonorepoActor ? actorConfig.dockerContextDir : actorConfig.folder;
+    const sourceRootAbs = path.resolve(sourceRoot.path);
+    const keptFilePaths = await collectNonIgnoredFiles(sourceRoot, repoRoot);
     if (!isMonorepoActor) {
-        return Promise.all(keptFilePaths.map(async (filePath) => readSourceFile(filePath, dockerContextDirAbs)));
+        return Promise.all(keptFilePaths.map(async (filePath) => readSourceFile(filePath, sourceRootAbs)));
     }
-    const { tempDir, filePaths } = await flattenMonorepoContext(actorName, absActorDir, contextAbsDir, actorJson, keptFilePaths);
+    const { tempDir, filePaths } = await flattenMonorepoContext(actorConfig.actorFullName, absActorDir, sourceRootAbs, actorJson, keptFilePaths);
     try {
         return await Promise.all(filePaths.map(async (filePath) => readSourceFile(filePath, tempDir)));
     }
@@ -49,13 +46,9 @@ export const collectSourceFiles = async (actorName, actorDir) => {
 // hardcoded secret-pattern backstop (keys, certs, .env variants) are dropped unconditionally,
 // .actor/ included, since those should never ship regardless of what the ignore files say.
 export const collectNonIgnoredFiles = async (dockerContextDir, repoRoot) => {
-    const relativePaths = await listRepoFilePaths(repoRoot, dockerContextDir);
+    const relativePaths = await listRepoFilePaths(repoRoot, path.resolve(repoRoot, dockerContextDir.path));
     const ignoredPaths = await getGitignoredPaths(relativePaths, repoRoot);
-    const rootRelativePaths = new Map(relativePaths.map((relPath) => [
-        relPath,
-        path.relative(dockerContextDir, path.join(repoRoot, relPath)).split(path.sep).join('/'),
-    ]));
-    const isDockerIgnored = buildDockerIgnoreMatcher(dockerContextDir);
+    const isDockerIgnored = loadDockerIgnore(dockerContextDir);
     return relativePaths
         .filter((relPath) => {
         if (isSecretFile(path.basename(relPath)))
@@ -65,7 +58,7 @@ export const collectNonIgnoredFiles = async (dockerContextDir, repoRoot) => {
             return true;
         if (ignoredPaths.has(relPath))
             return false;
-        return !isDockerIgnored(rootRelativePaths.get(relPath));
+        return !isDockerIgnored(relPath);
     })
         .map((relPath) => path.join(repoRoot, relPath));
 };
@@ -157,7 +150,7 @@ export const runBuildsFromLocal = async ({ actorConfigs, dryRun, }) => {
     return runAndSummarizeBuilds(actorConfigs, 'LOCAL BUILDS', async (actorConfig, builder) => {
         // Zipped and uploaded like `apify push` does, since inline SOURCE_FILES are capped at ~9 MB.
         const zip = new AdmZip();
-        for (const { name, content } of await collectSourceFiles(actorConfig.actorFullName, actorConfig.folder)) {
+        for (const { name, content } of await collectSourceFiles(actorConfig)) {
             zip.addFile(name, content);
         }
         const actorVersion = {