@uipath/data-fabric-tool 1.201.0 → 1.202.0-preview.136

package/tests/entity-project-packaging.e2e.test.ts

@@ -0,0 +1,549 @@
+import {
+    cpSync,
+    readdirSync,
+    readFileSync,
+    rmSync,
+    writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { unzipSync } from "fflate";
+import { describe, expect, it } from "vitest";
+import {
+    type E2EManifest,
+    MANIFEST_PATH,
+} from "../../../tests/e2e-shared/global-setup";
+import {
+    createDir,
+    extractLastJson,
+    localCliRawWithArgs,
+    localCliWithArgs,
+    readManifest,
+} from "../../../tests/e2e-shared/helpers";
+
+// Owner of the df-entity-project-packaging thread: how an `Entity` project
+// behaves inside a solution for `uip solution validate` / `uip solution pack`.
+// Scenario: scenarios/data-fabric-tool/entity-project-packaging.md
+//
+// Pack of an Entity project is a local operation — no tenant, no login — so
+// these build their own solution on disk and read the produced .zip.
+
+const manifest = readManifest<E2EManifest>(MANIFEST_PATH);
+const { tempDir: installDir } = manifest.sharedInstall;
+const PACK_TIMEOUT = 5 * 60_000;
+
+/** The api-workflow JSON fixture: a project that really does emit a .nupkg, so
+ *  a mixed solution can be packed without a tenant. */
+const API_FIXTURE = resolve(
+    import.meta.dirname,
+    "../../api-workflow-tool/tests/test-data/ApiWorkflowJsonProject",
+);
+
+/** Entry names inside the produced solution .zip. */
+function zipEntries(outputDir: string): string[] {
+    const zip = readdirSync(outputDir).find((name) => name.endsWith(".zip"));
+    expect(zip).toBeDefined();
+    return Object.keys(
+        unzipSync(new Uint8Array(readFileSync(join(outputDir, zip as string)))),
+    );
+}
+
+interface PackEnvelope {
+    Result: string;
+    Code?: string;
+    ErrorCode?: string;
+    Message?: string;
+    Data?: { Packages?: string[] };
+}
+
+/**
+ * Scaffold a solution with one Entity project: `project.uiproj`, the `.entity`
+ * pointer, the definition resource under the solution root, and the `.uipx`
+ * entry — the shape `entityInitAsync` produces.
+ */
+function seedEntitySolution(
+    root: string,
+    options: { entityName?: string; withApiProject?: boolean } = {},
+): string {
+    const entityName = options.entityName ?? "PurchaseOrder";
+    const solutionDir = join(root, "EntitySolution");
+    const projectDir = join(solutionDir, "MasterData");
+    createDir(projectDir);
+
+    const projects: Array<Record<string, string>> = [
+        {
+            Id: "11111111-1111-1111-1111-111111111111",
+            Type: "Entity",
+            ProjectRelativePath: "MasterData/project.uiproj",
+        },
+    ];
+
+    writeFileSync(
+        join(projectDir, "project.uiproj"),
+        `${JSON.stringify({ Name: "MasterData", ProjectType: "Entity" }, null, 2)}\n`,
+    );
+    const resourcePath = `resources/solution_folder/entity/native/${entityName}.json`;
+    writeFileSync(
+        join(projectDir, `${entityName}.entity`),
+        `${JSON.stringify({ name: entityName, resourcePath }, null, 2)}\n`,
+    );
+
+    const resourceDir = join(
+        solutionDir,
+        "resources",
+        "solution_folder",
+        "entity",
+        "native",
+    );
+    createDir(resourceDir);
+    writeFileSync(
+        join(resourceDir, `${entityName}.json`),
+        `${JSON.stringify(entityResource(entityName), null, 2)}\n`,
+    );
+
+    if (options.withApiProject) {
+        const apiDir = join(solutionDir, "ApiProj");
+        cpSync(API_FIXTURE, apiDir, { recursive: true });
+        projects.push({
+            Id: "22222222-2222-2222-2222-222222222222",
+            Type: "Api",
+            ProjectRelativePath: "ApiProj/project.json",
+        });
+    }
+
+    writeFileSync(
+        join(solutionDir, "EntitySolution.uipx"),
+        `${JSON.stringify(
+            {
+                DocVersion: "1.0.0",
+                StudioMinVersion: "2025.10.0",
+                SolutionId: "00000000-0000-0000-0000-0000000000aa",
+                Projects: projects,
+            },
+            null,
+            2,
+        )}\n`,
+    );
+    return solutionDir;
+}
+
+/** A minimal valid entity definition resource: the 5 system fields only. */
+function entityResource(name: string): unknown {
+    const systemField = (
+        fieldName: string,
+        sqlType: string,
+        over: Record<string, unknown> = {},
+    ) => ({
+        IsPrimaryKey: false,
+        IsForeignKey: false,
+        IsExternalField: false,
+        IsHiddenField: true,
+        FieldCategoryId: 0,
+        IsUnique: false,
+        ReferenceType: "ManyToOne",
+        Transformation: null,
+        IsRequired: false,
+        IsEncrypted: false,
+        Description: "",
+        IsSystemField: true,
+        FieldDisplayType: "Basic",
+        IsAttachment: false,
+        IsRbacEnabled: false,
+        IsModelReserved: false,
+        Name: fieldName,
+        DisplayName: fieldName,
+        SqlType: { Name: sqlType },
+        ...over,
+    });
+    const entity = {
+        Id: "8673235c-6cb4-4536-9ff7-f19e4337147f",
+        Name: name,
+        DisplayName: name,
+        EntityTypeId: 0,
+        EntityType: "Entity",
+        Description: "",
+        FolderId: "99999999-9999-9999-9999-999999999999",
+        Fields: [
+            systemField("Id", "UNIQUEIDENTIFIER", { IsPrimaryKey: true }),
+            systemField("CreateTime", "DATETIMEOFFSET"),
+            systemField("CreatedBy", "UNIQUEIDENTIFIER", {
+                FieldDisplayType: "Relationship",
+            }),
+            systemField("UpdateTime", "DATETIMEOFFSET"),
+            systemField("UpdatedBy", "UNIQUEIDENTIFIER", {
+                FieldDisplayType: "Relationship",
+            }),
+        ],
+        Data: null,
+        ExternalFields: null,
+        SourceJoinCriterias: null,
+        RecordCount: 0,
+        StorageSizeInMB: null,
+        UsedStorageSizeInMB: null,
+        AttachmentSizeInByte: null,
+        IsRbacEnabled: false,
+        InvalidIdentifiers: [],
+        IsModelReserved: false,
+        CategoryId: null,
+    };
+    return {
+        docVersion: "1.0.0",
+        resource: {
+            name,
+            kind: "entity",
+            type: "native",
+            apiVersion: "dataservice.uipath.com/v2",
+            isOverridable: true,
+            dependencies: [],
+            runtimeDependencies: [],
+            folders: [{ fullyQualifiedName: "solution_folder" }],
+            spec: {
+                resourceJson: JSON.stringify(entity),
+                name,
+                displayName: name,
+                description: "",
+            },
+            locks: [],
+            key: entity.Id,
+            files: [],
+        },
+    };
+}
+
+/** Pack a seeded solution and return the parsed envelope plus exit code. */
+function packSolution(
+    root: string,
+    solutionDir: string,
+): { exitCode: number; envelope: PackEnvelope; output: string } {
+    const output = join(root, "out");
+    const { exitCode, stdout } = localCliRawWithArgs(
+        installDir,
+        ["solution", "pack", solutionDir, output],
+        undefined,
+        { timeout: PACK_TIMEOUT },
+    );
+    return {
+        exitCode,
+        envelope: extractLastJson(stdout) as PackEnvelope,
+        output,
+    };
+}
+
+/** Every failure case asserts the same envelope shape; only the message differs.
+ *  The tool's own ENTITY_VALIDATION_FAILED code does not reach the CLI — pack
+ *  reports INTERNAL_ERROR and carries the diagnostic in Message. */
+function expectPackFailure(
+    result: { exitCode: number; envelope: PackEnvelope },
+    ...messageFragments: string[]
+): void {
+    expect(result.exitCode).not.toBe(0);
+    expect(result.envelope.Result).toBe("Failure");
+    expect(result.envelope.Message).toContain("Entity validation failed");
+    for (const fragment of messageFragments) {
+        expect(result.envelope.Message).toContain(fragment);
+    }
+}
+
+describe("entity project packaging e2e", () => {
+    it(
+        "S1: pack a solution whose only project is an Entity project",
+        async () => {
+            const root = join(installDir, "entity-pack-only");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            const output = join(root, "out");
+
+            const out = localCliWithArgs(
+                installDir,
+                ["solution", "pack", solutionDir, output],
+                undefined,
+                { timeout: PACK_TIMEOUT },
+            );
+            const result = extractLastJson(out) as PackEnvelope;
+            expect(result.Result).toBe("Success");
+            expect(result.Code).toBe("SolutionPack");
+
+            // The entity definition IS the deliverable: it ships in the zip, and
+            // because nothing was compiled there is no .nupkg and no folder for
+            // the Entity project.
+            const entries = zipEntries(output);
+            expect(entries).toContain(
+                "resources/solution_folder/entity/native/PurchaseOrder.json",
+            );
+            expect(entries.filter((e) => e.endsWith(".nupkg"))).toEqual([]);
+            expect(entries.some((e) => e.startsWith("MasterData/"))).toBe(
+                false,
+            );
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S2: check the same solution without producing a package",
+        async () => {
+            const root = join(installDir, "entity-validate");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+
+            // There is no `solution validate` command: `pack --dry-run` runs the
+            // same checks and produces nothing.
+            const out = localCliWithArgs(
+                installDir,
+                ["solution", "pack", solutionDir, "--dry-run"],
+                undefined,
+                { timeout: PACK_TIMEOUT },
+            );
+
+            expect((extractLastJson(out) as PackEnvelope).Result).toBe(
+                "Success",
+            );
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S3: pack a mixed solution (Entity alongside a package-producing project)",
+        async () => {
+            const root = join(installDir, "entity-pack-mixed");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root, {
+                withApiProject: true,
+            });
+            const output = join(root, "out");
+
+            const out = localCliWithArgs(
+                installDir,
+                ["solution", "pack", solutionDir, output],
+                undefined,
+                { timeout: PACK_TIMEOUT },
+            );
+            const result = extractLastJson(out) as PackEnvelope;
+
+            // Two projects, one package. The Api project contributes a .nupkg
+            // under files/<projectId>/; the Entity project contributes its
+            // definition resource instead, and that asymmetry is not an error.
+            expect(result.Result).toBe("Success");
+            expect(result.Code).toBe("SolutionPack");
+            const entries = zipEntries(output);
+            expect(entries.filter((e) => e.endsWith(".nupkg"))).toHaveLength(1);
+            expect(entries).toContain(
+                "resources/solution_folder/entity/native/PurchaseOrder.json",
+            );
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S4: a `.entity` whose resource file is missing fails the pack",
+        async () => {
+            const root = join(installDir, "entity-pack-missing");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            rmSync(
+                join(
+                    solutionDir,
+                    "resources/solution_folder/entity/native/PurchaseOrder.json",
+                ),
+            );
+
+            const { exitCode, stdout } = localCliRawWithArgs(
+                installDir,
+                ["solution", "pack", solutionDir, join(root, "out")],
+                undefined,
+                { timeout: PACK_TIMEOUT },
+            );
+
+            // The tool's own ENTITY_VALIDATION_FAILED code does not reach the
+            // CLI envelope — pack reports INTERNAL_ERROR and carries the
+            // diagnostic in Message, so assert on what the user actually sees.
+            expect(exitCode).not.toBe(0);
+            const failure = extractLastJson(stdout) as PackEnvelope;
+            expect(failure.Result).toBe("Failure");
+            expect(failure.Message).toContain("Entity validation failed");
+            expect(failure.Message).toContain(
+                "resources/solution_folder/entity/native/PurchaseOrder.json",
+            );
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S5: a `.entity` whose filename does not match the entity name fails the pack",
+        async () => {
+            const root = join(installDir, "entity-name-mismatch");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            // Rename the stub only: its `name` still says Order.
+            cpSync(
+                join(solutionDir, "MasterData", "PurchaseOrder.entity"),
+                join(solutionDir, "MasterData", "Renamed.entity"),
+            );
+            rmSync(join(solutionDir, "MasterData", "PurchaseOrder.entity"));
+
+            expectPackFailure(packSolution(root, solutionDir), "Renamed");
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S6: a `resourcePath` pointing outside the solution fails the pack",
+        async () => {
+            const root = join(installDir, "entity-escapes");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            writeFileSync(
+                join(solutionDir, "MasterData", "PurchaseOrder.entity"),
+                `${JSON.stringify({ name: "PurchaseOrder", resourcePath: "../../outside/PurchaseOrder.json" }, null, 2)}\n`,
+            );
+
+            expectPackFailure(
+                packSolution(root, solutionDir),
+                "outside the solution",
+            );
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S7: an invalid schema is reported against the resource file, not the stub",
+        async () => {
+            const root = join(installDir, "entity-bad-schema");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            const resource = join(
+                solutionDir,
+                "resources/solution_folder/entity/native/PurchaseOrder.json",
+            );
+            const parsed = JSON.parse(readFileSync(resource, "utf8"));
+            const entity = JSON.parse(parsed.resource.spec.resourceJson);
+            // A custom field with a type combination the modeller cannot author.
+            entity.Fields.push({
+                Name: "Bad",
+                DisplayName: "Bad",
+                SqlType: { Name: "UNKNOWN" },
+                FieldDisplayType: "Basic",
+                IsRequired: false,
+                IsUnique: false,
+                IsPrimaryKey: false,
+                IsForeignKey: false,
+                IsSystemField: false,
+                IsExternalField: false,
+                IsHiddenField: false,
+                FieldCategoryId: 0,
+                ReferenceType: "ManyToOne",
+                IsEncrypted: false,
+                Description: "",
+                IsAttachment: false,
+                IsRbacEnabled: false,
+                IsModelReserved: false,
+            });
+            parsed.resource.spec.resourceJson = JSON.stringify(entity);
+            writeFileSync(resource, `${JSON.stringify(parsed, null, 2)}\n`);
+
+            expectPackFailure(packSolution(root, solutionDir), "Bad");
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S8: the same entity name in two Entity projects fails the pack",
+        async () => {
+            const root = join(installDir, "entity-dup-name");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            // A second Entity project declaring the same entity name.
+            const second = join(solutionDir, "MoreData");
+            createDir(second);
+            writeFileSync(
+                join(second, "project.uiproj"),
+                `${JSON.stringify({ Name: "MoreData", ProjectType: "Entity" }, null, 2)}\n`,
+            );
+            cpSync(
+                join(solutionDir, "MasterData", "PurchaseOrder.entity"),
+                join(second, "PurchaseOrder.entity"),
+            );
+            const uipx = join(solutionDir, "EntitySolution.uipx");
+            const manifest = JSON.parse(readFileSync(uipx, "utf8"));
+            manifest.Projects.push({
+                Id: "33333333-3333-3333-3333-333333333333",
+                Type: "Entity",
+                ProjectRelativePath: "MoreData/project.uiproj",
+            });
+            writeFileSync(uipx, `${JSON.stringify(manifest, null, 2)}\n`);
+
+            expectPackFailure(packSolution(root, solutionDir), "PurchaseOrder");
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S9: a misplaced `.flow` inside an Entity project fails with move guidance",
+        async () => {
+            const root = join(installDir, "entity-misplaced-flow");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            writeFileSync(
+                join(solutionDir, "MasterData", "Stray.flow"),
+                "{}\n",
+            );
+
+            expectPackFailure(
+                packSolution(root, solutionDir),
+                "Stray.flow",
+                "Flow project",
+            );
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S10: an Entity project with no entities packs successfully",
+        async () => {
+            const root = join(installDir, "entity-empty");
+            createDir(root);
+            // Keep the Api project: a solution whose every resource is removed
+            // fails earlier, on an empty solution definition, which is not what
+            // this scenario is about.
+            const solutionDir = seedEntitySolution(root, {
+                withApiProject: true,
+            });
+            // Remove the only entity: the project itself stays registered.
+            rmSync(join(solutionDir, "MasterData", "PurchaseOrder.entity"));
+            rmSync(
+                join(
+                    solutionDir,
+                    "resources/solution_folder/entity/native/PurchaseOrder.json",
+                ),
+            );
+
+            const result = packSolution(root, solutionDir);
+            expect(result.exitCode).toBe(0);
+            expect(result.envelope.Result).toBe("Success");
+        },
+        PACK_TIMEOUT,
+    );
+
+    it(
+        "S11: every pack diagnostic is reported, not just the first",
+        async () => {
+            const root = join(installDir, "entity-two-issues");
+            createDir(root);
+            const solutionDir = seedEntitySolution(root);
+            // Two independent entity problems: a stub whose filename no longer
+            // matches its entity name, and a stray Flow main file.
+            cpSync(
+                join(solutionDir, "MasterData", "PurchaseOrder.entity"),
+                join(solutionDir, "MasterData", "Renamed.entity"),
+            );
+            rmSync(join(solutionDir, "MasterData", "PurchaseOrder.entity"));
+            writeFileSync(
+                join(solutionDir, "MasterData", "Stray.flow"),
+                "{}\n",
+            );
+
+            const result = packSolution(root, solutionDir);
+            expectPackFailure(result);
+            expect(result.envelope.Message).toContain("2 issue(s)");
+        },
+        PACK_TIMEOUT,
+    );
+});

package/tests/files-management.e2e.test.ts

@@ -18,6 +18,7 @@ import {
     readManifest,
     SETUP_TIMEOUT,
 } from "../../../tests/e2e-shared/helpers";
+import { e2eResourceName } from "../../../tests/e2e-shared/tenant-cleanup";
 
 const manifest = readManifest<E2EManifest>(MANIFEST_PATH);
 const { tempDir } = manifest.sharedInstall;
@@ -124,7 +125,7 @@ let folderScopedRecordId: string | undefined;
 const RUN_ID = `${process.pid}_${Date.now()}`;
 const scratchEntityName = `E2eDfFiles${RUN_ID}`;
 const folderScopedEntityName = `E2eDfFilesFolder${RUN_ID}`;
-const scratchFolderName = `e2e-df-files-folder-${RUN_ID}`;
+const scratchFolderName = e2eResourceName("e2e-df-files-folder");
 const uploadPath = join(SCRATCH_DIR, "sample.bin");
 const UPLOAD_BYTES = Buffer.from("data-fabric e2e sample", "utf-8");
 

package/dist/browser-strategy-yccf8mtd.js

@@ -1,99 +0,0 @@
-import {
-  getGlobalThis
-} from "./tool-9qecd4wb.js";
-import {
-  AUTH_CANCELLED_ERROR_CODE
-} from "./tool-5arsyj36.js";
-import"./tool-0v6na3yp.js";
-
-// ../auth/src/strategies/browser-strategy.ts
-class BrowserAuthStrategy {
-  async execute(url, _redirectUri, expectedState, opts) {
-    const global = getGlobalThis();
-    if (!global?.window) {
-      throw new Error("Browser environment required for authentication");
-    }
-    const screenWidth = global.window.screen?.width ?? 1024;
-    const screenHeight = global.window.screen?.height ?? 768;
-    const width = 600;
-    const height = 700;
-    const left = screenWidth / 2 - width / 2;
-    const top = screenHeight / 2 - height / 2;
-    if (!global.window.open) {
-      throw new Error("window.open is not available");
-    }
-    const popupResult = global.window.open(url, "uip_auth", `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`);
-    const popup = popupResult;
-    if (!popup) {
-      throw new Error(`Authentication popup was blocked by your browser.
-
-` + `To continue:
-` + `1. Look for a popup blocker icon in your address bar
-` + `2. Allow popups for this site
-` + `3. Try logging in again
-
-` + "If using an ad blocker, you may need to temporarily disable it.");
-    }
-    return new Promise((resolve, reject) => {
-      let timer;
-      const messageHandler = (event) => {
-        if (event.data?.type === "UIP_AUTH_CODE" && event.data.code) {
-          if (event.data.state !== expectedState) {
-            cleanup();
-            reject(new Error("OAuth state mismatch — the callback state does not match the expected value. " + "This may indicate a CSRF attack. Please try signing in again."));
-            popup.close();
-            return;
-          }
-          cleanup();
-          resolve(event.data.code);
-          popup.close();
-        } else if (event.data?.type === "UIP_AUTH_ERROR") {
-          cleanup();
-          const errorMsg = event.data.error || "Authentication failed";
-          reject(new Error(`Authentication failed: ${errorMsg}
-
-` + "Please check your credentials and try again. " + "If the problem persists, verify your UiPath account is active."));
-          popup.close();
-        }
-      };
-      const cleanup = () => {
-        global.window?.removeEventListener?.("message", messageHandler);
-        opts?.signal?.removeEventListener("abort", onAbort);
-        if (timer)
-          clearInterval(timer);
-      };
-      const onAbort = () => {
-        cleanup();
-        const err = new Error(`Authentication was cancelled.
-
-` + "The sign-in was cancelled before completing the login process. " + "Please try again and complete the authentication flow.");
-        err.code = AUTH_CANCELLED_ERROR_CODE;
-        reject(err);
-        popup.close();
-      };
-      if (opts?.signal) {
-        if (opts.signal.aborted) {
-          onAbort();
-          return;
-        }
-        opts.signal.addEventListener("abort", onAbort, { once: true });
-      }
-      if (global.window?.addEventListener) {
-        global.window.addEventListener("message", messageHandler);
-      }
-      timer = setInterval(() => {
-        if (popup.closed) {
-          cleanup();
-          reject(new Error(`Authentication was cancelled.
-
-` + "The authentication popup was closed before completing the login process. " + "Please try again and complete the authentication flow."));
-        }
-      }, 1000);
-    });
-  }
-}
-export {
-  BrowserAuthStrategy
-};
-
-//# debugId=B13A3005E9EE6C6564756E2164756E21