@sanity/workbench 0.1.0-alpha.8 → 0.1.0-alpha.9

package/src/core/shared/urls.test.ts

@@ -1,182 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { createPath, joinUrlPaths, normalizePath, parsePath } from "./urls";
-
-describe("joinUrlPaths", () => {
-  it("joins two simple segments", () => {
-    expect(joinUrlPaths("foo", "bar")).toBe("foo/bar");
-  });
-
-  it("handles trailing slash on first segment", () => {
-    expect(joinUrlPaths("foo/", "bar")).toBe("foo/bar");
-  });
-
-  it("handles leading slash on second segment", () => {
-    expect(joinUrlPaths("foo", "/bar")).toBe("foo/bar");
-  });
-
-  it("collapses double slashes at the join", () => {
-    expect(joinUrlPaths("foo/", "/bar")).toBe("foo/bar");
-  });
-
-  it("joins multiple segments", () => {
-    expect(joinUrlPaths("a", "b", "c")).toBe("a/b/c");
-  });
-
-  it("skips null and undefined values", () => {
-    expect(joinUrlPaths("a", null, undefined, "b")).toBe("a/b");
-  });
-
-  it("returns empty string for all nullish inputs", () => {
-    expect(joinUrlPaths(null, undefined)).toBe("");
-  });
-
-  it("returns empty string with no arguments", () => {
-    expect(joinUrlPaths()).toBe("");
-  });
-
-  it("returns single segment unchanged", () => {
-    expect(joinUrlPaths("foo")).toBe("foo");
-  });
-
-  it("extracts pathname from URL objects", () => {
-    const url = new URL("https://example.com/api");
-    expect(joinUrlPaths(url, "users")).toBe("/api/users");
-  });
-
-  it("handles URL object with trailing slash", () => {
-    const url = new URL("https://example.com/api/");
-    expect(joinUrlPaths(url, "users")).toBe("/api/users");
-  });
-
-  it("joins two URL objects", () => {
-    const a = new URL("https://example.com/api");
-    const b = new URL("https://example.com/v2");
-    expect(joinUrlPaths(a, b)).toBe("/api/v2");
-  });
-});
-
-describe("normalizePath", () => {
-  it("adds leading slash when missing", () => {
-    expect(normalizePath("foo")).toBe("/foo");
-  });
-
-  it("preserves existing leading slash", () => {
-    expect(normalizePath("/foo")).toBe("/foo");
-  });
-
-  it("removes trailing slash", () => {
-    expect(normalizePath("/foo/")).toBe("/foo");
-  });
-
-  it("preserves root path", () => {
-    expect(normalizePath("/")).toBe("/");
-  });
-
-  it("handles bare segment with trailing slash", () => {
-    expect(normalizePath("foo/")).toBe("/foo");
-  });
-
-  it("handles deeper paths", () => {
-    expect(normalizePath("/a/b/c/")).toBe("/a/b/c");
-  });
-});
-
-describe("parsePath", () => {
-  it("parses pathname only", () => {
-    expect(parsePath("/foo")).toEqual({ pathname: "/foo" });
-  });
-
-  it("parses pathname with search", () => {
-    expect(parsePath("/foo?bar=1")).toEqual({
-      pathname: "/foo",
-      search: "?bar=1",
-    });
-  });
-
-  it("parses pathname with hash", () => {
-    expect(parsePath("/foo#heading")).toEqual({
-      pathname: "/foo",
-      hash: "#heading",
-    });
-  });
-
-  it("parses pathname with search and hash", () => {
-    expect(parsePath("/foo?bar=1#heading")).toEqual({
-      pathname: "/foo",
-      search: "?bar=1",
-      hash: "#heading",
-    });
-  });
-
-  it("parses hash that appears before search in the string", () => {
-    expect(parsePath("/foo#heading?notSearch")).toEqual({
-      pathname: "/foo",
-      hash: "#heading?notSearch",
-    });
-  });
-
-  it("returns empty object for empty string", () => {
-    expect(parsePath("")).toEqual({});
-  });
-
-  it("parses search-only path", () => {
-    expect(parsePath("?q=1")).toEqual({ search: "?q=1" });
-  });
-
-  it("parses hash-only path", () => {
-    expect(parsePath("#top")).toEqual({ hash: "#top" });
-  });
-});
-
-describe("createPath", () => {
-  it("returns pathname only", () => {
-    expect(createPath({ pathname: "/foo" })).toBe("/foo");
-  });
-
-  it("appends search string", () => {
-    expect(createPath({ pathname: "/foo", search: "?bar=1" })).toBe(
-      "/foo?bar=1",
-    );
-  });
-
-  it("appends hash string", () => {
-    expect(createPath({ pathname: "/foo", hash: "#heading" })).toBe(
-      "/foo#heading",
-    );
-  });
-
-  it("appends both search and hash", () => {
-    expect(
-      createPath({
-        pathname: "/foo",
-        search: "?bar=1",
-        hash: "#heading",
-      }),
-    ).toBe("/foo?bar=1#heading");
-  });
-
-  it("adds ? prefix when search is missing it", () => {
-    expect(createPath({ pathname: "/foo", search: "bar=1" })).toBe(
-      "/foo?bar=1",
-    );
-  });
-
-  it("adds # prefix when hash is missing it", () => {
-    expect(createPath({ pathname: "/foo", hash: "heading" })).toBe(
-      "/foo#heading",
-    );
-  });
-
-  it("defaults pathname to /", () => {
-    expect(createPath({})).toBe("/");
-  });
-
-  it("ignores bare ? search", () => {
-    expect(createPath({ pathname: "/foo", search: "?" })).toBe("/foo");
-  });
-
-  it("ignores bare # hash", () => {
-    expect(createPath({ pathname: "/foo", hash: "#" })).toBe("/foo");
-  });
-});

package/src/core/user-applications/core-app.test.ts

@@ -1,236 +0,0 @@
-// eslint-disable-next-line no-restricted-imports
-import type { ApplicationResource as ProtocolApplicationResource } from "@sanity/message-protocol";
-import { afterEach, describe, expect, expectTypeOf, it, vi } from "vitest";
-
-import { APPLICATION_DATA } from "../__tests__/__fixtures__";
-import {
-  CoreAppApplication,
-  parseCoreApplication,
-  type CoreAppUserApplication,
-} from "./core-app";
-import type { UserApplicationId } from "./user-application";
-
-const setup = () => new CoreAppApplication(APPLICATION_DATA);
-
-describe("CoreAppApplication", () => {
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-  it("should have a type of coreApp", () => {
-    const application = setup();
-    expect(application.type).toBe("coreApp");
-  });
-
-  it("should have a href of <application>/<id>", () => {
-    const application = setup();
-    expect(application.href).toBe("/application/v27rvqtlp3lmdvcln6ey3lro");
-  });
-
-  it("should have a name of the application title", () => {
-    const application = setup();
-    expect(application.title).toBe("sdk-movie-list");
-  });
-
-  it("should have a updatedAt property", () => {
-    const application = setup();
-    expect(application.updatedAt).toBe("2025-03-27T19:00:32.792Z");
-  });
-
-  it("should have an activeDeployment property", () => {
-    const application = setup();
-    expect(application.activeDeployment).toMatchInlineSnapshot(`
-      {
-        "createdAt": "2025-03-27T19:07:21.038Z",
-        "deployedAt": "2025-03-27T19:07:21.082Z",
-        "deployedBy": "gwXueEBci",
-        "id": "dv3kz3fsl4aqha3parc8k391",
-        "isActiveDeployment": true,
-        "isAutoUpdating": false,
-        "manifest": null,
-        "size": 528292,
-        "updatedAt": "2025-03-27T19:07:21.082Z",
-        "userApplicationId": "v27rvqtlp3lmdvcln6ey3lro",
-        "version": "3.81.0",
-      }
-    `);
-  });
-
-  it("should implement the toProtocolResource method", () => {
-    vi.stubEnv("VITE_SANITY_ENV", "staging");
-    vi.stubEnv("VITE_SANITY_DOMAIN", "sanity.work");
-    const application = setup();
-    expect(application.toProtocolResource()).toMatchInlineSnapshot(`
-      {
-        "activeDeployment": {
-          "createdAt": "2025-03-27T19:07:21.038Z",
-          "deployedAt": "2025-03-27T19:07:21.082Z",
-          "deployedBy": "gwXueEBci",
-          "id": "dv3kz3fsl4aqha3parc8k391",
-          "isActiveDeployment": true,
-          "isAutoUpdating": false,
-          "manifest": null,
-          "size": 528292,
-          "updatedAt": "2025-03-27T19:07:21.082Z",
-          "userApplicationId": "v27rvqtlp3lmdvcln6ey3lro",
-          "version": "3.81.0",
-        },
-        "appHost": "x7apsmr6fxvc",
-        "createdAt": "2025-03-27T19:00:32.792Z",
-        "dashboardStatus": "default",
-        "id": "v27rvqtlp3lmdvcln6ey3lro",
-        "organizationId": "oSyH1iET5",
-        "title": "sdk-movie-list",
-        "type": "application",
-        "updatedAt": "2025-03-27T19:00:32.792Z",
-        "url": "https://x7apsmr6fxvc.studio.sanity.work/",
-        "urlType": "internal",
-      }
-    `);
-
-    expectTypeOf(
-      application.toProtocolResource(),
-    ).toEqualTypeOf<ProtocolApplicationResource>();
-  });
-
-  it("should return undefined for subtitle", () => {
-    const application = setup();
-    expect(application.subtitle).toBeUndefined();
-  });
-
-  describe("get", () => {
-    it("should throw when accessing a non-existent attribute", () => {
-      const application = setup();
-      expect(() =>
-        // @ts-expect-error - testing invalid attribute
-        application.get("nonExistent"),
-      ).toThrow(
-        "Attribute nonExistent does not exist on application v27rvqtlp3lmdvcln6ey3lro",
-      );
-    });
-  });
-
-  describe("manifest functionality", () => {
-    it("should use manifest from application when present", () => {
-      const application = new CoreAppApplication(
-        parseCoreApplication({
-          ...APPLICATION_DATA,
-          activeDeployment: {
-            ...APPLICATION_DATA.activeDeployment!,
-            manifest: {
-              version: "1.0.0",
-              icon: "<svg>test-icon</svg>",
-              title: "Manifest Title",
-            },
-          },
-        }),
-      );
-      expect(application.title).toBe("Manifest Title");
-    });
-
-    it("should use manifest from activeDeployment when application manifest is not present", () => {
-      const application = new CoreAppApplication(
-        parseCoreApplication({
-          ...APPLICATION_DATA,
-          activeDeployment: {
-            ...APPLICATION_DATA.activeDeployment!,
-            manifest: {
-              version: "1.0.0",
-              icon: "<svg>deployment-icon</svg>",
-              title: "Deployment Title",
-            },
-          },
-        }),
-      );
-      expect(application.title).toBe("Deployment Title");
-    });
-
-    it("should allow you to get attributes from the application", () => {
-      const application = setup();
-
-      expect(application.get("title")).toBe("sdk-movie-list");
-      expect(application.get("urlType")).toBe("internal");
-      expect(application.get("appHost")).toBe("x7apsmr6fxvc");
-      expectTypeOf(application.get("appHost")).toEqualTypeOf<string>();
-    });
-  });
-});
-
-const VALID_INTERNAL_CORE_APP = {
-  id: "app-001",
-  appHost: "my-app-host",
-  createdAt: "2025-01-01T00:00:00Z",
-  updatedAt: "2025-01-01T00:00:00Z",
-  dashboardStatus: "default",
-  title: "My App",
-  organizationId: "org-001",
-  type: "coreApp",
-  urlType: "internal",
-  activeDeployment: {
-    id: "deploy-001",
-    version: "1.0.0",
-    isActiveDeployment: true,
-    userApplicationId: "app-001",
-    isAutoUpdating: false,
-    manifest: null,
-    size: 500,
-    deployedAt: "2025-01-01T00:00:00Z",
-    deployedBy: "user-001",
-    createdAt: "2025-01-01T00:00:00Z",
-    updatedAt: "2025-01-01T00:00:00Z",
-  },
-} as const;
-
-const VALID_EXTERNAL_CORE_APP = {
-  id: "app-002",
-  appHost: "https://my-app.example.com",
-  createdAt: "2025-01-01T00:00:00Z",
-  updatedAt: "2025-01-01T00:00:00Z",
-  dashboardStatus: "default",
-  title: "My External App",
-  organizationId: "org-001",
-  type: "coreApp",
-  urlType: "external",
-  activeDeployment: null,
-} as const;
-
-describe("parseCoreApplication", () => {
-  it("parses a valid internal core application", () => {
-    const app = parseCoreApplication(VALID_INTERNAL_CORE_APP);
-    expect(app.urlType).toBe("internal");
-    expect(app.title).toBe("My App");
-    expectTypeOf(app).toEqualTypeOf<CoreAppUserApplication>();
-    expectTypeOf(app.id).toEqualTypeOf<UserApplicationId>();
-  });
-
-  it("parses a valid external core application", () => {
-    const app = parseCoreApplication(VALID_EXTERNAL_CORE_APP);
-    expect(app.urlType).toBe("external");
-    expect(app.activeDeployment).toBeNull();
-  });
-
-  it("rejects missing required fields", () => {
-    expect(() => parseCoreApplication({ id: "app-001" })).toThrow();
-  });
-
-  it("rejects an empty id", () => {
-    expect(() =>
-      parseCoreApplication({ ...VALID_INTERNAL_CORE_APP, id: "" }),
-    ).toThrow();
-  });
-
-  it("parses core app with deployment manifest", () => {
-    const app = parseCoreApplication({
-      ...VALID_INTERNAL_CORE_APP,
-      activeDeployment: {
-        ...VALID_INTERNAL_CORE_APP.activeDeployment,
-        manifest: {
-          version: "1.0.0",
-          title: "Manifest Title",
-          icon: "<svg></svg>",
-        },
-      },
-    });
-
-    expect(app.activeDeployment?.manifest?.title).toBe("Manifest Title");
-  });
-});

package/src/core/user-applications/studios/schemas.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, expectTypeOf, it } from "vitest";
-
-import type { UserApplicationId } from "../user-application";
-import {
-  parseStudioUserApplication,
-  type StudioUserApplication,
-} from "./schemas";
-
-const VALID_INTERNAL_STUDIO = {
-  id: "studio-001",
-  appHost: "my-studio",
-  createdAt: "2025-01-01T00:00:00Z",
-  updatedAt: "2025-01-01T00:00:00Z",
-  dashboardStatus: "default",
-  title: null,
-  projectId: "proj-001",
-  type: "studio",
-  urlType: "internal",
-  manifest: null,
-  manifestData: null,
-  autoUpdatingVersion: "latest",
-  activeDeployment: {
-    id: "deploy-001",
-    version: "4.0.0",
-    isActiveDeployment: true,
-    userApplicationId: "studio-001",
-    isAutoUpdating: true,
-    manifest: null,
-    size: 1000,
-    deployedAt: "2025-01-01T00:00:00Z",
-    deployedBy: "user-001",
-    createdAt: "2025-01-01T00:00:00Z",
-    updatedAt: "2025-01-01T00:00:00Z",
-  },
-  config: {},
-} as const;
-
-const VALID_EXTERNAL_STUDIO = {
-  id: "studio-002",
-  appHost: "https://my-studio.example.com",
-  createdAt: "2025-01-01T00:00:00Z",
-  updatedAt: "2025-01-01T00:00:00Z",
-  dashboardStatus: "default",
-  title: "My External Studio",
-  projectId: "proj-001",
-  type: "studio",
-  urlType: "external",
-  manifest: null,
-  manifestData: null,
-  autoUpdatingVersion: null,
-  activeDeployment: null,
-  config: {},
-} as const;
-
-describe("parseStudioUserApplication", () => {
-  it("parses a valid internal studio application", () => {
-    const studio = parseStudioUserApplication(VALID_INTERNAL_STUDIO);
-    expect(studio.urlType).toBe("internal");
-    expect(studio.activeDeployment?.version).toBe("4.0.0");
-    expectTypeOf(studio).toEqualTypeOf<StudioUserApplication>();
-    expectTypeOf(studio.id).toEqualTypeOf<UserApplicationId>();
-  });
-
-  it("parses a valid external studio application", () => {
-    const studio = parseStudioUserApplication(VALID_EXTERNAL_STUDIO);
-    expect(studio.urlType).toBe("external");
-    expect(studio.activeDeployment).toBeNull();
-    expect(studio.title).toBe("My External Studio");
-  });
-
-  it("rejects missing required fields", () => {
-    expect(() => parseStudioUserApplication({ id: "studio-001" })).toThrow();
-  });
-
-  it("rejects an empty id", () => {
-    expect(() =>
-      parseStudioUserApplication({ ...VALID_INTERNAL_STUDIO, id: "" }),
-    ).toThrow();
-  });
-
-  it("rejects invalid urlType", () => {
-    expect(() =>
-      parseStudioUserApplication({
-        ...VALID_INTERNAL_STUDIO,
-        urlType: "unknown",
-      }),
-    ).toThrow();
-  });
-
-  it("parses studio with manifestData", () => {
-    const studio = parseStudioUserApplication({
-      ...VALID_INTERNAL_STUDIO,
-      manifestData: {
-        value: {
-          version: 2,
-          createdAt: "2025-01-01T00:00:00Z",
-          workspaces: [
-            {
-              name: "default",
-              title: "Default",
-              basePath: "/",
-              projectId: "proj-001",
-              dataset: "production",
-              schema: "schema.json",
-            },
-          ],
-        },
-      },
-    });
-
-    expect(studio.manifestData?.value.workspaces).toHaveLength(1);
-  });
-});