@sanity/workbench 0.1.0-alpha.6 → 0.1.0-alpha.7

package/src/core/projects.ts

@@ -0,0 +1,114 @@
+import { z } from "zod";
+
+import { OrganizationId } from "./organizations";
+
+/**
+ * Project ID schema, branded for type safety.
+ * @public
+ */
+export const ProjectId = z.string().nonempty().brand("ProjectId");
+
+/**
+ * Project ID type, branded for type safety.
+ * @public
+ */
+export type ProjectId = z.output<typeof ProjectId>;
+
+/**
+ * Validates and brands a string as a ProjectId.
+ * @public
+ */
+export function brandProjectId(id: string): ProjectId {
+  return ProjectId.parse(id);
+}
+
+const ProjectMember = z.object({
+  id: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  isCurrentUser: z.boolean(),
+  isRobot: z.boolean(),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string(),
+    }),
+  ),
+});
+
+/**
+ * @public
+ */
+export type ProjectMember = z.output<typeof ProjectMember>;
+
+/**
+ * Project schema — validates and brands API responses
+ * from the `/projects/:id` endpoint.
+ * @public
+ */
+export const Project = z.object({
+  id: ProjectId,
+  displayName: z.string(),
+  studioHost: z.string().nullable(),
+  organizationId: OrganizationId,
+  metadata: z.object({
+    color: z.string().optional(),
+    externalStudioHost: z.string().optional(),
+    initialTemplate: z.string().optional(),
+    cliInitializedAt: z.string().optional(),
+    integration: z.literal(["manage", "cli"]),
+  }),
+  isBlocked: z.boolean(),
+  isDisabled: z.boolean(),
+  isDisabledByUser: z.boolean(),
+  activityFeedEnabled: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+/**
+ * Represents a Sanity project with optional members and
+ * features arrays depending on the generic parameters.
+ * By default, neither members nor features are included.
+ * - `Project` — base fields only (default)
+ * - `Project<true>` — includes `members`
+ * - `Project<true, true>` — includes both
+ * @public
+ */
+export type Project<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+> = z.output<typeof Project> &
+  (IncludeMembers extends true ? { members: ProjectMember[] } : unknown) &
+  (IncludeFeatures extends true ? { features: string[] } : unknown);
+
+/**
+ * Validates and parses a raw API response into a branded
+ * Project. The options control which schema is used —
+ * matching what the API returns based on query params.
+ * @public
+ */
+export function parseProject<
+  IncludeMembers extends boolean = true,
+  IncludeFeatures extends boolean = true,
+>(
+  data: unknown,
+  options?: {
+    includeMembers?: IncludeMembers;
+    includeFeatures?: IncludeFeatures;
+  },
+): Project<IncludeMembers, IncludeFeatures> {
+  const includeMembers = options?.includeMembers ?? true;
+  const includeFeatures = options?.includeFeatures ?? true;
+
+  const extensions = {
+    ...(includeMembers && { members: z.array(ProjectMember) }),
+    ...(includeFeatures && { features: z.array(z.string()) }),
+  };
+
+  const schema =
+    Object.keys(extensions).length > 0 ? Project.extend(extensions) : Project;
+
+  return schema.parse(data) as Project<IncludeMembers, IncludeFeatures>;
+}

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

@@ -0,0 +1,182 @@
+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/shared/urls.ts

@@ -0,0 +1,128 @@
+/**
+ * Joins multiple path segments into a single path string.
+ * Handles null, undefined, and URL objects gracefully.
+ *
+ * @param paths - An array of path segments to join.
+ * @returns A single joined path string.
+ */
+export const joinUrlPaths = (
+  ...paths: Array<string | URL | null | undefined>
+): string => {
+  let nextPath = null;
+
+  const safeJoinSegments = (
+    segment1: string | null | undefined,
+    segment2: string | null | undefined,
+  ): string => {
+    if (!segment1) {
+      if (!segment2) {
+        return "";
+      }
+
+      return segment2;
+    }
+
+    if (!segment2) {
+      return segment1;
+    }
+
+    if (segment1.endsWith("/") && segment2.startsWith("/")) {
+      return segment1 + segment2.slice(1);
+    }
+
+    if (segment1.endsWith("/") || segment2.startsWith("/")) {
+      return segment1 + segment2;
+    }
+
+    return `${segment1}/${segment2}`;
+  };
+
+  const validPaths = paths.filter(
+    (path) => path !== null && path !== undefined,
+  );
+
+  for (const path of validPaths) {
+    nextPath = safeJoinSegments(
+      nextPath,
+      path instanceof URL ? path.pathname : path,
+    );
+  }
+
+  return nextPath ?? "";
+};
+
+/**
+ * Returns a normalized path by ensuring it starts with a single leading slash
+ * and does not end with a trailing slash (unless it's the root path).
+ */
+export function normalizePath(pathname: string): string {
+  if (!pathname.startsWith("/")) {
+    pathname = `/${pathname}`;
+  }
+
+  if (pathname !== "/" && pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+
+  return pathname;
+}
+
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path {
+  /**
+   * A URL pathname, beginning with a /.
+   */
+  pathname: string;
+  /**
+   * A URL search string, beginning with a ?.
+   */
+  search: string;
+  /**
+   * A URL fragment identifier, beginning with a #.
+   */
+  hash: string;
+}
+
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+export function parsePath(path: string): Partial<Path> {
+  let parsedPath: Partial<Path> = {};
+
+  if (path) {
+    let hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substring(hashIndex);
+      path = path.substring(0, hashIndex);
+    }
+
+    let searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substring(searchIndex);
+      path = path.substring(0, searchIndex);
+    }
+
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+
+  return parsedPath;
+}
+
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+export function createPath({
+  pathname = "/",
+  search = "",
+  hash = "",
+}: Partial<Path>) {
+  if (search && search !== "?")
+    pathname += search.charAt(0) === "?" ? search : `?${search}`;
+  if (hash && hash !== "#")
+    pathname += hash.charAt(0) === "#" ? hash : `#${hash}`;
+  return pathname;
+}

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

@@ -0,0 +1,151 @@
+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 } from "./core-app";
+
+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",
+        "projectId": null,
+        "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 applicationWithManifest = {
+        ...APPLICATION_DATA,
+        activeDeployment: {
+          ...APPLICATION_DATA.activeDeployment,
+          manifest: {
+            version: "1.0.0",
+            icon: "<svg>test-icon</svg>",
+            title: "Manifest Title",
+          },
+        },
+      };
+      const application = new CoreAppApplication(applicationWithManifest);
+      expect(application.title).toBe("Manifest Title");
+    });
+
+    it("should use manifest from activeDeployment when application manifest is not present", () => {
+      const applicationWithDeploymentManifest = {
+        ...APPLICATION_DATA,
+        activeDeployment: {
+          ...APPLICATION_DATA.activeDeployment,
+          manifest: {
+            version: "1.0.0",
+            icon: "<svg>deployment-icon</svg>",
+            title: "Deployment Title",
+          },
+        },
+      };
+      const application = new CoreAppApplication(
+        applicationWithDeploymentManifest,
+      );
+      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>();
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+import type {
+  ApplicationResource as ProtocolApplicationResource,
+  CoreApplication,
+} from "@sanity/message-protocol";
+
+import { UserApplication } from "./user-application";
+
+/**
+ * @internal
+ */
+export class CoreAppApplication extends UserApplication<
+  CoreApplication,
+  "coreApp",
+  ProtocolApplicationResource
+> {
+  readonly activeDeployment: CoreApplication["activeDeployment"];
+
+  constructor(application: CoreApplication) {
+    super(application, "coreApp");
+
+    this.activeDeployment = application.activeDeployment;
+  }
+
+  get href() {
+    return `/application/${this.application.id}`;
+  }
+
+  get title() {
+    return this.activeDeployment?.manifest?.title ?? this.application.title;
+  }
+
+  get subtitle() {
+    return undefined;
+  }
+
+  get updatedAt() {
+    return this.application.updatedAt;
+  }
+
+  get<TKey extends keyof CoreApplication>(attr: TKey): CoreApplication[TKey] {
+    if (!(attr in this.application)) {
+      throw new Error(
+        `Attribute ${attr.toString()} does not exist on application ${this.application.id}`,
+      );
+    }
+
+    return this.application[attr];
+  }
+
+  toProtocolResource(): ProtocolApplicationResource {
+    return {
+      ...this.application,
+      type: "application",
+      url: this.url.toString(),
+    } satisfies ProtocolApplicationResource;
+  }
+}