apify-test-tools 0.8.6 → 0.9.0-beta.0

package/README.md

@@ -4,29 +4,99 @@
 
 ## Getting Started
 
-1. Install the package `npm i -D apify-test-tools`
-    - because it uses [annotate](https://vitest.dev/guide/test-context.html#annotate), `vitest` version to be at least `3.2.0`
-    - make sure that `target` and `module` in your `tsconfig.json`'s `compilerOptions` are set to `ES2022`
-2. create test directories: `mkdir -p test/platform/core`
-    - core (hourly) tests should go to `test/platform/core`
-    - daily tests should go to `test/platform`
-3. setup github worklows TODO
+### 1. Install the package
 
-File structure:
+```bash
+npm i -D apify-test-tools
+```
+
+- Requires `vitest` version `3.2.0` or later (uses [annotate](https://vitest.dev/guide/test-context.html#annotate))
+- Make sure `target` and `module` in your `tsconfig.json`'s `compilerOptions` are set to `ES2022`
+
+### 2. Create the config file
+
+Every repo that uses `apify-test-tools` must have an `apify-test-tools.config.json` file at the root. This file tells the tool which actors live in the repo, how to identify them, and which token to use.
+
+```json
+{
+    "actors": [
+        {
+            "folder": "actors/web-scraper",
+            "actorFullName": "myteam/web-scraper",
+            "tokenEnvVar": "APIFY_TOKEN_MYTEAM"
+        },
+        {
+            "folder": "actors/email-sender",
+            "actorFullName": "myteam/email-sender",
+            "tokenEnvVar": "APIFY_TOKEN_MYTEAM",
+            "overrideActorContext": ["actors/email-sender", "packages/shared"]
+        }
+    ]
+}
+```
+
+Each entry has:
+
+| Field                  | Required | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| ---------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `folder`               | yes      | Relative path from repo root to the actor's own project directory — the folder that directly contains `.actor/actor.json` (i.e. `<folder>/.actor/actor.json`), the actor's README/CHANGELOG, and its source. Use `"."` for a single-actor repo where `.actor/` is at the root.                                                                                                                                                                                                                                |
+| `actorFullName`        | yes      | Full actor identifier in `owner/name` format (e.g. `"apify/web-scraper"`). This is the source of truth for the actor name — the `name` field in `actor.json` is not used.                                                                                                                                                                                                                                                                                                                                     |
+| `tokenEnvVar`          | yes      | Name of the environment variable holding the Apify API token for this actor. No fallback — if the env var is not set at build time, the build fails.                                                                                                                                                                                                                                                                                                                                                          |
+| `overrideActorContext` | no       | Array of paths (relative to repo root) that define which files are relevant to this actor. When set, replaces the `dockerContextDir` from `actor.json` for change detection. Useful when an actor depends on shared packages outside its Docker build context. Entries must not be prefixes of one another (e.g. `["", "code"]` or `["actors", "actors/foo"]` are rejected), and the list must include a path that reaches the actor's own `folder` — otherwise the actor could never be detected as changed. |
+
+### 3. Set up actor folders
+
+Each actor in the config must have a `.actor/actor.json` file. The `dockerContextDir` field in `actor.json` defines the build context boundary — this is what the tool uses to determine which files can affect the actor's build.
 
 ```
-google-maps
+my-repo
+├── apify-test-tools.config.json
 ├── actors
-└── src
+│   ├── web-scraper
+│   │   ├── .actor
+│   │   │   └── actor.json
+│   │   └── src/
+│   └── email-sender
+│       ├── .actor
+│       │   └── actor.json
+│       └── src/
 └── test
     ├── unit
     └── platform
-        ├── core                  <- Core tests need to be inside core directory
+        ├── core                    <- Core (hourly) tests
         │   └── core.test.ts
-        ├── some.test.ts          <- Other tests can be defined anywhere inside platform directory
+        ├── some.test.ts            <- Daily tests can be anywhere inside platform/
         └── some-other.test.ts
 ```
 
+For a single-actor repo, set `"folder": "."` in the config and place `.actor/actor.json` at the repo root.
+
+### Change detection
+
+When a PR is opened or code is pushed, the tool determines which actors need to be built and tested based on the changed files. For each changed file, for each actor:
+
+1. **Sibling exclusion** — files inside another actor's `folder` are excluded first. This prevents an actor with broad context from being triggered by changes that belong to a sibling actor.
+2. **CHANGELOG classification** — a `CHANGELOG.md` file is always `cosmetic` (only triggers a release build, not tests), for every actor, regardless of context or folder. (See [issue #106](https://github.com/apify/apify-test-tools/issues/106).)
+3. **Context matching** — the file must fall within one of the actor's context paths (`dockerContextDir` from `actor.json` by default, or `overrideActorContext` from config if set). Files outside every context path are skipped.
+4. **Hardcoded ignore list, context-aware** — the file path is first "hoisted" relative to the context path it matched (e.g. a standalone actor's own `.eslintrc` is checked as just `.eslintrc`, not the full repo-root-relative path), then checked against repo-level dev file patterns (`.vscode/`, `.gitignore`, `.husky/`, `.eslintrc`, `eslint.config.mjs`, `.prettierrc`, `.editorconfig`). There's no hardcoded special-casing for legacy `code/`/`shared/` layouts — repos that need those directories treated as top-level must list them explicitly in `overrideActorContext`.
+5. **`.dockerignore` filtering** — if a `.dockerignore` exists at the root of the actor's `dockerContextDir`, matching files are ignored. Patterns are resolved relative to `dockerContextDir`, matching Docker's own behavior.
+6. **README classification** — a `README.md` file is `cosmetic` (only triggers a release build, not tests) if it lives inside the actor's own `folder`; otherwise it's ignored entirely, since it isn't documentation for this actor.
+7. **Cosmetic JSON classification** — `.json` files inside the actor's own `.actor/` directory with only cosmetic schema changes (whitespace, key ordering) only trigger a release build.
+8. **Functional** — everything else triggers both build and tests.
+
+### 4. Create test directories
+
+```bash
+mkdir -p test/platform/core
+```
+
+- Core (hourly) tests go in `test/platform/core`
+- Daily tests go anywhere in `test/platform`
+
+### 5. Set up GitHub workflows
+
+See the [GitHub workflows](#github-worklows) section below.
+
 ## Github worklows
 
 There should be 4 GH workflow files in `.github/workflows`.
@@ -343,7 +413,7 @@ GITHUB_WORKSPACE=. \
 Remove `--dry-run` to actually trigger builds and update the branch names/ The command outputs a JSON array of build objects to stdout:
 
 ```json
-[{ "buildId": "...", "actorId": "...", "buildNumber": "...", "actorName": "john.doe/my-actor" }]
+[{ "buildId": "...", "actorRawId": "...", "buildNumber": "...", "actorFullName": "john.doe/my-actor" }]
 ```
 
 #### Build from local source (no push needed)

package/bin/build-from-local.ts

@@ -5,14 +5,10 @@ import path from 'node:path';
 import type { ActorVersionSourceFile } from 'apify-client';
 
 import { ApifyBuilder, waitAndSummarizeBuilds } from './build.js';
+import { buildDockerIgnoreMatcher } from './dockerignore.js';
+import { isPathWithinScope } from './path-utils.js';
 import type { ActorConfig, BuildData } from './types.js';
-import {
-    getDockerignoredPaths,
-    getGitignoredPaths,
-    isOutsideDir,
-    listRepoFilePaths,
-    toActorVersionSourceFile,
-} from './utils.js';
+import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, toActorVersionSourceFile } from './utils.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
@@ -34,11 +30,13 @@ export const collectSourceFiles = async (actorName: string, actorDir: string): P
     const contextAbsDir = rawContextDir ? path.resolve(absActorDir, '.actor', rawContextDir) : undefined;
     const isMonorepoActor = !!contextAbsDir && isOutsideDir(contextAbsDir, absActorDir);
 
-    const collectRootDir = isMonorepoActor ? contextAbsDir! : absActorDir;
-    const keptFilePaths = collectNonIgnoredFiles(collectRootDir, repoRoot);
+    const dockerContextDirAbs = isMonorepoActor ? contextAbsDir! : absActorDir;
+    const keptFilePaths = collectNonIgnoredFiles(dockerContextDirAbs, repoRoot);
 
     if (!isMonorepoActor) {
-        return Promise.all(keptFilePaths.map(async (filePath) => toActorVersionSourceFile(filePath, collectRootDir)));
+        return Promise.all(
+            keptFilePaths.map(async (filePath) => toActorVersionSourceFile(filePath, dockerContextDirAbs)),
+        );
     }
 
     const { tempDir, filePaths } = await flattenMonorepoContext(
@@ -47,7 +45,6 @@ export const collectSourceFiles = async (actorName: string, actorDir: string): P
         contextAbsDir!,
         actorJson,
         keptFilePaths,
-        repoRoot,
     );
     try {
         return await Promise.all(filePaths.map(async (filePath) => toActorVersionSourceFile(filePath, tempDir)));
@@ -61,21 +58,21 @@ export const collectSourceFiles = async (actorName: string, actorDir: string): P
 // manual directory walk — nested .gitignore files, `.git/info/exclude`, and global excludes are
 // all honored since this delegates to git itself instead of re-implementing gitignore matching,
 // and .git/ is never walked because git never lists its own internals here. `.dockerignore` at
-// `rootDir` (the Docker build context) is honored the same way, since those files would never
-// reach a real Docker build either. `.actor/` (the Actor specification folder) is always kept
+// `dockerContextDir` (the Docker build context) is honored the same way, since those files would
+// never reach a real Docker build either. `.actor/` (the Actor specification folder) is always kept
 // 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 = (rootDir: string, repoRoot: string): string[] => {
-    const relativePaths = listRepoFilePaths(repoRoot, rootDir);
+export const collectNonIgnoredFiles = (dockerContextDir: string, repoRoot: string): string[] => {
+    const relativePaths = listRepoFilePaths(repoRoot, dockerContextDir);
     const ignoredPaths = getGitignoredPaths(relativePaths);
     const rootRelativePaths = new Map(
         relativePaths.map((relPath) => [
             relPath,
-            path.relative(rootDir, path.join(repoRoot, relPath)).split(path.sep).join('/'),
+            path.relative(dockerContextDir, path.join(repoRoot, relPath)).split(path.sep).join('/'),
         ]),
     );
-    const dockerIgnoredPaths = getDockerignoredPaths(rootDir, [...rootRelativePaths.values()]);
+    const isDockerIgnored = buildDockerIgnoreMatcher(dockerContextDir);
 
     return relativePaths
         .filter((relPath) => {
@@ -83,7 +80,7 @@ export const collectNonIgnoredFiles = (rootDir: string, repoRoot: string): strin
             const isUnderActorDir = relPath.split('/').includes('.actor');
             if (isUnderActorDir) return true;
             if (ignoredPaths.has(relPath)) return false;
-            return !dockerIgnoredPaths.has(rootRelativePaths.get(relPath)!);
+            return !isDockerIgnored(rootRelativePaths.get(relPath)!);
         })
         .map((relPath) => path.join(repoRoot, relPath));
 };
@@ -92,8 +89,8 @@ export const collectNonIgnoredFiles = (rootDir: string, repoRoot: string): strin
 // collect the actor directory of a monorepo actor — the platform would reject any path
 // escaping it. Fix: create a temporary "flattened" directory where:
 //   - the Docker context's non-ignored files (repo root) are copied to the temp dir root
-//   - the actor's .actor/ directory is overlaid at the temp dir root (through the same
-//     gitignore/secret-pattern filter as the rest of the context — see collectNonIgnoredFiles)
+//   - the actor's own .actor/ directory (already present within those same non-ignored files)
+//     is overlaid at the temp dir root instead of its original nested position
 //   - actor.json path fields are rewritten to be relative to the new location
 //
 // Result: the collected root IS the Docker context, .actor/ is at that root, and
@@ -105,7 +102,6 @@ export const flattenMonorepoContext = async (
     contextAbsDir: string,
     actorJson: Record<string, unknown>,
     keptContextFiles: string[],
-    repoRoot: string,
 ): Promise<{ tempDir: string; filePaths: string[] }> => {
     console.error(`[${actorName}]: monorepo actor detected — flattening from Docker context`);
 
@@ -124,11 +120,13 @@ export const flattenMonorepoContext = async (
         }),
     );
 
-    // Step 2: overlay the actor's .actor/ directory at the temp dir root. collectNonIgnoredFiles
-    // always keeps .actor/ paths regardless of .gitignore, but still drops the hardcoded secret
-    // patterns — so this isn't a raw copy, a stray secret file living inside .actor/ is still dropped.
+    // Step 2: overlay the actor's own .actor/ directory at the temp dir root. Its files are already
+    // present in keptContextFiles (collectNonIgnoredFiles keeps .actor/ paths unconditionally — see
+    // step 1 above) — pick out this actor's own subset (ignoring any sibling actors' .actor/ folders
+    // that might also appear in the broader context) and hoist each to its position relative to
+    // .actor/ itself, so it lands under tempDir/.actor/ instead of its original nested location.
     const actorMetaDir = path.join(absActorDir, '.actor');
-    const keptActorFiles = collectNonIgnoredFiles(actorMetaDir, repoRoot);
+    const keptActorFiles = keptContextFiles.filter((absFilePath) => isPathWithinScope(absFilePath, actorMetaDir));
     await Promise.all(
         keptActorFiles.map(async (absFilePath) => {
             const relPath = path.relative(actorMetaDir, absFilePath);
@@ -196,26 +194,29 @@ export const runBuildsFromLocal = async ({
 }): Promise<BuildData[]> => {
     if (dryRun) {
         console.error('[DRY RUN] Would build from local source:');
-        for (const { actorName, folder } of actorConfigs) {
-            console.error(`  ${actorName} (${folder})`);
+        for (const { actorFullName, folder } of actorConfigs) {
+            console.error(`  ${actorFullName} (${folder})`);
         }
-        return actorConfigs.map(({ actorName }) => ({
+        return actorConfigs.map(({ actorFullName }) => ({
             buildId: 'dry-run',
-            actorId: 'dry-run',
+            actorRawId: 'dry-run',
             buildNumber: '0.98.0',
-            actorName,
+            actorFullName,
         }));
     }
 
     console.error('=========================================');
     console.error('STARTED LOCAL BUILDS:');
+    const buildersByActorFullName = new Map<string, ApifyBuilder>(
+        actorConfigs.map((actorConfig) => [actorConfig.actorFullName, ApifyBuilder.fromActorConfig(actorConfig)]),
+    );
     const startedBuilds = await Promise.all(
-        actorConfigs.map(async ({ actorName, folder }) => {
-            const builder = ApifyBuilder.fromActorName(actorName);
-            const sourceFiles = await collectSourceFiles(actorName, folder);
+        actorConfigs.map(async ({ actorFullName, folder }) => {
+            const builder = buildersByActorFullName.get(actorFullName)!;
+            const sourceFiles = await collectSourceFiles(actorFullName, folder);
             return builder.startActorBuildFromSourceFiles(sourceFiles);
         }),
     );
 
-    return waitAndSummarizeBuilds(startedBuilds, 'LOCAL BUILDS');
+    return waitAndSummarizeBuilds(startedBuilds, buildersByActorFullName, 'LOCAL BUILDS');
 };

package/bin/build.ts

@@ -9,13 +9,13 @@ type BuildPrActorOptions = {
     buildTag?: string;
     versionNumber: string;
     gitRepoUrl: string;
-    actorName: string;
+    actorConfig: ActorConfig;
     useDockerCache: boolean;
 };
 export class ApifyBuilder {
     private constructor(
         private readonly apifyClient: ApifyClient,
-        private readonly actorName: string,
+        private readonly actorFullName: string,
     ) {}
 
     // Usually 'latest' but not necessarily (can be e.g. 'version-0')
@@ -24,35 +24,35 @@ export class ApifyBuilder {
         defaultVersionNumber: string;
         defaultBuildTag: string;
     }> => {
-        const actorClient = this.apifyClient.actor(this.actorName);
+        const actorClient = this.apifyClient.actor(this.actorFullName);
         const actorInfo = await actorClient.get();
 
         if (!actorInfo) {
             throw new Error(
-                `[${this.actorName}] not found. It is not published or we are missing token to access it privately or its name is misspelled`,
+                `[${this.actorFullName}] not found. It is not published or we are missing token to access it privately or its name is misspelled`,
             );
         }
 
         const defaultBuildTag = actorInfo.defaultRunOptions.build;
-        console.error(`Default build tag for ${this.actorName} is ${defaultBuildTag}`);
+        console.error(`Default build tag for ${this.actorFullName} is ${defaultBuildTag}`);
 
         // We could technically allow this but in most cases this is accidentally set wrongly and there is a workaround
         if (defaultBuildTag.match(/\d+\.\d+\.\d+/)) {
             throw new Error(
-                `[${this.actorName}] Default build is a build number, not a tag. While this could work, ` +
+                `[${this.actorFullName}] Default build is a build number, not a tag. While this could work, ` +
                     `we want to have a default as tag so this is often an accidental misconfiguration from the dev`,
             );
         }
         // I reported that buildNumber should probably not be optional
         if (!actorInfo.taggedBuilds?.[defaultBuildTag]?.buildNumber) {
             throw new Error(
-                `[${this.actorName}] No build found for tag "${defaultBuildTag}". ` +
+                `[${this.actorFullName}] No build found for tag "${defaultBuildTag}". ` +
                     `The first build must be triggered manually on the platform before CI can take over.`,
             );
         }
         const defaultBuildNumber = actorInfo.taggedBuilds![defaultBuildTag].buildNumber!;
         const defaultVersionNumber = defaultBuildNumber.match(/(\d+\.\d+)\.\d+/)![1];
-        console.error(`Default version for ${this.actorName} is ${defaultVersionNumber}`);
+        console.error(`Default version for ${this.actorFullName} is ${defaultVersionNumber}`);
 
         return { defaultBuildNumber, defaultVersionNumber, defaultBuildTag };
     };
@@ -63,11 +63,11 @@ export class ApifyBuilder {
         gitRepoUrl,
         useDockerCache,
     }: BuildPrActorOptions): Promise<BuildData> => {
-        const actorClient = this.apifyClient.actor(this.actorName);
+        const actorClient = this.apifyClient.actor(this.actorFullName);
         const actorInfo = await actorClient.get();
         if (!actorInfo) {
             throw new Error(
-                `No actor named '${this.actorName}' was found on the platform. If this` +
+                `No actor named '${this.actorFullName}' was found on the platform. If this` +
                     ' is unexpected, make sure the actor you are targeting is spelled the' +
                     ' same as the folder in the repository.',
             );
@@ -97,17 +97,17 @@ export class ApifyBuilder {
         // We also get back actId so the testing actor can both match by actor ID and name
         const { id, actId, buildNumber } = await actorClient.build(versionNumber, { useCache: useDockerCache });
 
-        console.error(`[${this.actorName}]: ${id} (${buildNumber})`);
-        return { buildId: id, actorId: actId, buildNumber, actorName: this.actorName };
+        console.error(`[${this.actorFullName}]: ${id} (${buildNumber})`);
+        return { buildId: id, actorRawId: actId, buildNumber, actorFullName: this.actorFullName };
     };
 
     startActorBuildFromSourceFiles = async (sourceFiles: ActorVersionSourceFile[]): Promise<BuildData> => {
         const ZIP_VERSION = '0.98';
-        const actorClient = this.apifyClient.actor(this.actorName);
+        const actorClient = this.apifyClient.actor(this.actorFullName);
         const actorInfo = await actorClient.get();
         if (!actorInfo) {
             throw new Error(
-                `No actor named '${this.actorName}' was found on the platform. If this` +
+                `No actor named '${this.actorFullName}' was found on the platform. If this` +
                     ' is unexpected, make sure the actor you are targeting is spelled the' +
                     ' same as the folder in the repository.',
             );
@@ -130,49 +130,39 @@ export class ApifyBuilder {
         }
 
         const { id, actId, buildNumber } = await actorClient.build(ZIP_VERSION, { useCache: false });
-        console.error(`[${this.actorName}]: ${id} (${buildNumber})`);
-        return { buildId: id, actorId: actId, buildNumber, actorName: this.actorName };
+        console.error(`[${this.actorFullName}]: ${id} (${buildNumber})`);
+        return { buildId: id, actorRawId: actId, buildNumber, actorFullName: this.actorFullName };
     };
 
-    waitForBuildToFinish = async (buildId: string, actorName: string): Promise<Build> => {
+    waitForBuildToFinish = async (buildId: string): Promise<Build> => {
         const build = await this.apifyClient.build(buildId).waitForFinish();
         const versionNumber = build.buildNumber;
         if (build.status === 'FAILED' || build.status === 'TIMED-OUT') {
-            console.error(`[${this.actorName}]: ${versionNumber}`);
+            console.error(`[${this.actorFullName}]: ${versionNumber}`);
             try {
                 const log = await this.apifyClient.build(buildId).log().get();
                 const logTail = log?.split('\n').slice(-40).join('\n');
                 console.error(`\n--- BUILD LOG (last 40 lines) ---\n${logTail}\n---`);
             } catch (err) {
-                console.error(`[${this.actorName}]: Failed to fetch build log: ${err}`);
+                console.error(`[${this.actorFullName}]: Failed to fetch build log: ${err}`);
             }
             throw new Error(
-                `[BUILD][${actorName}]: Build ${buildId} (${versionNumber}) failed. ` +
+                `[BUILD][${this.actorFullName}]: Build ${buildId} (${versionNumber}) failed. ` +
                     `Not continuing with other builds and tests.`,
             );
         }
-        console.error(`[${this.actorName}]: ${versionNumber}`);
+        console.error(`[${this.actorFullName}]: ${versionNumber}`);
         return build;
     };
 
-    /**
-     * Create ApifyBuilder with actor owner's token
-     */
-    static fromActorName = (actorName: string): ApifyBuilder => {
-        const username = actorName.split('/')[0];
-        // GitHib secrets only allow word characters (alphanum + underscore)
-        const usernameInGitHubSecretsFormat = username.replaceAll(/\W/g, '_').toUpperCase();
-        const usernameEnvVar = `APIFY_TOKEN_${usernameInGitHubSecretsFormat}`;
-        const token = process.env[usernameEnvVar];
+    static fromActorConfig = (actorConfig: ActorConfig): ApifyBuilder => {
+        const { actorFullName, tokenEnvVar } = actorConfig;
+        const token = process.env[tokenEnvVar];
         if (!token) {
-            throw new Error(
-                `Cannot find Apify API token for username: ${username}. ` +
-                    `Have you set secret env var to this GitHub repo with key: ${usernameEnvVar}?`,
-            );
+            throw new Error(`Env var ${tokenEnvVar} is not set (needed for actor "${actorFullName}").`);
         }
         const apifyClient = new ApifyClient({ token });
-        const builder = new ApifyBuilder(apifyClient, actorName);
-        return builder;
+        return new ApifyBuilder(apifyClient, actorFullName);
     };
 
     /**
@@ -204,7 +194,7 @@ export class ApifyBuilder {
         const DEFAULT_DAYS_BACK_PROD_VERSIONS = 30;
         const DEFAULT_DAYS_BACK_DEVEL = 7;
 
-        const actorInfo = (await this.apifyClient.actor(this.actorName).get())!;
+        const actorInfo = (await this.apifyClient.actor(this.actorFullName).get())!;
 
         // 'devel' used to be hardcoded for testing version 0.99, once we get rid of this tag everywhere, we can remove this code
         const taggedDevelBuildNumber: string | undefined = actorInfo.taggedBuilds!.devel?.buildNumber;
@@ -216,12 +206,10 @@ export class ApifyBuilder {
             tag,
         }));
 
-        const { items } = await this.apifyClient.actor(this.actorName).builds().list();
+        const { items } = await this.apifyClient.actor(this.actorFullName).builds().list();
 
         // Deleting default build throws an error, so we skip it
-        const { defaultBuildNumber, defaultBuildTag } = await ApifyBuilder.fromActorName(
-            this.actorName,
-        ).getDefaultVersionAndTag();
+        const { defaultBuildNumber, defaultBuildTag } = await this.getDefaultVersionAndTag();
 
         const daysAgoUnixProd = Date.now() - DEFAULT_DAYS_BACK_PROD_VERSIONS * 24 * 60 * 60 * 1000;
         const daysAgoUnixDevel = Date.now() - DEFAULT_DAYS_BACK_DEVEL * 24 * 60 * 60 * 1000;
@@ -231,7 +219,7 @@ export class ApifyBuilder {
         const buildsToDelete = (items as CorrectBuildColletionItem[]).filter((build) => {
             if (build.buildNumber === defaultBuildNumber) {
                 console.error(
-                    `[DELETE OLD BUILDS][${this.actorName}]: Skipping default build ${defaultBuildNumber} (${defaultBuildTag}). ` +
+                    `[DELETE OLD BUILDS][${this.actorFullName}]: Skipping default build ${defaultBuildNumber} (${defaultBuildTag}). ` +
                         `We never delete default builds`,
                 );
                 return false;
@@ -242,7 +230,7 @@ export class ApifyBuilder {
             );
             if (protectedTagFound) {
                 console.error(
-                    `[DELETE OLD BUILDS][${this.actorName}]: Skipping protected build ${protectedTagFound.buildNumber} (${protectedTagFound.tag}).`,
+                    `[DELETE OLD BUILDS][${this.actorFullName}]: Skipping protected build ${protectedTagFound.buildNumber} (${protectedTagFound.tag}).`,
                 );
                 return false;
             }
@@ -251,7 +239,7 @@ export class ApifyBuilder {
                 const shouldDeleteDevelBuild = build.startedAt.getTime() < daysAgoUnixDevel;
                 if (shouldDeleteDevelBuild) {
                     console.error(
-                        `[DELETE OLD BUILDS][${this.actorName}]: Removing olf devel build ${taggedDevelBuildNumber}.`,
+                        `[DELETE OLD BUILDS][${this.actorFullName}]: Removing olf devel build ${taggedDevelBuildNumber}.`,
                     );
                 }
                 return shouldDeleteDevelBuild;
@@ -260,7 +248,7 @@ export class ApifyBuilder {
         });
 
         console.error(
-            `[DELETE OLD BUILDS][${this.actorName}]: Deleting ${buildsToDelete.length} old builds that are non-default and ` +
+            `[DELETE OLD BUILDS][${this.actorFullName}]: Deleting ${buildsToDelete.length} old builds that are non-default and ` +
                 `older than 30 days from total ${items.length}`,
         );
         for (const build of buildsToDelete) {
@@ -269,20 +257,24 @@ export class ApifyBuilder {
     }
 }
 
-export const waitAndSummarizeBuilds = async (startedBuilds: BuildData[], label: string): Promise<BuildData[]> => {
+export const waitAndSummarizeBuilds = async (
+    startedBuilds: BuildData[],
+    buildersMap: Map<string, ApifyBuilder>,
+    label: string,
+): Promise<BuildData[]> => {
     console.error('=========================================');
     console.error(`FINISHED ${label}:`);
     await Promise.all(
         startedBuilds.map(async (buildData) => {
-            const builder = ApifyBuilder.fromActorName(buildData.actorName);
-            await builder.waitForBuildToFinish(buildData.buildId, buildData.actorName);
+            const builder = buildersMap.get(buildData.actorFullName)!;
+            await builder.waitForBuildToFinish(buildData.buildId);
         }),
     );
 
     console.error('=========================================');
     console.error('SUMMARY:');
-    for (const buildData of startedBuilds.sort((a, b) => a.actorName.localeCompare(b.actorName))) {
-        console.error(`[${buildData.actorName}]: ${buildData.buildNumber}`);
+    for (const buildData of startedBuilds.sort((a, b) => a.actorFullName.localeCompare(b.actorFullName))) {
+        console.error(`[${buildData.actorFullName}]: ${buildData.buildNumber}`);
     }
     console.error('=========================================');
 
@@ -308,13 +300,13 @@ export const runBuilds = async ({
 }: RunBuildsOptions) => {
     const buildConfigs: BuildPrActorOptions[] = [];
 
-    for (const { actorName, folder } of actorConfigs) {
+    for (const actorConfig of actorConfigs) {
         let versionNumber: string;
         let buildTag: string | undefined;
 
         if (isLatest) {
             const { defaultVersionNumber, defaultBuildTag } =
-                await ApifyBuilder.fromActorName(actorName).getDefaultVersionAndTag();
+                await ApifyBuilder.fromActorConfig(actorConfig).getDefaultVersionAndTag();
             versionNumber = defaultVersionNumber;
             buildTag = defaultBuildTag;
         } else {
@@ -323,30 +315,34 @@ export const runBuilds = async ({
 
         // Depending on if these are miniactors or standaloneActors
         let gitRepoUrl = `${repoUrl}#${branch}`;
-        if (folder) {
-            gitRepoUrl = `${gitRepoUrl}:${folder}`;
+        if (actorConfig.folder) {
+            gitRepoUrl = `${gitRepoUrl}:${actorConfig.folder}`;
         }
-        buildConfigs.push({ actorName, gitRepoUrl, versionNumber, buildTag, useDockerCache });
+        buildConfigs.push({ actorConfig, gitRepoUrl, versionNumber, buildTag, useDockerCache });
     }
 
     if (dryRun) {
         return buildConfigs;
     }
+
+    const buildersByActorFullName = new Map<string, ApifyBuilder>(
+        actorConfigs.map((actorConfig) => [actorConfig.actorFullName, ApifyBuilder.fromActorConfig(actorConfig)]),
+    );
     console.error('=========================================');
     console.error('STARTED BUILDS:');
     const startedBuilds = await Promise.all(
         buildConfigs.map(async (buildConfig) => {
-            const builder = ApifyBuilder.fromActorName(buildConfig.actorName);
+            const builder = buildersByActorFullName.get(buildConfig.actorConfig.actorFullName)!;
             const buildData = await builder.startActorBuild(buildConfig);
             return buildData;
         }),
     );
 
-    return waitAndSummarizeBuilds(startedBuilds, 'BUILDS');
+    return waitAndSummarizeBuilds(startedBuilds, buildersByActorFullName, 'BUILDS');
 };
 
 export const deleteOldBuilds = async (actorConfigs: ActorConfig[]) => {
-    for (const { actorName } of actorConfigs) {
-        await ApifyBuilder.fromActorName(actorName).deleteOldBuilds();
+    for (const actorConfig of actorConfigs) {
+        await ApifyBuilder.fromActorConfig(actorConfig).deleteOldBuilds();
     }
 };